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

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

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

revision 744, Fri Dec 8 04:11:42 2000 UTC revision 761, Sat Dec 23 05:37:37 2000 UTC
# Line 40  Line 40 
40    type instrStream = (I.instruction,C.cellset) T.stream    type instrStream = (I.instruction,C.cellset) T.stream
41    type mltreeStream = (T.stm,T.mlrisc list) T.stream    type mltreeStream = (T.stm,T.mlrisc list) T.stream
42    
43    
44    val (intTy,naturalWidths) = if bit64mode then (64,[32,64]) else (32,[32])    val (intTy,naturalWidths) = if bit64mode then (64,[32,64]) else (32,[32])
45    structure Gen = MLTreeGen    structure Gen = MLTreeGen
46      (structure T = T      (structure T = T
# Line 62  Line 63 
63        I.ROTATEI{oper=I.RLWINM,ra=d,rs=r,sh=I.ImmedOp(32-i),mb=i,me=SOME(31)}        I.ROTATEI{oper=I.RLWINM,ra=d,rs=r,sh=I.ImmedOp(32-i),mb=i,me=SOME(31)}
64    
65    (*    (*
   val _ = if C.lr = 80 then () else error "LR must be encoded as 80!"  
    *)  
   
   (*  
66     * Integer multiplication     * Integer multiplication
67     *)     *)
68    functor Multiply32 = MLTreeMult    functor Multiply32 = MLTreeMult
# Line 124  Line 121 
121        val newFreg = C.newFreg        val newFreg = C.newFreg
122        val newCCreg = C.newCell C.CC        val newCCreg = C.newCell C.CC
123    
124        fun signed16 i = ~32768 <= i andalso i < 32768  
125        fun signed12 i = ~2048 <= i andalso i < 2048        val int_0       = T.I.int_0
126        fun unsigned16 i = 0 <= i andalso i < 65536        val int_m0x8000 = T.I.fromInt(32, ~32768)
127        fun unsigned5  i = 0 <= i andalso i < 32        val int_0x8000  = T.I.fromInt(32,  32768)
128        fun unsigned6  i = 0 <= i andalso i < 64        val int_m0x800  = T.I.fromInt(32, ~2048)
129          val int_0x800   = T.I.fromInt(32,  2048)
130          fun LT (x,y)    = T.I.LT(32, x, y)
131          fun LE (x,y)    = T.I.LE(32, x, y)
132          fun toInt mi = T.I.toInt(32, mi)
133          fun LI i = T.I.fromInt(32, i)
134    
135          fun signed16 mi   = LE(int_m0x8000, mi) andalso LT(mi, int_0x8000)
136          fun signed12 mi   = LE(int_m0x800, mi) andalso LT(mi, int_0x800)
137          fun unsigned16 mi = LE(int_0, mi) andalso LT(mi, T.I.int_0x10000)
138          fun unsigned5 mi  = LE(int_0, mi) andalso LT(mi, T.I.int_32)
139          fun unsigned6 mi  = LE(int_0, mi) andalso LT(mi, T.I.int_64)
140    
141        fun move(rs,rd,an) =        fun move(rs,rd,an) =
142          if C.sameColor(rs,rd) then ()          if C.sameColor(rs,rd) then ()
# Line 158  Line 166 
166            defineLabel fallThrLab            defineLabel fallThrLab
167        end        end
168    
169        fun split n =        fun split n = let
170        let val wtoi = Word.toIntX          val wtoi = Word32.toIntX
171            val w = Word.fromInt n          val w = T.I.toWord32(32, n)
172            val hi = Word.~>>(w, 0w16)          val hi = W32.~>>(w, 0w16)
173            val lo = Word.andb(w, 0w65535)          val lo = W32.andb(w, 0w65535)
174            val (high, low) = if lo < 0w32768 then (hi, lo)          val (high, low) =
175                              else (hi+0w1, lo-0w65536)            if W32.<(lo,0w32768) then (hi, lo) else (hi+0w1, lo-0w65536)
176        in (wtoi high, wtoi low) end        in
177            (wtoi high, wtoi low)
178          end
179    
180        fun loadImmedHiLo(0, lo, rt, an) =        fun loadImmedHiLo(0, lo, rt, an) =
181              mark(I.ARITHI{oper=I.ADDI, rt=rt, ra=zeroR, im=I.ImmedOp lo}, an)              mark(I.ARITHI{oper=I.ADDI, rt=rt, ra=zeroR, im=I.ImmedOp lo}, an)
# Line 176  Line 186 
186    
187        fun loadImmed(n, rt, an) =        fun loadImmed(n, rt, an) =
188          if signed16 n then          if signed16 n then
189             mark(I.ARITHI{oper=I.ADDI, rt=rt, ra=zeroR, im=I.ImmedOp n}, an)             mark(I.ARITHI{oper=I.ADDI, rt=rt, ra=zeroR, im=I.ImmedOp(toInt(n))}, an)
190          else let val (hi, lo) = split n          else let val (hi, lo) = split n
191               in loadImmedHiLo(hi, lo, rt, an) end             in loadImmedHiLo(hi, lo, rt, an)
   
       fun loadImmedw(w, rt, an) =  
           let val wtoi = Word32.toIntX  
           in  if w < 0w32768 then  
                  mark(I.ARITHI{oper=I.ADDI,rt=rt,ra=zeroR,  
                                im=I.ImmedOp(wtoi w)}, an)  
               else  
                let val hi = Word32.~>>(w, 0w16)  
                    val lo = Word32.andb(w, 0w65535)  
                    val (high, low) =  
                     if lo < 0w32768 then (hi, lo) else (hi+0w1, lo-0w65536)  
                in loadImmedHiLo(wtoi high, wtoi low, rt, an)  
                end  
192            end            end
193    
194        fun loadLabel(lexp, rt, an) =        fun loadLabel(lexp, rt, an) =
# Line 202  Line 199 
199                          im=I.LabelOp(LE.CONST c)}, an)                          im=I.LabelOp(LE.CONST c)}, an)
200    
201        fun immedOpnd range (e1, e2 as T.LI i) =        fun immedOpnd range (e1, e2 as T.LI i) =
202             (expr e1, if range i then I.ImmedOp i else I.RegOp(expr e2))             (expr e1, if range i then I.ImmedOp(toInt i) else I.RegOp(expr e2))
203          | immedOpnd _ (e1, T.CONST c) = (expr e1, I.LabelOp(LE.CONST c))          | immedOpnd _ (e1, T.CONST c) = (expr e1, I.LabelOp(LE.CONST c))
204          | immedOpnd _ (e1, T.LABEL lexp) = (expr e1, I.LabelOp lexp)          | immedOpnd _ (e1, T.LABEL lexp) = (expr e1, I.LabelOp lexp)
         | immedOpnd range (e1, e2 as T.LI32 w) =  
           let fun opnd2() = I.RegOp(expr e2)  
           in (expr e1,  
               let val i = Word32.toIntX w  
               in if range i then I.ImmedOp i else opnd2()  
               end handle Overflow => opnd2())  
           end  
