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-fp.sml
ViewVC logotype

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

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

revision 1002, Fri Nov 30 17:11:33 2001 UTC revision 1003, Fri Dec 7 02:45:32 2001 UTC
# Line 144  Line 144 
144       | invert _ = error "invert"       | invert _ = error "invert"
145    
146     (* Pseudo instructions *)     (* Pseudo instructions *)
147     fun FLD(I.FP32, ea) = I.FLDS ea     fun FLD(I.FP32, ea) = I.flds ea
148       | FLD(I.FP64, ea) = I.FLDL ea       | FLD(I.FP64, ea) = I.fldl ea
149       | FLD(I.FP80, ea) = I.FLDT ea       | FLD(I.FP80, ea) = I.fldt ea
150    
151     fun FILD(I.I8, ea) = error "FILD"     fun FILD(I.I8, ea) = error "FILD"
152       | FILD(I.I16, ea) = I.FILD ea       | FILD(I.I16, ea) = I.fild ea
153       | FILD(I.I32, ea) = I.FILDL ea       | FILD(I.I32, ea) = I.fildl ea
154       | FILD(I.I64, ea) = I.FILDLL ea       | FILD(I.I64, ea) = I.fildll ea
155    
156     fun FSTP(I.FP32, ea) = I.FSTPS ea     fun FSTP(I.FP32, ea) = I.fstps ea
157       | FSTP(I.FP64, ea) = I.FSTPL ea       | FSTP(I.FP64, ea) = I.fstpl ea
158       | FSTP(I.FP80, ea) = I.FSTPT ea       | FSTP(I.FP80, ea) = I.fstpt ea
159    
160     fun FST(I.FP32, ea) = I.FSTS ea     fun FST(I.FP32, ea) = I.fsts ea
161       | FST(I.FP64, ea) = I.FSTL ea       | FST(I.FP64, ea) = I.fstl ea
162       | FST(I.FP80, ea) = error "FSTT"       | FST(I.FP80, ea) = error "FSTT"
163    
164     (*-----------------------------------------------------------------------     (*-----------------------------------------------------------------------
# Line 422  Line 422 
422                     A.sub(stTable, n)                     A.sub(stTable, n)
423                    )                    )
424    
425         fun FXCH n = I.FXCH{opnd=C.ST n}         fun FXCH n = I.fxch{opnd=C.ST n}
426    
427         val ST0 = ST 0         val ST0 = ST 0
428         val ST1 = ST 1         val ST1 = ST 1
429         val POP_ST = I.FSTPL ST0 (* Instruction to pop an entry *)         val POP_ST = I.fstpl ST0 (* Instruction to pop an entry *)
430    
431         (* Dump instructions *)         (* Dump instructions *)
432         fun dump instrs =         fun dump instrs =
# Line 572  Line 572 
572                          )                          )
573                        else (ST.xch(stack,0,i);                        else (ST.xch(stack,0,i);
574                              ST.pop stack;                              ST.pop stack;
575                              loop(0, depth-1, I.FSTPL(ST i)::code)                              loop(0, depth-1, I.fstpl(ST i)::code)
576                             )                             )
577                       )                       )
578                 end                 end
# Line 1103  Line 1103 
1103                 val oldIdToNewId = IntHashTable.lookup idMap                 val oldIdToNewId = IntHashTable.lookup idMap
1104    
1105                 (* Retarget a jump instruction to label l *)                 (* Retarget a jump instruction to label l *)
1106                 fun retargetJump(I.JMP(I.ImmedLabel(T.LABEL _), [_]), l) =                 fun retargetJump(I.INSTR(I.JMP(I.ImmedLabel(T.LABEL _), [_])), l) =
1107                       I.JMP(I.ImmedLabel(T.LABEL l), [l])                       I.jmp(I.ImmedLabel(T.LABEL l), [l])
1108                   | retargetJump(I.JCC{cond,opnd=I.ImmedLabel(T.LABEL _)},l)=                   | retargetJump(I.INSTR(I.JCC{cond,opnd=I.ImmedLabel(T.LABEL _)}),l)=
1109                       I.JCC{cond=cond,opnd=I.ImmedLabel(T.LABEL l)}                       I.jcc{cond=cond,opnd=I.ImmedLabel(T.LABEL l)}
1110                   | retargetJump(I.ANNOTATION{i,a},l) =                   | retargetJump(I.ANNOTATION{i,a},l) =
1111                       I.ANNOTATION{i=retargetJump(i,l),a=a}                       I.ANNOTATION{i=retargetJump(i,l),a=a}
1112                   | retargetJump(_,l) = error "retargetJump"                   | retargetJump(_,l) = error "retargetJump"
# Line 1360  Line 1360 
1360                                   (ST.pop stack; kill(fs, POP_ST::code))                                   (ST.pop stack; kill(fs, POP_ST::code))
1361                                 else                                 else
1362                                   (ST.xch(stack,0,i); ST.pop stack;                                   (ST.xch(stack,0,i); ST.pop stack;
1363                                    kill(fs, I.FSTPL(ST i)::code)                                    kill(fs, I.fstpl(ST i)::code)
1364                                   )                                   )
1365                             end                             end
1366                         end                         end
# Line 1410  Line 1410 
1410                           * set fd to %st(0)                           * set fd to %st(0)
1411                           *)                           *)
1412                        let val code = alloc(fd, code)                        let val code = alloc(fd, code)
1413                        in  DONE(mark(I.FLDL(ST ss),an)::code)                        in  DONE(mark(I.fldl(ST ss),an)::code)
1414                        end                        end
1415                 end                 end
1416    
# Line 1429  Line 1429 
1429                 fun xch(n) = (ST.xch(stack,0,n); FXCH n)                 fun xch(n) = (ST.xch(stack,0,n); FXCH n)
1430    
1431                 (* push %st(n) onto the stack *)                 (* push %st(n) onto the stack *)
1432                 fun push(n) = (ST.push(stack,~2); I.FLDL(ST n))                 fun push(n) = (ST.push(stack,~2); I.fldl(ST n))
1433    
1434    
1435                 (* push mem onto the stack *)                 (* push mem onto the stack *)
1436                 fun pushmem(src) = (ST.push(stack,~2); I.FLDL(src))                 fun pushmem(src) = (ST.push(stack,~2); I.fldl(src))
1437    
1438                 (* register -> memory move.                 (* register -> memory move.
1439                  * Use pop version of the opcode if it is the last use.                  * Use pop version of the opcode if it is the last use.
# Line 1463  Line 1463 
1463                     end                     end
1464                   | fiload{isize,ea,dst} =                   | fiload{isize,ea,dst} =
1465                     let val code = mark(FILD(isize,ea),an)::code                     let val code = mark(FILD(isize,ea),an)::code
1466                         val code = I.FSTPL(dst)::code (* XXX *)                         val code = I.fstpl(dst)::code (* XXX *)
1467                     in  DONE code                     in  DONE code
1468                     end                     end
1469    
# Line 1492  Line 1492 
1492                 (* Floating point unary operator *)                 (* Floating point unary operator *)
1493                 fun funop{fsize,unOp,src,dst} =                 fun funop{fsize,unOp,src,dst} =
1494                     let val code = movetotop(fsize, src, code)                     let val code = movetotop(fsize, src, code)
1495                         val code = mark(I.FUNARY unOp,an)::code                         val code = mark(I.funary unOp,an)::code
1496    
1497                         (* Moronic hack to deal with partial tangent! *)                         (* Moronic hack to deal with partial tangent! *)
1498                         val code =                         val code =
# Line 1518  Line 1518 
1518                     (* op2 := op1 - op2 *)                     (* op2 := op1 - op2 *)
1519                     fun oper(binOp,op1,op2,n,code) =                     fun oper(binOp,op1,op2,n,code) =
1520                     let val code =                     let val code =
1521                          mark(I.FBINARY{binOp=binOp,src=op1,dst=op2},an)                          mark(I.fbinary{binOp=binOp,src=op1,dst=op2},an)
1522                             ::code                             ::code
1523                     in  storeResult(I.FP64, dst, n, code)                     in  storeResult(I.FP64, dst, n, code)
1524                     end                     end
# Line 1607  Line 1607 
1607                 (* Floating point binary operator with integer conversion *)                 (* Floating point binary operator with integer conversion *)
1608                 fun fibinop{isize,binOp,lsrc,rsrc,dst} =                 fun fibinop{isize,binOp,lsrc,rsrc,dst} =
1609                 let fun oper(binOp,src,code) =                 let fun oper(binOp,src,code) =
1610                     let val code = mark(I.FIBINARY{binOp=binOp,src=src},an)                     let val code = mark(I.fibinary{binOp=binOp,src=src},an)
1611                                       ::code                                       ::code
1612                     in  storeResult(I.FP64, dst, 0, code)                     in  storeResult(I.FP64, dst, 0, code)
1613                     end                     end
# Line 1631  Line 1631 
1631                  *)                  *)
1632                 fun fcmp{fsize,lsrc,rsrc} =                 fun fcmp{fsize,lsrc,rsrc} =
1633                 let fun fucompp() =                 let fun fucompp() =
1634                         (ST.pop stack; ST.pop stack; mark(I.FUCOMPP,an))                         (ST.pop stack; ST.pop stack; mark(I.fucompp,an))
1635                     fun fucomp(n) =                     fun fucomp(n) =
1636                         (ST.pop stack; mark(I.FUCOMP(ST n),an))                         (ST.pop stack; mark(I.fucomp(ST n),an))
1637                     fun fucom(n) = mark(I.FUCOM(ST n),an)                     fun fucom(n) = mark(I.fucom(ST n),an)
1638    
1639                     fun genmemcmp() =                     fun genmemcmp() =
1640                         let val code = movememtotop(fsize, rsrc, code)                         let val code = movememtotop(fsize, rsrc, code)
# Line 1687  Line 1687 
1687                         let val (dx, sx) = getfs fx                         let val (dx, sx) = getfs fx
1688                             val (dy, sy) = getfs fy                             val (dy, sy) = getfs fy
1689                             fun fstp(n) =                             fun fstp(n) =
1690                                 (ST.xch(stack,n,0); ST.pop stack; I.FSTPL(ST n))                                 (ST.xch(stack,n,0); ST.pop stack; I.fstpl(ST n))
1691                         in  if sx = sy then regsame(dx, sx) (* same register!*)                         in  if sx = sy then regsame(dx, sx) (* same register!*)
1692                             else                             else
1693                                 (* first, move sx to %st(0) *)                                 (* first, move sx to %st(0) *)
# Line 1755  Line 1755 
1755                       | genCopy((fd, fs)::copies, code) =                       | genCopy((fd, fs)::copies, code) =
1756                         let val ss   = ST.fp(stack, CB.registerNum fs)                         let val ss   = ST.fp(stack, CB.registerNum fs)
1757                             val _    = ST.push(stack, CB.registerNum fd)                             val _    = ST.push(stack, CB.registerNum fd)
1758                             val code = I.FLDL(ST ss)::code                             val code = I.fldl(ST ss)::code
1759                         in  genCopy(copies, code) end                         in  genCopy(copies, code) end
1760    
1761                     (* perform the renaming; it must be done in parallel! *)                     (* perform the renaming; it must be done in parallel! *)
# Line 1790  Line 1790 
1790                 end                 end
1791    
1792                 fun call(instr, return) = let                 fun call(instr, return) = let
1793                   val code = mark(instr, an)::code                   val code = mark(I.INSTR instr, an)::code
1794                   val returnSet = SL.return(SL.uniq(getCell return))                   val returnSet = SL.return(SL.uniq(getCell return))
1795                 in                 in
1796                   case returnSet of                   case returnSet of
# Line 1800  Line 1800 
1800                       error "can't return more than one fp argument (yet)";                       error "can't return more than one fp argument (yet)";
1801                     DONE code                     DONE code
1802                 end                 end
1803                   fun x86trans instr =
1804             in  case instr of                  (case instr
1805                   (* annotation handling *)                    of I.FMOVE x   => (log(); fmove x)
                  I.ANNOTATION{i,a} =>  
                      trans(stamp, i, a::an, rest, dead, lastUses, code)  
   
                  (* handle floating point stuff *)  
                | I.FMOVE x   => (log(); fmove x)  
1806                 | I.FBINOP x  => (log(); fbinop x)                 | I.FBINOP x  => (log(); fbinop x)
1807                 | I.FIBINOP x => (log(); fibinop x)                 | I.FIBINOP x => (log(); fibinop x)
1808                 | I.FUNOP x   => (log(); funop x)                 | I.FUNOP x   => (log(); funop x)
# Line 1831  Line 1826 
1826                   ) => bug("Illegal FP instructions")                   ) => bug("Illegal FP instructions")
1827    
1828                    (* Other instructions are untouched *)                    (* Other instructions are untouched *)
1829                 | instr => FINISH(mark(instr, an)::code)                     | instr => FINISH(mark(I.INSTR instr, an)::code)
1830                   (*esac*))
1831               in
1832                   case instr
1833                   of I.ANNOTATION{a,i} =>
1834                          trans(stamp, i, a::an, rest, dead, lastUses, code)
1835                    | I.INSTR instr => x86trans(instr)
1836                    | _  => error "trans"
1837             end (* trans *)             end (* trans *)
1838    
1839             (*             (*
# Line 1842  Line 1844 
1844             let val n = ref(ST.depth stackIn)             let val n = ref(ST.depth stackIn)
1845                 fun push() = n := !n + 1                 fun push() = n := !n + 1
1846                 fun pop() = n := !n - 1                 fun pop() = n := !n - 1
1847                 fun scan(I.FBINARY{binOp, ...}) =                 fun scan(I.INSTR(I.FBINARY{binOp, ...})) =
1848                        (case binOp of                        (case binOp of
1849                          ( I.FADDP | I.FSUBP | I.FSUBRP | I.FMULP                          ( I.FADDP | I.FSUBP | I.FSUBRP | I.FMULP
1850                          | I.FDIVP | I.FDIVRP) => pop()                          | I.FDIVP | I.FDIVRP) => pop()
1851                        | _ => ()                        | _ => ()
1852                        )                        )
1853                   | scan(I.FIBINARY{binOp, ...}) = ()                   | scan(I.INSTR(I.FIBINARY{binOp, ...})) = ()
1854                   | scan(I.FUNARY I.FPTAN) = push()                   | scan(I.INSTR(I.FUNARY I.FPTAN)) = push()
1855                   | scan(I.FUNARY _) = ()                   | scan(I.INSTR(I.FUNARY _)) = ()
1856                   | scan(I.FLDL(I.ST n)) = push()                   | scan(I.INSTR(I.FLDL(I.ST n))) = push()
1857                   | scan(I.FLDL mem) = push()                   | scan(I.INSTR(I.FLDL mem)) = push()
1858                   | scan(I.FLDS mem) = push()                   | scan(I.INSTR(I.FLDS mem)) = push()
1859                   | scan(I.FLDT mem) = push()                   | scan(I.INSTR(I.FLDT mem)) = push()
1860                   | scan(I.FSTL(I.ST n)) = ()                   | scan(I.INSTR(I.FSTL(I.ST n))) = ()
1861                   | scan(I.FSTPL(I.ST n)) = pop()                   | scan(I.INSTR(I.FSTPL(I.ST n))) = pop()
1862                   | scan(I.FSTL mem) = ()                   | scan(I.INSTR(I.FSTL mem)) = ()
1863                   | scan(I.FSTS mem) = ()                   | scan(I.INSTR(I.FSTS mem)) = ()
1864                   | scan(I.FSTPL mem) = pop()                   | scan(I.INSTR(I.FSTPL mem)) = pop()
1865                   | scan(I.FSTPS mem) = pop()                   | scan(I.INSTR(I.FSTPS mem)) = pop()
1866                   | scan(I.FSTPT mem) = pop()                   | scan(I.INSTR(I.FSTPT mem)) = pop()
1867                   | scan(I.FXCH{opnd=i,...}) = ()                   | scan(I.INSTR(I.FXCH{opnd=i,...})) = ()
1868                   | scan(I.FUCOM _) = ()                   | scan(I.INSTR(I.FUCOM _)) = ()
1869                   | scan(I.FUCOMP _) = pop()                   | scan(I.INSTR(I.FUCOMP _)) = pop()
1870                   | scan(I.FUCOMPP) = (pop(); pop())                   | scan(I.INSTR(I.FUCOMPP)) = (pop(); pop())
1871                   | scan(I.FILD mem) = push()                   | scan(I.INSTR(I.FILD mem)) = push()
1872                   | scan(I.FILDL mem) = push()                   | scan(I.INSTR(I.FILDL mem)) = push()
1873                   | scan(I.FILDLL mem) = push()                   | scan(I.INSTR(I.FILDLL mem)) = push()
1874                   | scan _ = ()                   | scan _ = ()
1875                 val _ = app scan (rev insns);                 val _ = app scan (rev insns);
1876                 val n = !n                 val n = !n
1877                 val m = ST.depth stackOut                 val m = ST.depth stackOut
1878             in  if n <> m then             in
1879                   if n <> m then
1880                    (dump(insns);                    (dump(insns);
1881                     bug("Bad translation n="^i2s n^ " expected="^i2s m^"\n")                     bug("Bad translation n="^i2s n^ " expected="^i2s m^"\n")
1882                    )                    )

Legend:
Removed from v.1002  
changed lines
  Added in v.1003

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