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 /MLRISC/trunk/amd64/staged-allocation/test.sml
ViewVC logotype

Annotation of /MLRISC/trunk/amd64/staged-allocation/test.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3009 - (view) (download)

1 : mrainey 3009 (*
2 :     * Client defined extensions. None for now.
3 :     * You'll need this only if you need to extend the set of MLTREE operators
4 :     *)
5 :     structure UserExtension =
6 :     struct
7 :    
8 :     type ('s,'r,'f,'c) sx = ('s,'r,'f,'c) AMD64InstrExt.sext
9 :     type ('s,'r,'f,'c) rx = unit
10 :     type ('s,'r,'f,'c) fx = unit
11 :     type ('s,'r,'f,'c) ccx = unit
12 :    
13 :     end
14 :    
15 :     (*
16 :     * This module controls how we handle user extensions. Since we don't
17 :     * have any yet. This is just a bunch of dummy routines.
18 :     *)
19 :     functor UserMLTreeExtComp
20 :     ( structure I : AMD64INSTR where T.Extension = UserExtension
21 :     structure TS : MLTREE_STREAM where T = I.T
22 :     structure CFG : CONTROL_FLOW_GRAPH where I = I and P = TS.S.P
23 :     ) : MLTREE_EXTENSION_COMP =
24 :     struct
25 :     structure T = TS.T
26 :     structure TS = TS
27 :     structure I = I
28 :     structure CFG = CFG
29 :     structure C = I.C
30 :    
31 :     structure CompInstrExt = AMD64CompInstrExt (
32 :     structure I = I
33 :     structure TS = TS
34 :     structure CFG = CFG)
35 :    
36 :     type reducer =
37 :     (I.instruction,C.cellset,I.operand,I.addressing_mode,CFG.cfg) TS.reducer
38 :    
39 :     val compileSext = CompInstrExt.compileSext
40 :    
41 :     fun compileRext _ = raise Fail "AMD64CompExtFn.compileRext"
42 :     fun compileFext _ = raise Fail "AMD64CompExtFn.compileFext"
43 :     fun compileCCext _ = raise Fail "AMD64CompExtFn.compileCCext"
44 :    
45 :     end
46 :    
47 : mrainey 2990 val floats16ByteAligned = true
48 :    
49 :     structure AMD64MLTree =
50 :     MLTreeF (structure Constant = UserConst
51 :     structure Region = UserRegion
52 :     structure Extension = UserExtension)
53 :    
54 :     structure AMD64MLTreeEval =
55 :     MLTreeEval (structure T = AMD64MLTree
56 :     fun eq _ _ = false
57 :     val eqRext = eq val eqFext = eq
58 :     val eqCCext = eq val eqSext = eq)
59 :    
60 :     (*
61 :     structure AMD64PseudoOps =
62 :     struct
63 :     structure Client =
64 :     struct
65 :     datatype pseudo_op_ext = COMM of (Label.label * int)
66 :     structure AsmPseudoOps = AMD64GasPseudoOps (
67 :     structure T = AMD64MLTree
68 :     structure MLTreeEval = AMD64MLTreeEval)
69 :     type pseudo_op = pseudo_op_ext
70 :     fun toString (COMM(lab, sz)) = concat[
71 :     "\t.comm\t"(*, P.lexpToString(P.T.LABEL lab)*),
72 :     ",", Int.toString sz]
73 :     fun emitValue {pOp, loc, emit} = raise Fail "emitValue"
74 :     fun sizeOf _ = 0
75 :     fun adjustLabels _ = false
76 :     end (* Client *)
77 :    
78 :     structure T = AMD64MLTree
79 :     type pseudo_op = (T.labexp, Client.pseudo_op) PseudoOpsBasisTyp.pseudo_op
80 :     fun toString _ = ""
81 :     fun emitValue _ = ()
82 :     fun sizeOf _ = 0
83 :     fun adjustLabels _ = false
84 :     end (* AMD64PseudoOps *)
85 :     *)
86 :    
87 : mrainey 3000
88 : mrainey 2990 functor AMD64PseudoOpsFn (
89 :     structure T : MLTREE
90 :     structure MLTreeEval : MLTREE_EVAL where T = T
91 : mrainey 2993 ) : PSEUDO_OPS_BASIS = AMD64GasPseudoOps (
92 :     structure T = T
93 :     structure MLTreeEval = MLTreeEval)
94 :    
95 : mrainey 3000 (*
96 : mrainey 2993 functor AMD64PseudoOpsFn (
97 :     structure T : MLTREE
98 :     structure MLTreeEval : MLTREE_EVAL where T = T
99 : mrainey 2990 ) : PSEUDO_OPS_BASIS = AMD64DarwinPseudoOps (
100 :     structure T = T
101 :     structure MLTreeEval = MLTreeEval)
102 : mrainey 3000 *)
103 : mrainey 2990
104 :     structure AMD64PseudoOps = AMD64PseudoOpsFn(
105 :     structure T = AMD64MLTree
106 :     structure MLTreeEval = AMD64MLTreeEval)
107 :    
108 :     structure PseudoOps =
109 :     struct
110 :    
111 :     structure Client =
112 :     struct
113 :     structure AsmPseudoOps = AMD64PseudoOps
114 :     type pseudo_op = unit
115 :    
116 :     fun toString () = ""
117 :    
118 :     fun emitValue _ = raise Fail "todo"
119 :     fun sizeOf _ = raise Fail "todo"
120 :     fun adjustLabels _ = raise Fail "todo"
121 :     end (* Client *)
122 :    
123 :     structure PseudoOps = PseudoOps (structure Client = Client)
124 :     end
125 :    
126 :     structure AMD64Stream = InstructionStream(PseudoOps.PseudoOps)
127 :     structure AMD64Instr = AMD64Instr (AMD64MLTree)
128 :     structure AMD64Shuffle = AMD64Shuffle(AMD64Instr)
129 :    
130 :     structure AMD64MLTreeHash =
131 :     MLTreeHash (structure T = AMD64MLTree
132 :     fun h _ _ = 0w0
133 :     val hashRext = h val hashFext = h
134 :     val hashCCext = h val hashSext = h)
135 :    
136 :     structure AMD64Asm = AMD64AsmEmitter
137 :     (structure Instr = AMD64Instr
138 :     structure S = AMD64Stream
139 :     structure MLTreeEval = AMD64MLTreeEval
140 :     structure Shuffle = AMD64Shuffle
141 :     )
142 :    
143 :     structure AMD64InsnProps = AMD64Props
144 :     (structure Instr = AMD64Instr
145 :     structure MLTreeHash = AMD64MLTreeHash
146 :     structure MLTreeEval = AMD64MLTreeEval)
147 :    
148 :     structure AMD64CFG = ControlFlowGraph (
149 :     structure I = AMD64Asm.I
150 :     structure GraphImpl = DirectedGraph
151 :     structure InsnProps = AMD64InsnProps
152 :     structure Asm = AMD64Asm)
153 :    
154 :     (*structure AMD64Stream = InstructionStream(AMD64PseudoOps)*)
155 :     structure AMD64MLTStream = MLTreeStream (
156 :     structure T = AMD64MLTree
157 :     structure S = AMD64Stream)
158 :    
159 :     structure CompInstrExt = AMD64CompInstrExt (
160 :     structure I = AMD64Instr
161 :     structure TS = AMD64MLTStream
162 :     structure CFG = AMD64CFG)
163 :    
164 :     structure AMD64MTC = struct
165 :     structure T = AMD64MLTree
166 :     structure TS = AMD64MLTStream
167 :     structure I = AMD64Instr
168 :     structure CFG = AMD64CFG
169 :     structure C = I.C
170 :     type reducer =
171 :     (I.instruction,C.cellset,I.operand,I.addressing_mode,AMD64CFG.cfg) TS.reducer
172 :     fun unimplemented _ = MLRiscErrorMsg.impossible "UserMLTreeExtComp"
173 :     val compileSext = CompInstrExt.compileSext
174 :     val compileRext = unimplemented
175 :     val compileFext = unimplemented
176 :     val compileCCext = unimplemented
177 :    
178 :     structure AMD64MLTreeUtils : MLTREE_UTILS =
179 :     struct
180 :     structure T = AMD64MLTree
181 :     structure IX = AMD64InstrExt
182 :     structure U = MLTreeUtils (
183 :     structure T = T
184 :     fun hashSext _ _ = 0w0
185 :     fun hashRext _ _ = 0w0
186 :     fun hashFext _ _ = 0w0
187 :     fun hashCCext _ _ = 0w0
188 :     fun eqSext _ _ = raise Fail "eqSext"
189 :     fun eqRext _ _ = raise Fail "eqRext"
190 :     fun eqFext _ _ = raise Fail "eqFext"
191 :     fun eqCCext _ _ = raise Fail "eqCCext"
192 :     fun showSext (prt : T.printer) ext = raise Fail "todo"
193 :     fun showRext _ _ = raise Fail "showRext"
194 :     fun showFext _ _ = raise Fail "showFext"
195 :     fun showCCext _ _ = raise Fail "showCCext")
196 :     open U
197 :     end
198 :     end
199 :    
200 :     structure AMD64 = AMD64Gen (
201 :     structure I = AMD64Instr
202 :     structure MLTreeUtils = AMD64MTC.AMD64MLTreeUtils
203 :     structure ExtensionComp = AMD64MTC
204 :     val floats16ByteAligned = floats16ByteAligned
205 :     fun signBit _ = raise Fail "todo"
206 :     fun negateSignBit _ = raise Fail "todo"
207 :     )
208 :    
209 :     structure AMD64Emit = CFGEmit (
210 :     structure CFG = AMD64CFG
211 :     structure E = AMD64Asm)
212 :    
213 :    
214 :     structure AMD64FlowGraph = BuildFlowgraph
215 :     (structure Props = AMD64InsnProps
216 :     structure Stream = AMD64Stream
217 :     structure CFG = AMD64CFG)
218 :    
219 :     structure AMD64Expand = CFGExpandCopies (structure CFG=AMD64CFG
220 :     structure Shuffle = AMD64Shuffle)
221 :     structure AMD64BlockPlacement = DefaultBlockPlacement(AMD64CFG)
222 :    
223 :     structure RASpill = RASpillWithRenaming (
224 :     structure Asm = AMD64Asm
225 :     structure InsnProps = AMD64InsnProps
226 :     val max_dist = ref 4
227 :     val keep_multiple_values = ref false)
228 :    
229 :     structure C = AMD64Cells
230 :    
231 :     datatype spill_operand_kind = SPILL_LOC
232 :     | CONST_VAL
233 :    
234 :     datatype ra_phase = SPILL_PROPAGATION
235 :     | SPILL_COLORING
236 :    
237 :     structure IntRA =
238 :     struct
239 :     val dedicated = [C.rsp, C.rbp]
240 :     val allRegs = C.Regs CellsBasis.GP {from=0, to=15, step=1}
241 :     val allRegsSet = foldl C.addReg C.empty allRegs
242 :     val avail = let
243 :     val availSet = foldl C.rmvReg allRegsSet dedicated
244 :     in
245 :     C.getReg availSet
246 :     end
247 :     fun spillInit _ = ()
248 :     fun spillLoc {info=frame, an, cell, id=loc} =
249 : mrainey 2995 raise Fail ""
250 :     (* {opnd = AMD64Instr.Immed 0, kind = SPILL_LOC}*)
251 : mrainey 2990 val phases = [SPILL_PROPAGATION, SPILL_COLORING]
252 :     end (* IntRA *)
253 :    
254 :     structure FloatRA =
255 :     struct
256 :     val avail = C.Regs CellsBasis.FP {from=0, to=15, step=1}
257 :     val dedicated = []
258 :     fun spillInit _ = ()
259 : mrainey 2995 fun spillLoc (info, ans, id) = raise Fail ""
260 : mrainey 2990 val phases = [SPILL_PROPAGATION, SPILL_COLORING]
261 :     end (* FloatRA *)
262 :    
263 :     (* register allocation *)
264 :     structure AMD64RA = AMD64RegAlloc (
265 :     structure I = AMD64Instr
266 :     structure CFG = AMD64CFG
267 :     structure Asm = AMD64Asm
268 :     structure SpillHeur = ChowHennessySpillHeur
269 :     structure Spill = RASpill
270 :     structure Props = AMD64InsnProps
271 :     val floats16ByteAligned = floats16ByteAligned
272 :     type spill_info = unit
273 :     fun beforeRA (Graph.GRAPH graph) = ()
274 :     datatype spill_operand_kind = datatype spill_operand_kind
275 :     datatype ra_phase = datatype ra_phase
276 :     structure Int = IntRA
277 :     structure Float = FloatRA)
278 :    
279 :     structure AMD64Expand = CFGExpandCopies (
280 :     structure CFG=AMD64CFG
281 :     structure Shuffle = AMD64Shuffle)
282 :    
283 :     structure CCalls = AMD64SVID (
284 :     structure T = AMD64MLTree
285 :     val frameAlign = 16)
286 : mrainey 3000
287 :    
288 :     structure RA2 =
289 :     RISC_RA
290 :     (structure I = AMD64Instr
291 :     structure Asm = AMD64Asm
292 :     structure CFG = AMD64CFG
293 :     structure InsnProps = AMD64InsnProps
294 :     structure Rewrite =
295 :     struct
296 :     structure I = AMD64Instr
297 : mrainey 3008 structure C=I.C
298 :     structure CB = CellsBasis
299 :     fun error msg = MLRiscErrorMsg.error("X86Rewrite", msg)
300 :    
301 :     fun operand (rs,rt) opnd =
302 :     (case opnd
303 :     of I.Direct (sz, r) => if CB.sameColor(r,rs) then I.Direct (sz, rt) else opnd
304 :     | I.Displace{base, disp, mem} =>
305 :     if CB.sameColor(base,rs) then I.Displace{base=rt, disp=disp, mem=mem}
306 :     else opnd
307 :     | I.Indexed{base as SOME b, index, scale, disp, mem} => let
308 :     val base'= if CB.sameColor(b,rs) then SOME rt else base
309 :     val index'=if CB.sameColor(index,rs) then rt else index
310 :     in I.Indexed{base=base', index=index', scale=scale, disp=disp, mem=mem}
311 :     end
312 :     | I.Indexed{base, index, scale, disp, mem=mem} =>
313 :     if CB.sameColor(index,rs) then
314 :     I.Indexed{base=base, index=rt, scale=scale, disp=disp, mem=mem}
315 :     else opnd
316 :     | _ => opnd
317 :     (*end case*))
318 :    
319 :    
320 :     fun rewriteDef (instr, rs, rt) = let
321 :     fun operand(opnd as I.Direct (sz, r)) =
322 :     if CB.sameColor(r,rs) then I.Direct (sz, rt) else opnd
323 :     | operand _ = error "operand: not I.Direct"
324 :     fun replace r = if CB.sameColor(r,rs) then rt else r
325 :     fun rewriteX86Def(instr) =
326 :     (case instr
327 :     of I.CALL{opnd, defs, uses, return, cutsTo, mem, pops} =>
328 :     I.CALL{opnd=opnd, cutsTo=cutsTo,
329 :     return=CB.CellSet.map {from=rs,to=rt} return, pops=pops,
330 :     defs=CB.CellSet.map {from=rs,to=rt} defs, uses=uses, mem=mem}
331 :     | I.MOVE{mvOp, src, dst} => I.MOVE{mvOp=mvOp, src=src, dst=operand dst}
332 :     | I.LEAL{r32, addr} => I.LEAL{r32=replace r32, addr=addr}
333 :     | I.LEAQ{r64, addr} => I.LEAQ{r64=replace r64, addr=addr}
334 :     | I.BINARY{binOp, src, dst} =>
335 :     I.BINARY{binOp=binOp, src=src, dst=operand dst}
336 :     | I.SHIFT{shiftOp, src, dst, count} =>
337 :     I.SHIFT{shiftOp=shiftOp, src=src, count=count, dst=operand dst}
338 :     | I.UNARY{unOp, opnd} => I.UNARY{unOp=unOp, opnd=operand opnd}
339 :     | I.SET{cond, opnd} => I.SET{cond=cond, opnd=operand opnd}
340 :     | _ => instr
341 :     (* end case *))
342 :    
343 :     fun f (I.ANNOTATION{a,i}) =
344 :     I.ANNOTATION{i=rewriteDef(i,rs,rt),
345 :     a=(case a of
346 :     CB.DEF_USE{cellkind=CB.GP,defs,uses} =>
347 :     CB.DEF_USE{cellkind=CB.GP,uses=uses,
348 :     defs=map replace defs}
349 :     | _ => a)}
350 :     | f (I.INSTR i) = I.INSTR(rewriteX86Def(i))
351 :     | f (I.COPY{k as CB.GP, sz, dst, src, tmp}) =
352 :     I.COPY{k=k, sz=sz, dst=map replace dst, src=src, tmp=tmp}
353 :     in
354 :     f(instr)
355 :     end
356 :    
357 :    
358 :     fun rewriteUse (instr, rs, rt) = let
359 :     val operand = operand (rs, rt)
360 :     fun replace r = if CB.sameColor(r,rs) then rt else r
361 :     fun rewrite instr = (case instr
362 :     of I.JMP(opnd, labs) => I.JMP(operand opnd, labs)
363 :     | I.JCC{cond, opnd} => I.JCC{cond=cond, opnd = operand opnd}
364 :     | I.CALL{opnd, defs, uses, return, cutsTo, mem, pops} =>
365 :     I.CALL{opnd=operand opnd, defs=defs, return=return,
366 :     uses=CB.CellSet.map {from=rs,to=rt} uses, cutsTo=cutsTo,
367 :     mem=mem, pops=pops}
368 :     | I.MOVE{mvOp, src, dst as I.Direct _} =>
369 :     I.MOVE{mvOp=mvOp, src=operand src, dst=dst}
370 :     | I.MOVE{mvOp, src, dst} =>
371 :     I.MOVE{mvOp=mvOp, src=operand src, dst=operand dst}
372 :     | I.LEAL{r32, addr} => I.LEAL{r32=r32, addr=operand addr}
373 :     | I.LEAQ{r64, addr} => I.LEAQ{r64=r64, addr=operand addr}
374 :     | I.CMPL{lsrc, rsrc} => I.CMPL{lsrc=operand lsrc, rsrc=operand rsrc}
375 :     | I.CMPW{lsrc, rsrc} => I.CMPW{lsrc=operand lsrc, rsrc=operand rsrc}
376 :     | I.CMPB{lsrc, rsrc} => I.CMPB{lsrc=operand lsrc, rsrc=operand rsrc}
377 :     | I.TESTL{lsrc, rsrc} => I.TESTL{lsrc=operand lsrc, rsrc=operand rsrc}
378 :     | I.TESTW{lsrc, rsrc} => I.TESTW{lsrc=operand lsrc, rsrc=operand rsrc}
379 :     | I.TESTB{lsrc, rsrc} => I.TESTB{lsrc=operand lsrc, rsrc=operand rsrc}
380 :     | I.BITOP{bitOp, lsrc, rsrc} =>
381 :     I.BITOP{bitOp=bitOp, lsrc=operand lsrc, rsrc=operand rsrc}
382 :     | I.BINARY{binOp, src, dst} =>
383 :     I.BINARY{binOp=binOp, src=operand src, dst=operand dst}
384 :     | I.SHIFT{shiftOp, src, dst, count} =>
385 :     I.SHIFT{shiftOp=shiftOp, src=operand src, dst=operand dst,
386 :     count=operand src}
387 :     (* end case *))
388 :    
389 :     fun f(I.ANNOTATION{a,i}) =
390 :     I.ANNOTATION{i=rewriteUse(i, rs, rt),
391 :     a = case a of
392 :     CB.DEF_USE{cellkind=CB.GP,defs,uses} =>
393 :     CB.DEF_USE{cellkind=CB.GP,uses=map replace uses,
394 :     defs=defs}
395 :     | _ => a}
396 :     | f(I.INSTR i) = I.INSTR(rewrite(i))
397 :     | f(I.COPY{k as CB.GP, sz, dst, src, tmp}) =
398 :     I.COPY{k=k, sz=sz, dst=dst, src=List.map replace src, tmp=tmp}
399 :     in
400 :     f (instr:I.instruction)
401 :     end
402 :    
403 :    
404 : mrainey 3000 fun frewriteDef _ = raise Fail ""
405 :     fun frewriteUse _ = raise Fail ""
406 :     end
407 :     structure SpillInstr = AMD64SpillInstr (
408 :     structure I = I
409 :     structure Props = AMD64InsnProps
410 :     val floats16ByteAligned = true)
411 :     structure SpillHeur = ChaitinSpillHeur
412 :     structure Spill = RASpill (structure InsnProps = AMD64InsnProps
413 :     structure Asm = AMD64Asm)
414 :    
415 :     datatype spillOperandKind = SPILL_LOC | CONST_VAL
416 :     type spill_info = unit
417 : mrainey 3008 fun beforeRA _ = ()
418 : mrainey 3000
419 :     val architecture = "amd64"
420 :     fun pure _ = true
421 :    
422 :     structure Int =
423 :     struct
424 : mrainey 3008 val avail = C.Regs CellsBasis.GP {from=0, to=15, step=1}
425 :     val dedicated = [C.rsp, C.rbp]
426 : mrainey 3000 fun spillLoc _ = raise Fail ""
427 :     val mode = RACore.NO_OPTIMIZATION
428 :     end
429 :     structure Float =
430 :     struct
431 : mrainey 3008 val avail = C.Regs CellsBasis.FP {from=0, to=15, step=1}
432 : mrainey 3000 val dedicated = []
433 :     fun spillLoc _ = raise Fail ""
434 : mrainey 3008 val mode = Word.orb (RACore.HAS_PARALLEL_COPIES, RACore.DEAD_COPY_ELIM)
435 : mrainey 3000 end
436 :    
437 :     )
438 :    
439 : mrainey 3009 structure RA = RA2
440 :     structure Cells = AMD64Instr.C
441 :     structure T = AMD64MLTree
442 :     structure CFG = AMD64CFG
443 :     structure FlowGraph = AMD64FlowGraph
444 :    
445 :     structure TestStagedAllocation =
446 :     struct
447 :    
448 :     val wordTy = 64
449 :    
450 :     fun codegen (functionName, target, proto, initStms, args) = let
451 :     val _ = Label.reset()
452 :    
453 :     val [functionName, target] = List.map Label.global [functionName, target]
454 :    
455 :     val insnStrm = FlowGraph.build()
456 :     (* construct the C call *)
457 :     val {result, callseq} = CCalls.genCall {
458 :     name=T.LABEL target,
459 :     paramAlloc=fn _ => false,
460 :     structRet=fn _ => T.REG (64, Cells.rax),
461 :     saveRestoreDedicated=fn _ => {save=[], restore=[]},
462 :     callComment=NONE,
463 :     proto=proto,
464 :     args=args}
465 :    
466 :     fun wordLit i = T.LI (T.I.fromInt (wordTy, i))
467 :    
468 :     val stms = List.concat [
469 :     [T.EXT(AMD64InstrExt.PUSHQ(T.REG(64, Cells.rbp))),
470 :     T.COPY (wordTy, [Cells.rbp], [Cells.rsp])],
471 :     initStms,
472 :     callseq,
473 :     [T.EXT(AMD64InstrExt.LEAVE)],
474 :     [T.RET []]]
475 :    
476 :     val stream as AMD64Stream.STREAM
477 :     { beginCluster, (* start a cluster *)
478 :     endCluster, (* end a cluster *)
479 :     emit, (* emit MLTREE stm *)
480 :     defineLabel, (* define a local label *)
481 :     entryLabel, (* define an external entry *)
482 :     exitBlock, (* mark the end of a procedure *)
483 :     pseudoOp, (* emit a pseudo op *)
484 :     annotation, (* add an annotation *)
485 :     ... } =
486 :     AMD64.selectInstructions insnStrm
487 :     fun doit () = (
488 :     beginCluster 0; (* start a new cluster *)
489 :     pseudoOp PseudoOpsBasisTyp.TEXT;
490 :     pseudoOp (PseudoOpsBasisTyp.EXPORT [functionName]);
491 :     entryLabel functionName; (* define the entry label *)
492 :     List.app emit stms; (* emit all the statements *)
493 :     exitBlock result;
494 :     endCluster [])
495 :     val cfg = doit ()
496 :     val cfg = RA.run cfg
497 :     val cfg = AMD64Expand.run cfg
498 :     in
499 :     (cfg, stream) (* end the cluster *)
500 :     end (* codegen *)
501 :    
502 :     fun dumpOutput (cfg, stream) = let
503 :     val (cfg as Graph.GRAPH graph, blocks) =
504 :     AMD64BlockPlacement.blockPlacement cfg
505 :     val CFG.INFO{annotations=an, data, decls, ...} = #graph_info graph
506 :     in
507 :     AMD64Emit.asmEmit (cfg, blocks)
508 :     end (* dumpOutput *)
509 :    
510 :     end
511 :    
512 :    
513 :     (* machine-specific data *)
514 :     val wordTy = 64
515 :     val wordSzB = wordTy div 8
516 :     val param0 = T.REG(wordTy, Cells.rdi)
517 :    
518 :     (* maximum argument size in machine words *)
519 :     val maxArgSz = 16
520 :     val maxArgSzB = maxArgSz * wordSzB

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