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
 [smlnj] / sml / trunk / src / MLRISC / alpha / mltree / alpha.sml

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

revision 761, Sat Dec 23 05:37:37 2000 UTC revision 788, Wed Feb 28 04:09:48 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 *)

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()
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         *)         *)
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)  =
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
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 *)
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()
# 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)
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)
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 1354  Line 1352
1352                  | (T.NE,(true,e),ONE)  => (I.CMOVLBC,expr e,x,y)                  | (T.NE,(true,e),ONE)  => (I.CMOVLBC,expr e,x,y)
1353                       (* signed  *)                       (* signed  *)
1354                  | (T.EQ,_,_)           => (I.CMOVEQ,sub(a,b),x,y)                  | (T.EQ,_,_)           => (I.CMOVEQ,sub(a,b),x,y)
1355                  | (T.NE,_,_)           => (I.CMOVEQ,cmp(T.EQ,a,b),y,x)                  | (T.NE,_,_)           => (I.CMOVNE,sub(a,b),x,y)
1356                  | (T.GT,_,_)           => (I.CMOVGT,sub(a,b),x,y)                  | (T.GT,_,_)           => (I.CMOVGT,sub(a,b),x,y)
1357                  | (T.GE,_,_)           => (I.CMOVGE,sub(a,b),x,y)                  | (T.GE,_,_)           => (I.CMOVGE,sub(a,b),x,y)
1358                  | (T.LT,_,_)           => (I.CMOVLT,sub(a,b),x,y)                  | (T.LT,_,_)           => (I.CMOVLT,sub(a,b),x,y)
# 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, [_]) =>
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.761 changed lines Added in v.788