205          | immedOpnd _ (e1, e2) = (expr e1, I.RegOp(expr e2))          | immedOpnd _ (e1, e2) = (expr e1, I.RegOp(expr e2))
206    
207        and commImmedOpnd range (e1 as T.LI _, e2) =        and commImmedOpnd range (e1 as T.LI _, e2) =
# Line 235  Line 225 
225         *)         *)
226        and addr(size,T.ADD(_, e, T.LI i)) =        and addr(size,T.ADD(_, e, T.LI i)) =
227            let val ra = expr e            let val ra = expr e
228            in  if size i then (ra, I.ImmedOp i) else            in  if size i then (ra, I.ImmedOp(toInt i)) else
229                let val (hi, lo) = split i                let val (hi, lo) = split i
230                    val tmpR = newReg()                    val tmpR = newReg()
231                in  emit(I.ARITHI{oper=I.ADDIS, rt=tmpR, ra=ra, im=I.ImmedOp hi});                in  emit(I.ARITHI{oper=I.ADDIS, rt=tmpR, ra=ra, im=I.ImmedOp hi});
# Line 244  Line 234 
234            end            end
235          | addr(size,T.ADD(ty, T.LI i, e)) = addr(size,T.ADD(ty, e, T.LI i))          | addr(size,T.ADD(ty, T.LI i, e)) = addr(size,T.ADD(ty, e, T.LI i))
236          | addr(size,exp as T.SUB(ty, e, T.LI i)) =          | addr(size,exp as T.SUB(ty, e, T.LI i)) =
237              (addr(size,T.ADD(ty, e, T.LI (~i)))              (addr(size,T.ADD(ty, e, T.LI (T.I.NEGT(32, i))))
238                 handle Overflow => (expr exp, I.ImmedOp 0))                 handle Overflow => (expr exp, I.ImmedOp 0))
239          | addr(size,T.ADD(_, e1, e2)) = (expr e1, I.RegOp (expr e2))          | addr(size,T.ADD(_, e1, e2)) = (expr e1, I.RegOp (expr e2))
240          | addr(size,e) = (expr e, I.ImmedOp 0)          | addr(size,e) = (expr e, I.ImmedOp 0)
# Line 290  Line 280 
280          | stmt(s, _) = doStmts(Gen.compileStm s)          | stmt(s, _) = doStmts(Gen.compileStm s)
281    
282        and branch(T.CMP(_, _, T.LI _, T.LI _), _, _) = error "branch"        and branch(T.CMP(_, _, T.LI _, T.LI _), _, _) = error "branch"
         | branch(T.CMP(ty, cc, T.ANDB(_, e1, e2), T.LI 0), lab, an) =  
           (case commImmedOpnd unsigned16 (e1, e2)  
             of (ra, I.RegOp rb) =>  
                 emit(I.ARITH{oper=I.AND, ra=ra, rb=rb, rt=newReg(),  
                              Rc=true, OE=false})  
              | (ra, opnd) =>  
                 emit(I.ARITHI{oper=I.ANDI_Rc, ra=ra, im=opnd, rt=newReg()})  
            (*esac*);  
             branch(T.CC(cc, CR0), lab, an)  
           )  
