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

Annotation of /sml/trunk/src/MLRISC/sparc/instructions/sparcProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 498 - (view) (download)
Original Path: sml/branches/SMLNJ/src/MLRISC/sparc/instructions/sparcProps.sml

1 : monnier 411 functor SparcProps(SparcInstr : SPARCINSTR) : INSN_PROPERTIES =
2 : monnier 245 struct
3 :     structure I = SparcInstr
4 :     structure C = I.C
5 :    
6 :     exception NegateConditional
7 :    
8 : monnier 411 fun error msg = MLRiscErrorMsg.error("SparcProps",msg)
9 : monnier 245
10 : monnier 411 datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL | IK_GROUP
11 :     | IK_PHI | IK_SOURCE | IK_SINK
12 : monnier 245 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
13 :    
14 :     (*========================================================================
15 :     * Instruction Kinds
16 :     *========================================================================*)
17 :     fun instrKind(I.Bicc _) = IK_JUMP
18 :     | instrKind(I.FBfcc _) = IK_JUMP
19 :     | instrKind(I.JMP _) = IK_JUMP
20 :     | instrKind(I.RET _) = IK_JUMP
21 : monnier 411 | instrKind(I.BR _) = IK_JUMP
22 :     | instrKind(I.BP _) = IK_JUMP
23 :     | instrKind(I.COPY _) = IK_COPY
24 :     | instrKind(I.FCOPY _) = IK_COPY
25 :     | instrKind(I.CALL _) = IK_CALL
26 :     | instrKind(I.JMPL _) = IK_CALL
27 :     | instrKind(I.ANNOTATION{i,...}) = instrKind i
28 :     | instrKind(I.GROUP _) = IK_GROUP
29 : monnier 245 | instrKind _ = IK_INSTR
30 :    
31 :     fun branchTargets(I.Bicc{b=I.BA,label,...}) = [LABELLED label]
32 :     | branchTargets(I.Bicc{label,...}) = [LABELLED label, FALLTHROUGH]
33 :     | branchTargets(I.FBfcc{b=I.FBA,label,...}) = [LABELLED label]
34 :     | branchTargets(I.FBfcc{label,...}) = [LABELLED label, FALLTHROUGH]
35 : monnier 411 | branchTargets(I.BR{label,...}) = [LABELLED label, FALLTHROUGH]
36 :     | branchTargets(I.BP{label,...}) = [LABELLED label, FALLTHROUGH]
37 : monnier 245 | branchTargets(I.JMP{labs=[],...}) = [ESCAPES]
38 :     | branchTargets(I.RET _) = [ESCAPES]
39 :     | branchTargets(I.JMP{labs,...}) = map LABELLED labs
40 : monnier 411 | branchTargets(I.ANNOTATION{i,...}) = branchTargets i
41 : monnier 245 | branchTargets _ = error "branchTargets"
42 :    
43 :     fun setTargets(I.Bicc{b=I.BA,a,nop,...},[L]) =
44 :     I.Bicc{b=I.BA,a=a,label=L,nop=nop}
45 :     | setTargets(I.Bicc{b,a,nop,...},[F,T]) =
46 :     I.Bicc{b=b,a=a,label=T,nop=nop}
47 :     | setTargets(I.FBfcc{b,a,nop,...},[F,T]) =
48 :     I.FBfcc{b=b,a=a,label=T,nop=nop}
49 : monnier 411 | setTargets(I.BR{rcond,p,r,a,nop,...},[F,T]) =
50 :     I.BR{rcond=rcond,p=p,r=r,a=a,label=T,nop=nop}
51 :     | setTargets(I.BP{b,cc,p,a,nop,...},[F,T]) =
52 :     I.BP{b=b,cc=cc,p=p,a=a,label=T,nop=nop}
53 : monnier 245 | setTargets(I.JMP{r,i,nop,...},labels) =
54 :     I.JMP{r=r,i=i,labs=labels,nop=nop}
55 : monnier 411 | setTargets(I.ANNOTATION{i,a},labs) =
56 :     I.ANNOTATION{i=setTargets(i,labs),a=a}
57 : monnier 245 | setTargets(i,_) = i
58 :    
59 : monnier 411 fun revCond I.BA = I.BN
60 :     | revCond I.BN = I.BA
61 :     | revCond I.BNE = I.BE
62 :     | revCond I.BE = I.BNE
63 :     | revCond I.BG = I.BLE
64 :     | revCond I.BLE = I.BG
65 :     | revCond I.BGE = I.BL
66 :     | revCond I.BL = I.BGE
67 :     | revCond I.BGU = I.BLEU
68 :     | revCond I.BLEU = I.BGU
69 :     | revCond I.BCC = I.BCS
70 :     | revCond I.BCS = I.BCC
71 :     | revCond I.BPOS = I.BNEG
72 :     | revCond I.BNEG = I.BPOS
73 :     | revCond I.BVC = I.BVS
74 :     | revCond I.BVS = I.BVC
75 :    
76 :     fun revFcond I.FBA = I.FBN
77 :     | revFcond I.FBN = I.FBA
78 :     | revFcond I.FBU = I.FBO
79 :     | revFcond I.FBG = I.FBULE
80 :     | revFcond I.FBUG = I.FBLE
81 :     | revFcond I.FBL = I.FBUGE
82 :     | revFcond I.FBUL = I.FBGE
83 :     | revFcond I.FBLG = I.FBUE
84 :     | revFcond I.FBNE = I.FBE
85 :     | revFcond I.FBE = I.FBNE
86 :     | revFcond I.FBUE = I.FBLG
87 :     | revFcond I.FBGE = I.FBUL
88 :     | revFcond I.FBUGE = I.FBL
89 :     | revFcond I.FBLE = I.FBUG
90 :     | revFcond I.FBULE = I.FBG
91 :     | revFcond I.FBO = I.FBU
92 :    
93 :     fun revRcond I.RZ = I.RNZ
94 :     | revRcond I.RLEZ = I.RGZ
95 :     | revRcond I.RLZ = I.RGEZ
96 :     | revRcond I.RNZ = I.RZ
97 :     | revRcond I.RGZ = I.RLEZ
98 :     | revRcond I.RGEZ = I.RLZ
99 :    
100 :     fun revP I.PT = I.PN
101 :     | revP I.PN = I.PT
102 :    
103 : monnier 245 fun negateConditional(I.Bicc{b,a,label,nop}) =
104 : monnier 411 I.Bicc{b=revCond b,a=a,label=label,nop=nop}
105 : monnier 245 | negateConditional(I.FBfcc{b,a,label,nop}) =
106 : monnier 411 I.FBfcc{b=revFcond b,a=a,label=label,nop=nop}
107 :     | negateConditional(I.BR{p,r,rcond,a,label,nop}) =
108 :     I.BR{p=revP p,a=a,r=r,rcond=revRcond rcond,label=label,nop=nop}
109 :     | negateConditional(I.BP{b,cc,p,a,label,nop}) =
110 :     I.BP{p=revP p,a=a,b=revCond b,cc=cc,label=label,nop=nop}
111 :     | negateConditional(I.ANNOTATION{i,a}) =
112 :     I.ANNOTATION{i=negateConditional i,a=a}
113 : monnier 245 | negateConditional _ = raise NegateConditional
114 :    
115 :     fun jump label = I.Bicc{b=I.BA,a=true,label=label,nop=true}
116 :    
117 : monnier 411 val immedRange = {lo= ~4096, hi = 4095}
118 :    
119 :     fun loadImmed{immed,t} = I.ARITH{a=I.OR,r=0,i=I.IMMED immed,d=t}
120 :    
121 : monnier 245 fun moveInstr(I.COPY _) = true
122 :     | moveInstr(I.FCOPY _) = true
123 : monnier 411 | moveInstr(I.ANNOTATION{i,...}) = moveInstr i
124 : monnier 245 | moveInstr _ = false
125 :    
126 :     fun nop() = I.SETHI{d=0, i=0}
127 :    
128 :     (*========================================================================
129 :     * Parallel Move
130 :     *========================================================================*)
131 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r),...}) = SOME r
132 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f),...}) = SOME f
133 : monnier 411 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
134 : monnier 245 | moveTmpR _ = NONE
135 :    
136 :     fun moveDstSrc(I.COPY{dst,src,...}) = (dst,src)
137 :     | moveDstSrc(I.FCOPY{dst,src,...}) = (dst,src)
138 : monnier 411 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
139 : monnier 245 | moveDstSrc _ = error "moveDstSrc"
140 :    
141 : monnier 411 (*========================================================================
142 :     * Equality and hashing
143 :     *========================================================================*)
144 :     fun hashOpn(I.REG r) = Word.fromInt r
145 :     | hashOpn(I.IMMED i) = Word.fromInt i
146 :     | hashOpn(I.LAB l) = LabelExp.hash l
147 :     | hashOpn(I.LO l) = LabelExp.hash l
148 :     | hashOpn(I.HI l) = LabelExp.hash l
149 :     | hashOpn(I.CONST c) = I.Constant.hash c
150 :     fun eqOpn(I.REG a,I.REG b) = a = b
151 :     | eqOpn(I.IMMED a,I.IMMED b) = a = b
152 :     | eqOpn(I.LAB a,I.LAB b) = LabelExp.==(a,b)
153 :     | eqOpn(I.LO a,I.LO b) = LabelExp.==(a,b)
154 :     | eqOpn(I.HI a,I.HI b) = LabelExp.==(a,b)
155 :     | eqOpn(I.CONST a,I.CONST b) = I.Constant.==(a,b)
156 :     | eqOpn _ = false
157 : monnier 245
158 :     fun defUseR instr =
159 :     let
160 :     fun oper (I.REG r,def,use) = (def,r::use)
161 :     | oper (_,def,use) = (def,use)
162 :     in
163 :     case instr of
164 :     (* load/store instructions *)
165 :     I.LOAD {r,d,i,...} => oper(i,[d],[r])
166 :     | I.STORE {r,d,i,...} => oper(i,[],[r,d])
167 :     | I.FLOAD {r,d,i,...} => oper(i,[],[r])
168 :     | I.FSTORE {r,d,i,...} => oper(i,[],[r])
169 :     | I.SETHI {d,...} => ([d],[])
170 :     | I.ARITH {r,i,d,...} => oper(i,[d],[r])
171 :     | I.SHIFT {r,i,d,...} => oper(i,[d],[r])
172 :     | I.JMPL{defs,uses,d,r,i,...} => oper(i,d:: #1 defs,r:: #1 uses)
173 : monnier 411 | I.BR{r,...} => ([],[r])
174 :     | I.MOVicc{i,d,...} => oper(i,[d],[d])
175 :     | I.MOVfcc{i,d,...} => oper(i,[d],[d])
176 :     | I.MOVR{r,i,d,...} => oper(i,[d],[r,d])
177 : monnier 245 | I.CALL{defs,uses,...} => (15 :: #1 defs, #1 uses)
178 :     | I.JMP{r,i,...} => oper(i,[],[r])
179 :     | I.RET{leaf=false,...} => ([],[31])
180 :     | I.RET{leaf=true,...} => ([],[15])
181 :     | I.COPY{src,dst,tmp=SOME(I.Direct r),...} => (r::dst,src)
182 :     | I.COPY{src,dst,...} => (dst,src)
183 :     | I.SAVE{r,i,d} => oper(i,[d],[r])
184 :     | I.RESTORE{r,i,d} => oper(i,[d],[r])
185 :     | I.Ticc{r,i,...} => oper(i,[],[r])
186 :     | I.RDY{d,...} => ([d],[])
187 :     | I.WRY{r,i,...} => oper(i,[],[r])
188 : monnier 498 | I.ANNOTATION{a, i, ...} => defUseR i
189 : monnier 245 | _ => ([],[])
190 :     end
191 :    
192 :     (* Use of FP registers *)
193 :     fun defUseF instr =
194 :     case instr of
195 :     I.FLOAD{r,d,i,...} => ([d],[])
196 :     | I.FSTORE{r,d,i,...} => ([],[d])
197 :     | I.FPop1{r,d,...} => ([d],[r])
198 :     | I.FPop2{r1,r2,d,...} => ([d],[r1,r2])
199 :     | I.FCMP{r1,r2,...} => ([],[r1,r2])
200 :     | I.JMPL{defs,uses,...} => (#2 defs,#2 uses)
201 :     | I.CALL{defs,uses,...} => (#2 defs,#2 uses)
202 : monnier 411 | I.FMOVicc{r,d,...} => ([d],[r,d])
203 :     | I.FMOVfcc{r,d,...} => ([d],[r,d])
204 : monnier 245 | I.FCOPY{src,dst,tmp=SOME(I.FDirect r),...} => (r::dst,src)
205 :     | I.FCOPY{src,dst,...} => (dst,src)
206 : monnier 498 | I.ANNOTATION{a, i, ...} => defUseF i
207 : monnier 245 | _ => ([],[])
208 :    
209 :     fun defUse C.GP = defUseR
210 :     | defUse C.FP = defUseF
211 :     | defUse _ = error "defUse"
212 :    
213 : monnier 411 (*========================================================================
214 :     * Annotations
215 :     *========================================================================*)
216 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
217 :     let val (i,an) = getAnnotations i in (i,a::an) end
218 :     | getAnnotations i = (i,[])
219 : monnier 411 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
220 : monnier 245
221 : monnier 411 (*========================================================================
222 :     * Groups
223 :     *========================================================================*)
224 :     fun getGroup(I.ANNOTATION{i,...}) = getGroup i
225 :     | getGroup(I.GROUP r) = r
226 :     | getGroup _ = error "getGroup"
227 :    
228 :     val makeGroup = I.GROUP
229 : monnier 245 end
230 :    
231 :    
232 :    

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