Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/emit/hppaAsm.sml
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/emit/hppaAsm.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 411 - (view) (download)

1 : monnier 411 (*
2 :     * This file was automatically generated by MDGen
3 :     * from the machine description file "hppa/hppa.md".
4 : monnier 245 *)
5 :    
6 : monnier 411
7 :     functor HppaAsmEmitter(structure Instr : HPPAINSTR
8 :     structure Stream : INSTRUCTION_STREAM
9 :     structure Shuffle : HPPASHUFFLE
10 :     where I = Instr
11 :     ) : INSTRUCTION_EMITTER =
12 : monnier 245 struct
13 : monnier 411 structure I = Instr
14 :     structure C = I.C
15 :     structure S = Stream
16 :     structure P = S.P
17 :     structure LE = LabelExp
18 :     structure Constant = I.Constant
19 :    
20 :     fun error msg = MLRiscErrorMsg.error("HppaAsm",msg)
21 :    
22 :     fun makeStream() =
23 :     let val stream = !AsmStream.asmOutStream
24 :     fun emit s = TextIO.output(stream,s)
25 :     fun nl() = emit "\n"
26 :     fun comma() = emit ","
27 :     fun tab() = emit "\t"
28 :     fun ms n = if n<0 then "-"^Int.toString(~n)
29 :     else Int.toString n
30 :     fun emit_label lab = emit(Label.nameOf lab)
31 :     fun emit_labexp le = emit(LabelExp.toString le)
32 :     fun emit_const c = emit(Constant.toString c)
33 :     fun emit_int i = emit(ms i)
34 :     fun paren f = (emit "("; f(); emit ")")
35 :     fun defineLabel lab = emit(Label.nameOf lab^":\n")
36 :     fun entryLabel lab = defineLabel lab
37 :     fun comment msg = emit("\t/* " ^ msg ^ " */")
38 :     fun annotation a = (comment(Annotations.toString a); nl())
39 :     fun blockName b = (comment(S.B.toString b); nl())
40 :     fun emit_region mem = comment(I.Region.toString mem)
41 :     fun pseudoOp pOp = emit(P.toString pOp)
42 :     fun init size = (comment("Code Size = " ^ ms size); nl())
43 :     fun doNothing _ = ()
44 :     fun emitter regmap =
45 :     let
46 : monnier 245
47 : monnier 411 fun emit_CC r = (emit (C.showCC (regmap r)))
48 :     and emit_CR r = (emit (C.showCR (regmap r)))
49 :     and emit_GP r = (emit (C.showGP (regmap r)))
50 :     and emit_FP r = (emit (C.showFP (regmap r)))
51 : monnier 245
52 : monnier 411 fun asm_cmplt (I.ADDR) = ""
53 :     | asm_cmplt (I.ADDR_S) = ",s"
54 :     | asm_cmplt (I.ADDR_M) = ",m"
55 :     | asm_cmplt (I.ADDR_SM) = ",sm"
56 :     and emit_cmplt x = (emit (asm_cmplt x))
57 :     and asm_store (I.STW) = "stw"
58 :     | asm_store (I.STH) = "sth"
59 :     | asm_store (I.STB) = "stb"
60 :     and emit_store x = (emit (asm_store x))
61 :     and asm_fcond (I.False_) = "false?"
62 :     | asm_fcond (I.False) = "false"
63 :     | asm_fcond (I.?) = "?"
64 :     | asm_fcond (I.!<=>) = "!<=>"
65 :     | asm_fcond (I.==) = "=="
66 :     | asm_fcond (I.EQT) = "=T"
67 :     | asm_fcond (I.?=) = "?="
68 :     | asm_fcond (I.!<>) = "!<>"
69 :     | asm_fcond (I.!?>=) = "!?>="
70 :     | asm_fcond (I.<) = "<"
71 :     | asm_fcond (I.?<) = "?<"
72 :     | asm_fcond (I.!>=) = "!>="
73 :     | asm_fcond (I.!?>) = "!?>"
74 :     | asm_fcond (I.<=) = "<="
75 :     | asm_fcond (I.?<=) = "?<="
76 :     | asm_fcond (I.!>) = "!>"
77 :     | asm_fcond (I.!?<=) = "!?<="
78 :     | asm_fcond (I.>) = ">"
79 :     | asm_fcond (I.?>) = "?>"
80 :     | asm_fcond (I.!<=) = "!<="
81 :     | asm_fcond (I.!?<) = "!?<"
82 :     | asm_fcond (I.>=) = ">="
83 :     | asm_fcond (I.?>=) = "?>="
84 :     | asm_fcond (I.!<) = "!<"
85 :     | asm_fcond (I.!?=) = "!?="
86 :     | asm_fcond (I.<>) = "<>"
87 :     | asm_fcond (I.!=) = "!="
88 :     | asm_fcond (I.NET) = "!=T"
89 :     | asm_fcond (I.!?) = "!?"
90 :     | asm_fcond (I.<=>) = "<=>"
91 :     | asm_fcond (I.True_) = "true?"
92 :     | asm_fcond (I.True) = "true"
93 :     and emit_fcond x = (emit (asm_fcond x))
94 :     and asm_floadx (I.FLDDX) = "flddx"
95 :     | asm_floadx (I.FLDDX_S) = "flddx,s"
96 :     | asm_floadx (I.FLDDX_M) = "flddx,m"
97 :     | asm_floadx (I.FLDDX_SM) = "flddx,sm"
98 :     | asm_floadx (I.FLDWX) = "fldwx"
99 :     | asm_floadx (I.FLDWX_S) = "fldwx,s"
100 :     | asm_floadx (I.FLDWX_M) = "fldwx,m"
101 :     | asm_floadx (I.FLDWX_SM) = "fldwx,sm"
102 :     and emit_floadx x = (emit (asm_floadx x))
103 :     and asm_fstorex (I.FSTDX) = "fstdx"
104 :     | asm_fstorex (I.FSTDX_S) = "fstdx,s"
105 :     | asm_fstorex (I.FSTDX_M) = "fstdx,m"
106 :     | asm_fstorex (I.FSTDX_SM) = "fstdx,sm"
107 :     | asm_fstorex (I.FSTWX) = "fstwx"
108 :     | asm_fstorex (I.FSTWX_S) = "fstwx,s"
109 :     | asm_fstorex (I.FSTWX_M) = "fstwx,m"
110 :     | asm_fstorex (I.FSTWX_SM) = "fstwx,sm"
111 :     and emit_fstorex x = (emit (asm_fstorex x))
112 :     and asm_fcnv (I.FCNVFF_SD) = "fcnvff,sgl,dbl"
113 :     | asm_fcnv (I.FCNVFF_SQ) = "fcnvff,sgl,quad"
114 :     | asm_fcnv (I.FCNVFF_DS) = "fcnvff,dbl,sgl"
115 :     | asm_fcnv (I.FCNVFF_DQ) = "fcnvff,dbl,quad"
116 :     | asm_fcnv (I.FCNVFF_QS) = "fcnvff,quad,sgl"
117 :     | asm_fcnv (I.FCNVFF_QD) = "fcnvff,quad,dbl"
118 :     | asm_fcnv (I.FCNVXF_S) = "fcnvxf,,sgl"
119 :     | asm_fcnv (I.FCNVXF_D) = "fcnvxf,,dbl"
120 :     | asm_fcnv (I.FCNVXF_Q) = "fcnvxf,,quad"
121 :     | asm_fcnv (I.FCNVFX_S) = "fcnvfx,sgl,"
122 :     | asm_fcnv (I.FCNVFX_D) = "fcnvfx,dbl,"
123 :     | asm_fcnv (I.FCNVFX_Q) = "fcnvfx,quad,"
124 :     | asm_fcnv (I.FCNVFXT_S) = "fcnvfxt,sgl,"
125 :     | asm_fcnv (I.FCNVFXT_D) = "fcnvfxt,dbl,"
126 :     | asm_fcnv (I.FCNVFXT_Q) = "fcnvfxt,quad,"
127 :     and emit_fcnv x = (emit (asm_fcnv x))
128 :     and asm_arithi (I.ADDI) = "addi"
129 :     | asm_arithi (I.ADDIO) = "addio"
130 :     | asm_arithi (I.ADDIL) = "addil"
131 :     | asm_arithi (I.SUBI) = "subi"
132 :     | asm_arithi (I.SUBIO) = "subio"
133 :     and emit_arithi x = (emit (asm_arithi x))
134 :     and asm_fload (I.FLDDS) = "fldds"
135 :     | asm_fload (I.FLDWS) = "fldws"
136 :     and emit_fload x = (emit (asm_fload x))
137 :     and asm_fmt (I.SGL) = "sgl"
138 :     | asm_fmt (I.DBL) = "dbl"
139 :     | asm_fmt (I.QUAD) = "quad"
140 :     and emit_fmt x = (emit (asm_fmt x))
141 :     and asm_bitcond (I.BSET) = "<"
142 :     | asm_bitcond (I.BCLR) = ">="
143 :     and emit_bitcond x = (emit (asm_bitcond x))
144 :     and asm_cmpi (I.COMIBT) = "comibt"
145 :     | asm_cmpi (I.COMIBF) = "comibf"
146 :     and emit_cmpi x = (emit (asm_cmpi x))
147 :     and asm_loadi (I.LDW) = "ldw"
148 :     | asm_loadi (I.LDH) = "ldh"
149 :     | asm_loadi (I.LDB) = "ldb"
150 :     and emit_loadi x = (emit (asm_loadi x))
151 :     and asm_cmp (I.COMBT) = "combt"
152 :     | asm_cmp (I.COMBF) = "combf"
153 :     and emit_cmp x = (emit (asm_cmp x))
154 :     and asm_farith (I.FADD_S) = "fadd,sgl"
155 :     | asm_farith (I.FADD_D) = "fadd,dbl"
156 :     | asm_farith (I.FADD_Q) = "fadd,quad"
157 :     | asm_farith (I.FSUB_S) = "fsub,sgl"
158 :     | asm_farith (I.FSUB_D) = "fsub,dbl"
159 :     | asm_farith (I.FSUB_Q) = "fsub,quad"
160 :     | asm_farith (I.FMPY_S) = "fmpy,sgl"
161 :     | asm_farith (I.FMPY_D) = "fmpy,dbl"
162 :     | asm_farith (I.FMPY_Q) = "fmpy,quad"
163 :     | asm_farith (I.FDIV_S) = "fdiv,sgl"
164 :     | asm_farith (I.FDIV_D) = "fdiv,dbl"
165 :     | asm_farith (I.FDIV_Q) = "fdiv,quad"
166 :     | asm_farith (I.XMPYU) = "xmpyu"
167 :     and emit_farith x = (emit (asm_farith x))
168 :     and asm_bcond (I.EQ) = "="
169 :     | asm_bcond (I.LT) = "<"
170 :     | asm_bcond (I.LE) = "<="
171 :     | asm_bcond (I.LTU) = "<<"
172 :     | asm_bcond (I.LEU) = "<<="
173 :     | asm_bcond (I.NE) = "<>"
174 :     | asm_bcond (I.GE) = ">="
175 :     | asm_bcond (I.GT) = ">"
176 :     | asm_bcond (I.GTU) = ">>"
177 :     | asm_bcond (I.GEU) = ">>="
178 :     and emit_bcond x = (emit (asm_bcond x))
179 :     and asm_shift (I.EXTRU) = "extru"
180 :     | asm_shift (I.EXTRS) = "extrs"
181 :     | asm_shift (I.ZDEP) = "zdep"
182 :     and emit_shift x = (emit (asm_shift x))
183 :     and asm_arith (I.ADD) = "add"
184 :     | asm_arith (I.ADDL) = "addl"
185 :     | asm_arith (I.ADDO) = "addo"
186 :     | asm_arith (I.SH1ADD) = "sh1add"
187 :     | asm_arith (I.SH1ADDL) = "sh1addl"
188 :     | asm_arith (I.SH1ADDO) = "sh1addo"
189 :     | asm_arith (I.SH2ADD) = "sh2add"
190 :     | asm_arith (I.SH2ADDL) = "sh2addl"
191 :     | asm_arith (I.SH2ADDO) = "sh2addo"
192 :     | asm_arith (I.SH3ADD) = "sh3add"
193 :     | asm_arith (I.SH3ADDL) = "sh3addl"
194 :     | asm_arith (I.SH3ADDO) = "sh3addo"
195 :     | asm_arith (I.SUB) = "sub"
196 :     | asm_arith (I.SUBO) = "subo"
197 :     | asm_arith (I.OR) = "or"
198 :     | asm_arith (I.XOR) = "xor"
199 :     | asm_arith (I.AND) = "and"
200 :     | asm_arith (I.ANDCM) = "andcm"
201 :     and emit_arith x = (emit (asm_arith x))
202 :     and asm_load (I.LDWX) = "ldwx"
203 :     | asm_load (I.LDWX_S) = "ldwx,s"
204 :     | asm_load (I.LDWX_M) = "ldwx,m"
205 :     | asm_load (I.LDWX_SM) = "ldwx,sm"
206 :     | asm_load (I.LDHX) = "ldhx"
207 :     | asm_load (I.LDHX_S) = "ldhx,s"
208 :     | asm_load (I.LDHX_M) = "ldhx,m"
209 :     | asm_load (I.LDHX_SM) = "ldhx,sm"
210 :     | asm_load (I.LDBX) = "ldbx"
211 :     | asm_load (I.LDBX_M) = "ldbx,m"
212 :     and emit_load x = (emit (asm_load x))
213 :     and asm_shiftv (I.VEXTRU) = "vextru"
214 :     | asm_shiftv (I.VEXTRS) = "vextrs"
215 :     | asm_shiftv (I.ZVDEP) = "zvdep"
216 :     and emit_shiftv x = (emit (asm_shiftv x))
217 :     and asm_funary (I.FCPY_S) = "fcpy,sgl"
218 :     | asm_funary (I.FCPY_D) = "fcpy,dbl"
219 :     | asm_funary (I.FCPY_Q) = "fcpy,quad"
220 :     | asm_funary (I.FABS_S) = "fabs,sgl"
221 :     | asm_funary (I.FABS_D) = "fabs,dbl"
222 :     | asm_funary (I.FABS_Q) = "fabs,quad"
223 :     | asm_funary (I.FSQRT_S) = "fsqrt,sgl"
224 :     | asm_funary (I.FSQRT_D) = "fsqrt,dbl"
225 :     | asm_funary (I.FSQRT_Q) = "fsqrt,quad"
226 :     | asm_funary (I.FRND_S) = "frnd,sgl"
227 :     | asm_funary (I.FRND_D) = "frnd,dbl"
228 :     | asm_funary (I.FRND_Q) = "frnd,quad"
229 :     and emit_funary x = (emit (asm_funary x))
230 :     and emit_operand (I.IMMED int) = (emit_int int)
231 :     | emit_operand (I.LabExp(labexp, field_selector)) = (emit_labexp labexp)
232 :     | emit_operand (I.HILabExp(labexp, field_selector)) = (emit_labexp labexp)
233 :     | emit_operand (I.LOLabExp(labexp, field_selector)) = (emit_labexp labexp)
234 :     | emit_operand (I.ConstOp const) = (emit_const const)
235 :     and asm_fstore (I.FSTDS) = "fstds"
236 :     | asm_fstore (I.FSTWS) = "fstws"
237 :     and emit_fstore x = (emit (asm_fstore x))
238 : monnier 245
239 : monnier 411 fun emit_n false = ()
240 :     | emit_n true = (emit ",n")
241 : monnier 245
242 : monnier 411 fun emit_nop false = ()
243 :     | emit_nop true = (emit "\n\tnop")
244 : monnier 245
245 : monnier 411 fun emitInstr instr =
246 :     ((tab ());
247 :    
248 :     (
249 :     case instr of
250 :     I.LOADI{li, r, i, t, mem} =>
251 :     ((emit_loadi li);
252 :     (emit "\t");
253 :     (emit_operand i);
254 :     (emit "(");
255 :     (emit_GP r);
256 :     (emit "), ");
257 :     (emit_GP t);
258 :     (emit_region mem))
259 :     | I.LOAD{l, r1, r2, t, mem} =>
260 :     ((emit_load l);
261 :     (emit "\t");
262 :     (emit_GP r2);
263 :     (emit "(");
264 :     (emit_GP r1);
265 :     (emit "), ");
266 :     (emit_GP t);
267 :     (emit_region mem))
268 :     | I.STORE{st, b, d, r, mem} =>
269 :     ((emit_store st);
270 :     (emit "\t");
271 :     (emit_GP r);
272 :     (emit ", ");
273 :     (emit_operand d);
274 :     (emit "(");
275 :     (emit_GP b);
276 :     (emit ")");
277 :     (emit_region mem))
278 :     | I.ARITH{a, r1, r2, t} =>
279 :     ((emit_arith a);
280 :     (emit "\t");
281 :     (emit_GP r1);
282 :     (emit ", ");
283 :     (emit_GP r2);
284 :     (emit ", ");
285 :     (emit_GP t))
286 :     | I.ARITHI{ai, i, r, t} =>
287 :     ((emit_arithi ai);
288 :     (emit "\t");
289 :     (emit_operand i);
290 :     (emit ", ");
291 :     (emit_GP r);
292 :     (emit ", ");
293 :     (emit_GP t))
294 :     | I.COMCLR_LDO{cc, r1, r2, t1, i, b, t2} =>
295 :     ((emit "comclr,");
296 :     (emit_bcond cc);
297 :     (emit "\t");
298 :     (emit_GP r1);
299 :     (emit ", ");
300 :     (emit_GP r2);
301 :     (emit ", ");
302 :     (emit_GP t1);
303 :     (emit "\n\tldo\t");
304 :     (emit_int i);
305 :     (emit "(");
306 :     (emit_GP b);
307 :     (emit "), ");
308 :     (emit_GP t2))
309 :     | I.SHIFTV{sv, r, len, t} =>
310 :     ((emit_shiftv sv);
311 :     (emit "\t");
312 :     (emit_GP r);
313 :     (emit ", ");
314 :     (emit_int len);
315 :     (emit ", ");
316 :     (emit_GP t))
317 :     | I.SHIFT{s, r, p, len, t} =>
318 :     ((emit_shift s);
319 :     (emit "\t");
320 :     (emit_GP r);
321 :     (emit ", ");
322 :     (emit_int p);
323 :     (emit ", ");
324 :     (emit_int len);
325 :     (emit ", ");
326 :     (emit_GP t))
327 :     | I.BCOND{cmp, bc, r1, r2, n, nop, t, f} =>
328 :     ((emit_cmp cmp);
329 :     (emit ",");
330 :     (emit_bcond bc);
331 :     (emit_n n);
332 :     (emit "\t");
333 :     (emit_GP r1);
334 :     (emit ", ");
335 :     (emit_GP r2);
336 :     (emit ", ");
337 :     (emit_label t);
338 :     (emit_nop nop))
339 :     | I.BCONDI{cmpi, bc, i, r2, n, nop, t, f} =>
340 :     ((emit_cmpi cmpi);
341 :     (emit ",");
342 :     (emit_bcond bc);
343 :     (emit_n n);
344 :     (emit "\t");
345 :     (emit_int i);
346 :     (emit ", ");
347 :     (emit_GP r2);
348 :     (emit ", ");
349 :     (emit_label t);
350 :     (emit_nop nop))
351 :     | I.BB{bc, r, p, n, nop, t, f} =>
352 :     ((emit "bb,");
353 :     (emit_bitcond bc);
354 :     (emit_n n);
355 :     (emit "\t");
356 :     (emit_GP r);
357 :     (emit ", ");
358 :     (emit_int p);
359 :     (emit ", ");
360 :     (emit_label t);
361 :     (emit_nop nop))
362 :     | I.B{lab, n} =>
363 :     ((emit "b");
364 :     (emit_n n);
365 :     (emit "\t");
366 :     (emit_label lab))
367 :     | I.BV{x, b, labs, n} =>
368 :     ((emit "bv");
369 :     (emit_n n);
370 :     (emit "\t");
371 :     (emit_GP x);
372 :     (emit "(");
373 :     (emit_GP b);
374 :     (emit ")"))
375 :     | I.BLR{x, t, labs, n} =>
376 :     ((emit "blr");
377 :     (emit_n n);
378 :     (emit "\t");
379 :     (emit_GP x);
380 :     (emit "(");
381 :     (emit_GP t);
382 :     (emit ")"))
383 :     | I.BL{x, t, defs, uses, n} =>
384 :     ((emit "bl");
385 :     (emit_n n);
386 :     (emit "\t");
387 :     (emit_operand x);
388 :     (emit "), ");
389 :     (emit_GP t))
390 :     | I.BLE{d, b, sr, t, defs, uses, mem} =>
391 :     ((emit "ble\t");
392 :     (emit_operand d);
393 :     (emit "(");
394 :     (emit_int sr);
395 :     (emit ",");
396 :     (emit_GP b);
397 :     (emit ")");
398 :     (emit_region mem))
399 :     | I.LDIL{i, t} =>
400 :     ((emit "ldil\t");
401 :     (emit_operand i);
402 :     (emit ", ");
403 :     (emit_GP t))
404 :     | I.LDO{i, b, t} =>
405 :     ((emit "ldo\t");
406 :     (emit_operand i);
407 :     (emit "(");
408 :     (emit_GP b);
409 :     (emit "), ");
410 :     (emit_GP t))
411 :     | I.MTCTL{r, t} =>
412 :     ((emit "mtctl\t");
413 :     (emit_GP r);
414 :     (emit ", ");
415 :     (emit_CR t))
416 : monnier 245 | I.FSTORE{fst, b, d, r, mem} =>
417 : monnier 411 ((emit_fstore fst);
418 :     (emit "\t");
419 :     (emit_int d);
420 :     (emit "(");
421 :     (emit_GP b);
422 :     (emit "), ");
423 :     (emit_FP r);
424 :     (emit_region mem))
425 : monnier 245 | I.FSTOREX{fstx, b, x, r, mem} =>
426 : monnier 411 ((emit_fstorex fstx);
427 :     (emit "\t");
428 :     (emit_GP x);
429 :     (emit "(");
430 :     (emit_GP b);
431 :     (emit "), ");
432 :     (emit_FP r);
433 :     (emit_region mem))
434 :     | I.FLOAD{fl, b, d, t, mem} =>
435 :     ((emit_fload fl);
436 :     (emit "\t");
437 :     (emit_int d);
438 :     (emit "(");
439 :     (emit_GP b);
440 :     (emit "), ");
441 :     (emit_FP t);
442 :     (emit_region mem))
443 :     | I.FLOADX{flx, b, x, t, mem} =>
444 :     ((emit_floadx flx);
445 :     (emit "\t");
446 :     (emit_GP x);
447 :     (emit "(");
448 :     (emit_GP b);
449 :     (emit "), ");
450 :     (emit_FP t);
451 :     (emit_region mem))
452 :     | I.FARITH{fa, r1, r2, t} =>
453 :     ((emit_farith fa);
454 :     (emit "\t");
455 :     (emit_FP r1);
456 :     (emit ", ");
457 :     (emit_FP r2);
458 :     (emit ", ");
459 :     (emit_FP t))
460 :     | I.FUNARY{fu, f, t} =>
461 :     ((emit_funary fu);
462 :     (emit "\t");
463 :     (emit_FP f);
464 :     (emit ", ");
465 :     (emit_FP t))
466 :     | I.FCNV{fcnv, f, t} =>
467 :     ((emit_fcnv fcnv);
468 :     (emit "\t");
469 :     (emit_FP f);
470 :     (emit ", ");
471 :     (emit_FP t))
472 :     | I.FBRANCH{cc, fmt, f1, f2, t, f, n, long} =>
473 :     ((emit "fcmp,");
474 :     (emit_fmt fmt);
475 :     (emit ",");
476 :     (emit_fcond cc);
477 :     (emit "\t");
478 :     (emit_FP f1);
479 :     (emit ", ");
480 :     (emit_FP f2);
481 :     (emit "\n\tftest\n\tb");
482 :     (emit_n n);
483 :     (emit "\t");
484 :     (emit_label t))
485 :     | I.BREAK{code1, code2} =>
486 :     ((emit "break\t");
487 :     (emit_int code1);
488 :     (emit ", ");
489 :     (emit_int code2))
490 :     | I.NOP => (emit "nop")
491 :     | I.COPY{dst, src, impl, tmp} => (emitInstrs (Shuffle.shuffle {regmap=regmap, tmp=tmp, src=src, dst=dst}))
492 :     | I.FCOPY{dst, src, impl, tmp} => (emitInstrs (Shuffle.shufflefp {regmap=regmap, tmp=tmp, src=src, dst=dst}))
493 :     | I.ANNOTATION{i, a} =>
494 :     ((emitInstr i);
495 :     (comment (Annotations.toString a)))
496 :     | I.GROUP annotation => (comment (Annotations.toString annotation))
497 :     );
498 :     (nl ()))
499 :     and emitInstrs [] = ()
500 :     | emitInstrs (i::is) =
501 :     (emitInstr i; app (fn i => (tab(); emitInstr i)) is)
502 :     in emitInstr end
503 :    
504 :     in S.STREAM{init=init,
505 :     pseudoOp=pseudoOp,
506 :     emit=emitter,
507 :     finish=doNothing,
508 :     defineLabel=defineLabel,
509 :     entryLabel=entryLabel,
510 :     comment=comment,
511 :     exitBlock=doNothing,
512 :     blockName=blockName,
513 :     annotation=annotation
514 :     }
515 :     end
516 : monnier 245 end
517 :    

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0