283          | branch(T.CMP(ty, cc, e1 as T.LI _, e2), lab, an) =          | branch(T.CMP(ty, cc, e1 as T.LI _, e2), lab, an) =
284            let val cc' = T.Basis.swapCond cc            let val cc' = T.Basis.swapCond cc
285            in  branch(T.CMP(ty, cc', e2, e1), lab, an)            in  branch(T.CMP(ty, cc', e2, e1), lab, an)
286            end            end
287          | branch(cmp as T.CMP(ty, cond, _, _), lab, an) =          | branch(cmp as T.CMP(ty, cond, e1, e2), lab, an) = let
           let val ccreg = if true then CR0 else newCCreg() (* XXX *)  
288                val (bo, cf) =                val (bo, cf) =
289                  (case cond of                (case cond
290                     T.LT =>  (I.TRUE,  I.LT)                 of T.LT  => (I.TRUE,  I.LT)
291                   | T.LE =>  (I.FALSE, I.GT)                   | T.LE =>  (I.FALSE, I.GT)
292                   | T.EQ =>  (I.TRUE,  I.EQ)                   | T.EQ =>  (I.TRUE,  I.EQ)
293                   | T.NE =>  (I.FALSE, I.EQ)                   | T.NE =>  (I.FALSE, I.EQ)
# Line 319  Line 298 
298                   | T.GTU => (I.TRUE,  I.GT)                   | T.GTU => (I.TRUE,  I.GT)
299                   | T.GEU => (I.FALSE, I.LT)                   | T.GEU => (I.FALSE, I.LT)
300                 (*esac*))                 (*esac*))
301                val ccreg = if true then CR0 else newCCreg() (* XXX *)
302               val addr = I.LabelOp(LE.LABEL lab)               val addr = I.LabelOp(LE.LABEL lab)
303            in doCCexpr(cmp, ccreg, []);              fun default() =
304               emitBranch{bo=bo, bf=ccreg, bit=cf, addr=addr, LK=false}                (doCCexpr(cmp, ccreg, []);
305                   emitBranch{bo=bo, bf=ccreg, bit=cf, addr=addr, LK=false})
306              in
307                case (e1, e2)
308                of (T.ANDB(_, a1, a2), T.LI z) =>
309                    if T.I.isZero(z) then
310                      (case commImmedOpnd unsigned16 (a1, a2)
311                       of (ra, I.RegOp rb) =>
312                            emit(I.ARITH{oper=I.AND, ra=ra, rb=rb, rt=newReg(), Rc=true, OE=false})
313                        | (ra, opnd) =>
314                            emit(I.ARITHI{oper=I.ANDI_Rc, ra=ra, im=opnd, rt=newReg()})
315                       (*esac*);
316                       branch(T.CC(cond, CR0), lab, an))
317                    else
318                      default()
319                 | _ =>
320                      default()
321            end            end
322          | branch(T.CC(cc, cr), lab, an) =          | branch(T.CC(cc, cr), lab, an) =
323            let val addr=I.LabelOp(LE.LABEL lab)            let val addr=I.LabelOp(LE.LABEL lab)
# Line 398  Line 394 
394    
395        and subfImmed(i, ra, rt, an) =        and subfImmed(i, ra, rt, an) =
396            if signed16 i then            if signed16 i then
397               mark(I.ARITHI{oper=I.SUBFIC, rt=rt, ra=ra, im=I.ImmedOp i}, an)               mark(I.ARITHI{oper=I.SUBFIC, rt=rt, ra=ra, im=I.ImmedOp(toInt i)}, an)
398            else            else
399               mark(I.ARITH{oper=I.SUBF, rt=rt, ra=ra, rb=expr(T.LI i),               mark(I.ARITH{oper=I.SUBF, rt=rt, ra=ra, rb=expr(T.LI i),
400                            Rc=false, OE=false}, an)                            Rc=false, OE=false}, an)
# Line 462  Line 458 
458    
459        (* Generate a subtract operation *)        (* Generate a subtract operation *)
460        and subtract(ty, e1, e2 as T.LI i, rt, an) =        and subtract(ty, e1, e2 as T.LI i, rt, an) =
461              (doExpr(T.ADD(ty, e1, T.LI (~i)), rt, an)              (doExpr(T.ADD(ty, e1, T.LI (T.I.NEGT(32, i))), rt, an)
462                handle Overflow =>                handle Overflow =>
463                mark(I.ARITH{oper=I.SUBF, rt=rt, ra=expr e2,                mark(I.ARITH{oper=I.SUBF, rt=rt, ra=expr e2,
464                             rb=expr e1, OE=false, Rc=false}, an)                             rb=expr e1, OE=false, Rc=false}, an)
# Line 471  Line 467 
467          | subtract(ty, T.CONST c, e2, rt, an) =          | subtract(ty, T.CONST c, e2, rt, an) =
468               mark(I.ARITHI{oper=I.SUBFIC,rt=rt,ra=expr e2,               mark(I.ARITHI{oper=I.SUBFIC,rt=rt,ra=expr e2,
469                             im=I.LabelOp(LE.CONST c)},an)                             im=I.LabelOp(LE.CONST c)},an)
         | subtract(ty, T.LI32 w, e2, rt, an) =  
              subfImmed(Word32.toIntX w, expr e2, rt, an)  
470          | subtract(ty, e1, e2, rt, an) =          | subtract(ty, e1, e2, rt, an) =
471            let val rb = expr e1 val ra = expr e2            let val rb = expr e1 val ra = expr e2
472            in  mark(I.ARITH{oper=I.SUBF,rt=rt,ra=ra,rb=rb,Rc=false,OE=false},an)            in  mark(I.ARITH{oper=I.SUBF,rt=rt,ra=ra,rb=rb,Rc=false,OE=false},an)
# Line 489  Line 483 
483                       an)]                       an)]
484                fun const(e,i) =                fun const(e,i) =
485                    let val r = expr e                    let val r = expr e
486                    in  genMult{r=r,i=i,d=rt}                    in  genMult{r=r,i=toInt(i),d=rt}
487                        handle _ => nonconst(T.REG(ty,r),T.LI i)                        handle _ => nonconst(T.REG(ty,r),T.LI i)
488                    end                    end
               fun constw(e,i) = const(e,Word32.toInt i)  
                                  handle _ => nonconst(e,T.LI32 i)  
