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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 129 - (view) (download)

1 : monnier 129 functor SparcProps
2 :     (structure SparcInstr : SPARCINSTR
3 :     structure Shuffle : SPARCSHUFFLE
4 :     sharing Shuffle.I = SparcInstr) : INSN_PROPERTIES =
5 :     struct
6 :     structure I = SparcInstr
7 :     structure C = I.C
8 :     (*
9 :     structure A = I.A
10 :     *)
11 :    
12 :     exception NegateConditional
13 :    
14 :     fun error msg = MLRiscErrorMsg.impossible ("sparcProps."^msg)
15 :    
16 :     datatype kind = IK_JUMP | IK_NOP | IK_INSTR
17 :     datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
18 :    
19 :     (*========================================================================
20 :     * Instruction Kinds
21 :     *========================================================================*)
22 :     fun instrKind(I.Bicc _) = IK_JUMP
23 :     | instrKind(I.FBfcc _) = IK_JUMP
24 :     | instrKind(I.JMP _) = IK_JUMP
25 :     (*
26 :     | instrKind(I.ANNOTATION(i,_)) = instrKind i
27 :     *)
28 :     | instrKind _ = IK_INSTR
29 :    
30 :     fun branchTargets(I.Bicc{b=I.BA,label,...}) = [LABELLED label]
31 :     | branchTargets(I.Bicc{label,...}) = [LABELLED label, FALLTHROUGH]
32 :     | branchTargets(I.FBfcc{b=I.FBA,label,...}) = [LABELLED label]
33 :     | branchTargets(I.FBfcc{label,...}) = [LABELLED label, FALLTHROUGH]
34 :     | branchTargets(I.JMP{labs,...}) = map LABELLED labs
35 :     (*
36 :     | branchTargets(I.ANNOTATION(i,_)) = branchTargets i
37 :     *)
38 :     | branchTargets _ = error "branchTargets"
39 :    
40 :     fun setTargets(I.Bicc{b=I.BA,a,nop,...},[L]) =
41 :     I.Bicc{b=I.BA,a=a,label=L,nop=nop}
42 :     | setTargets(I.Bicc{b,a,nop,...},[T,F]) =
43 :     I.Bicc{b=b,a=a,label=T,nop=nop}
44 :     | setTargets(I.FBfcc{b,a,nop,...},[T,F]) =
45 :     I.FBfcc{b=b,a=a,label=F,nop=nop}
46 :     | setTargets(I.JMP{r,i,nop,...},labels) =
47 :     I.JMP{r=r,i=i,labs=labels,nop=nop}
48 :     (*
49 :     | setTargets(I.ANNOTATION(i,a),labs) = I.ANNOTATION(setTargets(i,labs),a)
50 :     *)
51 :     | setTargets(i,_) = i
52 :    
53 :     fun negateConditional(I.Bicc{b,a,label,nop}) =
54 :     I.Bicc{b=I.revCond b,a=a,label=label,nop=nop}
55 :     | negateConditional(I.FBfcc{b,a,label,nop}) =
56 :     I.FBfcc{b=I.revFcond b,a=a,label=label,nop=nop}
57 :     (*
58 :     | negateConditional(I.ANNOTATION(i,a)) =
59 :     I.ANNOTATION(negateConditional i,a)
60 :     *)
61 :     | negateConditional _ = raise NegateConditional
62 :    
63 :     fun jump label = I.Bicc{b=I.BA,a=true,label=label,nop=true}
64 :    
65 :     fun moveInstr(I.COPY _) = true
66 :     | moveInstr(I.FCOPY _) = true
67 :     (*
68 :     | moveInstr(I.ANNOTATION(i,_)) = moveInstr i
69 :     *)
70 :     | moveInstr _ = false
71 :    
72 :     fun nop() = I.SETHI{d=0, i=0}
73 :    
74 :     (*========================================================================
75 :     * Parallel Move
76 :     *========================================================================*)
77 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r),...}) = SOME r
78 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f),...}) = SOME f
79 :     (*
80 :     | moveTmpR(I.ANNOTATION(i,_)) = moveTmpR i
81 :     *)
82 :     | moveTmpR _ = NONE
83 :    
84 :     fun moveDstSrc(I.COPY{dst,src,...}) = (dst,src)
85 :     | moveDstSrc(I.FCOPY{dst,src,...}) = (dst,src)
86 :     (*
87 :     | moveDstSrc(I.ANNOTATION(i,_)) = moveDstSrc i
88 :     *)
89 :     | moveDstSrc _ = error "moveDstSrc"
90 :    
91 :     fun copy{src,dst} =
92 :     I.COPY{src=src,dst=dst,impl=ref NONE,
93 :     tmp=case src of [_] => NONE | _ => SOME(I.Direct(C.newReg()))}
94 :    
95 :     fun fcopy{dst,src} = let
96 :     fun trans r = if r >= 32 andalso r < 64 then r-32 else r
97 :     val src = map trans src
98 :     val dst = map trans dst
99 :     in
100 :     I.FCOPY{dst=dst,src=src,impl=ref NONE,
101 :     tmp=case src of [_] => NONE | _ => SOME(I.FDirect(C.newFreg()))}
102 :     end
103 :    
104 :     fun splitCopies{regmap, insns} = let
105 :     val shuffle = Shuffle.shuffle
106 :     val shufflefp = Shuffle.shufflefp
107 :     fun scan([],is') = rev is'
108 :     | scan(I.COPY{dst, src, tmp,...}::is,is') =
109 :     scan(is, shuffle{regMap=regmap,temp=tmp,dst=dst,src=src}@is')
110 :     | scan(I.FCOPY{dst, src, tmp,...}::is,is') =
111 :     scan(is, shufflefp{regMap=regmap,temp=tmp,dst=dst,src=src}@is')
112 :     | scan(i::is, is') = scan(is, i::is')
113 :     in scan(insns,[])
114 :     end
115 :    
116 :    
117 :     fun defUseR instr =
118 :     let
119 :     fun oper (I.REG r,def,use) = (def,r::use)
120 :     | oper (_,def,use) = (def,use)
121 :     in
122 :     case instr of
123 :     (* load/store instructions *)
124 :     I.LOAD {r,d,i,...} => oper(i,[d],[r])
125 :     | I.STORE {r,d,i,...} => oper(i,[],[r,d])
126 :     | I.FLOAD {r,d,i,...} => oper(i,[],[r])
127 :     | I.FSTORE {r,d,i,...} => oper(i,[],[r])
128 :     | I.SETHI {d,...} => ([d],[])
129 :     | I.ARITH {r,i,d,...} => oper(i,[d],[r])
130 :     | I.SHIFT {r,i,d,...} => oper(i,[d],[r])
131 :     | I.JMPL{defs,uses,d,r,i,...} => oper(i,d:: #1 defs,r:: #1 uses)
132 :     | I.CALL{defs,uses,...} => (15 :: #1 defs, #1 uses)
133 :     | I.JMP{r,i,...} => oper(i,[],[r])
134 :     | I.RET{leaf=false,...} => ([15],[])
135 :     | I.RET{leaf=true,...} => ([31],[])
136 :     | I.COPY{src,dst,tmp=SOME(I.Direct r),...} => (r::dst,src)
137 :     | I.COPY{src,dst,...} => (dst,src)
138 :     | I.SAVE{r,i,d} => oper(i,[d],[r])
139 :     | I.RESTORE{r,i,d} => oper(i,[d],[r])
140 :     | I.Ticc{r,i,...} => oper(i,[],[r])
141 :     | I.RDY{d,...} => ([d],[])
142 :     | I.WRY{r,i,...} => oper(i,[],[r])
143 :     (*
144 :     | I.ANNOTATION(i,_) => defUseR i
145 :     *)
146 :     | _ => ([],[])
147 :     end
148 :    
149 :     (* Use of FP registers *)
150 :     fun defUseF instr =
151 :     case instr of
152 :     I.FLOAD{r,d,i,...} => ([d],[])
153 :     | I.FSTORE{r,d,i,...} => ([],[d])
154 :     | I.FPop1{r,d,...} => ([d],[r])
155 :     | I.FPop2{r1,r2,d,...} => ([d],[r1,r2])
156 :     | I.FCMP{r1,r2,...} => ([],[r1,r2])
157 :     | I.JMPL{defs,uses,...} => (#2 defs,#2 uses)
158 :     | I.CALL{defs,uses,...} => (#2 defs,#2 uses)
159 :     | I.FCOPY{src,dst,tmp=SOME(I.FDirect r),...} => (r::dst,src)
160 :     | I.FCOPY{src,dst,...} => (dst,src)
161 :     (*
162 :     | I.ANNOTATION(i,_) => defUseF i
163 :     *)
164 :     | _ => ([],[])
165 :    
166 :     fun defUse C.GP = defUseR
167 :     | defUse C.FP = defUseF
168 :     | defUse _ = error "defUse"
169 :    
170 :     (*
171 :     fun annotate(i,a) = I.ANNOTATION(i,a)
172 :     fun annotations i =
173 :     let fun f(I.ANNOTATION(i,a),l) = f(i,a::l)
174 :     | f(i,l) = (i,l)
175 :     in f(i,[]) end
176 :     *)
177 :    
178 :     end
179 :    
180 :    
181 :     (*
182 :     * $Log$
183 :     *)

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