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

SCM Repository

[smlnj] Diff of /sml/trunk/src/MLRISC/x86/instructions/x86Props.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/x86/instructions/x86Props.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1008, Fri Dec 14 21:01:29 2001 UTC revision 1009, Wed Jan 9 19:44:22 2002 UTC
# Line 25  Line 25 
25    *  Instruction Kinds    *  Instruction Kinds
26    *========================================================================*)    *========================================================================*)
27    fun instrKind (I.ANNOTATION{i, ...}) = instrKind i    fun instrKind (I.ANNOTATION{i, ...}) = instrKind i
28        | instrKind (I.COPY _) = IK_COPY
29      | instrKind (I.INSTR i)  =      | instrKind (I.INSTR i)  =
30         (case i         (case i
31           of I.JMP _ => IK_JUMP           of I.JMP _ => IK_JUMP
32            | I.JCC _ => IK_JUMP            | I.JCC _ => IK_JUMP
           | I.COPY _ => IK_COPY  
           | I.FCOPY _ => IK_COPY  
33            | I.CALL{cutsTo=_::_,...} => IK_CALL_WITH_CUTS            | I.CALL{cutsTo=_::_,...} => IK_CALL_WITH_CUTS
34            | I.CALL _ => IK_CALL            | I.CALL _ => IK_CALL
35            | I.PHI _    => IK_PHI            | I.PHI _    => IK_PHI
# Line 43  Line 42 
42    fun moveInstr(I.ANNOTATION{i, ...}) = moveInstr i    fun moveInstr(I.ANNOTATION{i, ...}) = moveInstr i
43      | moveInstr(I.LIVE _) = false      | moveInstr(I.LIVE _) = false
44      | moveInstr(I.KILL _) = false      | moveInstr(I.KILL _) = false
45        | moveInstr(I.COPY _) = true
46      | moveInstr(I.INSTR i)  =      | moveInstr(I.INSTR i)  =
47         (case i         (case i
48           of I.COPY _ => true           of I.MOVE{mvOp=I.MOVL, src=I.Direct _, dst=I.MemReg _, ...} => true
           | I.FCOPY _ =>true  
           | I.MOVE{mvOp=I.MOVL, src=I.Direct _, dst=I.MemReg _, ...} => true  
49            | I.MOVE{mvOp=I.MOVL, src=I.MemReg _, dst=I.Direct _, ...} => true            | I.MOVE{mvOp=I.MOVL, src=I.MemReg _, dst=I.Direct _, ...} => true
50            | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FPR _, ...} => true            | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FPR _, ...} => true
51            | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FDirect _, ...} => true            | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FDirect _, ...} => true
52            | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FPR _, ...} => true            | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FPR _, ...} => true
53            | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FDirect _, ...} => true            | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FDirect _, ...} => true
54            | _ => false )            | _ => false )
     | moveInstr _ = false  
