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/alpha32/instructions/alpha32Props.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/alpha32/instructions/alpha32Props.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 236 - (view) (download)

1 : monnier 225 (* alpha32Props.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 :     functor Alpha32Props
8 :     (structure Alpha32Instr:ALPHA32INSTR
9 :     structure Shuffle : ALPHA32SHUFFLE
10 :     sharing Shuffle.I = Alpha32Instr):INSN_PROPERTIES =
11 :     struct
12 :     structure I = Alpha32Instr
13 :     structure C = I.C
14 :     structure LE = LabelExp
15 :    
16 :     exception NegateConditional
17 :    
18 :     fun error msg = MLRiscErrorMsg.impossible ("alpha32Props."^msg)
19 :    
20 :     val zeroR = 31
21 :    
22 :     datatype kind = IK_JUMP | IK_NOP | IK_INSTR
23 :     datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
24 :    
25 :     (*========================================================================
26 :     * Instruction Kinds
27 :     *========================================================================*)
28 :     fun instrKind(I.BRANCH _) = IK_JUMP
29 :     | instrKind(I.FBRANCH _) = IK_JUMP
30 :     | instrKind(I.JMPL _) = IK_JUMP
31 :     | instrKind _ = IK_INSTR
32 :    
33 :     fun moveInstr(I.COPY _) = true
34 :     | moveInstr(I.FCOPY _) = true
35 :     | moveInstr _ = false
36 :    
37 :     val nop =
38 :     fn () => I.OPERATE{oper=I.BIS, ra=zeroR, rb=I.REGop zeroR, rc=zeroR}
39 :    
40 :     (*========================================================================
41 :     * Parallel Move
42 :     *========================================================================*)
43 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r
44 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f
45 :     | moveTmpR _ = NONE
46 :    
47 :     fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
48 :     | moveDstSrc(I.FCOPY{dst, src, ...}) = (dst, src)
49 :     | moveDstSrc _ = error "moveDstSrc"
50 :    
51 :     fun copy{src, dst} =
52 :     I.COPY{src=src, dst=dst, impl=ref NONE,
53 :     tmp=case src of [_] => NONE | _ => SOME(I.Direct(C.newReg()))}
54 :    
55 :     fun fcopy{src,dst} = let
56 :     fun trans r = if r >= 32 andalso r < 64 then r-32 else r
57 :     val src = map trans src
58 :     val dst = map trans dst
59 :     in
60 :     I.FCOPY{src=src,dst=dst,impl=ref NONE,
61 :     tmp=case src of [_] => NONE | _ => SOME(I.FDirect(C.newFreg()))}
62 :     end
63 :    
64 :     fun splitCopies{regmap,insns} = let
65 :     val shuffle = Shuffle.shuffle
66 :     val shufflefp = Shuffle.shufflefp
67 :     fun scan([],is') = rev is'
68 :     | scan(I.COPY{dst,src,tmp,...}::is,is') =
69 :     scan(is,shuffle{regMap=regmap,src=src,dst=dst,temp=tmp}@is')
70 :     | scan(I.FCOPY{dst,src,tmp,...}::is,is') =
71 :     scan(is,shufflefp{regMap=regmap,src=src,dst=dst,temp=tmp}@is')
72 :     | scan(i::is,is') = scan(is,i::is')
73 :     in scan(insns,[])
74 :     end
75 :    
76 :     (*========================================================================
77 :     * Branches and Calls/Returns
78 :     *========================================================================*)
79 :     fun branchTargets(I.BRANCH(I.BR, _, lab)) = [LABELLED lab]
80 :     | branchTargets(I.BRANCH(_, _, lab)) = [LABELLED lab, FALLTHROUGH]
81 :     | branchTargets(I.FBRANCH(_, _, lab)) = [LABELLED lab, FALLTHROUGH]
82 :     | branchTargets(I.JMPL(_,[])) = [ESCAPES]
83 :     | branchTargets(I.JMPL(_,labs)) = map LABELLED labs
84 :     | branchTargets _ = error "branchTargets"
85 :    
86 :     fun jump label = I.BRANCH(I.BR,31,label)
87 :    
88 :     fun setTargets(I.BRANCH(I.BR,0,_),[L]) = I.BRANCH(I.BR,0,L)
89 :     | setTargets(I.BRANCH(b,r,_),[F,T]) = I.BRANCH(b,r,T)
90 :     | setTargets(I.FBRANCH(b,r,_),[F,T]) = I.FBRANCH(b,r,T)
91 :     | setTargets(I.JMPL(x,_),labs) = I.JMPL(x,labs)
92 :     | setTargets(i,_) = i
93 :    
94 :     fun negateConditional br = let
95 :     fun revBranch I.BEQ = I.BNE
96 :     | revBranch I.BGE = I.BLT
97 :     | revBranch I.BGT = I.BLE
98 :     | revBranch I.BLE = I.BGT
99 :     | revBranch I.BLT = I.BGE
100 :     | revBranch I.BLBC = I.BLBS
101 :     | revBranch I.BLBS = I.BLBC
102 :     | revBranch _ = raise NegateConditional
103 :     in
104 :     case br
105 :     of I.BRANCH(br,r,label) => I.BRANCH(revBranch br,r,label)
106 :     | I.FBRANCH(br,r,label) => I.FBRANCH(revBranch br,r,label)
107 :     | _ => raise NegateConditional
108 :     end
109 :    
110 :     (*========================================================================
111 :     * Definition and use (for register allocation mainly)
112 :     *========================================================================*)
113 :     fun defUseR instr =
114 :     let
115 :     fun Oper {oper, ra, rb=I.REGop rb, rc} = ([rc], [ra, rb])
116 :     | Oper {oper, ra, rb, rc} = ([rc], [ra])
117 :     fun FMem (freg, (rd, _)) = ([], [rd])
118 :     fun trap (def,use) =(def, use)
119 :     in
120 :     case instr of
121 :     (* load/store instructions *)
122 :     I.LDA{r, b, ...} => ([r], [b])
123 :     | I.LDAH{r, b, ...} => ([r], [b])
124 :     | I.LOAD{r, b, ...} => ([r], [b])
125 :     | I.STORE{r, b, ...} => ([], [r,b])
126 :     | I.FLOAD{b, ...} => ([], [b])
127 :     | I.FSTORE{b, ...} => ([], [b])
128 :     (* branch instructions *)
129 :     | I.JMPL ({r, b, ...},_) => ([r], [b])
130 :     | I.JSR({r, b, ...}, def, use) => (r:: #1 def, b:: #1 use)
131 :     | I.BRANCH(I.BR, reg, _) => ([reg], [])
132 :     | I.BRANCH(_, reg, _) => ([], [reg])
133 :     (* operate *)
134 :     | I.OPERATE arg => Oper arg
135 :     | I.PSEUDOARITH {oper, ra, rb=I.REGop rb, rc, tmps} =>
136 :     (rc:: #1 tmps, [ra, rb])
137 :     | I.PSEUDOARITH {oper, ra, rb, rc, tmps} => (rc:: #1 tmps, [ra])
138 :     | I.OPERATEV arg => trap(Oper arg)
139 :     (* copy *)
140 : monnier 235 (* and similarly for FCOPY
141 :     | I.COPY{dst, src, tmp, ...} =>
142 :     (case tmp
143 :     of NONE => (dst, src)
144 :     | SOME(I.Direct r) => (d::dst, src)
145 :     | SOME(I.Displace{base, disp}) => (dst, base::src)
146 :     (*esac*))
147 :     *)
148 : monnier 225 | I.COPY{dst, src, tmp=SOME(I.Direct r), ...} => (r::dst, src)
149 :     | I.COPY{dst, src, ...} => (dst, src)
150 :     (* floating operate *)
151 :     | I.FOPERATEV _ => trap([], [])
152 :     | I.TRAPB => trap([],[])
153 :     (* macro *)
154 :     | I.CALL_PAL{def,use, ...} => (def, use)
155 :    
156 :     | _ => ([],[])
157 :     end
158 :    
159 :     (* Use of FP registers *)
160 :     fun defUseF instr =
161 :     case instr of
162 :     I.DEFFREG freg => ([freg], [])
163 :     | I.FBRANCH(_, freg, lab) => ([],[freg])
164 :     | I.FLOAD{r, ...} => ([r], [])
165 :     | I.FSTORE{r, ...} => ([], [r])
166 :     | I.FOPERATE{fa, fb, fc, ...} => ([fc], [fa, fb])
167 :     | I.PSEUDOARITH{tmps, ...} => (#2 tmps, [])
168 :     | I.FOPERATEV{oper=I.CVTTQ, fa, fb, fc} => ([fc], [fa, fb])
169 :     | I.FOPERATEV{fa, fb, fc, ...} => ([fc], [fa, fb, fc])
170 :     | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
171 :     | I.FCOPY{dst, src, ...} => (dst, src)
172 :     | I.JSR(_,def,use) => (#2 def,#2 use)
173 :     | _ => ([],[])
174 :    
175 :     fun defUse C.GP = defUseR
176 :     | defUse C.FP = defUseF
177 :     | defUse _ = error "defUse"
178 :     end
179 :    
180 :    
181 :     (*
182 :     * $Log: alpha32Props.sml,v $
183 : monnier 235 * Revision 1.1.1.1 1999/01/04 21:54:46 george
184 :     * Version 110.12
185 :     *
186 : monnier 225 * Revision 1.3 1998/05/25 15:10:48 george
187 :     * Fixed RCS keywords
188 :     *
189 :     *)

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