Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/MLRISC/alpha/instructions/alphaProps.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/alpha/instructions/alphaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1082 - (view) (download)

1 : monnier 409 (* alphaProps.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 : george 984 functor AlphaProps
8 :     (structure Instr : ALPHAINSTR
9 :     structure MLTreeHash : MLTREE_HASH where T = Instr.T
10 :     structure MLTreeEval : MLTREE_EVAL where T = Instr.T
11 :     ):INSN_PROPERTIES =
12 : monnier 409 struct
13 : george 984 structure I = Instr
14 : monnier 409 structure C = I.C
15 : george 889 structure CB = CellsBasis
16 : monnier 409
17 :     exception NegateConditional
18 :    
19 :     fun error msg = MLRiscErrorMsg.impossible ("alphaProps."^msg)
20 :    
21 : george 889 val zeroR = Option.valOf(C.zeroReg CB.GP)
22 : monnier 409
23 : george 545 datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL
24 : leunga 796 | IK_CALL_WITH_CUTS | IK_PHI | IK_SOURCE | IK_SINK
25 : george 1003
26 : monnier 409 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
27 :    
28 :     (*========================================================================
29 :     * Instruction Kinds
30 :     *========================================================================*)
31 : george 1003 fun instrKind(I.ANNOTATION{i, ...}) = instrKind i
32 : george 1009 | instrKind(I.COPY _) = IK_COPY
33 : george 1003 | instrKind(I.INSTR instr) =
34 :     (case instr
35 :     of (I.BRANCH _) => IK_JUMP
36 :     | (I.FBRANCH _) => IK_JUMP
37 :     | (I.JMPL _) => IK_JUMP
38 :     | (I.JSR{cutsTo=[],...}) => IK_CALL
39 :     | (I.JSR _) => IK_CALL_WITH_CUTS
40 :     | (I.BSR{cutsTo=[],...}) => IK_CALL
41 :     | (I.BSR _) => IK_CALL_WITH_CUTS
42 :     | (I.RET _) => IK_JUMP
43 :     | (I.PHI _) => IK_PHI
44 :     | (I.SOURCE _) => IK_SOURCE
45 :     | (I.SINK _) => IK_SINK
46 :     | _ => IK_INSTR
47 :     (*esac*))
48 :     | instrKind _ = IK_INSTR
49 : monnier 409
50 : george 1003 fun moveInstr(I.ANNOTATION{i, ...}) = moveInstr i
51 : george 1009 | moveInstr(I.COPY _) = true
52 :     | moveInstr _ = false
53 : monnier 409
54 :     val nop =
55 : george 1003 fn () => I.operate{oper=I.BIS, ra=zeroR, rb=I.REGop zeroR, rc=zeroR}
56 : monnier 409
57 :     (*========================================================================
58 :     * Parallel Move
59 :     *========================================================================*)
60 : george 1009 fun moveTmpR(I.COPY{tmp=SOME t, ...}) =
61 :     (case t of I.Direct r => SOME r | I.FDirect f => SOME f | _ => NONE)
62 : monnier 409 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
63 :     | moveTmpR _ = NONE
64 :    
65 : george 1009 fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
66 : monnier 409 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
67 :     | moveDstSrc _ = error "moveDstSrc"
68 :    
69 :     (*========================================================================
70 :     * Branches and Calls/Returns
71 :     *========================================================================*)
72 : george 1003 fun branchTargets(I.ANNOTATION{i,...}) = branchTargets i
73 :     | branchTargets(I.INSTR(instr)) =
74 :     (case instr
75 :     of (I.BRANCH{b=I.BR, lab, ...}) => [LABELLED lab]
76 :     | (I.BRANCH{lab, ...}) => [LABELLED lab, FALLTHROUGH]
77 :     | (I.FBRANCH{lab, ...}) => [LABELLED lab, FALLTHROUGH]
78 :     | (I.JMPL(_,[])) => [ESCAPES]
79 :     | (I.JMPL(_,labs)) => map LABELLED labs
80 :     | (I.RET _) => [ESCAPES]
81 :     | (I.JSR{cutsTo, ...}) => FALLTHROUGH::map LABELLED cutsTo
82 :     | (I.BSR{cutsTo, ...}) => FALLTHROUGH::map LABELLED cutsTo
83 :     | _ => error "branchTargets"
84 :     (*esac*))
85 : monnier 409 | branchTargets _ = error "branchTargets"
86 :    
87 : george 1003 fun jump label = I.branch{b=I.BR,r=zeroR,lab=label}
88 : monnier 409
89 :     val immedRange = {lo= ~32768, hi = 32768}
90 : leunga 657 fun loadImmed{immed,t} =
91 : george 1003 I.lda{r=t,b=zeroR,
92 : leunga 657 d=if #lo immedRange <= immed andalso immed <= #hi immedRange
93 : leunga 775 then I.IMMop immed else I.LABop(I.T.LI(I.T.I.fromInt(64,immed)))}
94 : george 1003 fun loadOperand{opn,t} = I.lda{r=t,b=zeroR,d=opn}
95 : monnier 409
96 : george 1003 fun setTargets(I.INSTR(I.BRANCH{b=I.BR,r as CB.CELL{id=31,...}, ...}),[L]) =
97 :     I.branch{b=I.BR,r=r,lab=L}
98 :     | setTargets(I.INSTR(I.BRANCH{b,r,...}),[F,T]) = I.branch{b=b,r=r,lab=T}
99 :     | setTargets(I.INSTR(I.FBRANCH{b,f,...}),[F,T]) = I.fbranch{b=b,f=f,lab=T}
100 :     | setTargets(I.INSTR(I.JMPL(x,_)),labs) = I.jmpl(x,labs)
101 : monnier 409 | setTargets(I.ANNOTATION{i,a},labs) =
102 : george 545 I.ANNOTATION{i=setTargets(i,labs),a=a}
103 : monnier 409 | setTargets(i,_) = i
104 :    
105 : jhr 1082 fun negateConditional (br, lab) = let
106 : monnier 409 fun revBranch I.BEQ = I.BNE
107 :     | revBranch I.BGE = I.BLT
108 :     | revBranch I.BGT = I.BLE
109 :     | revBranch I.BLE = I.BGT
110 :     | revBranch I.BLT = I.BGE
111 :     | revBranch I.BLBC = I.BLBS
112 :     | revBranch I.BLBS = I.BLBC
113 :     | revBranch _ = raise NegateConditional
114 :     fun revFBranch I.FBEQ = I.FBNE
115 :     | revFBranch I.FBNE = I.FBEQ
116 :     | revFBranch I.FBGE = I.FBLT
117 :     | revFBranch I.FBGT = I.FBLE
118 :     | revFBranch I.FBLE = I.FBGT
119 :     | revFBranch I.FBLT = I.FBGE
120 :     in
121 :     case br
122 : jhr 1082 of I.INSTR(I.BRANCH{b,r,...}) => I.branch{b=revBranch b,r=r,lab=lab}
123 :     | I.INSTR(I.FBRANCH{b,f,...}) => I.fbranch{b=revFBranch b,f=f,lab=lab}
124 :     | I.ANNOTATION{i,a} => I.ANNOTATION{i=negateConditional(i, lab),a=a}
125 : monnier 409 | _ => raise NegateConditional
126 :     end
127 :    
128 :     (*========================================================================
129 :     * Equality and hashing for operands
130 :     *========================================================================*)
131 : george 889 fun hashOpn(I.REGop r) = CB.hashCell r
132 : monnier 409 | hashOpn(I.IMMop i) = Word.fromInt i
133 : george 984 | hashOpn(I.HILABop l) = MLTreeHash.hash l
134 :     | hashOpn(I.LOLABop l) = MLTreeHash.hash l
135 :     | hashOpn(I.LABop l) = MLTreeHash.hash l
136 : monnier 409
137 : george 889 fun eqOpn(I.REGop a,I.REGop b) = CB.sameColor(a,b)
138 : monnier 409 | eqOpn(I.IMMop a,I.IMMop b) = a = b
139 : george 984 | eqOpn(I.HILABop a,I.HILABop b) = MLTreeEval.==(a,b)
140 :     | eqOpn(I.LOLABop a,I.LOLABop b) = MLTreeEval.==(a,b)
141 :     | eqOpn(I.LABop a,I.LABop b) = MLTreeEval.==(a,b)
142 : monnier 409 | eqOpn _ = false
143 :    
144 :     (*========================================================================
145 :     * Definition and use (for register allocation mainly)
146 :     *========================================================================*)
147 : george 1003 fun defUseR instr = let
148 :     fun alphaDU(instr) = let
149 :     fun Oper {oper, ra, rb=I.REGop rb, rc} = ([rc], [ra, rb])
150 :     | Oper {oper, ra, rb, rc} = ([rc], [ra])
151 :     fun Opn(I.REGop rb,rs) = rb::rs
152 :     | Opn(_,rs) = rs
153 :     fun FMem (freg, (rd, _)) = ([], [rd])
154 :     fun trap (def,use) =(def, use)
155 : monnier 409
156 : george 1003 in
157 :     case instr of
158 :     (* load/store instructions *)
159 :     I.LDA{r, b, ...} => ([r], [b])
160 :     | I.LDAH{r, b, ...} => ([r], [b])
161 :     | I.LOAD{r, b, ...} => ([r], [b])
162 :     | I.STORE{r, b, ...} => ([], [r,b])
163 :     | I.FLOAD{b, ...} => ([], [b])
164 :     | I.FSTORE{b, ...} => ([], [b])
165 :     (* branch instructions *)
166 :     | I.JMPL ({r, b, ...},_) => ([r], [b])
167 :     | I.JSR{r, b, defs, uses, ...} => (r::C.getReg defs, b::C.getReg uses)
168 :     | I.BSR{r, defs, uses, ...} => (r::C.getReg defs,C.getReg uses)
169 :     | I.RET{r, b, ...} => ([r],[b])
170 :     | I.BRANCH{b=I.BR, r, ...} => ([r], [])
171 :     | I.BRANCH{r, ...} => ([], [r])
172 :     (* operate *)
173 :     | I.OPERATE arg => Oper arg
174 :     | I.PSEUDOARITH {oper, ra, rb=I.REGop rb, rc, tmps} =>
175 :     (rc:: C.getReg tmps, [ra, rb])
176 :     | I.PSEUDOARITH {oper, ra, rb, rc, tmps} => (rc:: C.getReg tmps, [ra])
177 :     | I.OPERATEV arg => trap(Oper arg)
178 :     | I.CMOVE{ra,rb,rc,...} => ([rc],Opn(rb,[ra,rc]))
179 :     (* floating operate *)
180 :     | I.FOPERATEV _ => trap([], [])
181 :     | I.TRAPB => trap([],[])
182 :     (* macro *)
183 :     | I.CALL_PAL{def,use, ...} => (C.getReg def, C.getReg use)
184 :     | _ => ([],[])
185 :     end
186 :     in
187 :     case instr
188 :     of I.ANNOTATION{a, i, ...} => defUseR i
189 :     | I.LIVE{regs, ...} => ([], C.getReg regs)
190 :     | I.KILL{regs, ...} => (C.getReg regs, [])
191 : george 1009 | I.COPY{k=CB.GP, dst, src, tmp, ...} =>
192 :     (case tmp
193 :     of SOME(I.Direct r) => (r::dst, src)
194 :     | SOME(I.Displace{base, ...}) => (dst, base::src)
195 :     | _ => (dst, src)
196 :     (*esac*))
197 :     | I.COPY _ => ([], [])
198 : george 1003 | I.INSTR(i) => alphaDU(i)
199 :    
200 :     end
201 :    
202 : monnier 409 (* Use of FP registers *)
203 : george 1003 fun defUseF instr = let
204 :     fun alphaDU instr =
205 :     case instr of
206 :     I.FBRANCH{f, ...} => ([],[f])
207 :     | I.FLOAD{r, ...} => ([r], [])
208 :     | I.FSTORE{r, ...} => ([], [r])
209 :     | I.FOPERATE{fa, fb, fc, ...} => ([fc], [fa, fb])
210 :     | I.FUNARY{fb, fc, ...} => ([fc], [fb])
211 :     | I.PSEUDOARITH{tmps, ...} => (C.getFreg tmps, [])
212 :     | I.FOPERATEV{fa, fb, fc, ...} => ([fc], [fa, fb])
213 :     | I.FCMOVE{fa,fb,fc,...} => ([fc], [fa, fb])
214 :     | I.JSR{defs,uses, ...} => (C.getFreg defs,C.getFreg uses)
215 :     | I.BSR{defs,uses, ...} => (C.getFreg defs,C.getFreg uses)
216 :     | _ => ([],[])
217 :     in
218 :     case instr
219 :     of I.ANNOTATION{a, i, ...} => defUseF i
220 :     | I.INSTR(i) => alphaDU(i)
221 :     | I.LIVE{regs, ...} => ([], C.getFreg regs)
222 : george 1009 | I.COPY{k=CB.FP, dst, src, tmp, ...} =>
223 :     (case tmp
224 :     of SOME(I.FDirect f) => (f::dst, src)
225 :     | _ => (dst, src)
226 :     (*esac*))
227 :     | I.COPY _ => ([], [])
228 : george 1003 | I.KILL{regs, ...} => (C.getFreg regs, [])
229 :     end
230 : monnier 409
231 : george 889 fun defUse CB.GP = defUseR
232 :     | defUse CB.FP = defUseF
233 : monnier 409 | defUse _ = error "defUse"
234 :    
235 :     (*=======================================================================
236 :     * Annotations
237 :     *=======================================================================*)
238 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
239 :     let val (i,an) = getAnnotations i in (i,a::an) end
240 :     | getAnnotations i = (i,[])
241 : monnier 409 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
242 : leunga 657
243 :     (*========================================================================
244 :     * Replicate an instruction
245 :     *========================================================================*)
246 :     fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}
247 : george 1009 | replicate(I.COPY{k, sz, tmp=SOME _, dst, src}) =
248 :     I.COPY{tmp=SOME(I.Direct(C.newReg())), dst=dst, src=src, k=k, sz=sz}
249 : leunga 657 | replicate i = i
250 : monnier 409 end

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