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 774, Wed Jan 10 12:50:56 2001 UTC revision 775, Fri Jan 12 01:17:51 2001 UTC
# Line 10  Line 10 
10    
11  functor Alpha  functor Alpha
12     (structure AlphaInstr : ALPHAINSTR     (structure AlphaInstr : ALPHAINSTR
     structure AlphaMLTree : MLTREE  
13      structure PseudoInstrs : ALPHA_PSEUDO_INSTR      structure PseudoInstrs : ALPHA_PSEUDO_INSTR
14      structure ExtensionComp : MLTREE_EXTENSION_COMP      structure ExtensionComp : MLTREE_EXTENSION_COMP
15         where T = AlphaMLTree and I = AlphaInstr         where I = AlphaInstr
        sharing AlphaMLTree.Region   = AlphaInstr.Region  
        sharing AlphaMLTree.LabelExp = AlphaInstr.LabelExp  
16         sharing PseudoInstrs.I = AlphaInstr         sharing PseudoInstrs.I = AlphaInstr
        sharing PseudoInstrs.T = AlphaMLTree  
17    
18        (* Cost of multiplication in cycles *)        (* Cost of multiplication in cycles *)
19      val multCost : int ref      val multCost : int ref
# Line 37  Line 33 
33     ) : MLTREECOMP =     ) : MLTREECOMP =
34  struct  struct
35    
   structure T   = AlphaMLTree  
   structure S   = T.Stream  
   structure R   = AlphaMLTree.Region  
36    structure I   = AlphaInstr    structure I   = AlphaInstr
37    structure C   = AlphaInstr.C    structure C   = I.C
38    structure LE  = I.LabelExp    structure T   = I.T
39      structure S   = T.Stream
40      structure R   = T.Region
41    structure W32 = Word32    structure W32 = Word32
42    structure P   = PseudoInstrs    structure P   = PseudoInstrs
43    structure A   = MLRiscAnnotations    structure A   = MLRiscAnnotations
# Line 165  Line 160 
160    fun toInt i = T.I.toInt(32, i)    fun toInt i = T.I.toInt(32, i)
161    val int_0   = T.I.int_0    val int_0   = T.I.int_0
162    val int_1   = T.I.int_1    val int_1   = T.I.int_1
163    fun EQ(x,y) = T.I.EQ(32, x, y)    fun EQ(x:IntInf.int,y) = x=y
   fun GE(x,y) = T.I.GE(32, x, y)  
   fun LE(x,y) = T.I.LE(32, x, y)  
   fun LT(x,y) = T.I.LT(32, x, y)  
