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/instructions/alphaProps.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/alpha/instructions/alphaProps.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 22  Line 22 
22    
23      datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL      datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL
24                    | IK_CALL_WITH_CUTS | IK_PHI | IK_SOURCE | IK_SINK                    | IK_CALL_WITH_CUTS | IK_PHI | IK_SOURCE | IK_SINK
25    
26      datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES      datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
27    
28     (*========================================================================     (*========================================================================
29      *  Instruction Kinds      *  Instruction Kinds
30      *========================================================================*)      *========================================================================*)
31      fun instrKind(I.BRANCH _)  = IK_JUMP      fun instrKind(I.ANNOTATION{i, ...}) = instrKind i
32        | instrKind(I.FBRANCH _) = IK_JUMP        | instrKind(I.INSTR instr) =
33        | instrKind(I.JMPL _)    = IK_JUMP          (case instr
34        | instrKind(I.COPY _)    = IK_COPY            of (I.BRANCH _)       => IK_JUMP
35        | instrKind(I.FCOPY _)   = IK_COPY             | (I.FBRANCH _)      => IK_JUMP
36        | instrKind(I.JSR{cutsTo=[],...}) = IK_CALL             | (I.JMPL _)         => IK_JUMP
37        | instrKind(I.JSR _) = IK_CALL_WITH_CUTS             | (I.COPY _)         => IK_COPY
38        | instrKind(I.BSR{cutsTo=[],...}) = IK_CALL             | (I.FCOPY _)        => IK_COPY
39        | instrKind(I.BSR _) = IK_CALL_WITH_CUTS             | (I.JSR{cutsTo=[],...}) => IK_CALL
40        | instrKind(I.RET _)     = IK_JUMP             | (I.JSR _)          => IK_CALL_WITH_CUTS
41        | instrKind(I.PHI _)     = IK_PHI             | (I.BSR{cutsTo=[],...}) => IK_CALL
42        | instrKind(I.SOURCE _)  = IK_SOURCE             | (I.BSR _)          => IK_CALL_WITH_CUTS
43        | instrKind(I.SINK _)    = IK_SINK             | (I.RET _)          => IK_JUMP
44        | instrKind(I.ANNOTATION{i,...}) = instrKind i             | (I.PHI _)          => IK_PHI
45               | (I.SOURCE _)       => IK_SOURCE
46               | (I.SINK _)         => IK_SINK
47               |  _                 => IK_INSTR
48            (*esac*))
49        | instrKind _            = IK_INSTR        | instrKind _            = IK_INSTR
50    
51      fun moveInstr(I.COPY _)  = true      fun moveInstr(I.ANNOTATION{i, ...}) = moveInstr i
52        | moveInstr(I.FCOPY _) = true        | moveInstr(I.INSTR(i)) =
53        | moveInstr(I.ANNOTATION{i,...}) = moveInstr i          (case i
54        | moveInstr _          = false            of (I.COPY _)  => true
55               | (I.FCOPY _) => true
56               | _ => false
57            (*esac*))
58          | moveInstr(I.LIVE _) = false
59          | moveInstr(I.KILL _) = false
60          | moveInstr _ = error "moveInstr"
61    
62      val nop =      val nop =
63        fn () => I.OPERATE{oper=I.BIS, ra=zeroR, rb=I.REGop zeroR, rc=zeroR}        fn () => I.operate{oper=I.BIS, ra=zeroR, rb=I.REGop zeroR, rc=zeroR}
64    
65     (*========================================================================     (*========================================================================
66      *  Parallel Move      *  Parallel Move
67      *========================================================================*)      *========================================================================*)
68      fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r      fun moveTmpR(I.INSTR(I.COPY{tmp=SOME(I.Direct r), ...})) = SOME r
69        | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f        | moveTmpR(I.INSTR(I.FCOPY{tmp=SOME(I.FDirect f), ...})) = SOME f
70        | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i        | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
71        | moveTmpR _ = NONE        | moveTmpR _ = NONE
72    
73      fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)      fun moveDstSrc(I.INSTR(I.COPY{dst, src, ...})) = (dst, src)
74        | moveDstSrc(I.FCOPY{dst, src, ...}) = (dst, src)        | moveDstSrc(I.INSTR(I.FCOPY{dst, src, ...})) = (dst, src)
75        | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i        | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
76        | moveDstSrc _ = error "moveDstSrc"        | moveDstSrc _ = error "moveDstSrc"
77    
78     (*========================================================================     (*========================================================================
79      *  Branches and Calls/Returns      *  Branches and Calls/Returns
80      *========================================================================*)      *========================================================================*)
81      fun branchTargets(I.BRANCH{b=I.BR, lab, ...}) = [LABELLED lab]      fun branchTargets(I.ANNOTATION{i,...}) = branchTargets i
82        | branchTargets(I.BRANCH{lab, ...})  = [LABELLED lab, FALLTHROUGH]        | branchTargets(I.INSTR(instr)) =
83        | branchTargets(I.FBRANCH{lab, ...}) = [LABELLED lab, FALLTHROUGH]          (case instr
84        | branchTargets(I.JMPL(_,[]))       = [ESCAPES]           of (I.BRANCH{b=I.BR, lab, ...}) => [LABELLED lab]
85        | branchTargets(I.JMPL(_,labs))     = map LABELLED labs            | (I.BRANCH{lab, ...})  => [LABELLED lab, FALLTHROUGH]
86        | branchTargets(I.RET _)            = [ESCAPES]            | (I.FBRANCH{lab, ...}) => [LABELLED lab, FALLTHROUGH]
87        | branchTargets(I.JSR{cutsTo, ...}) = FALLTHROUGH::map LABELLED cutsTo            | (I.JMPL(_,[]))       => [ESCAPES]
88        | branchTargets(I.BSR{cutsTo, ...}) = FALLTHROUGH::map LABELLED cutsTo            | (I.JMPL(_,labs))     => map LABELLED labs
89        | branchTargets(I.ANNOTATION{i,...}) = branchTargets i            | (I.RET _)            => [ESCAPES]
90              | (I.JSR{cutsTo, ...}) => FALLTHROUGH::map LABELLED cutsTo
91              | (I.BSR{cutsTo, ...}) => FALLTHROUGH::map LABELLED cutsTo
92              |  _ => error "branchTargets"
93            (*esac*))
94        | branchTargets _ = error "branchTargets"        | branchTargets _ = error "branchTargets"
95    
96      fun jump label = I.BRANCH{b=I.BR,r=zeroR,lab=label}      fun jump label = I.branch{b=I.BR,r=zeroR,lab=label}
97    
98      val immedRange = {lo= ~32768, hi = 32768}      val immedRange = {lo= ~32768, hi = 32768}
99      fun loadImmed{immed,t} =      fun loadImmed{immed,t} =
100          I.LDA{r=t,b=zeroR,          I.lda{r=t,b=zeroR,
101                d=if #lo immedRange <= immed andalso immed <= #hi immedRange                d=if #lo immedRange <= immed andalso immed <= #hi immedRange
102                then I.IMMop immed else I.LABop(I.T.LI(I.T.I.fromInt(64,immed)))}                then I.IMMop immed else I.LABop(I.T.LI(I.T.I.fromInt(64,immed)))}
103      fun loadOperand{opn,t} = I.LDA{r=t,b=zeroR,d=opn}      fun loadOperand{opn,t} = I.lda{r=t,b=zeroR,d=opn}
104    
105      fun setTargets(I.BRANCH{b=I.BR,r as CB.CELL{id=31,...}, ...},[L]) =      fun setTargets(I.INSTR(I.BRANCH{b=I.BR,r as CB.CELL{id=31,...}, ...}),[L]) =
106               I.BRANCH{b=I.BR,r=r,lab=L}               I.branch{b=I.BR,r=r,lab=L}
107        | setTargets(I.BRANCH{b,r,...},[F,T])  = I.BRANCH{b=b,r=r,lab=T}        | setTargets(I.INSTR(I.BRANCH{b,r,...}),[F,T])  = I.branch{b=b,r=r,lab=T}
108        | setTargets(I.FBRANCH{b,f,...},[F,T]) = I.FBRANCH{b=b,f=f,lab=T}        | setTargets(I.INSTR(I.FBRANCH{b,f,...}),[F,T]) = I.fbranch{b=b,f=f,lab=T}
109        | setTargets(I.JMPL(x,_),labs)       = I.JMPL(x,labs)        | setTargets(I.INSTR(I.JMPL(x,_)),labs)       = I.jmpl(x,labs)
110        | setTargets(I.ANNOTATION{i,a},labs) =        | setTargets(I.ANNOTATION{i,a},labs) =
111              I.ANNOTATION{i=setTargets(i,labs),a=a}              I.ANNOTATION{i=setTargets(i,labs),a=a}
112        | setTargets(i,_) = i        | setTargets(i,_) = i
# Line 114  Line 129 
129    
130      in      in
131        case br        case br
132        of I.BRANCH{b,r,lab} => I.BRANCH{b=revBranch b,r=r,lab=lab}        of I.INSTR(I.BRANCH{b,r,lab}) => I.branch{b=revBranch b,r=r,lab=lab}
133         | I.FBRANCH{b,f,lab} => I.FBRANCH{b=revFBranch b,f=f,lab=lab}         | I.INSTR(I.FBRANCH{b,f,lab}) => I.fbranch{b=revFBranch b,f=f,lab=lab}
134         | I.ANNOTATION{i,a} => I.ANNOTATION{i=negateConditional i,a=a}         | I.ANNOTATION{i,a} => I.ANNOTATION{i=negateConditional i,a=a}
135         | _ => raise NegateConditional         | _ => raise NegateConditional
136      end      end
# Line 139  Line 154 
154     (*========================================================================     (*========================================================================
155      *  Definition and use (for register allocation mainly)      *  Definition and use (for register allocation mainly)
156      *========================================================================*)      *========================================================================*)
157      fun defUseR instr =      fun defUseR instr = let
158        let          fun alphaDU(instr) = let
159          fun Oper {oper, ra, rb=I.REGop rb, rc} = ([rc], [ra, rb])          fun Oper {oper, ra, rb=I.REGop rb, rc} = ([rc], [ra, rb])
160            | Oper {oper, ra, rb, rc} = ([rc], [ra])            | Oper {oper, ra, rb, rc} = ([rc], [ra])
161          fun Opn(I.REGop rb,rs) = rb::rs          fun Opn(I.REGop rb,rs) = rb::rs
162            | Opn(_,rs) = rs            | Opn(_,rs) = rs
163          fun FMem (freg, (rd, _)) = ([], [rd])          fun FMem (freg, (rd, _)) = ([], [rd])
164          fun trap (def,use) =(def, use)          fun trap (def,use) =(def, use)
165    
166        in        in
167          case instr of          case instr of
168            (* load/store instructions *)            (* load/store instructions *)
# Line 178  Line 194 
194           | I.TRAPB      => trap([],[])           | I.TRAPB      => trap([],[])
195           (* macro *)           (* macro *)
196           | I.CALL_PAL{def,use, ...} => (C.getReg def, C.getReg use)           | I.CALL_PAL{def,use, ...} => (C.getReg def, C.getReg use)
          | I.ANNOTATION{a=CB.DEF_USE{cellkind=CB.GP,defs,uses}, i, ...} =>  
            let val (d,u) = defUseR i in (defs@d, u@uses) end  
          | I.ANNOTATION{a, i, ...} => defUseR i  
