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/hppa/hppa.md
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/hppa.md

Parent Directory Parent Directory | Revision Log Revision Log


Revision 429 - (view) (download)

1 : monnier 409 (*
2 :     * This is the new machine description language.
3 :     *
4 :     *)
5 :    
6 :     architecture Hppa =
7 :     struct
8 :    
9 :     name "Hppa"
10 :    
11 :     version "1"
12 :    
13 :     superscalar
14 :    
15 :     big endian
16 :    
17 :     lowercase assembly
18 :    
19 :     instruction delayslot 4
20 :    
21 :     (* debug MC *)
22 :    
23 :     storage
24 :     GP = 32 cells of 32 bits in cellset called "register"
25 :     assembly as (fn r => "%r"^Int.toString r)
26 :     | FP = 32 cells of 64 bits in cellset called "floating point register"
27 :     assembly as (fn f => "%f"^Int.toString f)
28 :     | CR = 32 cells of 32 bits called "control register"
29 :     assembly as (fn cr => "%cr"^Int.toString cr)
30 :     | CC = cells of 32 bits in cellset GP called "condition code register"
31 :     assembly as "cc"
32 :     locations
33 :     returnPtr = $GP[2]
34 :     and stackptrR = $GP[30]
35 :     and asmTmpR = $GP[29]
36 :     and fasmTmp = $FP[31]
37 :     and sar = $CR[11]
38 :    
39 :     structure Cells =
40 :     struct
41 :     fun zeroReg GP = SOME($GP[0])
42 :     | zeroReg FP = SOME($FP[0])
43 :     | zeroReg _ = NONE
44 :     end
45 :    
46 :     structure Instruction = struct
47 :    
48 :     datatype fmt! = SGL 0w0 | DBL 0w1 | QUAD 0w3
49 :    
50 :     datatype loadi :Op! = LDW 0x12 (* p5-28 *)
51 :     | LDH 0x11 (* p5-29 *)
52 :     | LDB 0x10 (* p5-30 *)
53 :    
54 :     datatype store :Op! = STW 0x1A (* p5-31 *)
55 :     | STH 0x19 (* p5-32 *)
56 :     | STB 0x18 (* p5-33 *)
57 :    
58 :     (* addressing mode
59 :     * when the u bit is set, the index "x" is scaled by the size
60 :     * when the m bit is set, the base is also auto-incremented
61 :     *)
62 :    
63 :     (* u, m *)
64 :     datatype cmplt = ADDR "" (0w0,0w0)
65 :     | ADDR_S ",s" (0w1,0w0)
66 :     | ADDR_M ",m" (0w0,0w1)
67 :     | ADDR_SM ",sm" (0w1,0w1)
68 :    
69 :     (* ext4, u, m *)
70 :     datatype load :ext4! = LDWX "ldwx" (0w2,0w0,0w0) (* p5-36 *)
71 :     | LDWX_S "ldwx,s" (0w2,0w1,0w0)
72 :     | LDWX_M "ldwx,m" (0w2,0w0,0w1)
73 :     | LDWX_SM "ldwx,sm" (0w2,0w1,0w1)
74 :     | LDHX "ldhx" (0w1,0w0,0w0) (* p5-37 *)
75 :     | LDHX_S "ldhx,s" (0w1,0w1,0w0)
76 :     | LDHX_M "ldhx,m" (0w1,0w0,0w1)
77 :     | LDHX_SM "ldhx,sm" (0w1,0w1,0w1)
78 :     | LDBX "ldbx" (0w0,0w0,0w0) (* p5-38 *)
79 :     | LDBX_M "ldbx,m" (0w0,0w0,0w1)
80 :    
81 :     (* All branching is done with nullification *)
82 :     datatype cmp! = COMBT 0wx20
83 :     | COMBF 0wx22
84 :    
85 :     datatype cmpi! = COMIBT 0wx21
86 :     | COMIBF 0wx23
87 :    
88 :     datatype arith! = ADD 0x18 (* p5-83 *)
89 :     | ADDL 0x28 (* p5-84 *)
90 :     | ADDO 0x38 (* p5-85 *)
91 :     | SH1ADD 0x19 (* p5-88 *)
92 :     | SH1ADDL 0x29 (* p5-89 *)
93 :     | SH1ADDO 0x39 (* p5-90 *)
94 :     | SH2ADD 0x1A (* p5-91 *)
95 :     | SH2ADDL 0x2A (* p5-92 *)
96 :     | SH2ADDO 0x3A (* p5-93 *)
97 :     | SH3ADD 0x1B (* p5-94 *)
98 :     | SH3ADDL 0x2B (* p5-95 *)
99 :     | SH3ADDO 0x3B (* p5-96 *)
100 :     | SUB 0x10 (* p5-97 *)
101 :     | SUBO 0x30 (* p5-98 *)
102 :     | OR 0x09 (* p5-105 *)
103 :     | XOR 0x0A (* p5-106 *)
104 :     | AND 0x08 (* p5-107 *)
105 :     | ANDCM 0x00 (* p5-108 *)
106 :    
107 :     datatype arithi! = ADDI (0wx2d,0w0)
108 :     | ADDIO (0wx2d,0w1)
109 :     | ADDIL
110 :     | SUBI (0wx25,0w0)
111 :     | SUBIO (0wx25,0w1)
112 :    
113 :     datatype shiftv! = VEXTRU | VEXTRS | ZVDEP
114 :    
115 :     datatype shift! = EXTRU | EXTRS | ZDEP
116 :    
117 :     datatype farith! = (* sop, fmt *)
118 :     FADD_S "fadd,sgl" (0w0, 0w0)
119 :     | FADD_D "fadd,dbl" (0w0, 0w1)
120 :     | FADD_Q "fadd,quad" (0w0, 0w3)
121 :    
122 :     | FSUB_S "fsub,sgl" (0w1, 0w0)
123 :     | FSUB_D "fsub,dbl" (0w1, 0w1)
124 :     | FSUB_Q "fsub,quad" (0w1, 0w3)
125 :    
126 :     | FMPY_S "fmpy,sgl" (0w2, 0w0)
127 :     | FMPY_D "fmpy,dbl" (0w2, 0w1)
128 :     | FMPY_Q "fmpy,quad" (0w2, 0w3)
129 :    
130 :     | FDIV_S "fdiv,sgl" (0w3, 0w0)
131 :     | FDIV_D "fdiv,dbl" (0w3, 0w1)
132 :     | FDIV_Q "fdiv,quad" (0w3, 0w3)
133 :    
134 :     | XMPYU (* ok *)
135 :    
136 :     datatype funary! = (* sop, fmt *)
137 :     (* copy *)
138 :     FCPY_S "fcpy,sgl" (0w2,0w0)
139 :     | FCPY_D "fcpy,dbl" (0w2,0w1)
140 :     | FCPY_Q "fcpy,quad" (0w2,0w3)
141 :    
142 :     | FABS_S "fabs,sgl" (0w3,0w0)
143 :     | FABS_D "fabs,dbl" (0w3,0w1)
144 :     | FABS_Q "fabs,quad" (0w3,0w3)
145 :    
146 :     | FSQRT_S "fsqrt,sgl" (0w4,0w0)
147 :     | FSQRT_D "fsqrt,dbl" (0w4,0w1)
148 :     | FSQRT_Q "fsqrt,quad" (0w4,0w3)
149 :    
150 :     (* round float to integer *)
151 :     | FRND_S "frnd,sgl" (0w5,0w0)
152 :     | FRND_D "frnd,dbl" (0w5,0w1)
153 :     | FRND_Q "frnd,quad" (0w5,0w3)
154 :    
155 :     (* FCNVXF --- the source is the LHS single precision floating register *)
156 :     datatype fcnv = (* sop, sf, df *)
157 :     (* floating point -> floating point *)
158 :     FCNVFF_SD "fcnvff,sgl,dbl" (0w0,0w0,0w1)
159 :     | FCNVFF_SQ "fcnvff,sgl,quad" (0w0,0w0,0w3)
160 :     | FCNVFF_DS "fcnvff,dbl,sgl" (0w0,0w1,0w0)
161 :     | FCNVFF_DQ "fcnvff,dbl,quad" (0w0,0w1,0w3)
162 :     | FCNVFF_QS "fcnvff,quad,sgl" (0w0,0w3,0w0)
163 :     | FCNVFF_QD "fcnvff,quad,dbl" (0w0,0w3,0w1)
164 :    
165 :     (* fixed point -> floating point *)
166 :     | FCNVXF_S "fcnvxf,,sgl" (0w1,0w0,0w0)
167 :     | FCNVXF_D "fcnvxf,,dbl" (0w1,0w0,0w1)
168 :     | FCNVXF_Q "fcnvxf,,quad" (0w1,0w0,0w3)
169 :    
170 :     (* floating point -> fixed point (use current rounding mode?) *)
171 :     | FCNVFX_S "fcnvfx,sgl," (0w2,0w0,0w0)
172 :     | FCNVFX_D "fcnvfx,dbl," (0w2,0w1,0w0)
173 :     | FCNVFX_Q "fcnvfx,quad," (0w2,0w3,0w0)
174 :    
175 :     (* floating point -> fixed point (and truncate) *)
176 :     | FCNVFXT_S "fcnvfxt,sgl," (0w3,0w0,0w0)
177 :     | FCNVFXT_D "fcnvfxt,dbl," (0w3,0w1,0w0)
178 :     | FCNVFXT_Q "fcnvfxt,quad," (0w3,0w3,0w0)
179 :    
180 :     datatype fstore! = FSTDS
181 :     | FSTWS
182 :     (* Op, uid, u, m *)
183 :     datatype fstorex! = FSTDX "fstdx" (0wxb,0w0,0w0,0w0)
184 :     | FSTDX_S "fstdx,s" (0wxb,0w0,0w1,0w0)
185 :     | FSTDX_M "fstdx,m" (0wxb,0w0,0w0,0w1)
186 :     | FSTDX_SM "fstdx,sm" (0wxb,0w0,0w1,0w1)
187 :     | FSTWX "fstwx" (0wx9,0w1,0w0,0w0)
188 :     | FSTWX_S "fstwx,s" (0wx9,0w1,0w1,0w0)
189 :     | FSTWX_M "fstwx,m" (0wx9,0w1,0w0,0w1)
190 :     | FSTWX_SM "fstwx,sm" (0wx9,0w1,0w1,0w1)
191 :    
192 :     (* FLDWX and FLDWS -- loads the RHS of the floating register *)
193 :     (* Op, uid, u, m *)
194 :     datatype floadx! = FLDDX "flddx" (0wxb,0w0,0w0,0w0)
195 :     | FLDDX_S "flddx,s" (0wxb,0w0,0w1,0w0)
196 :     | FLDDX_M "flddx,m" (0wxb,0w0,0w0,0w1)
197 :     | FLDDX_SM "flddx,sm" (0wxb,0w0,0w1,0w1)
198 :     | FLDWX "fldwx" (0wx9,0w1,0w0,0w0)
199 :     | FLDWX_S "fldwx,s" (0wx9,0w1,0w1,0w0)
200 :     | FLDWX_M "fldwx,m" (0wx9,0w1,0w0,0w1)
201 :     | FLDWX_SM "fldwx,sm" (0wx9,0w1,0w1,0w1)
202 :    
203 :     datatype fload! = FLDDS
204 :     | FLDWS
205 :    
206 :     (* page 5-5. fields for (c,f) *)
207 :     datatype bcond! = EQ "=" 0w1
208 :     | LT "<" 0w2
209 :     | LE "<=" 0w3
210 :     | LTU "<<" 0w4
211 :     | LEU "<<=" 0w5
212 :     | NE "<>" (* unimplemented *)
213 :     | GE ">=" (* ... *)
214 :     | GT ">"
215 :     | GTU ">>"
216 :     | GEU ">>="
217 :    
218 :     (* table 5-7 *)
219 :     datatype bitcond! = BSET "<" 0w2 (* bit is 1 *)
220 :     | BCLR ">=" 0w6 (* bit is 0 *)
221 :    
222 :     (* table 6-13 *)
223 :     datatype fcond [0..31] =
224 :     False_ "false?" | False "false" | ? | !<=> | == | EQT "=T" | ?= | !<>
225 :     | !?>= | < | ?< | !>= | !?> | <= | ?<= | !>
226 :     | !?<= | > | ?> | !<= | !?< | >= | ?>=
227 :     | !< | !?= | <> | != | NET "!=T" | !? | <=> | True_ "true?" | True "true"
228 :    
229 :     datatype scond = ALL_ZERO | LEFTMOST_ONE | LEFTMOST_ZERO | RIGHTMOST_ONE
230 :     | RIGHTMOST_ZERO
231 :    
232 :     datatype field_selector = F
233 :     | S
234 :     | D
235 :     | R
236 :     | T
237 :     | P
238 :    
239 :     datatype ea =
240 :     Direct of $GP
241 :     | FDirect of $GP
242 :     | Displace of {base: $GP, disp:int}
243 :    
244 :     datatype operand =
245 :     IMMED of int ``<int>''
246 :     | LabExp of LabelExp.labexp * field_selector ``<labexp>''
247 :     | HILabExp of LabelExp.labexp * field_selector ``<labexp>''
248 :     | LOLabExp of LabelExp.labexp * field_selector ``<labexp>''
249 :     | ConstOp of Constant.const ``<const>''
250 :    
251 :     end
252 :    
253 :     (*
254 :     * HP has 41 different instruction formats.
255 :     * The instruction encoding is, for the lack of a better phrase,
256 :     * all fucked up.
257 :     *
258 :     * See Appendix C.
259 :     *)
260 :     instruction formats 32 bits
261 :     (* sr=0 for load store, why? *)
262 :     Load{Op:6,b:GP 5,t:GP 5,s:2=0,im14:signed 14}
263 :     | Store{st:store 6,b:GP 5,r:GP 5,s:2=0,im14:signed 14}
264 :    
265 :     (* sr=3, m=0 no modify, cc=0 *)
266 :     | IndexedLoad{Op:6,b:GP 5,x:GP 5,s:2=3,u:1,_:1=0,cc:2=0,ext4:4,m:1,t:GP 5}
267 :    
268 :     | ShortDispLoad{Op:6,b:GP 5,im5:signed 5,s:2,a:1,_:1=1,cc:2,ext4:4,m:1,t:GP 5}
269 :     | ShoftDispShort{Op:6,b:5,r:5,s:2,a:1,_:1=1,cc:2,ext4:4,m:1,im5:signed 5}
270 :    
271 :     | LongImmed{Op:6,r:GP 5,im21:signed 21}
272 :    
273 :     | Arith{Op:6=0x2,r2:GP 5,r1:GP 5,c:3=0,f:1=0,a:arith 6,_:1=0,t:GP 5}
274 :     | Arithi{Op:6,r:GP 5,t:GP 5,c:3=0,f:1=0,e:1,im11:signed 11}
275 :    
276 :     | Extract{Op:6,r:GP 5,t:GP 5,c:3=0,ext3:3,p:int 5,clen:int 5}
277 :    
278 :     | Deposit{Op:6,t:GP 5,r:GP 5,c:3=0,ext3:3,cp:int 5,clen:int 5}
279 :    
280 :     | Shift{Op:6,r2:GP 5,r1:GP 5,c:3=0,ext3:3,cp:5,t:GP 5}
281 :     | ConditionalBranch{Op:6,r2:GP 5,r1:GP 5,c:bcond 3,w1:11,n:bool 1,w:1}
282 :     | ConditionalBranchi{Op:6,r2:GP 5,im5:5,c:bcond 3,w1:11,n:bool 1,w:1}
283 :     | BranchExternal{Op:6,b:GP 5,w1:5,s:3,w2:11,n:bool 1,w:1}
284 :     | BranchAndLink{Op:6,t:GP 5,w1:5,ext3:3,w2:11,n:bool 1,w:1}
285 :     | BranchVectored{Op:6,t:GP 5,x:GP 5,ext3:3,_:11=0,n:bool 1,w:1=0}
286 :     | Break{Op:6,im13:signed 13,ext8:8,im5:signed 5}
287 :     | BranchOnBit{Op:6=0x31,p:int 5,r:GP 5,c:3,w1:11,n:bool 1,w:1}
288 :    
289 :     | MoveToControlReg{Op:6,t:CR 5,r:GP 5,rv:3,ext8:8,_:5=0}
290 :     | Compare{Op:6=0wx2,r2:GP 5,r1:GP 5,c:3,f:1,ext:6,_:1=0,t:GP 5}
291 :    
292 :    
293 :     (* floating point loads and stores *)
294 :     | CoProcShort{Op:6,b:GP 5,im5:5,s:2,a:1,_:1=1,cc:2=0,
295 :     ls:1,uid:3,m:1=0,rt:FP 5}
296 :     | CoProcIndexed{Op:6,b:GP 5,x:GP 5,s:2,u:1,_:1=0,cc:2=0,
297 :     ls:1,uid:3,m:1,rt:FP 5}
298 :    
299 :     (* OR r0,r0,r0 *)
300 :     | NOP{Op:6=0x2,r2:5=0,r1:5=0,c:3=0,f:1=0,a:6=0x9,_:1=0,t:5=0}
301 :    
302 :     | Nop{nop} = if nop then NOP{} else ()
303 :    
304 :     (* floating point ops *)
305 :     | FloatOp0Maj0C{Op:6=0x0C,r:FP 5,_:5=0,sop:3,fmt:2,_:6=0,t:FP 5}
306 :     | FloatOp1Maj0C{Op:6=0x0C,r:FP 5,_:4=0,sop:2,df:2,sf:2,_:2=1,_:4=0,t:FP 5}
307 :     | FloatOp2Maj0C{Op:6=0x0C,r1:FP 5,r2:FP 5,sop:3,fmt:2,_:2=2,_:3=0,n:1,c:5}
308 :     | FloatOp3Maj0C{Op:6=0x0C,r1:FP 5,r2:FP 5,sop:3,fmt:2,_:2=3,_:3=0,n:1,t:FP 5}
309 :    
310 :     | FloatOp0Maj0E{Op:6=0x0E,r:FP 5,_:5=0,sop:3,fmt:2,_:3=0,r2:1,t2:1,_:1=0,
311 :     t:FP 5}
312 :     | FloatOp1Maj0E{Op:6=0x0E,r:FP 5,_:4=0,sop:2,df:2,sf:2,_:2=1,_:1=0,r2:1,t2:1,
313 :     _:1=0,t:FP 5}
314 :     | FloatOp2Maj0E{Op:6=0x0E,r1:FP 5,r2:FP 5,sop:3,r22:1,f:1,_:2=2,_:1=0,
315 :     r11:1,_:2=0,c:5}
316 :     | FloatOp3Maj0E{Op:6=0x0E,r1:FP 5,r2:FP 5,sop:3,r22:1,f:1,_:2=3,_:1=0,
317 :     r11:1,_:2=0,t:FP 5}
318 :     | FloatMultiOp{Op:6=0x0E,rm1:5,rm2:5,ta:5,ra:5,f:1,tm:5}
319 :    
320 :     (* page 6-62 *)
321 :     | FTest{Op:6=0x0C,r1:5=0,r2:5=0,sop:3=1,_:2=0,_:2=2,_:3=0,_:1=1,c:5=0}
322 :    
323 :     structure Assembly =
324 :     struct
325 :     fun emit_n false = () | emit_n true = emit ",n"
326 :     fun emit_nop false = () | emit_nop true = emit "\n\tnop"
327 :     end
328 :    
329 :     (*
330 :     * Various utility functions for emitting assembly code
331 :     *)
332 :     structure MC =
333 :     struct
334 :     fun opn opnd =
335 :     let fun hi21 n = (itow n) >> 0w11
336 :     fun hi21X n = (itow n) ~>> 0w11
337 :     fun lo11 n = (itow n) && 0wx7ff
338 :     (* BUG: should respect the field selectors instead of ignoring them *)
339 :     in case opnd of
340 :     I.HILabExp(lexp, _) => hi21X(LabelExp.valueOf lexp)
341 :     | I.LOLabExp(lexp, _) => lo11(LabelExp.valueOf lexp)
342 :     | I.ConstOp _ => error "ConstOp"
343 :     | I.LabExp(lexp, _) => itow(LabelExp.valueOf lexp)
344 :     | I.IMMED i => itow i
345 :    
346 :     end
347 :    
348 :     (* compute displacement address *)
349 :     fun disp lab = itow((Label.addrOf lab) - !loc - 8) ~>> 0w2
350 :     fun low_sign_ext_im14 n = ((n &&0wx1fff) << 0w1)||((n && 0wx2000) >> 0w13)
351 :     fun low_sign_ext_im11 n = ((n && 0wx3ff) << 0w1)||((n && 0wx400) >> 0w10)
352 :     fun low_sign_ext_im5 n = ((n && 0wxf) << 0w1)||((n && 0wx10) >> 0w4)
353 :    
354 :     fun assemble_3 n =
355 :     let val w1 = (n && 0w4) >> 0w2
356 :     val w2 = (n && 0w3) << 0w1
357 :     in w1 || w2 end
358 :    
359 :     fun assemble_12 n =
360 :     let val w = (n && 0wx800) >> 0w11
361 :     val w1 = ((n && 0wx3ff) << 0w1) || ((n && 0wx400) >> 0w10)
362 :     in (w1, w) end
363 :    
364 :     fun assemble_17 n =
365 :     let val w = (n && 0wx10000) >> 0w16
366 :     val w1 = (n && 0wxf800) >> 0w11
367 :     val w2 = (((n && 0wx3ff) << 0w1) || ((n && 0wx400) >> 0w10))
368 :     in (w, w1, w2) end
369 :    
370 :     fun assemble_21 disp =
371 :     let val w =
372 :     (((disp && 0wx000003) << 0w12) ||
373 :     ((disp && 0wx00007c) << 0w14) ||
374 :     ((disp && 0wx000180) << 0w7) ||
375 :     ((disp && 0wx0ffe00) >> 0w8) ||
376 :     ((disp && 0wx100000) >> 0w20))
377 :     in w end
378 :    
379 :     fun branchLink(Op,t,lab,ext3,n) =
380 :     let val (w,w1,w2) = assemble_17(disp lab)
381 :     in BranchAndLink{Op,t,w1,w2,w,ext3,n} end
382 :    
383 :     fun bcond(cmp,bc,r1,r2,n,t,nop) =
384 :     let val (w1,w) = assemble_12(disp t)
385 :     in ConditionalBranch{Op=emit_cmp cmp,c=bc,r1,r2,n,w,w1}; Nop{nop} end
386 :    
387 :     fun bcondi(cmpi,bc,i,r2,n,t,nop) =
388 :     let val (w1,w) = assemble_12(disp t)
389 :     in ConditionalBranchi{Op=emit_cmpi cmpi,c=bc,
390 :     im5=low_sign_ext_im5(itow i),r2,n,w,w1}; Nop{nop}
391 :     end
392 :     fun branchOnBit(bc,r,p,n,t,nop) =
393 :     let val (w1,w) = assemble_12(disp t)
394 :     in BranchOnBit{p=p,r=r,c=emit_bitcond bc,w1=w1,n=n,w=w}; Nop{nop}
395 :     end
396 :    
397 :     fun cmpCond cond =
398 :     case cond of
399 :     I.EQ => (0w1,0w0)
400 :     | I.LT => (0w2,0w0)
401 :     | I.LE => (0w3,0w0)
402 :     | I.LTU => (0w4,0w0)
403 :     | I.LEU => (0w5,0w0)
404 :     | I.NE => (0w1,0w1)
405 :     | I.GE => (0w2,0w1)
406 :     | I.GT => (0w3,0w1)
407 :     | I.GTU => (0w4,0w1)
408 :     | I.GEU => (0w5,0w1)
409 :    
410 :     end
411 :    
412 :     (* FLDWS, FLDWX = define the R half of the FP register.
413 :     * FSTWS = uses the R half of the FP register.
414 :     *)
415 :     instruction
416 :     LOADI of {li:loadi, r: $GP, i:operand, t: $GP, mem:Region.region}
417 :     ``<li>\t<i>(<r>), <t><mem>''
418 :     Load{Op=emit_loadi li,b=r,im14=low_sign_ext_im14(opn i),t=t}
419 :    
420 :     | LOAD of {l:load, r1: $GP, r2: $GP, t: $GP, mem:Region.region}
421 :     ``<l>\t<r2>(<r1>), <t><mem>''
422 :     (let val (ext4,u,m) = emit_load l
423 :     in IndexedLoad{Op=0w3,b=r1,x=r2,ext4,u,t,m}
424 :     end)
425 :    
426 :     | STORE of {st:store,b: $GP,d:operand,r: $GP, mem:Region.region}
427 :     ``<st>\t<r>, <d>(<b>)<mem>''
428 :     Store{st,b=b,im14=low_sign_ext_im14(opn d),r=r}
429 :    
430 :     | ARITH of {a:arith,r1: $GP, r2: $GP, t: $GP}
431 :     ``<a>\t<r1>, <r2>, <t>''
432 :     Arith{a,r1,r2,t}
433 :    
434 :     | ARITHI of {ai:arithi, i:operand, r: $GP, t: $GP}
435 :     ``<ai>\t<i>, <r>, <t>''
436 :     (case ai of
437 :     I.ADDIL => LongImmed{Op=0wxa,r=r,im21=assemble_21(opn i)}
438 :     | _ => let val (Op,e) = emit_arithi ai
439 :     in Arithi{Op=Op,r=r,t=t,im11=low_sign_ext_im11(opn i),e=e} end
440 :     )
441 :    
442 :     (* This is a composite instruction.
443 :     * The effect is the same as t <- if r1 cc r2 then i+b else 0
444 :     * if t1 = t2
445 :     * COMCLR,cc r1, r2, t1
446 :     * LDO i(b), t2
447 :     *)
448 :     | COMCLR_LDO of {cc:bcond, r1: $GP, r2: $GP, t1 : $GP,
449 :     i:int, b: $GP, t2: $GP}
450 :     ``comclr,<cc>\t<r1>, <r2>, <t1>\n\tldo\t<i>(<b>), <t2>''
451 :     (let val (c,f) = cmpCond cc
452 :     in Compare{r1,r2,t=t1,c,f,ext=0wx22};
453 :     Load{Op=0wx0d,b,im14=low_sign_ext_im14(itow i),t=t2}
454 :     end
455 :     )
456 :    
457 :     | SHIFTV of {sv:shiftv, r: $GP, len:int, t: $GP}
458 :     ``<sv>\t<r>, <len>, <t>''
459 :     (case sv of
460 :     I.VEXTRU => Extract{Op=0wx34,r,t,ext3=0w4,p=0,clen=32-len}
461 :     | I.VEXTRS => Extract{Op=0wx34,r,t,ext3=0w5,p=0,clen=32-len}
462 :     | I.ZVDEP => Deposit{Op=0wx35,t,r,ext3=0w0,cp=0,clen=32-len}
463 :     )
464 :    
465 :     | SHIFT of {s:shift, r: $GP, p:int, len:int, t: $GP}
466 :     ``<s>\t<r>, <p>, <len>, <t>''
467 :     (case s of
468 :     I.EXTRU => Extract{Op=0wx34,r,t,ext3=0w6,p=p,clen=32-len}
469 :     | I.EXTRS => Extract{Op=0wx34,r,t,ext3=0w7,p=p,clen=32-len}
470 :     | I.ZDEP => Deposit{Op=0wx35,t,r,ext3=0w2,cp=31-p,clen=32-len}
471 :     )
472 :    
473 :     | BCOND of {cmp: cmp, bc:bcond,r1: $GP,r2: $GP,n:bool,nop:bool,
474 :     t:Label.label, f:Label.label}
475 :     ``<cmp>,<bc><n>\t<r1>, <r2>, <emit_label t><nop>''
476 :     (bcond(cmp,bc,r1,r2,n,t,nop))
477 :     padded when nop = true
478 :     nullified when n = true
479 :     when nullified
480 :     if branching forwards then delayslot when not branching
481 :     else delayslot when branching
482 :     else delayslot
483 :     candidate of delayslot never
484 :    
485 :     | BCONDI of {cmpi: cmpi, bc:bcond, i:int, r2: $GP, n:bool, nop:bool,
486 :     t:Label.label, f:Label.label}
487 :     ``<cmpi>,<bc><n>\t<i>, <r2>, <emit_label t><nop>''
488 :     (bcondi(cmpi,bc,i,r2,n,t,nop))
489 :     padded when nop = true
490 :     nullified when n = true
491 :     when nullified
492 :     if branching forwards then delayslot when not branching
493 :     else delayslot when branching
494 :     else delayslot
495 :     candidate of delayslot never
496 :    
497 :     (* bc must be either < or >= *)
498 :     | BB of {bc:bitcond,r: $GP,p:int,n:bool,nop:bool,
499 :     t:Label.label, f:Label.label}
500 :     ``bb,<bc><n>\t<r>, <p>, <emit_label t><nop>''
501 :     (branchOnBit(bc,r,p,n,t,nop))
502 :     nullified when n = true
503 :     when nullified
504 :     if branching forwards then delayslot when not branching
505 :     else delayslot when branching
506 :     else delayslot
507 :     candidate of delayslot never
508 :    
509 :     | B of {lab:Label.label, n:bool}
510 :     ``b<n>\t<emit_label lab>''
511 :     (branchLink(0wx3a,0,lab,0w0,n))
512 :     nullified when n = true
513 :     candidate of delayslot never
514 :    
515 : monnier 429 | BE of {b: $GP, d:operand, sr:int, n:bool, labs: Label.label list}
516 :     ``be<n>\t<d>(<sr>,<b>)''
517 :     (let val (w,w1,w2) = assemble_17(opn d)
518 :     in BranchExternal{Op=0wx38,b=b,w1=w1,s=assemble_3(itow sr),
519 :     w2=w2,n=n,w=w}
520 :     end)
521 :    
522 : monnier 409 | BV of {x: $GP, b: $GP, labs: Label.label list, n:bool}
523 :     ``bv<n>\t<x>(<b>)''
524 :     BranchVectored{Op=0wx3a,t=b,x=x,ext3=0w6,n=n}
525 :     nullified when n = true
526 :     candidate of delayslot never
527 :    
528 :     | BLR of {x: $GP, t: $GP, labs: Label.label list, n:bool}
529 :     ``blr<n>\t<x>(<t>)''
530 :     BranchVectored{Op=0wx3a,t=t,x=x,ext3=0w2,n=n}
531 :     nullified when n = true
532 :     candidate of delayslot never
533 :    
534 :     | BL of {x:operand,t: $GP, defs: C.cellset, uses:C.cellset, n:bool}
535 :     ``bl<n>\t<x>), <t>''
536 :     (* not implemented *)
537 :     nullified when n = true
538 :     candidate of delayslot never
539 :    
540 :     | BLE of {d:operand,b: $GP, sr:int, t: $GP,
541 :     defs: C.cellset, uses:C.cellset, mem:Region.region}
542 :     ``ble\t<d>(<emit_int sr>,<b>)<mem>''
543 :     (case (d,t) of
544 :     (I.IMMED 0,31) =>
545 :     BranchExternal{Op=0wx39,b=b,w1=0w0,s=assemble_3(itow sr),
546 :     w2=0w0,n=true,w=0w0}
547 :     | _ => error "BLE: not implemented"
548 :     )
549 :     never nullified
550 :     candidate of delayslot never
551 :    
552 :     (* BLE implicitly defines %r31. The destination register t
553 :     * is assigned in the delay slot.
554 :     *)
555 :     | LDIL of {i:operand, t: $GP}
556 :     ``ldil\t<i>, <t>''
557 :     LongImmed{Op=0wx8,r=t,im21=assemble_21(opn i)}
558 :    
559 :     | LDO of {i:operand, b: $GP, t: $GP}
560 :     ``ldo\t<i>(<b>), <t>''
561 :     Load{Op=0wx0d,b,im14=low_sign_ext_im14(opn i),t=t}
562 :    
563 :     | MTCTL of {r: $GP, t: $CR}
564 :     ``mtctl\t<r>, <t>''
565 :     MoveToControlReg{Op=0w0,t,r,rv=0w0,ext8=0wxc2}
566 :    
567 :     | FSTORE of {fst:fstore,b: $GP, d:int, r: $FP,mem:Region.region}
568 :     ``<fst>\t<d>(<b>), <r><mem>''
569 :     (case fst of
570 :     I.FSTDS => CoProcShort{Op=0wxb,b,im5=low_sign_ext_im5(itow d),
571 :     s=0w0,a=0w0,ls=0w1,uid=0w0,rt=r}
572 :     | I.FSTWS => CoProcShort{Op=0wx9,b,im5=low_sign_ext_im5(itow d),
573 :     s=0w0,a=0w0,ls=0w1,uid=0w1,rt=r}
574 :     )
575 :    
576 :     | FSTOREX of {fstx:fstorex, b: $GP, x: $GP,r: $FP,mem:Region.region}
577 :     ``<fstx>\t<x>(<b>), <r><mem>''
578 :     (let val (Op,uid,u,m) = emit_fstorex fstx
579 :     in CoProcIndexed{Op=Op,b,x,s=0w0,u,m,ls=0w1,uid=uid,rt=r}
580 :     end)
581 :    
582 :     | FLOAD of {fl:fload, b: $GP, d:int, t: $FP, mem:Region.region}
583 :     ``<fl>\t<d>(<b>), <t><mem>''
584 :     (case fl of
585 :     I.FLDDS => CoProcShort{Op=0wxb,b,im5=low_sign_ext_im5(itow d),
586 :     s=0w0,a=0w0,ls=0w0,uid=0w0,rt=t}
587 :     | I.FLDWS => CoProcShort{Op=0wx9,b,im5=low_sign_ext_im5(itow d),
588 :     s=0w0,a=0w0,ls=0w0,uid=0w1,rt=t}
589 :     )
590 :    
591 :     | FLOADX of {flx:floadx, b: $GP, x: $GP, t: $FP, mem:Region.region}
592 :     ``<flx>\t<x>(<b>), <t><mem>''
593 :     (let val (Op,uid,u,m) = emit_floadx flx
594 :     in CoProcIndexed{Op=Op,b,x,s=0w0,u,m,ls=0w0,uid=uid,rt=t}
595 :     end)
596 :    
597 :     | FARITH of {fa:farith,r1: $FP, r2: $FP,t: $FP}
598 :     ``<fa>\t<r1>, <r2>, <t>''
599 :     (case fa of
600 :     I.XMPYU => FloatOp3Maj0E{sop=0w2,f=0w1,r1,r2,t,r11=0w0,r22=0w0}
601 :     | _ => let val (sop,fmt) = emit_farith fa
602 :     in FloatOp3Maj0C{sop,r1,r2,t,n=0w0,fmt} end
603 :     )
604 :    
605 :     | FUNARY of {fu:funary,f: $FP, t: $FP}
606 :     ``<fu>\t<f>, <t>''
607 :     (let val (sop,fmt) = emit_funary fu
608 :     in FloatOp0Maj0C{r=f,t=t,sop=sop,fmt=fmt}
609 :     end
610 :     )
611 :    
612 :     | FCNV of {fcnv:fcnv, f: $FP, t: $FP}
613 :     ``<fcnv>\t<f>, <t>''
614 :     (let val (sop,sf,df) = emit_fcnv fcnv
615 :     in FloatOp1Maj0E{r=f,t=t,sop=sop,sf=sf,df=df,r2=0w1,t2=0w0}
616 :     end
617 :     )
618 :    
619 :     (* The following three instructions have been replaced by FBRANCH.
620 :     This make life much easier for instruction schedulers.
621 :     | FCMP of fcond * int * int
622 :     | FTEST
623 :     | FBCC of {t:Label.label, f:Label.label, n:bool}
624 :     *)
625 :     | FBRANCH of {cc:fcond, fmt:fmt, f1: $FP, f2: $FP,
626 :     t:Label.label, f:Label.label, n:bool, long:bool}
627 :     ``fcmp,<fmt>,<cc>\t<f1>, <f2>\n\tftest\n\tb<n>\t<emit_label t>''
628 :     (* fmt = 1 means double precision; will have to extend later *)
629 :     (FloatOp2Maj0C{r1=f1,r2=f2,sop=0w0,fmt=emit_fmt fmt,
630 :     n=0w0,c=emit_fcond cc};
631 :     FTest{};
632 :     branchLink(0wx3a,0,t,0w0,n) (* B,n t *)
633 :     )
634 :     candidate of delayslot never
635 :    
636 :     | BREAK of {code1:int, code2:int}
637 :     ``break\t<code1>, <code2>''
638 :     candidate of delayslot never
639 :    
640 :     | NOP
641 :     ``nop''
642 :     NOP{}
643 :    
644 :     | COPY of {dst: $GP list, src: $GP list,
645 :     impl:instruction list option ref, tmp: ea option}
646 :     ``<emitInstrs (Shuffle.shuffle{regmap,tmp,src,dst})>''
647 :    
648 :     | FCOPY of {dst: $FP list, src: $FP list,
649 :     impl:instruction list option ref, tmp: ea option}
650 :     ``<emitInstrs (Shuffle.shufflefp{regmap,tmp,src,dst})>''
651 :    
652 :     | ANNOTATION of {i:instruction, a:Annotations.annotation}
653 :     ``<(emitInstr i; comment(Annotations.toString a))>''
654 :     (emitInstr i)
655 :    
656 :     | GROUP of Annotations.annotation
657 :     ``<comment(Annotations.toString annotation)>''
658 :    
659 :     end

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