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

Annotation of /sml/trunk/src/MLRISC/hppa/hppaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 106 - (view) (download)
Original Path: sml/branches/SMLNJ/src/MLRISC/hppa/hppaProps.sml

1 : monnier 16 (* hppaProps.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 :     functor HppaProps
8 :     (structure HppaInstr : HPPAINSTR
9 : monnier 106 structure Shuffle : HPPASHUFFLE
10 :     sharing Shuffle.I = HppaInstr) : INSN_PROPERTIES =
11 : monnier 16 struct
12 :     structure I = HppaInstr
13 : monnier 106 structure C = HppaInstr.C
14 : monnier 16 structure LE = LabelExp
15 :    
16 : monnier 106 exception NegateConditional
17 :    
18 : monnier 16 fun error msg = MLRiscErrorMsg.impossible ("HppaProps." ^ msg)
19 :    
20 :     datatype kind = IK_JUMP | IK_NOP | IK_INSTR
21 :     datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
22 :    
23 : monnier 106 (*========================================================================
24 :     * Instruction Kinds
25 :     *========================================================================*)
26 :     (* Note: BLE and BL used to implement calls are not view as branches *)
27 : monnier 16 fun instrKind(I.BCOND _) = IK_JUMP
28 :     | instrKind(I.BCONDI _) = IK_JUMP
29 :     | instrKind(I.B _) = IK_JUMP
30 :     | instrKind(I.FBCC _) = IK_JUMP
31 :     | instrKind(I.BV _) = IK_JUMP
32 :     | instrKind(I.NOP) = IK_NOP
33 :     | instrKind _ = IK_INSTR
34 :    
35 : monnier 106 fun moveInstr(I.COPY _) = true
36 :     | moveInstr(I.FCOPY _) = true
37 :     | moveInstr _ = false
38 : monnier 16
39 :     fun nop() = I.NOP
40 :    
41 : monnier 106 (*========================================================================
42 :     * Parallel Move
43 :     *========================================================================*)
44 : monnier 16 fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r
45 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f
46 :     | moveTmpR _ = NONE
47 :    
48 :     fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
49 :     | moveDstSrc(I.FCOPY{dst, src, ...}) = (dst, src)
50 :     | moveDstSrc _ = error "moveDstSrc"
51 :    
52 : monnier 106 fun copy{src, dst} =
53 :     I.COPY{src=src, dst=dst, impl=ref NONE,
54 :     tmp=case src of [_] => NONE | _ => SOME(I.Direct(C.newReg()))}
55 : monnier 16
56 : monnier 106 fun fcopy{dst,src} = let
57 :     fun trans r = if r >= 32 andalso r < 64 then r-32 else r
58 :     val src = map trans src
59 :     val dst = map trans dst
60 :     in
61 :     I.FCOPY{dst=dst,src=src,impl=ref NONE,
62 :     tmp=case src of [_] => NONE | _ => SOME(I.FDirect(C.newFreg()))}
63 :     end
64 :    
65 :     fun splitCopies{regmap, insns} = let
66 :     val shuffle = Shuffle.shuffle
67 :     val shufflefp = Shuffle.shufflefp
68 :     fun scan([],is') = rev is'
69 :     | scan(I.COPY{dst, src, tmp,...}::is,is') =
70 :     scan(is, shuffle{regMap=regmap,temp=tmp,dst=dst,src=src}@is')
71 :     | scan(I.FCOPY{dst, src, tmp,...}::is,is') =
72 :     scan(is, shufflefp{regMap=regmap,temp=tmp,dst=dst,src=src}@is')
73 :     | scan(i::is, is') = scan(is, i::is')
74 :     in scan(insns,[])
75 :     end
76 :    
77 :     (*========================================================================
78 :     * Branches and Calls/Returns
79 :     *========================================================================*)
80 :     fun branchTargets(I.BCOND{t, ...}) = [LABELLED t, FALLTHROUGH]
81 :     | branchTargets(I.BCONDI{t, ...}) = [LABELLED t, FALLTHROUGH]
82 :     | branchTargets(I.B{lab, ...}) = [LABELLED lab]
83 :     | branchTargets(I.FBCC{t,...}) = [LABELLED t, FALLTHROUGH]
84 :     | branchTargets(I.BV{labs=[],...}) = [ESCAPES]
85 :     | branchTargets(I.BV{labs,...}) = map LABELLED labs
86 :     | branchTargets _ = error "branchTargets"
87 :    
88 :     fun jump label = I.B{lab=label,n=true}
89 :     (*
90 :     fun setTargets(I.BCOND{cmp,bc,r1,r2,t,f,n},[F,T]) =
91 :     I.BCOND{cmp=cmp,bc=bc,r1=r1,r2=r2,t=T,f=F,n=n}
92 :     | setTargets(I.BCONDI{cmpi,bc,i,r2,t,f,n},[F,T]) =
93 :     I.BCONDI{cmpi=cmpi,bc=bc,i=i,r2=r2,t=T,f=F,n=n}
94 :     | setTargets(I.B{n,...},[L]) = I.B{lab=L,n=n}
95 :     | setTargets(I.FBRANCH{cc,n,long,r1,r2,...},[F,T]) =
96 :     I.FBRANCH{cc=cc,t=T,f=F,n=n,long=long,r1=r1,r2=r2}
97 :     | setTargets(I.BV{x,b,n,...},labels) = I.BV{x=x,b=b,labs=labels,n=n}
98 :     | setTargets(I.BLR{x,t,n,...},labels) = I.BLR{x=x,t=t,labs=labels,n=n}
99 :     | setTargets(i,_) = i
100 :     *)
101 :     fun setTargets _ = let
102 :     exception NotImplemented
103 :     in raise NotImplemented
104 :     end
105 :    
106 :     fun negateConditional br = let
107 :     fun revFcond I.? = I.!?
108 :     | revFcond I.!<=> = I.<=>
109 :     | revFcond I.== = I.!=
110 :     | revFcond I.?= = I.!?=
111 :     | revFcond I.!<> = I.<>
112 :     | revFcond I.!?>= = I.?>=
113 :     | revFcond I.< = I.!<
114 :     | revFcond I.?< = I.!?<
115 :     | revFcond I.!>= = I.>=
116 :     | revFcond I.!?> = I.?>
117 :     | revFcond I.<= = I.!<=
118 :     | revFcond I.?<= = I.!?<=
119 :     | revFcond I.!> = I.>
120 :     | revFcond I.!?<= = I.?<=
121 :     | revFcond I.> = I.!>
122 :     | revFcond I.?> = I.!?>
123 :     | revFcond I.!<= = I.<=
124 :     | revFcond I.!?< = I.?<
125 :     | revFcond I.>= = I.!>=
126 :     | revFcond I.?>= = I.!?>=
127 :     | revFcond I.!< = I.<
128 :     | revFcond I.!?= = I.?=
129 :     | revFcond I.<> = I.!<>
130 :     | revFcond I.!= = I.==
131 :     | revFcond I.!? = I.?
132 :     | revFcond I.<=> = I.!<=>
133 :     in
134 :     case br
135 :     of I.BCOND{cmp,bc,r1,r2,t,f,n} =>
136 :     I.BCOND{bc=bc, r1=r1, r2=r2, t=t, f=f, n=n,
137 :     cmp=case cmp of I.COMBT => I.COMBF | I.COMBF => I.COMBT}
138 :     | I.BCONDI{cmpi,bc,i,r2,t,f,n} =>
139 :     I.BCONDI{bc=bc, i=i, r2=r2, t=t, f=f, n=n,
140 :     cmpi=case cmpi of I.COMIBT => I.COMIBF | I.COMIBF => I.COMIBT}
141 :     (* | I.FBRANCH{cc,r1,r2,t,f,n,long} =>
142 :     I.FBRANCH{cc=revFcond cc,r1=r1,r2=r2,t=t,f=f,n=n,long=long} *)
143 :     | _ => raise NegateConditional
144 :     end
145 :    
146 :     (*========================================================================
147 :     * Definition and use (for register allocation mainly)
148 :     *========================================================================*)
149 : monnier 16 fun defUseR instr = let
150 : monnier 106 fun trap((I.ADDO | I.SUBO | I.SH1ADDO), d, u) = (d, u)
151 : monnier 16 | trap(_, d, u) = (d, u)
152 : monnier 106 fun trapi((I.ADDIO | I.SUBIO), d, u) = (d, u)
153 : monnier 16 | trapi(_, d, u) = (d, u)
154 :     in
155 :     case instr
156 :     of I.STORE {b, r,...} => ([], [b,r])
157 :     | I.LOAD {l, r1, r2, t, ...} => ([t], [r1,r2])
158 :     | I.LOADI {li, r, t, ...} => ([t], [r])
159 :     | I.ARITH {a, r1, r2, t, ...} => trap(a, [t], [r1,r2])
160 :     | I.ARITHI {ai, r, t, ...} => trapi(ai, [t], [r])
161 :     | I.COMCLR{r1, r2, t, ...} => ([t], [r1, r2])
162 :     | I.SHIFTV {r, t, ...} => ([t], [r])
163 :     | I.SHIFT {r, t, ...} => ([t], [r])
164 :     | I.BCOND {r1, r2, ...} => ([], [r1,r2])
165 :     | I.BCONDI {r2, ...} => ([], [r2])
166 :     | I.BV {x, b, ...} => ([], [x,b])
167 :     | I.BL{defs, uses, ...} => (#1 defs, #1 uses)
168 :     | I.BLE{t, b, defs, uses, ...}=> (31 :: t :: #1 defs, b :: #1 uses)
169 :     | I.LDIL{i, t} => ([t], [])
170 :     | I.LDO{b, t, ...} => ([t], [b])
171 :     | I.COPY{dst, src, tmp=SOME(I.Direct r), ...} => (r::dst, src)
172 :     | I.COPY{dst, src, ...} => (dst, src)
173 :     | I.MTCTL{r, t} => ([], [r])
174 :     | I.FSTORE {b, ...} => ([], [b])
175 :     | I.FSTOREX {b, x, ...} => ([], [b,x])
176 :     | I.FLOAD {b, ...} => ([], [b])
177 :     | I.FLOADX{b, x, ...} => ([], [b,x])
178 :     | _ => ([],[])
179 :     end
180 :    
181 :     fun defUseF instr =
182 :     case instr
183 :     of I.FSTORE {r, ...} => ([], [r])
184 :     | I.FSTOREX{r, ...} => ([], [r])
185 :     | I.FLOAD{t, ...} => ([t], [])
186 :     | I.FLOADX{t, ...} => ([t], [])
187 :     | I.FARITH {r1, r2, t, ...} => ([t], [r1,r2])
188 :     | I.FUNARY {f, t, ...} => ([t], [f])
189 :     | I.FCMP (_, f1, f2) => ([], [f1, f2])
190 :     | I.BL{defs, uses, ...} => (#2 defs, #2 uses)
191 :     | I.BLE{defs, uses, ...} => (#2 defs, #2 uses)
192 :     | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
193 :     | I.FCOPY{dst, src, ...} => (dst, src)
194 :     | _ => ([],[])
195 :    
196 : monnier 106 fun defUse C.GP = defUseR
197 :     | defUse C.FP = defUseF
198 :     | defUse _ = error "defUse"
199 : monnier 16 end
200 :    
201 :    
202 :    
203 :     (*
204 :     * $Log: hppaProps.sml,v $
205 : monnier 106 * Revision 1.2 1998/05/19 15:45:40 george
206 :     * Added a whole bunch of functions to support global scheduling.
207 :     *
208 : monnier 93 * Revision 1.1.1.1 1998/04/08 18:39:01 george
209 :     * Version 110.5
210 : monnier 16 *
211 :     *)

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