164    
165    (*    (*
166     * Specialize the modules for multiplication/division     * Specialize the modules for multiplication/division
# Line 405  Line 397 
397        end        end
398    
399    
400        (* emit load immed *)        (* emit load label expression *)
401        and loadConst(c,d,an) = mark(I.LDA{r=d,b=zeroR,d=I.LABop(LE.CONST c)},an)        and loadLabexp(le,d,an) = mark(I.LDA{r=d,b=zeroR,d=I.LABop le},an)
   
       (* emit load label *)  
       and loadLabel(l,d,an) = mark(I.LDA{r=d,b=zeroR,d=I.LABop l},an)  
402    
403        (* emit a copy *)        (* emit a copy *)
404        and copy(dst,src,an) =        and copy(dst,src,an) =
# Line 475  Line 464 
464        (* convert an expression into an operand *)        (* convert an expression into an operand *)
465        and opn(T.REG(_,r)) = I.REGop r        and opn(T.REG(_,r)) = I.REGop r
466          | opn(e as T.LI n) =          | opn(e as T.LI n) =
467              if LE(n, T.I.int_0xff) andalso GE(n, T.I.int_0) then              if IntInf.<=(n, T.I.int_0xff) andalso IntInf.>=(n, T.I.int_0) then
468                I.IMMop(toInt(n))                I.IMMop(toInt(n))
469              else let val tmpR = newReg()              else let val tmpR = newReg()
470                   in  loadImmed(n,zeroR,tmpR,[]); I.REGop tmpR end                   in  loadImmed(n,zeroR,tmpR,[]); I.REGop tmpR end
471          | opn(T.CONST c) = I.LABop(LE.CONST c)          | opn(e as (T.CONST _ | T.LABEL _)) = I.LABop e
472            | opn(T.LABEXP x) = I.LABop x
473          | opn e = I.REGop(expr e)          | opn e = I.REGop(expr e)
474    
475        (* compute base+displacement from an expression        (* compute base+displacement from an expression
476         *)         *)
477        and addr exp =        and addr exp =
478            let fun toLexp(I.IMMop i) = LE.INT i            let fun toLexp(I.IMMop i) = T.LI(IntInf.fromInt i)
479                  | toLexp(I.LABop le) = le                  | toLexp(I.LABop le) = le
480                  | toLexp _ = error "addr.toLexp"                  | toLexp _ = error "addr.toLexp"
481    
482                fun add(n,I.IMMop m)  = I.IMMop(toInt n + m)                fun add(t,n,I.IMMop m)  =
483                  | add(n,I.LABop le) = I.LABop(LE.PLUS(LE.INT(toInt(n)),le))                     I.IMMop(toInt(T.I.ADD(t,n,IntInf.fromInt m)))
484                  | add(n,_) = error "addr.add"                  | add(t,n,I.LABop le) = I.LABop(T.ADD(t,T.LI n,le))
485                fun addC(c,I.IMMop 0) = I.LABop(LE.CONST c)                  | add(t,n,_) = error "addr.add"
486                  | addC(c,disp) = I.LABop(LE.PLUS(LE.CONST c,toLexp disp))  
487                fun addL(l,I.IMMop 0) = I.LABop l                fun addLe(ty,le,I.IMMop 0) = I.LABop le
488                  | addL(l,disp) = I.LABop(LE.PLUS(l,toLexp disp))                  | addLe(ty,le,disp) = I.LABop(T.ADD(ty,le,toLexp disp))
489                fun sub(n,I.IMMop m) = I.IMMop(m - toInt n)  
490                  | sub(n,I.LABop le) = I.LABop(LE.MINUS(le,LE.INT(toInt n)))                fun sub(t,n,I.IMMop m) =
491                  | sub(n,_) = error "addr.sub"                    I.IMMop(toInt(T.I.SUB(t,IntInf.fromInt m,n)))
492                fun subC(c,disp) = I.LABop(LE.MINUS(toLexp disp, LE.CONST c))                  | sub(t,n,I.LABop le) = I.LABop(T.SUB(t,le,T.LI n))
493                fun subL(l,disp) = I.LABop(LE.MINUS(toLexp disp, l))                  | sub(t,n,_) = error "addr.sub"
494    
495                  fun subLe(ty,le,I.IMMop 0) = I.LABop le
496                    | subLe(ty,le,disp) = I.LABop(T.SUB(ty,le,toLexp disp))
497    
498                (* Should really take into account of the address width XXX *)                (* Should really take into account of the address width XXX *)
499                fun fold(T.ADD(_,e,T.LI n),disp) = fold(e, add(n,disp))                fun fold(T.ADD(t,e,T.LI n),disp) = fold(e,add(t,n,disp))
500                  | fold(T.ADD(_,e,T.CONST c),disp) = fold(e, addC(c,disp))                  | fold(T.ADD(t,e,x as T.CONST _),disp) = fold(e,addLe(t,x,disp))
501                  | fold(T.ADD(_,e,T.LABEL l),disp) = fold(e, addL(l,disp))                  | fold(T.ADD(t,e,x as T.LABEL _),disp) = fold(e,addLe(t,x,disp))
502                  | fold(T.ADD(_,T.LI n,e),disp) = fold(e, add(n,disp))                  | fold(T.ADD(t,e,T.LABEXP l),disp) = fold(e,addLe(t,l,disp))
503                  | fold(T.ADD(_,T.CONST n, e),disp) = fold(e, addC(n,disp))                  | fold(T.ADD(t,T.LI n,e),disp) = fold(e, add(t,n,disp))
504                  | fold(T.ADD(_,T.LABEL l, e),disp) = fold(e, addL(l,disp))                  | fold(T.ADD(t,x as T.CONST _,e),disp) = fold(e,addLe(t,x,disp))
505                  | fold(T.SUB(_,e,T.LI n),disp) = fold(e, sub(n,disp))                  | fold(T.ADD(t,x as T.LABEL _,e),disp) = fold(e,addLe(t,x,disp))
506                  | fold(T.SUB(_,e,T.CONST n),disp) = fold(e, subC(n,disp))                  | fold(T.ADD(t,T.LABEXP l,e),disp) = fold(e,addLe(t,l,disp))
507                  | fold(T.SUB(_,e,T.LABEL l),disp) = fold(e, subL(l,disp))                  | fold(T.SUB(t,e,T.LI n),disp) = fold(e,sub(t,n,disp))
508                    | fold(T.SUB(t,e,x as T.CONST _),disp) = fold(e,subLe(t,x,disp))
509                    | fold(T.SUB(t,e,x as T.LABEL _),disp) = fold(e,subLe(t,x,disp))
510                    | fold(T.SUB(t,e,T.LABEXP l),disp) = fold(e,subLe(t,l,disp))
511                  | fold(e,disp) = (expr e,disp)                  | fold(e,disp) = (expr e,disp)
512    
513            in  makeEA(fold(exp, zeroImm))            in  makeEA(fold(exp, zeroImm))
# Line 528  Line 524 
524                 end                 end
525             end             end
526          | offset(base,disp as I.LABop le,off) =          | offset(base,disp as I.LABop le,off) =
527             (base, I.LABop(LE.PLUS(le,LE.INT off)))             (base, I.LABop(T.ADD(64,le,T.LI(IntInf.fromInt off))))
528          | offset(base,disp,off) =          | offset(base,disp,off) =
529             let val tmp = newReg()             let val tmp = newReg()
530             in  emit(I.OPERATE{oper=I.ADDQ,ra=base,rb=disp,rc=tmp});             in  emit(I.OPERATE{oper=I.ADDQ,ra=base,rb=disp,rc=tmp});
# Line 706  Line 702 
702                fun const(e,i) =                fun const(e,i) =
703                    let val r = expr e                    let val r = expr e
704                    in  if !useMultByConst andalso                    in  if !useMultByConst andalso
705                             GE(i, T.I.int_0) andalso                             IntInf.>=(i, T.I.int_0) andalso
706                             LT(i, T.I.int_0x100) then                             IntInf.<(i, T.I.int_0x100) then
707                           mark'(gen{ra=r,rb=I.IMMop(toInt i),rc=rd},an)::trapb                           mark'(gen{ra=r,rb=I.IMMop(toInt i),rc=rd},an)::trapb
708                        else                        else
709                           (genConst{r=r,i=toInt i,d=rd}@trapb                           (genConst{r=r,i=toInt i,d=rd}@trapb
# Line 920  Line 916 
916            case exp of            case exp of
917              T.REG(_,r) => move(r,d,an)              T.REG(_,r) => move(r,d,an)
918            | T.LI n     => loadImmed(n,zeroR,d,an)            | T.LI n     => loadImmed(n,zeroR,d,an)
919            | T.LABEL l  => loadLabel(l,d,an)            | T.LABEL l  => loadLabexp(exp,d,an)
920            | T.CONST c  => loadConst(c,d,an)            | T.CONST c  => loadLabexp(exp,d,an)
921              | T.LABEXP le => loadLabexp(le,d,an)
922    
923              (* special optimizations for additions and subtraction              (* special optimizations for additions and subtraction
924               * Question: using LDA for all widths is not really correct               * Question: using LDA for all widths is not really correct
925               * since the result may not fit into the sign extension scheme.               * since the result may not fit into the sign extension scheme.
926               *)               *)
927            | T.ADD(64,e,T.LABEL le) => mark(I.LDA{r=d,b=expr e,d=I.LABop le},an)            | T.ADD(64,e,T.LABEXP le) => mark(I.LDA{r=d,b=expr e,d=I.LABop le},an)
928            | T.ADD(64,T.LABEL le,e) => mark(I.LDA{r=d,b=expr e,d=I.LABop le},an)            | T.ADD(64,T.LABEXP le,e) => mark(I.LDA{r=d,b=expr e,d=I.LABop le},an)
929            | T.ADD(64,e,T.CONST c)  =>            | T.ADD(64,e,x as (T.CONST _ | T.LABEL _))  =>
930                 mark(I.LDA{r=d,b=expr e,d=I.LABop(LE.CONST c)},an)                 mark(I.LDA{r=d,b=expr e,d=I.LABop x},an)
931            | T.ADD(64,T.CONST c,e)  =>            | T.ADD(64,x as (T.CONST _ | T.LABEL _),e)  =>
932                 mark(I.LDA{r=d,b=expr e,d=I.LABop(LE.CONST c)},an)                 mark(I.LDA{r=d,b=expr e,d=I.LABop x},an)
933            | T.ADD(64,e,T.LI i)     => loadImmed(i, expr e, d, an)            | T.ADD(64,e,T.LI i)     => loadImmed(i, expr e, d, an)
934            | T.ADD(64,T.LI i,e)     => loadImmed(i, expr e, d, an)            | T.ADD(64,T.LI i,e)     => loadImmed(i, expr e, d, an)
935            | T.SUB(sz, a, b as T.LI z)    =>            | T.SUB(sz, a, b as T.LI z)    =>
# Line 1334  Line 1331 
1331                val (cond,a,b) =                val (cond,a,b) =
1332                  (* move the immed operand to b *)                  (* move the immed operand to b *)
1333                  case a of                  case a of
1334                    (T.LI _ | T.CONST _) => (T.Basis.swapCond cond,b,a)                    (T.LI _ | T.CONST _ | T.LABEL _ | T.LABEXP _) =>
1335                        (T.Basis.swapCond cond,b,a)
1336                  | _ => (cond,a,b)                  | _ => (cond,a,b)
1337    
1338                fun sub(a, T.LI z) =                fun sub(a, T.LI z) =
# Line 1397  Line 1395 
1395                    end                    end
1396                val (cond,e1,e2) =                val (cond,e1,e2) =
1397                    case e1 of                    case e1 of
1398                      (T.LI _ | T.CONST _) =>                      (T.LI _ | T.CONST _ | T.LABEL _ | T.LABEXP _) =>
1399                         (T.Basis.swapCond cond,e2,e1)                         (T.Basis.swapCond cond,e2,e1)
1400                    | _ => (cond,e1,e2)                    | _ => (cond,e1,e2)
1401            in  case cond of            in  case cond of
# Line 1423  Line 1421 
1421             val uses=cellset uses             val uses=cellset uses
1422             val instr =             val instr =
1423                 case (ea, flow) of                 case (ea, flow) of
1424                   (T.LABEL(LE.LABEL lab), [_]) =>                   (T.LABEL lab, [_]) =>
1425                     I.BSR{lab=lab,r=C.returnAddr,defs=defs,uses=uses,mem=mem}                     I.BSR{lab=lab,r=C.returnAddr,defs=defs,uses=uses,mem=mem}
1426                 | _ => I.JSR{r=C.returnAddr,b=expr ea,                 | _ => I.JSR{r=C.returnAddr,b=expr ea,
1427                              d=0,defs=defs,uses=uses,mem=mem}                              d=0,defs=defs,uses=uses,mem=mem}
# Line 1453  Line 1451 
1451            | T.CCMV(r,e) => doCCexpr(e,r,an)            | T.CCMV(r,e) => doCCexpr(e,r,an)
1452            | T.COPY(ty,dst,src) => copy(dst,src,an)            | T.COPY(ty,dst,src) => copy(dst,src,an)
1453            | T.FCOPY(ty,dst,src) => fcopy(dst,src,an)            | T.FCOPY(ty,dst,src) => fcopy(dst,src,an)
1454            | T.JMP(T.LABEL(LE.LABEL lab),_) => goto(lab,an)            | T.JMP(T.LABEL lab,_) => goto(lab,an)
1455            | T.JMP(e,labs) => mark(I.JMPL({r=zeroR,b=expr e,d=0},labs),an)            | T.JMP(e,labs) => mark(I.JMPL({r=zeroR,b=expr e,d=0},labs),an)
1456            | T.BCC(cc,lab) => branch(cc,lab,an)            | T.BCC(cc,lab) => branch(cc,lab,an)
1457            | T.CALL{funct,targets,defs,uses,region,...} =>            | T.CALL{funct,targets,defs,uses,region,...} =>

Legend:
Removed from v.774  
changed lines
  Added in v.775

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