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/mltree/x86.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/x86/mltree/x86.sml

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

revision 839, Thu Jun 7 20:28:44 2001 UTC revision 889, Thu Jul 19 20:35:20 2001 UTC
# Line 71  Line 71 
71    structure W32 = Word32    structure W32 = Word32
72    structure LE = I.LabelExp    structure LE = I.LabelExp
73    structure A = MLRiscAnnotations    structure A = MLRiscAnnotations
74      structure CB = CellsBasis
75    
76    type instrStream = (I.instruction,C.cellset) T.stream    type instrStream = (I.instruction,C.cellset) T.stream
77    type mltreeStream = (T.stm,T.mlrisc list) T.stream    type mltreeStream = (T.stm,T.mlrisc list) T.stream
# Line 94  Line 95 
95    
96    (* The following hardcoded *)    (* The following hardcoded *)
97    fun isMemReg r = rewriteMemReg andalso    fun isMemReg r = rewriteMemReg andalso
98                     let val r = C.registerNum r                     let val r = CB.registerNum r
99                     in  r >= 8 andalso r < 32                     in  r >= 8 andalso r < 32
100                     end                     end
101    fun isFMemReg r = if enableFastFPMode andalso !fast_floating_point    fun isFMemReg r = if enableFastFPMode andalso !fast_floating_point
102                      then let val r = C.registerNum r                      then let val r = CB.registerNum r
103                           in r >= 8 andalso r < 32 end                           in r >= 8 andalso r < 32 end
104                      else true                      else true
105    val isAnyFMemReg = List.exists (fn r =>    val isAnyFMemReg = List.exists (fn r =>
106                                    let val r = C.registerNum r                                    let val r = CB.registerNum r
107                                    in  r >= 8 andalso r < 32 end                                    in  r >= 8 andalso r < 32 end
108                                   )                                   )
109    
# Line 177  Line 178 
178        fun copy([], [], an) = ()        fun copy([], [], an) = ()
179          | copy(dst, src, an) =          | copy(dst, src, an) =
180            let fun mvInstr{dst as I.MemReg rd, src as I.MemReg rs} =            let fun mvInstr{dst as I.MemReg rd, src as I.MemReg rs} =
181                    if C.sameColor(rd,rs) then [] else                    if CB.sameColor(rd,rs) then [] else
182                    let val tmpR = I.Direct(newReg())                    let val tmpR = I.Direct(newReg())
183                    in  [I.MOVE{mvOp=I.MOVL, src=src, dst=tmpR},                    in  [I.MOVE{mvOp=I.MOVL, src=src, dst=tmpR},
184                         I.MOVE{mvOp=I.MOVL, src=tmpR, dst=dst}]                         I.MOVE{mvOp=I.MOVL, src=tmpR, dst=dst}]
185                    end                    end
186                  | mvInstr{dst=I.Direct rd, src=I.Direct rs} =                  | mvInstr{dst=I.Direct rd, src=I.Direct rs} =
187                      if C.sameColor(rd,rs) then []                      if CB.sameColor(rd,rs) then []
188                      else [I.COPY{dst=[rd], src=[rs], tmp=NONE}]                      else [I.COPY{dst=[rd], src=[rs], tmp=NONE}]
189                  | mvInstr{dst, src} = [I.MOVE{mvOp=I.MOVL, src=src, dst=dst}]                  | mvInstr{dst, src} = [I.MOVE{mvOp=I.MOVL, src=src, dst=dst}]
190            in            in
# Line 288  Line 289 
289    
290        (* Move and annotate *)        (* Move and annotate *)
291        fun move'(src as I.Direct s, dst as I.Direct d, an) =        fun move'(src as I.Direct s, dst as I.Direct d, an) =
292            if C.sameColor(s,d) then ()            if CB.sameColor(s,d) then ()
293            else mark(I.COPY{dst=[d], src=[s], tmp=NONE}, an)            else mark(I.COPY{dst=[d], src=[s], tmp=NONE}, an)
294          | move'(I.Immed 0, dst as I.Direct d, an) =          | move'(I.Immed 0, dst as I.Direct d, an) =
295              mark(I.BINARY{binOp=I.XORL, src=dst, dst=dst}, an)              mark(I.BINARY{binOp=I.XORL, src=dst, dst=dst}, an)
# Line 366  Line 367 
367            (* generate code for tree and ensure that it is not in %esp *)            (* generate code for tree and ensure that it is not in %esp *)
368            and exprNotEsp tree =            and exprNotEsp tree =
369                let val r = expr tree                let val r = expr tree
370                in  if C.sameColor(r, C.esp) then                in  if CB.sameColor(r, C.esp) then
371                       let val tmp = newReg()                       let val tmp = newReg()
372                       in  move(I.Direct r, I.Direct tmp); tmp end                       in  move(I.Direct r, I.Direct tmp); tmp end
373                    else r                    else r
# Line 378  Line 379 
379              | displace(trees, t, b as SOME base, NONE, _, d) = (* no index *)              | displace(trees, t, b as SOME base, NONE, _, d) = (* no index *)
380                (* make t the index, but make sure that it is not %esp! *)                (* make t the index, but make sure that it is not %esp! *)
381                let val i = expr t                let val i = expr t
382                in  if C.sameColor(i, C.esp) then                in  if CB.sameColor(i, C.esp) then
383                      (* swap base and index *)                      (* swap base and index *)
384                      if C.sameColor(base, C.esp) then                      if CB.sameColor(base, C.esp) then
385                         doEA(trees, SOME i, b, 0, d)                         doEA(trees, SOME i, b, 0, d)
386                      else  (* base and index = %esp! *)                      else  (* base and index = %esp! *)
387                         let val index = newReg()                         let val index = newReg()
# Line 455  Line 456 
456            * Compute an integer expression and put the result in            * Compute an integer expression and put the result in
457            * the destination register rd.            * the destination register rd.
458            *)            *)
459        and doExpr(exp, rd : I.C.cell, an) =        and doExpr(exp, rd : CB.cell, an) =
460            let val rdOpnd = IntReg rd            let val rdOpnd = IntReg rd
461    
462                fun equalRd(I.Direct r) = C.sameColor(r, rd)                fun equalRd(I.Direct r) = CB.sameColor(r, rd)
463                  | equalRd(I.MemReg r) = C.sameColor(r, rd)                  | equalRd(I.MemReg r) = CB.sameColor(r, rd)
464                  | equalRd _ = false                  | equalRd _ = false
465    
466                   (* Emit a binary operator.  If the destination is                   (* Emit a binary operator.  If the destination is
# Line 770  Line 771 
771                    (* Generate addition *)                    (* Generate addition *)
772                fun addition(e1, e2) =                fun addition(e1, e2) =
773                    case e1 of                    case e1 of
774                      T.REG(_,rs) => if C.sameColor(rs,rd) then addN e2                      T.REG(_,rs) => if CB.sameColor(rs,rd) then addN e2
775                                     else addition1(e1,e2)                                     else addition1(e1,e2)
776                    | _ => addition1(e1,e2)                    | _ => addition1(e1,e2)
777                and addition1(e1, e2) =                and addition1(e1, e2) =
778                    case e2 of                    case e2 of
779                      T.REG(_,rs) => if C.sameColor(rs,rd) then addN e1                      T.REG(_,rs) => if CB.sameColor(rs,rd) then addN e1
780                                     else addition2(e1,e2)                                     else addition2(e1,e2)
781                    | _ => addition2(e1,e2)                    | _ => addition2(e1,e2)
782                and addition2(e1,e2) =                and addition2(e1,e2) =
# Line 964  Line 965 
965    
966            (* %eflags <- src *)            (* %eflags <- src *)
967        and moveToEflags src =        and moveToEflags src =
968            if C.sameColor(src, C.eflags) then ()            if CB.sameColor(src, C.eflags) then ()
969            else (move(I.Direct src, eax); emit(I.LAHF))            else (move(I.Direct src, eax); emit(I.LAHF))
970    
971            (* dst <- %eflags *)            (* dst <- %eflags *)
972        and moveFromEflags dst =        and moveFromEflags dst =
973            if C.sameColor(dst, C.eflags) then ()            if CB.sameColor(dst, C.eflags) then ()
974            else (emit(I.SAHF); move(eax, I.Direct dst))            else (emit(I.SAHF); move(eax, I.Direct dst))
975    
976           (* generate a condition code expression           (* generate a condition code expression
# Line 981  Line 982 
982             moveFromEflags rd             moveFromEflags rd
983            )            )
984          | doCCexpr(T.CC(cond,rs), rd, an) =          | doCCexpr(T.CC(cond,rs), rd, an) =
985            if C.sameColor(rs,C.eflags) orelse C.sameColor(rd,C.eflags) then            if CB.sameColor(rs,C.eflags) orelse CB.sameColor(rd,C.eflags) then
986               (moveToEflags rs; moveFromEflags rd)               (moveToEflags rs; moveFromEflags rd)
987            else            else
988               move'(I.Direct rs, I.Direct rd, an)               move'(I.Direct rs, I.Direct rd, an)
# Line 1082  Line 1083 
1083            let val src =            let val src =
1084                   case immedOrReg(operand d) of                   case immedOrReg(operand d) of
1085                       src as I.Direct r =>                       src as I.Direct r =>
1086                         if C.sameColor(r,C.eax)                         if CB.sameColor(r,C.eax)
1087                         then src else (move(src, eax); eax)                         then src else (move(src, eax); eax)
1088                     | src => src                     | src => src
1089            in  mark(I.MOVE{mvOp=mvOp, src=src, dst=address(ea,mem)},an)            in  mark(I.MOVE{mvOp=mvOp, src=src, dst=address(ea,mem)},an)
# Line 1244  Line 1245 
1245        and fload'(fty, ea, mem, fd, an) =        and fload'(fty, ea, mem, fd, an) =
1246              let val ea = address(ea, mem)              let val ea = address(ea, mem)
1247              in  mark(fld(fty, ea), an);              in  mark(fld(fty, ea), an);
1248                  if C.sameColor(fd,ST0) then ()                  if CB.sameColor(fd,ST0) then ()
1249                  else emit(fstp(fty, I.FDirect fd))                  else emit(fstp(fty, I.FDirect fd))
1250              end              end
1251    
# Line 1252  Line 1253 
1253    
1254            (* generate floating point expression and put the result in fd *)            (* generate floating point expression and put the result in fd *)
1255        and doFexpr'(fty, T.FREG(_, fs), fd, an) =        and doFexpr'(fty, T.FREG(_, fs), fd, an) =
1256              (if C.sameColor(fs,fd) then ()              (if CB.sameColor(fs,fd) then ()
1257               else mark(I.FCOPY{dst=[fd], src=[fs], tmp=NONE}, an)               else mark(I.FCOPY{dst=[fd], src=[fs], tmp=NONE}, an)
1258              )              )
1259          | doFexpr'(_, T.FLOAD(fty, ea, mem), fd, an) =          | doFexpr'(_, T.FLOAD(fty, ea, mem), fd, an) =
1260              fload'(fty, ea, mem, fd, an)              fload'(fty, ea, mem, fd, an)
1261          | doFexpr'(fty, T.FEXT fexp, fd, an) =          | doFexpr'(fty, T.FEXT fexp, fd, an) =
1262              (ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an};              (ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an};
1263               if C.sameColor(fd,ST0) then () else emit(fstp(fty, I.FDirect fd))               if CB.sameColor(fd,ST0) then () else emit(fstp(fty, I.FDirect fd))
1264              )              )
1265          | doFexpr'(fty, e, fd, an) =          | doFexpr'(fty, e, fd, an) =
1266              (reduceFexp(fty, e, []);              (reduceFexp(fty, e, []);
1267               if C.sameColor(fd,ST0) then ()               if CB.sameColor(fd,ST0) then ()
1268               else mark(fstp(fty, I.FDirect fd), an)               else mark(fstp(fty, I.FDirect fd), an)
1269              )              )
1270    
# Line 1345  Line 1346 
1346    
1347                and sameTree(LEAF(_, T.FREG(t1,f1), []),                and sameTree(LEAF(_, T.FREG(t1,f1), []),
1348                             LEAF(_, T.FREG(t2,f2), [])) =                             LEAF(_, T.FREG(t2,f2), [])) =
1349                          t1 = t2 andalso C.sameColor(f1,f2)                          t1 = t2 andalso CB.sameColor(f1,f2)
1350                  | sameTree _ = false                  | sameTree _ = false
1351    
1352                (* Traverse tree and generate code *)                (* Traverse tree and generate code *)
# Line 1544  Line 1545 
1545    
1546        and doFexpr''(fty, e, fd, an) =        and doFexpr''(fty, e, fd, an) =
1547            case e of            case e of
1548              T.FREG(_,fs) => if C.sameColor(fs,fd) then ()              T.FREG(_,fs) => if CB.sameColor(fs,fd) then ()
1549                              else fcopy''(fty, [fd], [fs], an)                              else fcopy''(fty, [fd], [fs], an)
1550              (* Stupid x86 does everything as 80-bits internally. *)              (* Stupid x86 does everything as 80-bits internally. *)
1551    

Legend:
Removed from v.839  
changed lines
  Added in v.889

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