197           | _            => ([],[])           | _            => ([],[])
198        end        end
199        in
200          case instr
201           of I.ANNOTATION{a, i, ...} => defUseR i
202            | I.LIVE{regs, ...} => ([], C.getReg regs)
203            | I.KILL{regs, ...} => (C.getReg regs, [])
204            | I.INSTR(i) => alphaDU(i)
205            | _ => error "defUseR"
206    
207        end
208    
209      (* Use of FP registers *)      (* Use of FP registers *)
210      fun defUseF instr =      fun defUseF instr = let
211          fun alphaDU instr =
212        case instr of        case instr of
213          I.DEFFREG freg                          => ([freg], [])            I.FBRANCH{f, ...}                     =>  ([],[f])
       | I.FBRANCH{f, ...}                       =>  ([],[f])  
214        | I.FLOAD{r, ...}                         => ([r], [])        | I.FLOAD{r, ...}                         => ([r], [])
215        | I.FSTORE{r, ...}                        => ([], [r])        | I.FSTORE{r, ...}                        => ([], [r])
216        | I.FOPERATE{fa, fb, fc, ...}             => ([fc], [fa, fb])        | I.FOPERATE{fa, fb, fc, ...}             => ([fc], [fa, fb])
217        | I.FUNARY{fb, fc, ...}                   => ([fc], [fb])        | I.FUNARY{fb, fc, ...}                   => ([fc], [fb])
218        | I.PSEUDOARITH{tmps, ...}                => (C.getFreg tmps, [])        | I.PSEUDOARITH{tmps, ...}                => (C.getFreg tmps, [])
219        | I.FOPERATEV{fa, fb, fc, ...}            => ([fc], [fa, fb, fc])          | I.FOPERATEV{fa, fb, fc, ...}          => ([fc], [fa, fb])
220        | I.FCMOVE{fa,fb,fc,...}                  => ([fc], [fa, fb, fc])          | I.FCMOVE{fa,fb,fc,...}                => ([fc], [fa, fb])
221        | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)        | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
222        | I.FCOPY{dst, src, ...}                  => (dst, src)        | I.FCOPY{dst, src, ...}                  => (dst, src)
223        | I.JSR{defs,uses, ...}        => (C.getFreg defs,C.getFreg uses)        | I.JSR{defs,uses, ...}        => (C.getFreg defs,C.getFreg uses)
224        | I.BSR{defs,uses, ...}        => (C.getFreg defs,C.getFreg uses)        | I.BSR{defs,uses, ...}        => (C.getFreg defs,C.getFreg uses)
       | I.ANNOTATION{a=CB.DEF_USE{cellkind=CB.FP,defs,uses}, i, ...} =>  
         let val (d,u) = defUseF i in (defs@d, u@uses) end  
       | I.ANNOTATION{a, i, ...} => defUseF i  