55    
56    
57      fun isMemMove(I.INSTR(i)) =
58          (case i
59            of I.MOVE{mvOp=I.MOVL, src=I.Direct _, dst=I.MemReg _, ...} => true
60             | I.MOVE{mvOp=I.MOVL, src=I.MemReg _, dst=I.Direct _, ...} => true
61             | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FPR _, ...} => true
62             | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FDirect _, ...} => true
63             | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FPR _, ...} => true
64             | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FDirect _, ...} => true
65             | _ => false
66          (*esac*))
67        | isMemMove _ = false
68    
69    
70      fun memMove(I.INSTR(i)) =
71          (case i
72            of I.MOVE{src=I.Direct rs, dst=I.MemReg rd, ...} => ([rd], [rs])
73             | I.MOVE{src=I.MemReg rs, dst=I.Direct rd, ...} => ([rd], [rs])
74             | I.FMOVE{src=I.FPR rs, dst=I.FPR rd, ...} => ([rd], [rs])
75             | I.FMOVE{src=I.FDirect rs, dst=I.FPR rd, ...} => ([rd], [rs])
76             | I.FMOVE{src=I.FPR rs, dst=I.FDirect rd, ...} => ([rd], [rs])
77             | I.FMOVE{src=I.FDirect rs, dst=I.FDirect rd, ...} => ([rd], [rs])
78             |  _ => error "memMove: INSTR"
79          (*esac*))
80        | memMove _ = error "memMove"
81    
82    val nop = fn () => I.nop    val nop = fn () => I.nop
83    
84    
# Line 64  Line 86 
86    *  Parallel Move    *  Parallel Move
87    *========================================================================*)    *========================================================================*)
88    fun moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i    fun moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
89      | moveTmpR(I.INSTR i) =      | moveTmpR(I.COPY{k=CB.GP, tmp=SOME(I.Direct r), ...}) = SOME r
90        (case i      | moveTmpR(I.COPY{k=CB.FP, tmp=SOME(I.FDirect f), ...}) = SOME f
91          of I.COPY{tmp=SOME(I.Direct r), ...} => SOME r      | moveTmpR(I.COPY{k=CB.FP, tmp=SOME(I.FPR f), ...}) = SOME f
          | I.FCOPY{tmp=SOME(I.FDirect f), ...} => SOME f  
          | I.FCOPY{tmp=SOME(I.FPR f), ...} => SOME f  
          |  _ => NONE)  
