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 1009, Wed Jan 9 19:44:22 2002 UTC revision 1181, Wed Mar 27 21:27:27 2002 UTC
# Line 1  Line 1 
1  (*  (* x86.sml
2   *   *
3   * COPYRIGHT (c) 1998 Bell Laboratories.   * COPYRIGHT (c) 1998 Bell Laboratories.
4   *   *
# Line 82  Line 82 
82    
83    structure Gen = MLTreeGen    structure Gen = MLTreeGen
84       (structure T = T       (structure T = T
85          structure Cells = C
86        val intTy = 32        val intTy = 32
87        val naturalWidths = [32]        val naturalWidths = [32]
88        datatype rep = SE | ZE | NEITHER        datatype rep = SE | ZE | NEITHER
# Line 149  Line 150 
150    
151        (* Add an overflow trap *)        (* Add an overflow trap *)
152        fun trap() =        fun trap() =
153        let val jmp =        let
154              val jmp =
155              case !trapLabel of              case !trapLabel of
156                NONE => let val label = Label.label "trap" ()                NONE => let val label = Label.label "trap" ()
157                            val jmp   = I.jcc{cond=I.O,                            val jmp   =
158                                              opnd=I.ImmedLabel(T.LABEL label)}                                I.ANNOTATION{i=I.jcc{cond=I.O,
159                                                       opnd=I.ImmedLabel(T.LABEL label)},
160                                               a=MLRiscAnnotations.BRANCHPROB (Probability.unlikely)}
161                        in  trapLabel := SOME(jmp, label); jmp end                        in  trapLabel := SOME(jmp, label); jmp end
162              | SOME(jmp, _) => jmp              | SOME(jmp, _) => jmp
163        in  emitInstruction jmp end        in  emitInstruction jmp end
# Line 289  Line 293 
293          | cond T.EQ = I.EQ | cond T.NE  = I.NE          | cond T.EQ = I.EQ | cond T.NE  = I.NE
294          | cond T.GE = I.GE | cond T.GEU = I.AE          | cond T.GE = I.GE | cond T.GEU = I.AE
295          | cond T.GT = I.GT | cond T.GTU = I.A          | cond T.GT = I.GT | cond T.GTU = I.A
296            | cond cc = error(concat["cond(", T.Basis.condToString cc, ")"])
297    
298        fun zero dst = emit(I.BINARY{binOp=I.XORL, src=dst, dst=dst})        fun zero dst = emit(I.BINARY{binOp=I.XORL, src=dst, dst=dst})
299    
# Line 760  Line 765 
765                let fun genCmov(dstR, _) =                let fun genCmov(dstR, _) =
766                    let val _ = doExpr(no, dstR, []) (* false branch *)                    let val _ = doExpr(no, dstR, []) (* false branch *)
767                        val cc = cmp(true, ty, cc, t1, t2, [])  (* compare *)                        val cc = cmp(true, ty, cc, t1, t2, [])  (* compare *)
768                    in  mark(I.CMOV{cond=cond cc, src=operand yes, dst=dstR}, an)                    in  mark(I.CMOV{cond=cond cc, src=regOrMem(operand yes),
769                                      dst=dstR}, an)
770                    end                    end
771                in  dstMustBeReg genCmov                in  dstMustBeReg genCmov
772                end                end
# Line 872  Line 878 
878               | T.REMU(32, x, y) => rem(false, false, x, y)               | T.REMU(32, x, y) => rem(false, false, x, y)
879    
880               | T.MULS(32, x, y) => multiply(x, y)               | T.MULS(32, x, y) => multiply(x, y)
881               | T.DIVS(32, x, y) => divide(true, false, x, y)               | T.DIVS(T.DIV_TO_ZERO, 32, x, y) => divide(true, false, x, y)
882               | T.REMS(32, x, y) => rem(true, false, x, y)               | T.REMS(T.DIV_TO_ZERO, 32, x, y) => rem(true, false, x, y)
883    
884               | T.ADDT(32, x, y) => (binaryComm(I.ADDL, x, y); trap())               | T.ADDT(32, x, y) => (binaryComm(I.ADDL, x, y); trap())
885               | T.SUBT(32, x, y) => (binary(I.SUBL, x, y); trap())               | T.SUBT(32, x, y) => (binary(I.SUBL, x, y); trap())
886               | T.MULT(32, x, y) => (multiply(x, y); trap())               | T.MULT(32, x, y) => (multiply(x, y); trap())
887               | T.DIVT(32, x, y) => divide(true, true, x, y)               | T.DIVT(T.DIV_TO_ZERO, 32, x, y) => divide(true, true, x, y)
888               | T.REMT(32, x, y) => rem(true, true, x, y)               | T.REMT(T.DIV_TO_ZERO, 32, x, y) => rem(true, true, x, y)
889    
890               | T.ANDB(32, x, y) => binaryComm(I.ANDL, x, y)               | T.ANDB(32, x, y) => binaryComm(I.ANDL, x, y)
891               | T.ORB(32, x, y)  => binaryComm(I.ORL, x, y)               | T.ORB(32, x, y)  => binaryComm(I.ORL, x, y)
# Line 899  Line 905 
905               | T.ZX(32,8,T.LOAD(8,ea,mem)) => load8(ea, mem)               | T.ZX(32,8,T.LOAD(8,ea,mem)) => load8(ea, mem)
906               | T.ZX(32,16,T.LOAD(16,ea,mem)) => load16(ea, mem)               | T.ZX(32,16,T.LOAD(16,ea,mem)) => load16(ea, mem)
907    
908               | T.COND(32, T.CMP(ty, cc, t1, t2), T.LI yes, T.LI no) =>               | T.COND(32, T.CMP(ty, cc, t1, t2), y as T.LI yes, n as T.LI no) =>
909                   setcc(ty, cc, t1, t2, toInt32 yes, toInt32 no)                  (case !arch of (* PentiumPro and higher has CMOVcc *)
910                      Pentium => setcc(ty, cc, t1, t2, toInt32 yes, toInt32 no)
911                    | _ => cmovcc(ty, cc, t1, t2, y, n)
912                    )
913               | T.COND(32, T.CMP(ty, cc, t1, t2), yes, no) =>               | T.COND(32, T.CMP(ty, cc, t1, t2), yes, no) =>
914                  (case !arch of (* PentiumPro and higher has CMOVcc *)                  (case !arch of (* PentiumPro and higher has CMOVcc *)
915                     Pentium => unknownExp exp                     Pentium => unknownExp exp
# Line 1116  Line 1125 
1125    
1126            (* generate code for floating point compare and branch *)            (* generate code for floating point compare and branch *)
1127        and fbranch(fty, fcc, t1, t2, lab, an) =        and fbranch(fty, fcc, t1, t2, lab, an) =
1128              let fun j cc = mark(I.JCC{cond=cc, opnd=immedLabel lab},an)
1129              in  fbranching(fty, fcc, t1, t2, j)
1130              end
1131    
1132          and fbranching(fty, fcc, t1, t2, j) =
1133            let fun ignoreOrder (T.FREG _) = true            let fun ignoreOrder (T.FREG _) = true
1134                  | ignoreOrder (T.FLOAD _) = true                  | ignoreOrder (T.FLOAD _) = true
1135                  | ignoreOrder (T.FMARK(e,_)) = ignoreOrder e                  | ignoreOrder (T.FMARK(e,_)) = ignoreOrder e
# Line 1137  Line 1151 
1151                        val rsrc = foperand(fty, t2)                        val rsrc = foperand(fty, t2)
1152                        val fsize = fsize fty                        val fsize = fsize fty
1153                        fun cmp(lsrc, rsrc, fcc) =                        fun cmp(lsrc, rsrc, fcc) =
1154                            (emit(I.FCMP{fsize=fsize,lsrc=lsrc,rsrc=rsrc}); fcc)                        let val i = !arch <> Pentium
1155                          in  emit(I.FCMP{i=i,fsize=fsize,lsrc=lsrc,rsrc=rsrc});
1156                              fcc
1157                          end
1158                    in  case (lsrc, rsrc) of                    in  case (lsrc, rsrc) of
1159                           (I.FPR _, I.FPR _) => cmp(lsrc, rsrc, fcc)                           (I.FPR _, I.FPR _) => cmp(lsrc, rsrc, fcc)
1160                         | (I.FPR _, mem) => cmp(mem,lsrc,T.Basis.swapFcond fcc)                         | (I.FPR _, mem) => cmp(mem,lsrc,T.Basis.swapFcond fcc)
# Line 1158  Line 1175 
1175                fun testil i = emit(I.TESTL{lsrc=eax,rsrc=I.Immed(i)})                fun testil i = emit(I.TESTL{lsrc=eax,rsrc=I.Immed(i)})
1176                fun xoril i = emit(I.BINARY{binOp=I.XORL,src=I.Immed(i),dst=eax})                fun xoril i = emit(I.BINARY{binOp=I.XORL,src=I.Immed(i),dst=eax})
1177                fun cmpil i = emit(I.CMPL{rsrc=I.Immed(i), lsrc=eax})                fun cmpil i = emit(I.CMPL{rsrc=I.Immed(i), lsrc=eax})
               fun j(cc, lab) = mark(I.JCC{cond=cc, opnd=immedLabel lab},an)  
1178                fun sahf() = emit(I.SAHF)                fun sahf() = emit(I.SAHF)
1179                fun branch(fcc) =                fun branch(fcc) =
1180                    case fcc                    case fcc
1181                    of T.==   => (andil 0x4400; xoril 0x4000; j(I.EQ, lab))                    of T.==   => (andil 0x4400; xoril 0x4000; j(I.EQ))
1182                     | T.?<>  => (andil 0x4400; xoril 0x4000; j(I.NE, lab))                     | T.?<>  => (andil 0x4400; xoril 0x4000; j(I.NE))
1183                     | T.?    => (sahf(); j(I.P,lab))                     | T.?    => (sahf(); j(I.P))
1184                     | T.<=>  => (sahf(); j(I.NP,lab))                     | T.<=>  => (sahf(); j(I.NP))
1185                     | T.>    => (testil 0x4500;  j(I.EQ,lab))                     | T.>    => (testil 0x4500;  j(I.EQ))
1186                     | T.?<=  => (testil 0x4500;  j(I.NE,lab))                     | T.?<=  => (testil 0x4500;  j(I.NE))
1187                     | T.>=   => (testil 0x500; j(I.EQ,lab))                     | T.>=   => (testil 0x500; j(I.EQ))
1188                     | T.?<   => (testil 0x500; j(I.NE,lab))                     | T.?<   => (testil 0x500; j(I.NE))
1189                     | T.<    => (andil 0x4500; cmpil 0x100; j(I.EQ,lab))                     | T.<    => (andil 0x4500; cmpil 0x100; j(I.EQ))
1190                     | T.?>=  => (andil 0x4500; cmpil 0x100; j(I.NE,lab))                     | T.?>=  => (andil 0x4500; cmpil 0x100; j(I.NE))
1191                     | T.<=   => (andil 0x4100; cmpil 0x100; j(I.EQ,lab);                     | T.<=   => (andil 0x4100; cmpil 0x100; j(I.EQ);
1192                                  cmpil 0x4000; j(I.EQ,lab))                                  cmpil 0x4000; j(I.EQ))
1193                     | T.?>   => (sahf(); j(I.P,lab); testil 0x4100; j(I.EQ,lab))                     | T.?>   => (sahf(); j(I.P); testil 0x4100; j(I.EQ))
1194                     | T.<>   => (testil 0x4400; j(I.EQ,lab))                     | T.<>   => (testil 0x4400; j(I.EQ))
1195                     | T.?=   => (testil 0x4400; j(I.NE,lab))                     | T.?=   => (testil 0x4400; j(I.NE))
1196                     | _      => error "fbranch"                     | _      => error(concat[
1197                                      "fbranch(", T.Basis.fcondToString fcc, ")"
1198                                    ])
1199                     (*esac*)
1200    
1201                  (*
1202                   *             P  Z  C
1203                   * x < y       0  0  1
1204                   * x > y       0  0  0
1205                   * x = y       0  1  0
1206                   * unordered   1  1  1
1207                   * When it's unordered, all three flags, P, Z, C are set.
1208                   *)
1209    
1210                  fun fast_branch(fcc) =
1211                      case fcc
1212                      of T.==   => orderedOnly(I.EQ)
1213                       | T.?<>  => (j(I.P); j(I.NE))
1214                       | T.?    => j(I.P)
1215                       | T.<=>  => j(I.NP)
1216                       | T.>    => orderedOnly(I.A)
1217                       | T.?<=  => j(I.BE)
1218                       | T.>=   => orderedOnly(I.AE)
1219                       | T.?<   => j(I.B)
1220                       | T.<    => orderedOnly(I.B)
1221                       | T.?>=  => (j(I.P); j(I.AE))
1222                       | T.<=   => orderedOnly(I.BE)
1223                       | T.?>   => (j(I.P); j(I.A))
1224                       | T.<>   => orderedOnly(I.NE)
1225                       | T.?=   => j(I.EQ)
1226                       | _      => error(concat[
1227                                      "fbranch(", T.Basis.fcondToString fcc, ")"
1228                                    ])
1229                   (*esac*)                   (*esac*)
1230                  and orderedOnly fcc =
1231                  let val label = Label.anon()
1232                  in  emit(I.JCC{cond=I.P, opnd=immedLabel label});
1233                      j fcc;
1234                      defineLabel label
1235                  end
1236    
1237                val fcc = compare()                val fcc = compare()
1238            in  emit I.FNSTSW;            in  if !arch <> Pentium andalso
1239                     (enableFastFPMode andalso !fast_floating_point) then
1240                    fast_branch(fcc)
1241                  else
1242                    (emit I.FNSTSW;
1243                branch(fcc)                branch(fcc)
1244                    )
1245            end            end
1246    
1247        (*========================================================        (*========================================================
# Line 1508  Line 1568 
1568        and fbinop(targetFty,        and fbinop(targetFty,
1569                   binOp, binOpR, ibinOp, ibinOpR, lsrc, rsrc, fd, an) =                   binOp, binOpR, ibinOp, ibinOpR, lsrc, rsrc, fd, an) =
1570                (* Put the mem operand in rsrc *)                (* Put the mem operand in rsrc *)
1571            let val _ = floatingPointUsed := true;            let
1572                fun isMemOpnd(T.FREG(_, f)) = isFMemReg f                fun isMemOpnd(T.FREG(_, f)) = isFMemReg f
1573                  | isMemOpnd(T.FLOAD _) = true                  | isMemOpnd(T.FLOAD _) = true
1574                  | isMemOpnd(T.CVTI2F(_, (16 | 32), _)) = true                  | isMemOpnd(T.CVTI2F(_, (16 | 32), _)) = true
# Line 1549  Line 1609 
1609            end            end
1610    
1611        and doFexpr''(fty, e, fd, an) =        and doFexpr''(fty, e, fd, an) =
1612             (floatingPointUsed := true;
1613            case e of            case e of
1614              T.FREG(_,fs) => if CB.sameColor(fs,fd) then ()              T.FREG(_,fs) => if CB.sameColor(fs,fd) then ()
1615                              else fcopy''(fty, [fd], [fs], an)                              else fcopy''(fty, [fd], [fs], an)
# Line 1590  Line 1651 
1651            | T.FEXT fexp =>            | T.FEXT fexp =>
1652               ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an}               ExtensionComp.compileFext (reducer()) {e=fexp, fd=fd, an=an}
1653            | _ => error("doFexpr''")            | _ => error("doFexpr''")
1654             )
1655    
1656         (*========================================================         (*========================================================
1657          * Tie the two styles of fp code generation together          * Tie the two styles of fp code generation together

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

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