489                val instrs =                val instrs =
490                   case (e1,e2) of                   case (e1,e2) of
491                     (_,T.LI i)   => const(e1,i)                     (_,T.LI i)   => const(e1,i)
                  | (_,T.LI32 i) => constw(e1,i)  
492                   | (T.LI i,_)   => const(e2,i)                   | (T.LI i,_)   => const(e2,i)
                  | (T.LI32 i,_) => constw(e2,i)  
493                   | _            => nonconst(e1,e2)                   | _            => nonconst(e1,e2)
494            in  app emit instrs end            in  app emit instrs end
495    
# Line 507  Line 497 
497    
498        and divt32 x = Mult32.divide{mode=T.TO_ZERO,stm=doStmt} x        and divt32 x = Mult32.divide{mode=T.TO_ZERO,stm=doStmt} x
499    
       (*  
       and GOTO lab = T.JMP(T.LABEL(LE.LABEL lab), [], [])  
   
       and roundToZero{ty,r,i,d} =  
       let val L = Label.newLabel ""  
           val dReg = T.REG(ty,d)  
       in  doStmt(T.MV(ty,d,T.REG(ty,r)));  
           doStmt(T.IF(T.CMP(ty,T.GE,dReg,T.LI 0),GOTO L,T.SEQ []));  
           doStmt(T.MV(ty,d,T.ADD(ty,dReg,T.LI i)));  
           defineLabel L  
       end  
        *)  
   