92      | moveTmpR _ = NONE      | moveTmpR _ = NONE
93    
94    fun moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i    fun moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
95        | moveDstSrc(I.COPY{src, dst, ...}) = (dst, src)
96      | moveDstSrc(I.INSTR i) =      | moveDstSrc(I.INSTR i) =
97        (case i        (case i
98          of I.COPY{src, dst, ...} => (dst, src)          of I.MOVE{src=I.Direct rs, dst=I.MemReg rd, ...} => ([rd], [rs])
          | I.FCOPY{src, dst, ...} => (dst, src)  
          | I.MOVE{src=I.Direct rs, dst=I.MemReg rd, ...} => ([rd], [rs])  
99           | I.MOVE{src=I.MemReg rs, dst=I.Direct rd, ...} => ([rd], [rs])           | I.MOVE{src=I.MemReg rs, dst=I.Direct rd, ...} => ([rd], [rs])
100           | I.FMOVE{src=I.FPR rs, dst=I.FPR rd, ...} => ([rd], [rs])           | I.FMOVE{src=I.FPR rs, dst=I.FPR rd, ...} => ([rd], [rs])
101           | I.FMOVE{src=I.FDirect rs, dst=I.FPR rd, ...} => ([rd], [rs])           | I.FMOVE{src=I.FDirect rs, dst=I.FPR rd, ...} => ([rd], [rs])
# Line 162  Line 180 
180    val eaxPair = [C.edx, C.eax]    val eaxPair = [C.edx, C.eax]
181    
182    fun defUseR instr = let    fun defUseR instr = let
     fun x86DefUseR instr = let  
183        fun operandAcc(I.Direct r, acc) = r::acc        fun operandAcc(I.Direct r, acc) = r::acc
184          | operandAcc(I.MemReg r, acc) = r::acc          | operandAcc(I.MemReg r, acc) = r::acc
185          | operandAcc(I.Displace{base, ...}, acc) = base::acc          | operandAcc(I.Displace{base, ...}, acc) = base::acc
# Line 170  Line 187 
187          | operandAcc(I.Indexed{base=NONE, index, ...}, acc) = index::acc          | operandAcc(I.Indexed{base=NONE, index, ...}, acc) = index::acc
188          | operandAcc(_, acc) = acc          | operandAcc(_, acc) = acc
189    
190        fun x86DefUseR instr = let
191        fun operandUse opnd = operandAcc(opnd, [])        fun operandUse opnd = operandAcc(opnd, [])
192    
193        fun operandUse2(src1, src2) = ([], operandAcc(src1, operandUse src2))        fun operandUse2(src1, src2) = ([], operandAcc(src1, operandUse src2))
# Line 223  Line 241 
241          | I.PUSHFD            => espOnly()          | I.PUSHFD            => espOnly()
242          | I.POPFD                     => espOnly()          | I.POPFD                     => espOnly()
243          | I.CDQ               => ([C.edx], [C.eax])          | I.CDQ               => ([C.edx], [C.eax])
   
         | I.COPY{dst, src, tmp=SOME(I.Direct r), ...}   => (r::dst, src)  
         | I.COPY{dst, src, ...} => (dst, src)  
244          | I.FSTPT opnd        => float opnd          | I.FSTPT opnd        => float opnd
245          | I.FSTPL opnd        => float opnd          | I.FSTPL opnd        => float opnd
246          | I.FSTPS opnd        => float opnd          | I.FSTPS opnd        => float opnd
# Line 263  Line 278 
278         of I.ANNOTATION{i, ...} => defUseR i         of I.ANNOTATION{i, ...} => defUseR i
279          | I.LIVE{regs, ...} => ([], C.getReg regs)          | I.LIVE{regs, ...} => ([], C.getReg regs)
280          | I.KILL{regs, ...} => (C.getReg regs, [])          | I.KILL{regs, ...} => (C.getReg regs, [])
281            | I.COPY{k=CB.GP, dst, src, tmp, ...} =>
282              (case tmp
283                of NONE => (dst, src)
284                 | SOME(I.Direct r) => (r::dst, src)
285                 | SOME(I.MemReg r) => (r::dst, src)
286                 | SOME(ea) => (dst, operandAcc(ea, src))
287              (*esac*))
288            | I.COPY _ => ([], [])
289          | I.INSTR i  => x86DefUseR(i)          | I.INSTR i  => x86DefUseR(i)
         | _ => error "defUseR"  
290    end    end
291    
292    fun defUseF instr = let    fun defUseF instr = let
# Line 300  Line 322 
322          | I.FUCOMP opnd           => ([], operand opnd)          | I.FUCOMP opnd           => ([], operand opnd)
323          | I.CALL{defs, uses, ...}       => (C.getFreg defs, C.getFreg uses)          | I.CALL{defs, uses, ...}       => (C.getFreg defs, C.getFreg uses)
324          | I.FBINARY{dst, src, ...}=> (operand dst, operand dst @ operand src)          | I.FBINARY{dst, src, ...}=> (operand dst, operand dst @ operand src)
         | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...}  => (f::dst, src)  
         | I.FCOPY{dst, src, tmp=SOME(I.FPR f), ...}  => (f::dst, src)  
         | I.FCOPY{dst, src, ...}  => (dst, src)  
325    
326          | I.FMOVE{src, dst, ...} => (operand dst, operand src)          | I.FMOVE{src, dst, ...} => (operand dst, operand src)
327          | I.FILOAD{ea, dst, ...} => (operand dst, [])          | I.FILOAD{ea, dst, ...} => (operand dst, [])
# Line 317  Line 336 
336       of (I.ANNOTATION{i, ...}) => defUseF(i)       of (I.ANNOTATION{i, ...}) => defUseF(i)
337          | I.LIVE{regs, ...} => ([], C.getFreg regs)          | I.LIVE{regs, ...} => ([], C.getFreg regs)
338          | I.KILL{regs, ...} => (C.getFreg regs, [])          | I.KILL{regs, ...} => (C.getFreg regs, [])
339          | I.COPY{k=CB.FP, dst, src, tmp, ...} =>
340            (case tmp
341              of NONE => (dst, src)
342               | SOME(I.FDirect f) => (f::dst, src)
343               | SOME(I.FPR f) => (f::dst, src)
344               | _ => (dst, src)
345            (*esac*))
346          | I.COPY _  => ([], [])
347        | (I.INSTR i) => x86DefUseF(i)        | (I.INSTR i) => x86DefUseF(i)
       | _ =>  error "defUseF not implemented"  
348    end    end
349    
350    fun defUse CB.GP = defUseR    fun defUse CB.GP = defUseR

Legend:
Removed from v.1008  
changed lines
  Added in v.1009

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