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 1009, Wed Jan 9 19:44:22 2002 UTC
# Line 42  Line 42 
42     structure MLTreeUtils : MLTREE_UTILS     structure MLTreeUtils : MLTREE_UTILS
43       where T = X86Instr.T       where T = X86Instr.T
44     structure ExtensionComp : MLTREE_EXTENSION_COMP     structure ExtensionComp : MLTREE_EXTENSION_COMP
45       where I = X86Instr                          where I = X86Instr and T = X86Instr.T
46       structure MLTreeStream : MLTREE_STREAM
47                            where T = ExtensionComp.T
48      datatype arch = Pentium | PentiumPro | PentiumII | PentiumIII      datatype arch = Pentium | PentiumPro | PentiumII | PentiumIII
49      val arch : arch ref      val arch : arch ref
50      val cvti2f :      val cvti2f :
# Line 65  Line 67 
67  struct  struct
68    structure I = X86Instr    structure I = X86Instr
69    structure T = I.T    structure T = I.T
70    structure S = T.Stream    structure TS = ExtensionComp.TS
71    structure C = I.C    structure C = I.C
72    structure Shuffle = Shuffle(I)    structure Shuffle = Shuffle(I)
73    structure W32 = Word32    structure W32 = Word32
   structure LE = I.LabelExp  