500            (* Generate optimized division code *)            (* Generate optimized division code *)
501        and divide(ty,oper,genDiv,e1,e2,rt,overflow,an) =        and divide(ty,oper,genDiv,e1,e2,rt,overflow,an) =
502            let fun nonconst(e1,e2) =            let fun nonconst(e1,e2) =
# Line 529  Line 506 
506                    )                    )
507                fun const(e,i) =                fun const(e,i) =
508                    let val r = expr e                    let val r = expr e
509                    in  app emit (genDiv{r=r,i=i,d=rt})                    in  app emit (genDiv{r=r,i=toInt(i),d=rt})
510                        handle _ => nonconst(T.REG(ty,r),T.LI i)                        handle _ => nonconst(T.REG(ty,r),T.LI i)
511                    end                    end
               fun constw(e,i) = const(e,Word32.toInt i)  
                                 handle _ => nonconst(e,T.LI32 i)  
512            in  case (e1,e2) of            in  case (e1,e2) of
513                  (_,T.LI i)   => const(e1,i)                  (_,T.LI i)   => const(e1,i)
               | (_,T.LI32 i) => constw(e1,i)  
514                | _            => nonconst(e1,e2)                | _            => nonconst(e1,e2)
515            end            end
516    
# Line 572  Line 546 
546               T.REG(_,rs)  => if C.sameColor(rs,C.lr) then mark(MFLR rt,an)               T.REG(_,rs)  => if C.sameColor(rs,C.lr) then mark(MFLR rt,an)
547                               else move(rs,rt,an)                               else move(rs,rt,an)
548             | T.LI i       => loadImmed(i, rt, an)             | T.LI i       => loadImmed(i, rt, an)
            | T.LI32 w     => loadImmedw(w, rt, an)  
549             | T.LABEL lexp => loadLabel(lexp, rt, an)             | T.LABEL lexp => loadLabel(lexp, rt, an)
550             | T.CONST c    => loadConst(c, rt, an)             | T.CONST c    => loadConst(c, rt, an)
551    

Legend:
Removed from v.744  
changed lines
  Added in v.761

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