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

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

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

revision 469, Wed Nov 10 22:42:52 1999 UTC revision 475, Wed Nov 10 22:59:58 1999 UTC
# Line 11  Line 11 
11  functor Alpha  functor Alpha
12     (structure AlphaInstr : ALPHAINSTR     (structure AlphaInstr : ALPHAINSTR
13      structure AlphaMLTree : MLTREE      structure AlphaMLTree : MLTREE
        where Region   = AlphaInstr.Region  
        and   Constant = AlphaInstr.Constant  
        where type cond = MLTreeBasis.cond  
        and   type fcond = MLTreeBasis.fcond  
        and   type rounding_mode = MLTreeBasis.rounding_mode  
14      structure PseudoInstrs : ALPHA_PSEUDO_INSTR      structure PseudoInstrs : ALPHA_PSEUDO_INSTR
15         where I = AlphaInstr         sharing AlphaMLTree.Region   = AlphaInstr.Region
16           sharing AlphaMLTree.Constant = AlphaInstr.Constant
17           sharing PseudoInstrs.I = AlphaInstr
18           sharing PseudoInstrs.T = AlphaMLTree
19    
20        (* Cost of multiplication in cycles *)        (* Cost of multiplication in cycles *)
21      val multCost : int ref      val multCost : int ref
# Line 34  Line 32 
32    structure C   = AlphaInstr.C    structure C   = AlphaInstr.C
33    structure LE  = LabelExp    structure LE  = LabelExp
34    structure W32 = Word32    structure W32 = Word32
   structure U   = MLTreeUtil  
35    structure P   = PseudoInstrs    structure P   = PseudoInstrs
36    
37   (*********************************************************   (*********************************************************
# Line 645  Line 642 
642            let val ra = expr a            let val ra = expr a
643                val rb = opn b                val rb = opn b
644                val t  = newReg()                val t  = newReg()
645            in  signExt32(ra,t);            in  (* On the alpha, all 32 bit values are already sign extended.
646                mark(I.OPERATE{oper=I.SRA,ra=t,rb=rb,rc=d},an)                 * So no sign extension is necessary.
647                   * signExt32(ra,t);
648                   * mark(I.OPERATE{oper=I.SRA,ra=t,rb=rb,rc=d},an)
649                   *)
650                  mark(I.OPERATE{oper=I.SRA,ra=ra,rb=rb,rc=d},an)
651            end            end
652    
653        and sra64(a,b,d,an) =        and sra64(a,b,d,an) =
# Line 964  Line 965 
965            | T.NOTB(_,e) => arith(I.ORNOT,zeroT,e,d,an)            | T.NOTB(_,e) => arith(I.ORNOT,zeroT,e,d,an)
966    
967              (* loads *)              (* loads *)
968            | T.CVTI2I(_,T.SIGN_EXTEND,T.LOAD(8,ea,mem)) => load8s(ea,d,mem,an)            | T.CVTI2I(_,T.SIGN_EXTEND,_,T.LOAD(8,ea,mem)) =>
969            | T.CVTI2I(_,T.SIGN_EXTEND,T.LOAD(16,ea,mem)) => load16s(ea,d,mem,an)                 load8s(ea,d,mem,an)
970            | T.CVTI2I(_,T.SIGN_EXTEND,T.LOAD(32,ea,mem)) => load32s(ea,d,mem,an)            | T.CVTI2I(_,T.SIGN_EXTEND,_,T.LOAD(16,ea,mem)) =>
971                   load16s(ea,d,mem,an)
972              | T.CVTI2I(_,T.SIGN_EXTEND,_,T.LOAD(32,ea,mem)) =>
973                   load32s(ea,d,mem,an)
974            | T.LOAD(8,ea,mem) => load8(ea,d,mem,an)            | T.LOAD(8,ea,mem) => load8(ea,d,mem,an)
975            | T.LOAD(16,ea,mem) => load16(ea,d,mem,an)            | T.LOAD(16,ea,mem) => load16(ea,d,mem,an)
976            | T.LOAD(32,ea,mem) => load32s(ea,d,mem,an)            | T.LOAD(32,ea,mem) => load32s(ea,d,mem,an)
977            | T.LOAD(64,ea,mem) => load(I.LDQ,ea,d,mem,an)            | T.LOAD(64,ea,mem) => load(I.LDQ,ea,d,mem,an)
978    
979             (* floating -> int conversion *)             (* floating -> int conversion *)
980            | T.CVTF2I(ty,rounding,e) =>            | T.CVTF2I(ty,rounding,fty,e) =>
981              (case (Gen.fsize e,ty) of              (case (fty,ty) of
982                 (32,32) => cvtf2i(P.cvtsl,rounding,e,d,an)                 (32,32) => cvtf2i(P.cvtsl,rounding,e,d,an)
983               | (32,64) => cvtf2i(P.cvtsq,rounding,e,d,an)               | (32,64) => cvtf2i(P.cvtsq,rounding,e,d,an)
984               | (64,32) => cvtf2i(P.cvttl,rounding,e,d,an)               | (64,32) => cvtf2i(P.cvttl,rounding,e,d,an)
# Line 986  Line 990 
990            | T.COND(_,T.CMP(ty,cond,e1,e2),T.LI 1,T.LI 0) =>            | T.COND(_,T.CMP(ty,cond,e1,e2),T.LI 1,T.LI 0) =>
991                 compare(ty,cond,e1,e2,d,an)                 compare(ty,cond,e1,e2,d,an)
992            | T.COND(_,T.CMP(ty,cond,e1,e2),T.LI 0,T.LI 1) =>            | T.COND(_,T.CMP(ty,cond,e1,e2),T.LI 0,T.LI 1) =>
993                 compare(ty,U.negateCond cond,e1,e2,d,an)                 compare(ty,T.Util.negateCond cond,e1,e2,d,an)
994            | T.COND(_,T.CMP(ty,cond,e1,e2),x,y) =>            | T.COND(_,T.CMP(ty,cond,e1,e2),x,y) =>
995                 cmove(ty,cond,e1,e2,x,y,d,an)                 cmove(ty,cond,e1,e2,x,y,d,an)
996    
997            | T.SEQ(s,e) => (doStmt s; doExpr(e,d,an))            | T.SEQ(s,e) => (doStmt s; doExpr(e,d,an))
998            | T.MARK(e,a) => doExpr(e,d,a::an)            | T.MARK(e,a) => doExpr(e,d,a::an)
999    
1000                (* On the alpha: all 32 bit values are already sign extended.
1001                 * So no sign extension is necessary
1002                 *)
1003              | T.CVTI2I(64, _, 32, e) => doExpr(e, d, an)
1004    
1005             (* Defaults *)             (* Defaults *)
1006            | e => doExpr(Gen.compile e,d,an)            | e => doExpr(Gen.compile e,d,an)
1007    
# Line 1063  Line 1072 
1072               * Note: it is not necessary to convert single precision               * Note: it is not necessary to convert single precision
1073               * to double on the alpha.               * to double on the alpha.
1074               *)               *)
1075            | T.CVTF2F(fty,_,e) => (* ignore rounding mode for now *)            | T.CVTF2F(fty,_,fty',e) => (* ignore rounding mode for now *)
1076              (case (fty,Gen.fsize e) of              (case (fty,fty') of
1077                 (64,64) => doFexpr(e,d,an)                 (64,64) => doFexpr(e,d,an)
1078               | (64,32) => doFexpr(e,d,an)               | (64,32) => doFexpr(e,d,an)
1079               | (32,32) => doFexpr(e,d,an)               | (32,32) => doFexpr(e,d,an)
# Line 1073  Line 1082 
1082              )              )
1083    
1084              (* integer -> floating point conversion *)              (* integer -> floating point conversion *)
1085            | T.CVTI2F(fty,T.SIGN_EXTEND,e) =>            | T.CVTI2F(fty,T.SIGN_EXTEND,ty,e) =>
1086              let val pseudo =              let val pseudo =
1087                  case (Gen.size e,fty) of                  case (ty,fty) of
1088                    (ty,32) => if ty <= 32 then P.cvtls else P.cvtqs                    (ty,32) => if ty <= 32 then P.cvtls else P.cvtqs
1089                  | (ty,64) => if ty <= 32 then P.cvtlt else P.cvtqt                  | (ty,64) => if ty <= 32 then P.cvtlt else P.cvtqt
1090                  | _       => error "CVTI2F"                  | _       => error "CVTI2F"
# Line 1104  Line 1113 
1113        and branch(c,e,lab,an) =        and branch(c,e,lab,an) =
1114            case e of            case e of
1115              T.CMP(ty,cc,e1 as T.LI _,e2) =>              T.CMP(ty,cc,e1 as T.LI _,e2) =>
1116                 branchBS(ty,U.swapCond cc,e2,e1,lab,an)                 branchBS(ty,T.Util.swapCond cc,e2,e1,lab,an)
1117            | T.CMP(ty,cc,e1 as T.LI32 _,e2) =>            | T.CMP(ty,cc,e1 as T.LI32 _,e2) =>
1118                 branchBS(ty,U.swapCond cc,e2,e1,lab,an)                 branchBS(ty,T.Util.swapCond cc,e2,e1,lab,an)
1119            | T.CMP(ty,cc,e1,e2) => branchBS(ty,cc,e1,e2,lab,an)            | T.CMP(ty,cc,e1,e2) => branchBS(ty,cc,e1,e2,lab,an)
1120            | e => mark(I.BRANCH(I.BNE,ccExpr e,lab),an)            | e => mark(I.BRANCH(I.BNE,ccExpr e,lab),an)
1121    
# Line 1203  Line 1212 
1212                  (* move the immed operand to b *)                  (* move the immed operand to b *)
1213                  case a of                  case a of
1214                    (T.LI _ | T.LI32 _ | T.CONST _) =>                    (T.LI _ | T.LI32 _ | T.CONST _) =>
1215                         (MLTreeUtil.swapCond cond,b,a)                         (T.Util.swapCond cond,b,a)
1216                  | _ => (cond,a,b)                  | _ => (cond,a,b)
1217    
1218                fun sub(a,(T.LI 0 | T.LI32 0w0)) = expr a                fun sub(a,(T.LI 0 | T.LI32 0w0)) = expr a
# Line 1264  Line 1273 
1273                val (cond,e1,e2) =                val (cond,e1,e2) =
1274                    case e1 of                    case e1 of
1275                      (T.LI _ | T.LI32 _ | T.CONST _) =>                      (T.LI _ | T.LI32 _ | T.CONST _) =>
1276                         (MLTreeUtil.swapCond cond,e2,e1)                         (T.Util.swapCond cond,e2,e1)
1277                    | _ => (cond,e1,e2)                    | _ => (cond,e1,e2)
1278            in  case cond of            in  case cond of
1279                  T.EQ  => eq(e1,e2,d)                  T.EQ  => eq(e1,e2,d)

Legend:
Removed from v.469  
changed lines
  Added in v.475

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