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/branches/SMLNJ/src/MLRISC/alpha/instructions/alphaProps.sml
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/MLRISC/alpha/instructions/alphaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 469 - (view) (download)

1 : monnier 409 (* alphaProps.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 :     functor AlphaProps(AlphaInstr:ALPHAINSTR):INSN_PROPERTIES =
8 :     struct
9 :     structure I = AlphaInstr
10 :     structure C = I.C
11 :     structure LE = LabelExp
12 :    
13 :     exception NegateConditional
14 :    
15 :     fun error msg = MLRiscErrorMsg.impossible ("alphaProps."^msg)
16 :    
17 :     val zeroR = 31
18 :    
19 :     datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL | IK_GROUP
20 :     | IK_PHI | IK_SOURCE | IK_SINK
21 :     datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
22 :    
23 :     (*========================================================================
24 :     * Instruction Kinds
25 :     *========================================================================*)
26 :     fun instrKind(I.BRANCH _) = IK_JUMP
27 :     | instrKind(I.FBRANCH _) = IK_JUMP
28 :     | instrKind(I.JMPL _) = IK_JUMP
29 :     | instrKind(I.COPY _) = IK_COPY
30 :     | instrKind(I.FCOPY _) = IK_COPY
31 :     | instrKind(I.JSR _) = IK_CALL
32 :     | instrKind(I.RET _) = IK_JUMP
33 :     | instrKind(I.ANNOTATION{i,...}) = instrKind i
34 :     | instrKind(I.GROUP _) = IK_GROUP
35 :     | instrKind _ = IK_INSTR
36 :    
37 :     fun moveInstr(I.COPY _) = true
38 :     | moveInstr(I.FCOPY _) = true
39 :     | moveInstr(I.ANNOTATION{i,...}) = moveInstr i
40 :     | moveInstr _ = false
41 :    
42 :     val nop =
43 :     fn () => I.OPERATE{oper=I.BIS, ra=zeroR, rb=I.REGop zeroR, rc=zeroR}
44 :    
45 :     (*========================================================================
46 :     * Parallel Move
47 :     *========================================================================*)
48 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r
49 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f
50 :     | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
51 :     | moveTmpR _ = NONE
52 :    
53 :     fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
54 :     | moveDstSrc(I.FCOPY{dst, src, ...}) = (dst, src)
55 :     | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
56 :     | moveDstSrc _ = error "moveDstSrc"
57 :    
58 :     (*========================================================================
59 :     * Branches and Calls/Returns
60 :     *========================================================================*)
61 :     fun branchTargets(I.BRANCH(I.BR, _, lab)) = [LABELLED lab]
62 :     | branchTargets(I.BRANCH(_, _, lab)) = [LABELLED lab, FALLTHROUGH]
63 :     | branchTargets(I.FBRANCH(_, _, lab)) = [LABELLED lab, FALLTHROUGH]
64 :     | branchTargets(I.JMPL(_,[])) = [ESCAPES]
65 :     | branchTargets(I.JMPL(_,labs)) = map LABELLED labs
66 :     | branchTargets(I.RET _) = [ESCAPES]
67 :     | branchTargets(I.ANNOTATION{i,...}) = branchTargets i
68 :     | branchTargets _ = error "branchTargets"
69 :    
70 :     fun jump label = I.BRANCH(I.BR,31,label)
71 :    
72 :     val immedRange = {lo= ~32768, hi = 32768}
73 :     fun loadImmed{immed,t} = I.LDA{r=t,b=31,d=I.IMMop immed}
74 :    
75 :     fun setTargets(I.BRANCH(I.BR,0,_),[L]) = I.BRANCH(I.BR,0,L)
76 :     | setTargets(I.BRANCH(b,r,_),[F,T]) = I.BRANCH(b,r,T)
77 :     | setTargets(I.FBRANCH(b,r,_),[F,T]) = I.FBRANCH(b,r,T)
78 :     | setTargets(I.JMPL(x,_),labs) = I.JMPL(x,labs)
79 :     | setTargets(I.ANNOTATION{i,a},labs) =
80 :     I.ANNOTATION{i=setTargets(i,labs),a=a}
81 :     | setTargets(i,_) = i
82 :    
83 :     fun negateConditional br = let
84 :     fun revBranch I.BEQ = I.BNE
85 :     | revBranch I.BGE = I.BLT
86 :     | revBranch I.BGT = I.BLE
87 :     | revBranch I.BLE = I.BGT
88 :     | revBranch I.BLT = I.BGE
89 :     | revBranch I.BLBC = I.BLBS
90 :     | revBranch I.BLBS = I.BLBC
91 :     | revBranch _ = raise NegateConditional
92 :     fun revFBranch I.FBEQ = I.FBNE
93 :     | revFBranch I.FBNE = I.FBEQ
94 :     | revFBranch I.FBGE = I.FBLT
95 :     | revFBranch I.FBGT = I.FBLE
96 :     | revFBranch I.FBLE = I.FBGT
97 :     | revFBranch I.FBLT = I.FBGE
98 :    
99 :     in
100 :     case br
101 :     of I.BRANCH(br,r,label) => I.BRANCH(revBranch br,r,label)
102 :     | I.FBRANCH(br,r,label) => I.FBRANCH(revFBranch br,r,label)
103 :     | I.ANNOTATION{i,a} => I.ANNOTATION{i=negateConditional i,a=a}
104 :     | _ => raise NegateConditional
105 :     end
106 :    
107 :     (*========================================================================
108 :     * Equality and hashing for operands
109 :     *========================================================================*)
110 :     fun hashOpn(I.REGop r) = Word.fromInt r
111 :     | hashOpn(I.IMMop i) = Word.fromInt i
112 :     | hashOpn(I.HILABop l) = LabelExp.hash l
113 :     | hashOpn(I.LOLABop l) = LabelExp.hash l
114 :     | hashOpn(I.LABop l) = LabelExp.hash l
115 :     | hashOpn(I.CONSTop c) = I.Constant.hash c
116 :    
117 :     fun eqOpn(I.REGop a,I.REGop b) = a = b
118 :     | eqOpn(I.IMMop a,I.IMMop b) = a = b
119 :     | eqOpn(I.HILABop a,I.HILABop b) = LabelExp.==(a,b)
120 :     | eqOpn(I.LOLABop a,I.LOLABop b) = LabelExp.==(a,b)
121 :     | eqOpn(I.LABop a,I.LABop b) = LabelExp.==(a,b)
122 :     | eqOpn(I.CONSTop a,I.CONSTop b) = I.Constant.==(a,b)
123 :     | eqOpn _ = false
124 :    
125 :     (*========================================================================
126 :     * Definition and use (for register allocation mainly)
127 :     *========================================================================*)
128 :     fun defUseR instr =
129 :     let
130 :     fun Oper {oper, ra, rb=I.REGop rb, rc} = ([rc], [ra, rb])
131 :     | Oper {oper, ra, rb, rc} = ([rc], [ra])
132 :     fun Opn(I.REGop rb,rs) = rb::rs
133 :     | Opn(_,rs) = rs
134 :     fun FMem (freg, (rd, _)) = ([], [rd])
135 :     fun trap (def,use) =(def, use)
136 :     in
137 :     case instr of
138 :     (* load/store instructions *)
139 :     I.LDA{r, b, ...} => ([r], [b])
140 :     | I.LDAH{r, b, ...} => ([r], [b])
141 :     | I.LOAD{r, b, ...} => ([r], [b])
142 :     | I.STORE{r, b, ...} => ([], [r,b])
143 :     | I.FLOAD{b, ...} => ([], [b])
144 :     | I.FSTORE{b, ...} => ([], [b])
145 :     (* branch instructions *)
146 :     | I.JMPL ({r, b, ...},_) => ([r], [b])
147 :     | I.JSR({r, b, ...}, def, use, mem) => (r:: #1 def, b:: #1 use)
148 :     | I.RET{r, b, ...} => ([r],[b])
149 :     | I.BRANCH(I.BR, reg, _) => ([reg], [])
150 :     | I.BRANCH(_, reg, _) => ([], [reg])
151 :     (* operate *)
152 :     | I.OPERATE arg => Oper arg
153 :     | I.PSEUDOARITH {oper, ra, rb=I.REGop rb, rc, tmps} =>
154 :     (rc:: #1 tmps, [ra, rb])
155 :     | I.PSEUDOARITH {oper, ra, rb, rc, tmps} => (rc:: #1 tmps, [ra])
156 :     | I.OPERATEV arg => trap(Oper arg)
157 :     | I.CMOVE{ra,rb,rc,...} => ([rc],Opn(rb,[ra,rc]))
158 :     (* copy *)
159 :     | I.COPY{dst, src, tmp=SOME(I.Direct r), ...} => (r::dst, src)
160 :     | I.COPY{dst, src, ...} => (dst, src)
161 :     (* floating operate *)
162 :     | I.FOPERATEV _ => trap([], [])
163 :     | I.TRAPB => trap([],[])
164 :     (* macro *)
165 :     | I.CALL_PAL{def,use, ...} => (def, use)
166 : monnier 469 | I.ANNOTATION{a, i, ...} =>
167 :     (case #peek BasicAnnotations.DEFUSER a of
168 :     SOME(d,u) => (d,u)
169 :     | NONE => defUseR i
170 :     )
171 : monnier 409 | _ => ([],[])
172 :     end
173 :    
174 :     (* Use of FP registers *)
175 :     fun defUseF instr =
176 :     case instr of
177 :     I.DEFFREG freg => ([freg], [])
178 :     | I.FBRANCH(_, freg, lab) => ([],[freg])
179 :     | I.FLOAD{r, ...} => ([r], [])
180 :     | I.FSTORE{r, ...} => ([], [r])
181 :     | I.FOPERATE{fa, fb, fc, ...} => ([fc], [fa, fb])
182 :     | I.FUNARY{fb, fc, ...} => ([fc], [fb])
183 :     | I.PSEUDOARITH{tmps, ...} => (#2 tmps, [])
184 :     | I.FOPERATEV{fa, fb, fc, ...} => ([fc], [fa, fb, fc])
185 :     | I.FCMOVE{fa,fb,fc,...} => ([fc], [fa, fb, fc])
186 :     | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
187 :     | I.FCOPY{dst, src, ...} => (dst, src)
188 :     | I.JSR(_,def,use, mem) => (#2 def,#2 use)
189 : monnier 469 | I.ANNOTATION{a, i, ...} =>
190 :     (case #peek BasicAnnotations.DEFUSEF a of
191 :     SOME(d,u) => (d,u)
192 :     | NONE => defUseF i
193 :     )
194 : monnier 409 | _ => ([],[])
195 :    
196 :     fun defUse C.GP = defUseR
197 :     | defUse C.FP = defUseF
198 :     | defUse _ = error "defUse"
199 :    
200 :     (*=======================================================================
201 :     * Annotations
202 :     *=======================================================================*)
203 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
204 :     let val (i,an) = getAnnotations i in (i,a::an) end
205 :     | getAnnotations i = (i,[])
206 : monnier 409 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
207 :    
208 :     (*=======================================================================
209 :     * Groups
210 :     *=======================================================================*)
211 :     fun getGroup(I.ANNOTATION{i,...}) = getGroup i
212 :     | getGroup(I.GROUP r) = r
213 :     | getGroup _ = error "getGroup"
214 :    
215 :     val makeGroup = I.GROUP
216 :     end
217 :    
218 :    

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