74    structure A = MLRiscAnnotations    structure A = MLRiscAnnotations
75      structure CFG = ExtensionComp.CFG
76      structure CB = CellsBasis
77    
78    type instrStream = (I.instruction,C.cellset) T.stream    type instrStream = (I.instruction,C.cellset,CFG.cfg) TS.stream
79    type mltreeStream = (T.stm,T.mlrisc list) T.stream    type mltreeStream = (T.stm,T.mlrisc list,CFG.cfg) TS.stream
80    
81    datatype kind = REAL | INTEGER    datatype kind = REAL | INTEGER
82    
# Line 94  Line 97 
97    
98    (* The following hardcoded *)    (* The following hardcoded *)
99    fun isMemReg r = rewriteMemReg andalso    fun isMemReg r = rewriteMemReg andalso
100                     let val r = C.registerNum r                     let val r = CB.registerNum r
101                     in  r >= 8 andalso r < 32                     in  r >= 8 andalso r < 32
102                     end                     end
103    fun isFMemReg r = if enableFastFPMode andalso !fast_floating_point    fun isFMemReg r = if enableFastFPMode andalso !fast_floating_point
104                      then let val r = C.registerNum r                      then let val r = CB.registerNum r
105                           in r >= 8 andalso r < 32 end                           in r >= 8 andalso r < 32 end
106                      else true                      else true
107    val isAnyFMemReg = List.exists (fn r =>    val isAnyFMemReg = List.exists (fn r =>
108                                    let val r = C.registerNum r                                    let val r = CB.registerNum r
109                                    in  r >= 8 andalso r < 32 end                                    in  r >= 8 andalso r < 32 end
110                                   )                                   )
111    
# Line 128  Line 131 
131     *)     *)
132    fun selectInstructions    fun selectInstructions
133         (instrStream as         (instrStream as
134          S.STREAM{emit,defineLabel,entryLabel,pseudoOp,annotation,getAnnotations,          TS.S.STREAM{emit=emitInstruction,defineLabel,entryLabel,pseudoOp,
135                   beginCluster,endCluster,exitBlock,comment,...}) =                      annotation,getAnnotations,beginCluster,endCluster,exitBlock,comment,...}) =
136    let exception EA    let
137          val emit = emitInstruction o I.INSTR
138          exception EA
139    
140        (* label where a trap is generated -- one per cluster *)        (* label where a trap is generated -- one per cluster *)
141        val trapLabel = ref (NONE: (I.instruction * Label.label) option)        val trapLabel = ref (NONE: (I.instruction * Label.label) option)
# Line 146  Line 151 
151        fun trap() =        fun trap() =
152        let val jmp =        let val jmp =
153              case !trapLabel of              case !trapLabel of
154                NONE => let val label = Label.newLabel "trap"                NONE => let val label = Label.label "trap" ()
155                            val jmp   = I.JCC{cond=I.O,                            val jmp   = I.jcc{cond=I.O,
156                                              opnd=I.ImmedLabel(T.LABEL label)}                                              opnd=I.ImmedLabel(T.LABEL label)}
157                        in  trapLabel := SOME(jmp, label); jmp end                        in  trapLabel := SOME(jmp, label); jmp end
158              | SOME(jmp, _) => jmp              | SOME(jmp, _) => jmp
159        in  emit jmp end        in  emitInstruction jmp end
160    
161        val newReg  = C.newReg        val newReg  = C.newReg
162        val newFreg = C.newFreg        val newFreg = C.newFreg
# Line 162  Line 167 
167          | fsize _  = error "fsize"          | fsize _  = error "fsize"
168    
169        (* mark an expression with a list of annotations *)        (* mark an expression with a list of annotations *)
170        fun mark'(i,[]) = i        fun mark'(i,[]) = emitInstruction(i)
171          | mark'(i,a::an) = mark'(I.ANNOTATION{i=i,a=a},an)          | mark'(i,a::an) = mark'(I.ANNOTATION{i=i,a=a},an)
172    
173        (* annotate an expression and emit it *)        (* annotate an expression and emit it *)
174        fun mark(i,an) = emit(mark'(i,an))        fun mark(i,an) = mark'(I.INSTR i,an)
175    
176        val emits = app emit        val emits = app emitInstruction
177    
178        (* emit parallel copies for integers        (* emit parallel copies for integers
179         * Translates parallel copies that involve memregs into         * Translates parallel copies that involve memregs into
# Line 177  Line 182 
182        fun copy([], [], an) = ()        fun copy([], [], an) = ()
183          | copy(dst, src, an) =          | copy(dst, src, an) =
184            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} =
185                    if C.sameColor(rd,rs) then [] else                    if CB.sameColor(rd,rs) then [] else
186                    let val tmpR = I.Direct(newReg())                    let val tmpR = I.Direct(newReg())
187                    in  [I.MOVE{mvOp=I.MOVL, src=src, dst=tmpR},                    in  [I.move{mvOp=I.MOVL, src=src, dst=tmpR},
188                         I.MOVE{mvOp=I.MOVL, src=tmpR, dst=dst}]                         I.move{mvOp=I.MOVL, src=tmpR, dst=dst}]
189                    end                    end
190                  | mvInstr{dst=I.Direct rd, src=I.Direct rs} =                  | mvInstr{dst=I.Direct rd, src=I.Direct rs} =
191                      if C.sameColor(rd,rs) then []                      if CB.sameColor(rd,rs) then []
192                      else [I.COPY{dst=[rd], src=[rs], tmp=NONE}]                      else [I.COPY{k=CB.GP, sz=32, dst=[rd], src=[rs], tmp=NONE}]
193                  | mvInstr{dst, src} = [I.MOVE{mvOp=I.MOVL, src=src, dst=dst}]                  | mvInstr{dst, src} = [I.move{mvOp=I.MOVL, src=src, dst=dst}]
194            in            in
195               emits (Shuffle.shuffle{mvInstr=mvInstr, ea=IntReg}               emits (Shuffle.shuffle{mvInstr=mvInstr, ea=IntReg}
196                 {tmp=SOME(I.Direct(newReg())),                 {tmp=SOME(I.Direct(newReg())),
# Line 246  Line 251 
251         *)         *)
252        fun fcopy'(fty, [], [], _) = ()        fun fcopy'(fty, [], [], _) = ()
253          | fcopy'(fty, dst as [_], src as [_], an) =          | fcopy'(fty, dst as [_], src as [_], an) =
254              mark(I.FCOPY{dst=dst,src=src,tmp=NONE}, an)              mark'(I.COPY{k=CB.FP, sz=fty, dst=dst,src=src,tmp=NONE}, an)
255          | fcopy'(fty, dst, src, an) =          | fcopy'(fty, dst, src, an) =
256              mark(I.FCOPY{dst=dst,src=src,tmp=SOME(I.FDirect(newFreg()))}, an)              mark'(I.COPY{k=CB.FP, sz=fty, dst=dst,src=src,tmp=SOME(I.FDirect(newFreg()))}, an)
257    
258        (* emit parallel copies for floating point.        (* emit parallel copies for floating point.
259         * Fast version.         * Fast version.
# Line 260  Line 265 
265          | fcopy''(fty, dst, src, an) =          | fcopy''(fty, dst, src, an) =
266            if true orelse isAnyFMemReg dst orelse isAnyFMemReg src then            if true orelse isAnyFMemReg dst orelse isAnyFMemReg src then
267            let val fsize = fsize fty            let val fsize = fsize fty
268                fun mvInstr{dst, src} = [I.FMOVE{fsize=fsize, src=src, dst=dst}]                fun mvInstr{dst, src} = [I.fmove{fsize=fsize, src=src, dst=dst}]
269            in            in
270                emits (Shuffle.shuffle{mvInstr=mvInstr, ea=RealReg}                emits (Shuffle.shuffle{mvInstr=mvInstr, ea=RealReg}
271                  {tmp=case dst of                  {tmp=case dst of
# Line 269  Line 274 
274                   dst=dst, src=src})                   dst=dst, src=src})
275            end            end
276            else            else
277              mark(I.FCOPY{dst=dst,src=src,tmp=              mark'(I.COPY{k=CB.FP, sz=fty, dst=dst,
278                            src=src,tmp=
279                           case dst of                           case dst of
280                             [_] => NONE                             [_] => NONE
281                           | _   => SOME(I.FPR(newFreg()))}, an)                           | _   => SOME(I.FPR(newFreg()))}, an)
# Line 288  Line 294 
294    
295        (* Move and annotate *)        (* Move and annotate *)
296        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) =
297            if C.sameColor(s,d) then ()            if CB.sameColor(s,d) then ()
298            else mark(I.COPY{dst=[d], src=[s], tmp=NONE}, an)            else mark'(I.COPY{k=CB.GP, sz=32, dst=[d], src=[s], tmp=NONE}, an)
299          | move'(I.Immed 0, dst as I.Direct d, an) =          | move'(I.Immed 0, dst as I.Direct d, an) =
300              mark(I.BINARY{binOp=I.XORL, src=dst, dst=dst}, an)              mark(I.BINARY{binOp=I.XORL, src=dst, dst=dst}, an)
301          | move'(src, dst, an) = mark(I.MOVE{mvOp=I.MOVL, src=src, dst=dst}, an)          | move'(src, dst, an) = mark(I.MOVE{mvOp=I.MOVL, src=src, dst=dst}, an)
# Line 366  Line 372 
372            (* generate code for tree and ensure that it is not in %esp *)            (* generate code for tree and ensure that it is not in %esp *)
373            and exprNotEsp tree =            and exprNotEsp tree =
374                let val r = expr tree                let val r = expr tree
375                in  if C.sameColor(r, C.esp) then                in  if CB.sameColor(r, C.esp) then
376                       let val tmp = newReg()                       let val tmp = newReg()
377                       in  move(I.Direct r, I.Direct tmp); tmp end                       in  move(I.Direct r, I.Direct tmp); tmp end
378                    else r                    else r
# Line 378  Line 384 
384              | displace(trees, t, b as SOME base, NONE, _, d) = (* no index *)              | displace(trees, t, b as SOME base, NONE, _, d) = (* no index *)
385                (* make t the index, but make sure that it is not %esp! *)                (* make t the index, but make sure that it is not %esp! *)
386                let val i = expr t                let val i = expr t
387                in  if C.sameColor(i, C.esp) then                in  if CB.sameColor(i, C.esp) then
388                      (* swap base and index *)                      (* swap base and index *)
389                      if C.sameColor(base, C.esp) then                      if CB.sameColor(base, C.esp) then
390                         doEA(trees, SOME i, b, 0, d)                         doEA(trees, SOME i, b, 0, d)
391                      else  (* base and index = %esp! *)                      else  (* base and index = %esp! *)
392                         let val index = newReg()                         let val index = newReg()
# Line 455  Line 461 
461            * Compute an integer expression and put the result in            * Compute an integer expression and put the result in
462            * the destination register rd.            * the destination register rd.
463            *)            *)
464        and doExpr(exp, rd : I.C.cell, an) =        and doExpr(exp, rd : CB.cell, an) =
465            let val rdOpnd = IntReg rd            let val rdOpnd = IntReg rd
466    
467                fun equalRd(I.Direct r) = C.sameColor(r, rd)                fun equalRd(I.Direct r) = CB.sameColor(r, rd)
468                  | equalRd(I.MemReg r) = C.sameColor(r, rd)                  | equalRd(I.MemReg r) = CB.sameColor(r, rd)
469                  | equalRd _ = false                  | equalRd _ = false
470    
471                   (* Emit a binary operator.  If the destination is                   (* Emit a binary operator.  If the destination is
# Line 553  Line 559 
559                       let val pow = T.LI(T.I.fromInt(32,log2 w))                       let val pow = T.LI(T.I.fromInt(32,log2 w))
560                       in  if signed then                       in  if signed then
561                           (* signed; simulate round towards zero *)                           (* signed; simulate round towards zero *)
562                           let val label = Label.newLabel ""                           let val label = Label.anon()
563                               val reg1  = expr e1                               val reg1  = expr e1
564                               val opnd1 = I.Direct reg1                               val opnd1 = I.Direct reg1
565                           in  if setZeroBit e1 then ()                           in  if setZeroBit e1 then ()
# Line 770  Line 776 
776                    (* Generate addition *)                    (* Generate addition *)
777                fun addition(e1, e2) =                fun addition(e1, e2) =
778                    case e1 of                    case e1 of
779                      T.REG(_,rs) => if C.sameColor(rs,rd) then addN e2                      T.REG(_,rs) => if CB.sameColor(rs,rd) then addN e2
780                                     else addition1(e1,e2)                                     else addition1(e1,e2)
781                    | _ => addition1(e1,e2)                    | _ => addition1(e1,e2)
782                and addition1(e1, e2) =                and addition1(e1, e2) =
783                    case e2 of                    case e2 of
784                      T.REG(_,rs) => if C.sameColor(rs,rd) then addN e1                      T.REG(_,rs) => if CB.sameColor(rs,rd) then addN e1
785                                     else addition2(e1,e2)                                     else addition2(e1,e2)
786                    | _ => addition2(e1,e2)                    | _ => addition2(e1,e2)
787                and addition2(e1,e2) =                and addition2(e1,e2) =
# Line 964  Line 970 
970    
971            (* %eflags <- src *)            (* %eflags <- src *)
972        and moveToEflags src =        and moveToEflags src =
973            if C.sameColor(src, C.eflags) then ()            if CB.sameColor(src, C.eflags) then ()
974            else (move(I.Direct src, eax); emit(I.LAHF))            else (move(I.Direct src, eax); emit(I.LAHF))
975    
976            (* dst <- %eflags *)            (* dst <- %eflags *)
977        and moveFromEflags dst =        and moveFromEflags dst =
978            if C.sameColor(dst, C.eflags) then ()            if CB.sameColor(dst, C.eflags) then ()
979            else (emit(I.SAHF); move(eax, I.Direct dst))            else (emit(I.SAHF); move(eax, I.Direct dst))
980    
981           (* generate a condition code expression           (* generate a condition code expression
# Line 981  Line 987 
987             moveFromEflags rd             moveFromEflags rd
988            )            )
989          | doCCexpr(T.CC(cond,rs), rd, an) =          | doCCexpr(T.CC(cond,rs), rd, an) =
990            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
991               (moveToEflags rs; moveFromEflags rd)               (moveToEflags rs; moveFromEflags rd)
992            else            else
993               move'(I.Direct rs, I.Direct rd, an)               move'(I.Direct rs, I.Direct rd, an)
# Line 1052  Line 1058 
1058         (* convert mlrisc to cellset:         (* convert mlrisc to cellset:
1059          *)          *)
1060         and cellset mlrisc =         and cellset mlrisc =
1061             let val addCCReg = C.CellSet.add             let val addCCReg = CB.CellSet.add
1062                 fun g([],acc) = acc                 fun g([],acc) = acc
1063                   | g(T.GPR(T.REG(_,r))::regs,acc)  = g(regs,C.addReg(r,acc))                   | g(T.GPR(T.REG(_,r))::regs,acc)  = g(regs,C.addReg(r,acc))
1064                   | g(T.FPR(T.FREG(_,f))::regs,acc) = g(regs,C.addFreg(f,acc))                   | g(T.FPR(T.FREG(_,f))::regs,acc) = g(regs,C.addFreg(f,acc))
# Line 1066  Line 1072 
1072        let fun return(set, []) = set        let fun return(set, []) = set
1073              | return(set, a::an) =              | return(set, a::an) =
1074                case #peek A.RETURN_ARG a of                case #peek A.RETURN_ARG a of
1075                  SOME r => return(C.CellSet.add(r, set), an)                  SOME r => return(CB.CellSet.add(r, set), an)
1076                | NONE => return(set, an)                | NONE => return(set, an)
1077        in        in
1078            mark(I.CALL{opnd=operand ea,defs=cellset(def),uses=cellset(use),            mark(I.CALL{opnd=operand ea,defs=cellset(def),uses=cellset(use),
# Line 1082  Line 1088 
1088            let val src =            let val src =
1089                   case immedOrReg(operand d) of                   case immedOrReg(operand d) of
1090                       src as I.Direct r =>                       src as I.Direct r =>
1091                         if C.sameColor(r,C.eax)                         if CB.sameColor(r,C.eax)
1092                         then src else (move(src, eax); eax)                         then src else (move(src, eax); eax)
1093                     | src => src                     | src => src
1094            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 1250 
1250        and fload'(fty, ea, mem, fd, an) =        and fload'(fty, ea, mem, fd, an) =
1251              let val ea = address(ea, mem)              let val ea = address(ea, mem)
1252              in  mark(fld(fty, ea), an);              in  mark(fld(fty, ea), an);
1253                  if C.sameColor(fd,ST0) then ()                  if CB.sameColor(fd,ST0) then ()
1254                  else emit(fstp(fty, I.FDirect fd))                  else emit(fstp(fty, I.FDirect fd))
1255              end              end
1256    
# Line 1252  Line 1258 
1258    
1259            (* generate floating point expression and put the result in fd *)            (* generate floating point expression and put the result in fd *)
1260        and doFexpr'(fty, T.FREG(_, fs), fd, an) =        and doFexpr'(fty, T.FREG(_, fs), fd, an) =
1261              (if C.sameColor(fs,fd) then ()              (if CB.sameColor(fs,fd) then ()
1262               else mark(I.FCOPY{dst=[fd], src=[fs], tmp=NONE}, an)               else mark'(I.COPY{k=CB.FP, sz=64, dst=[fd], src=[fs], tmp=NONE}, an)
1263              )              )
1264          | doFexpr'(_, T.FLOAD(fty, ea, mem), fd, an) =          | doFexpr'(_, T.FLOAD(fty, ea, mem), fd, an) =
1265              fload'(fty, ea, mem, fd, an)              fload'(fty, ea, mem, fd, an)
1266          | doFexpr'(fty, T.FEXT fexp, fd, an) =          | doFexpr'(fty, T.FEXT fexp, fd, an) =
1267              (ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an};              (ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an};
1268               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))
1269              )              )
1270          | doFexpr'(fty, e, fd, an) =          | doFexpr'(fty, e, fd, an) =
1271              (reduceFexp(fty, e, []);              (reduceFexp(fty, e, []);
1272               if C.sameColor(fd,ST0) then ()               if CB.sameColor(fd,ST0) then ()
1273               else mark(fstp(fty, I.FDirect fd), an)               else mark(fstp(fty, I.FDirect fd), an)
1274              )              )
1275    
# Line 1345  Line 1351 
1351    
1352                and sameTree(LEAF(_, T.FREG(t1,f1), []),                and sameTree(LEAF(_, T.FREG(t1,f1), []),
1353                             LEAF(_, T.FREG(t2,f2), [])) =                             LEAF(_, T.FREG(t2,f2), [])) =
1354                          t1 = t2 andalso C.sameColor(f1,f2)                          t1 = t2 andalso CB.sameColor(f1,f2)
1355                  | sameTree _ = false                  | sameTree _ = false
1356    
1357                (* Traverse tree and generate code *)                (* Traverse tree and generate code *)
# Line 1544  Line 1550 
1550    
1551        and doFexpr''(fty, e, fd, an) =        and doFexpr''(fty, e, fd, an) =
1552            case e of            case e of
1553              T.FREG(_,fs) => if C.sameColor(fs,fd) then ()              T.FREG(_,fs) => if CB.sameColor(fs,fd) then ()
1554                              else fcopy''(fty, [fd], [fs], an)                              else fcopy''(fty, [fd], [fs], an)
1555              (* Stupid x86 does everything as 80-bits internally. *)              (* Stupid x86 does everything as 80-bits internally. *)
1556    
# Line 1752  Line 1758 
1758           )           )
1759    
1760        and reducer() =        and reducer() =
1761            T.REDUCER{reduceRexp    = expr,            TS.REDUCER{reduceRexp    = expr,
1762                      reduceFexp    = fexpr,                      reduceFexp    = fexpr,
1763                      reduceCCexp   = ccExpr,                      reduceCCexp   = ccExpr,
1764                      reduceStm     = stmt,                      reduceStm     = stmt,
1765                      operand       = operand,                      operand       = operand,
1766                      reduceOperand = reduceOpnd,                      reduceOperand = reduceOpnd,
1767                      addressOf     = fn e => address(e, I.Region.memory), (*XXX*)                      addressOf     = fn e => address(e, I.Region.memory), (*XXX*)
1768                      emit          = mark,                      emit          = mark',
1769                      instrStream   = instrStream,                      instrStream   = instrStream,
1770                      mltreeStream  = self()                      mltreeStream  = self()
1771                     }                     }
1772    
1773        and self() =        and self() =
1774            S.STREAM            TS.S.STREAM
1775            {  beginCluster   = beginCluster',            {  beginCluster   = beginCluster',
1776               endCluster     = endCluster',               endCluster     = endCluster',
1777               emit           = doStmt,               emit           = doStmt,

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

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