225        | _ => ([],[])        | _ => ([],[])
226        in
227            case instr
228            of I.ANNOTATION{a, i, ...} => defUseF i
229             | I.INSTR(i) => alphaDU(i)
230             | I.LIVE{regs, ...} => ([], C.getFreg regs)
231             | I.KILL{regs, ...} => (C.getFreg regs, [])
232             | _ => error "defUseF"
233        end
234    
235      fun defUse CB.GP = defUseR      fun defUse CB.GP = defUseR
236        | defUse CB.FP = defUseF        | defUse CB.FP = defUseF
# Line 221  Line 248 
248     *  Replicate an instruction     *  Replicate an instruction
249     *========================================================================*)     *========================================================================*)
250    fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}    fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}
251      | replicate(I.COPY{tmp=SOME _, dst, src, impl}) =      | replicate(I.INSTR(I.COPY{tmp=SOME _, dst, src, impl})) =
252          I.COPY{tmp=SOME(I.Direct(C.newReg())), dst=dst, src=src, impl=ref NONE}          I.copy{tmp=SOME(I.Direct(C.newReg())), dst=dst, src=src, impl=ref NONE}
253      | replicate(I.FCOPY{tmp=SOME _, dst, src, impl}) =      | replicate(I.INSTR(I.FCOPY{tmp=SOME _, dst, src, impl})) =
254          I.FCOPY{tmp=SOME(I.FDirect(C.newFreg())),          I.fcopy{tmp=SOME(I.FDirect(C.newFreg())),
255                  dst=dst, src=src, impl=ref NONE}                  dst=dst, src=src, impl=ref NONE}
256      | replicate i = i      | replicate i = i
257  end  end

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