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/alpha/emit/alphaAsm.sml
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/MLRISC/alpha/emit/alphaAsm.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 469 - (view) (download)

1 : monnier 409 (*
2 :     * This file was automatically generated by MDGen
3 :     * from the machine description file "alpha/alpha.md".
4 :     *)
5 :    
6 :    
7 :     functor AlphaAsmEmitter(structure Instr : ALPHAINSTR
8 :     structure Stream : INSTRUCTION_STREAM
9 :     structure Shuffle : ALPHASHUFFLE
10 :     where I = Instr
11 :     ) : INSTRUCTION_EMITTER =
12 :     struct
13 :     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("AlphaAsm",msg)
21 :    
22 : monnier 429 fun makeStream formatAnnotations =
23 : monnier 409 let val stream = !AsmStream.asmOutStream
24 : monnier 429 fun emit' s = TextIO.output(stream,s)
25 :     val newline = ref true
26 :     val tabs = ref 0
27 :     fun tabbing 0 = ()
28 :     | tabbing n = (emit' "\t"; tabbing(n-1))
29 :     fun emit s = (tabbing(!tabs); tabs := 0; newline := false; emit' s)
30 :     fun nl() = (tabs := 0; if !newline then () else (newline := true; emit' "\n"))
31 : monnier 409 fun comma() = emit ","
32 : monnier 429 fun tab() = tabs := !tabs + 1
33 :     fun ms n = let val s = Int.toString n
34 :     in if n<0 then "-"^String.substring(s,1,size s-1)
35 :     else s
36 :     end
37 : monnier 409 fun emit_label lab = emit(Label.nameOf lab)
38 :     fun emit_labexp le = emit(LabelExp.toString le)
39 :     fun emit_const c = emit(Constant.toString c)
40 :     fun emit_int i = emit(ms i)
41 :     fun paren f = (emit "("; f(); emit ")")
42 :     fun defineLabel lab = emit(Label.nameOf lab^":\n")
43 :     fun entryLabel lab = defineLabel lab
44 :     fun comment msg = emit("\t/* " ^ msg ^ " */")
45 :     fun annotation a = (comment(Annotations.toString a); nl())
46 :     fun emit_region mem = comment(I.Region.toString mem)
47 :     fun pseudoOp pOp = emit(P.toString pOp)
48 :     fun init size = (comment("Code Size = " ^ ms size); nl())
49 :     fun doNothing _ = ()
50 : monnier 429 val emitRegInfo = AsmFormatUtil.reginfo(emit,formatAnnotations)
51 : monnier 409 fun emitter regmap =
52 :     let
53 :    
54 : monnier 429 fun emit_CC r =
55 :     ((emit (C.showCC (regmap r)));
56 :     (emitRegInfo r))
57 :     and emit_FP r =
58 :     ((emit (C.showFP (regmap r)));
59 :     (emitRegInfo r))
60 :     and emit_GP r =
61 :     ((emit (C.showGP (regmap r)));
62 :     (emitRegInfo r))
63 : monnier 409
64 : monnier 429 fun asm_pseudo_op (I.DIVL) = "divl"
65 :     | asm_pseudo_op (I.DIVLU) = "divlu"
66 :     | asm_pseudo_op (I.DIVQ) = "divq"
67 :     | asm_pseudo_op (I.DIVQU) = "divqu"
68 :     | asm_pseudo_op (I.REML) = "reml"
69 :     | asm_pseudo_op (I.REMLU) = "remlu"
70 :     | asm_pseudo_op (I.REMQ) = "remq"
71 :     | asm_pseudo_op (I.REMQU) = "remqu"
72 :     and emit_pseudo_op x = (emit (asm_pseudo_op x))
73 :     and asm_store (I.STL) = "stl"
74 :     | asm_store (I.STQ) = "stq"
75 :     | asm_store (I.STQ_U) = "stq_u"
76 :     and emit_store x = (emit (asm_store x))
77 :     and asm_osf_user_palcode (I.BPT) = "bpt"
78 : monnier 409 | asm_osf_user_palcode (I.BUGCHK) = "bugchk"
79 :     | asm_osf_user_palcode (I.CALLSYS) = "callsys"
80 :     | asm_osf_user_palcode (I.GENTRAP) = "gentrap"
81 :     | asm_osf_user_palcode (I.IMB) = "imb"
82 :     | asm_osf_user_palcode (I.RDUNIQUE) = "rdunique"
83 :     | asm_osf_user_palcode (I.WRUNIQUE) = "wrunique"
84 :     and emit_osf_user_palcode x = (emit (asm_osf_user_palcode x))
85 : monnier 429 and asm_foperateV (I.ADDSSUD) = "addssud"
86 :     | asm_foperateV (I.ADDSSU) = "addssu"
87 :     | asm_foperateV (I.ADDTSUD) = "addtsud"
88 :     | asm_foperateV (I.ADDTSU) = "addtsu"
89 :     | asm_foperateV (I.DIVSSUD) = "divssud"
90 :     | asm_foperateV (I.DIVSSU) = "divssu"
91 :     | asm_foperateV (I.DIVTSUD) = "divtsud"
92 :     | asm_foperateV (I.DIVTSU) = "divtsu"
93 :     | asm_foperateV (I.MULSSUD) = "mulssud"
94 :     | asm_foperateV (I.MULSSU) = "mulssu"
95 :     | asm_foperateV (I.MULTSUD) = "multsud"
96 :     | asm_foperateV (I.MULTSU) = "multsu"
97 :     | asm_foperateV (I.SUBSSUD) = "subssud"
98 :     | asm_foperateV (I.SUBSSU) = "subssu"
99 :     | asm_foperateV (I.SUBTSUD) = "subtsud"
100 :     | asm_foperateV (I.SUBTSU) = "subtsu"
101 :     and emit_foperateV x = (emit (asm_foperateV x))
102 :     and emit_operand (I.REGop GP) = (emit_GP GP)
103 :     | emit_operand (I.IMMop int) = (emit_int int)
104 :     | emit_operand (I.HILABop labexp) =
105 :     ((emit "hi(");
106 :     (emit_labexp labexp);
107 :     (emit ")"))
108 :     | emit_operand (I.LOLABop labexp) =
109 :     ((emit "lo(");
110 :     (emit_labexp labexp);
111 :     (emit ")"))
112 :     | emit_operand (I.LABop labexp) = (emit_labexp labexp)
113 :     | emit_operand (I.CONSTop const) = (emit_const const)
114 :     and asm_fload (I.LDF) = "ldf"
115 :     | asm_fload (I.LDG) = "ldg"
116 :     | asm_fload (I.LDS) = "lds"
117 :     | asm_fload (I.LDT) = "ldt"
118 :     and emit_fload x = (emit (asm_fload x))
119 : monnier 409 and asm_foperate (I.CPYS) = "cpys"
120 :     | asm_foperate (I.CPYSE) = "cpyse"
121 :     | asm_foperate (I.CPYSN) = "cpysn"
122 :     | asm_foperate (I.MF_FPCR) = "mf_fpcr"
123 :     | asm_foperate (I.MT_FPCR) = "mt_fpcr"
124 :     | asm_foperate (I.CMPTEQ) = "cmpteq"
125 :     | asm_foperate (I.CMPTLT) = "cmptlt"
126 :     | asm_foperate (I.CMPTLE) = "cmptle"
127 :     | asm_foperate (I.CMPTUN) = "cmptun"
128 :     | asm_foperate (I.CMPTEQSU) = "cmpteqsu"
129 :     | asm_foperate (I.CMPTLTSU) = "cmptltsu"
130 :     | asm_foperate (I.CMPTLESU) = "cmptlesu"
131 :     | asm_foperate (I.CMPTUNSU) = "cmptunsu"
132 :     and emit_foperate x = (emit (asm_foperate x))
133 : monnier 429 and asm_funary (I.CVTLQ) = "cvtlq"
134 :     | asm_funary (I.CVTQL) = "cvtql"
135 :     | asm_funary (I.CVTQLSV) = "cvtqlsv"
136 :     | asm_funary (I.CVTQLV) = "cvtqlv"
137 :     | asm_funary (I.CVTQS) = "cvtqs"
138 :     | asm_funary (I.CVTQSC) = "cvtqsc"
139 :     | asm_funary (I.CVTQT) = "cvtqt"
140 :     | asm_funary (I.CVTQTC) = "cvtqtc"
141 :     | asm_funary (I.CVTTS) = "cvtts"
142 :     | asm_funary (I.CVTTSC) = "cvttsc"
143 :     | asm_funary (I.CVTST) = "cvtst"
144 :     | asm_funary (I.CVTSTS) = "cvtsts"
145 :     | asm_funary (I.CVTTQ) = "cvttq"
146 :     | asm_funary (I.CVTTQC) = "cvttqc"
147 :     and emit_funary x = (emit (asm_funary x))
148 :     and asm_fstore (I.STF) = "stf"
149 :     | asm_fstore (I.STG) = "stg"
150 :     | asm_fstore (I.STS) = "sts"
151 :     | asm_fstore (I.STT) = "stt"
152 :     and emit_fstore x = (emit (asm_fstore x))
153 :     and asm_branch (I.BR) = "br"
154 :     | asm_branch (I.BSR) = "bsr"
155 :     | asm_branch (I.BLBC) = "blbc"
156 :     | asm_branch (I.BEQ) = "beq"
157 :     | asm_branch (I.BLT) = "blt"
158 :     | asm_branch (I.BLE) = "ble"
159 :     | asm_branch (I.BLBS) = "blbs"
160 :     | asm_branch (I.BNE) = "bne"
161 :     | asm_branch (I.BGE) = "bge"
162 :     | asm_branch (I.BGT) = "bgt"
163 :     and emit_branch x = (emit (asm_branch x))
164 : monnier 409 and asm_cmove (I.CMOVEQ) = "cmoveq"
165 :     | asm_cmove (I.CMOVLBC) = "cmovlbc"
166 :     | asm_cmove (I.CMOVLBS) = "cmovlbs"
167 :     | asm_cmove (I.CMOVGE) = "cmovge"
168 :     | asm_cmove (I.CMOVGT) = "cmovgt"
169 :     | asm_cmove (I.CMOVLE) = "cmovle"
170 :     | asm_cmove (I.CMOVLT) = "cmovlt"
171 :     | asm_cmove (I.CMOVNE) = "cmovne"
172 :     and emit_cmove x = (emit (asm_cmove x))
173 :     and asm_operateV (I.ADDLV) = "addlv"
174 :     | asm_operateV (I.ADDQV) = "addqv"
175 :     | asm_operateV (I.SUBLV) = "sublv"
176 :     | asm_operateV (I.SUBQV) = "subqv"
177 :     | asm_operateV (I.MULLV) = "mullv"
178 :     | asm_operateV (I.MULQV) = "mulqv"
179 :     and emit_operateV x = (emit (asm_operateV x))
180 : monnier 429 and asm_fbranch (I.FBEQ) = "fbeq"
181 :     | asm_fbranch (I.FBLT) = "fblt"
182 :     | asm_fbranch (I.FBLE) = "fble"
183 :     | asm_fbranch (I.FBNE) = "fbne"
184 :     | asm_fbranch (I.FBGE) = "fbge"
185 :     | asm_fbranch (I.FBGT) = "fbgt"
186 :     and emit_fbranch x = (emit (asm_fbranch x))
187 :     and asm_load (I.LDL) = "ldl"
188 :     | asm_load (I.LDL_L) = "ldl_l"
189 :     | asm_load (I.LDQ) = "ldq"
190 :     | asm_load (I.LDQ_L) = "ldq_l"
191 :     | asm_load (I.LDQ_U) = "ldq_u"
192 :     and emit_load x = (emit (asm_load x))
193 : monnier 409 and asm_operate (I.ADDL) = "addl"
194 :     | asm_operate (I.ADDQ) = "addq"
195 :     | asm_operate (I.CMPBGE) = "cmpbge"
196 :     | asm_operate (I.CMPEQ) = "cmpeq"
197 :     | asm_operate (I.CMPLE) = "cmple"
198 :     | asm_operate (I.CMPLT) = "cmplt"
199 :     | asm_operate (I.CMPULE) = "cmpule"
200 :     | asm_operate (I.CMPULT) = "cmpult"
201 :     | asm_operate (I.SUBL) = "subl"
202 :     | asm_operate (I.SUBQ) = "subq"
203 :     | asm_operate (I.S4ADDL) = "s4addl"
204 :     | asm_operate (I.S4ADDQ) = "s4addq"
205 :     | asm_operate (I.S4SUBL) = "s4subl"
206 :     | asm_operate (I.S4SUBQ) = "s4subq"
207 :     | asm_operate (I.S8ADDL) = "s8addl"
208 :     | asm_operate (I.S8ADDQ) = "s8addq"
209 :     | asm_operate (I.S8SUBL) = "s8subl"
210 :     | asm_operate (I.S8SUBQ) = "s8subq"
211 :     | asm_operate (I.AND) = "and"
212 :     | asm_operate (I.BIC) = "bic"
213 :     | asm_operate (I.BIS) = "bis"
214 :     | asm_operate (I.EQV) = "eqv"
215 :     | asm_operate (I.ORNOT) = "ornot"
216 :     | asm_operate (I.XOR) = "xor"
217 :     | asm_operate (I.EXTBL) = "extbl"
218 :     | asm_operate (I.EXTLH) = "extlh"
219 :     | asm_operate (I.EXTLL) = "extll"
220 :     | asm_operate (I.EXTQH) = "extqh"
221 :     | asm_operate (I.EXTQL) = "extql"
222 :     | asm_operate (I.EXTWH) = "extwh"
223 :     | asm_operate (I.EXTWL) = "extwl"
224 :     | asm_operate (I.INSBL) = "insbl"
225 :     | asm_operate (I.INSLH) = "inslh"
226 :     | asm_operate (I.INSLL) = "insll"
227 :     | asm_operate (I.INSQH) = "insqh"
228 :     | asm_operate (I.INSQL) = "insql"
229 :     | asm_operate (I.INSWH) = "inswh"
230 :     | asm_operate (I.INSWL) = "inswl"
231 :     | asm_operate (I.MSKBL) = "mskbl"
232 :     | asm_operate (I.MSKLH) = "msklh"
233 :     | asm_operate (I.MSKLL) = "mskll"
234 :     | asm_operate (I.MSKQH) = "mskqh"
235 :     | asm_operate (I.MSKQL) = "mskql"
236 :     | asm_operate (I.MSKWH) = "mskwh"
237 :     | asm_operate (I.MSKWL) = "mskwl"
238 :     | asm_operate (I.SLL) = "sll"
239 :     | asm_operate (I.SRA) = "sra"
240 :     | asm_operate (I.SRL) = "srl"
241 :     | asm_operate (I.ZAP) = "zap"
242 :     | asm_operate (I.ZAPNOT) = "zapnot"
243 :     | asm_operate (I.MULL) = "mull"
244 :     | asm_operate (I.MULQ) = "mulq"
245 :     | asm_operate (I.UMULH) = "umulh"
246 :     | asm_operate (I.SGNXL) = "addl"
247 :     and emit_operate x = (emit (asm_operate x))
248 : monnier 429 and asm_fcmove (I.FCMOVEQ) = "fcmoveq"
249 :     | asm_fcmove (I.FCMOVEGE) = "fcmovege"
250 :     | asm_fcmove (I.FCMOVEGT) = "fcmovegt"
251 :     | asm_fcmove (I.FCMOVLE) = "fcmovle"
252 :     | asm_fcmove (I.FCMOVELT) = "fcmovelt"
253 :     | asm_fcmove (I.FCMOVENE) = "fcmovene"
254 :     and emit_fcmove x = (emit (asm_fcmove x))
255 : monnier 409
256 : monnier 469 fun isZero (I.CONSTop c) = ((Constant.valueOf c) = 0)
257 :     | isZero _ = false
258 :    
259 : monnier 409 fun emitInstr instr =
260 :     ((tab ());
261 :    
262 :     (
263 :     case instr of
264 :     I.DEFFREG FP =>
265 :     ((emit "/* deffreg\t");
266 :     (emit_FP FP);
267 :     (emit " */"))
268 : monnier 469 | I.LDA{r, b, d} => (if (isZero d)andalso (r = b)
269 : monnier 409 then ()
270 :     else
271 : monnier 469 ((emit "lda\t");
272 :     (emit_GP r);
273 :     (emit ", ");
274 :     (emit_operand d);
275 :     (if (b = 31)
276 :     then ()
277 :     else
278 :     ((emit "(");
279 :     (emit_GP b);
280 :     (emit ")")))))
281 : monnier 409 | I.LDAH{r, b, d} =>
282 :     ((emit "ldah\t");
283 :     (emit_GP r);
284 :     (emit ", ");
285 :     (emit_operand d);
286 :     (if (b = 31)
287 :     then ()
288 :     else
289 :     ((emit "(");
290 :     (emit_GP b);
291 :     (emit ")"))))
292 :     | I.LOAD{ldOp, r, b, d, mem} =>
293 :     ((emit_load ldOp);
294 :     (emit "\t");
295 :     (emit_GP r);
296 :     (emit ", ");
297 :     (emit_operand d);
298 :     (emit "(");
299 :     (emit_GP b);
300 :     (emit ")");
301 :     (emit_region mem))
302 :     | I.STORE{stOp, r, b, d, mem} =>
303 :     ((emit_store stOp);
304 :     (emit "\t");
305 :     (emit_GP r);
306 :     (emit ", ");
307 :     (emit_operand d);
308 :     (emit "(");
309 :     (emit_GP b);
310 :     (emit ")");
311 :     (emit_region mem))
312 :     | I.FLOAD{ldOp, r, b, d, mem} =>
313 :     ((emit_fload ldOp);
314 :     (emit "\t");
315 :     (emit_FP r);
316 :     (emit ", ");
317 :     (emit_operand d);
318 :     (emit "(");
319 :     (emit_GP b);
320 :     (emit ")");
321 :     (emit_region mem))
322 :     | I.FSTORE{stOp, r, b, d, mem} =>
323 :     ((emit_fstore stOp);
324 :     (emit "\t");
325 :     (emit_FP r);
326 :     (emit ", ");
327 :     (emit_operand d);
328 :     (emit "(");
329 :     (emit_GP b);
330 :     (emit ")");
331 :     (emit_region mem))
332 :     | I.JMPL({r, b, d}, label) =>
333 :     ((emit "jmp\t");
334 :     (emit_GP r);
335 :     (emit ", (");
336 :     (emit_GP b);
337 :     (emit ")"))
338 :     | I.JSR({r, b, d}, cellset1, cellset2, region) =>
339 :     ((emit "jsr\t");
340 :     (emit_GP r);
341 :     (emit ", (");
342 :     (emit_GP b);
343 :     (emit ")");
344 :     (emit_region region))
345 :     | I.RET{r, b, d} =>
346 :     ((emit "ret\t");
347 :     (emit_GP r);
348 :     (emit ", (");
349 :     (emit_GP b);
350 :     (emit ")"))
351 :     | I.BRANCH(branch, GP, label) =>
352 :     ((emit_branch branch);
353 :     (emit "\t");
354 :     (emit_GP GP);
355 :     (emit ", ");
356 :     (emit_label label))
357 :     | I.FBRANCH(fbranch, FP, label) =>
358 :     ((emit_fbranch fbranch);
359 :     (emit "\t");
360 :     (emit_FP FP);
361 :     (emit ", ");
362 :     (emit_label label))
363 :     | I.OPERATE{oper, ra, rb, rc} => let
364 :    
365 : monnier 469 (*#line 313.1 "alpha/alpha.md"*)
366 : monnier 409
367 :     fun f (oper, ra, rb, rc) =
368 :     ((emit oper);
369 :     (tab ());
370 :     (emit_GP ra);
371 :     (emit ", ");
372 :     (emit_operand rb);
373 :     (emit ", ");
374 :     (emit_GP rc))
375 :     in
376 :     (
377 :     case (oper, ra, rb, rc) of
378 :     (I.BIS, 27, I.REGop 31, 29) => (emit "ldgp\t$29, 0($27)")
379 : monnier 429 | (I.BIS, 26, I.REGop 31, 29) => (emit "ldgp\t$29, 0($26)")
380 : monnier 409 | (I.ADDL, 30, I.CONSTop b, 30) => (if ((Constant.valueOf b) = 0)
381 :     then ()
382 :     else (f ("addl", ra, rb, rc)))
383 :     | (I.ADDQ, 30, I.CONSTop b, 30) => (if ((Constant.valueOf b) = 0)
384 :     then ()
385 :     else (f ("addq", ra, rb, rc)))
386 :     | (I.SUBL, 30, I.CONSTop b, 30) => (if ((Constant.valueOf b) = 0)
387 :     then ()
388 :     else (f ("subl", ra, rb, rc)))
389 :     | (I.SUBQ, 30, I.CONSTop b, 30) => (if ((Constant.valueOf b) = 0)
390 :     then ()
391 :     else (f ("subq", ra, rb, rc)))
392 :     | _ => (f ((asm_operate oper), ra, rb, rc))
393 :     )
394 :     end
395 :    
396 :     | I.OPERATEV{oper, ra, rb, rc} =>
397 :     ((emit_operateV oper);
398 :     (emit "\t");
399 :     (emit_GP ra);
400 :     (emit ", ");
401 :     (emit_operand rb);
402 :     (emit ", ");
403 :     (emit_GP rc))
404 :     | I.CMOVE{oper, ra, rb, rc} =>
405 :     ((emit_cmove oper);
406 :     (emit "\t");
407 :     (emit_GP ra);
408 :     (emit ", ");
409 :     (emit_operand rb);
410 :     (emit ", ");
411 :     (emit_GP rc))
412 :     | I.PSEUDOARITH{oper, ra, rb, rc, tmps} =>
413 :     ((emit_pseudo_op oper);
414 :     (emit "\t");
415 :     (emit_GP ra);
416 :     (emit ", ");
417 :     (emit_operand rb);
418 :     (emit ", ");
419 :     (emit_GP rc))
420 :     | I.COPY{dst, src, impl, tmp} => (emitInstrs (Shuffle.shuffle {regmap=regmap, tmp=tmp, dst=dst, src=src}))
421 :     | I.FCOPY{dst, src, impl, tmp} => (emitInstrs (Shuffle.shufflefp {regmap=regmap, tmp=tmp, dst=dst, src=src}))
422 :     | I.FUNARY{oper, fb, fc} =>
423 :     ((emit_funary oper);
424 :     (emit "\t");
425 :     (emit_FP fb);
426 :     (emit ", ");
427 :     (emit_FP fc))
428 :     | I.FOPERATE{oper, fa, fb, fc} =>
429 :     ((emit_foperate oper);
430 :     (emit "\t");
431 :     (emit_FP fa);
432 :     (emit ", ");
433 :     (emit_FP fb);
434 :     (emit ", ");
435 :     (emit_FP fc))
436 :     | I.FOPERATEV{oper, fa, fb, fc} =>
437 :     ((emit_foperateV oper);
438 :     (emit "\t");
439 :     (emit_FP fa);
440 :     (emit ", ");
441 :     (emit_FP fb);
442 :     (emit ", ");
443 :     (emit_FP fc))
444 :     | I.FCMOVE{oper, fa, fb, fc} =>
445 :     ((emit_fcmove oper);
446 :     (emit "\t");
447 :     (emit_FP fa);
448 :     (emit ", ");
449 :     (emit_FP fb);
450 :     (emit ", ");
451 :     (emit_FP fc))
452 :     | I.TRAPB => (emit "trapb")
453 :     | I.CALL_PAL{code, def, use} =>
454 :     ((emit "call_pal ");
455 :     (emit_osf_user_palcode code))
456 :     | I.ANNOTATION{i, a} =>
457 :     ((emitInstr i);
458 :     (comment (Annotations.toString a)))
459 :     | I.GROUP annotation => (comment (Annotations.toString annotation))
460 :     );
461 :     (nl ()))
462 :     and emitInstrs [] = ()
463 :     | emitInstrs (i::is) =
464 :     (emitInstr i; app (fn i => (tab(); emitInstr i)) is)
465 :     in emitInstr end
466 :    
467 : monnier 429 in S.STREAM{beginCluster=init,
468 : monnier 409 pseudoOp=pseudoOp,
469 :     emit=emitter,
470 : monnier 429 endCluster=doNothing,
471 : monnier 409 defineLabel=defineLabel,
472 :     entryLabel=entryLabel,
473 :     comment=comment,
474 :     exitBlock=doNothing,
475 : monnier 429 annotation=annotation,
476 :     phi=doNothing,
477 :     alias=doNothing
478 : monnier 409 }
479 :     end
480 :     end
481 :    

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