Annotation of /sml/trunk/src/MLRISC/alpha32/alpha32Rewrite.sml

Parent Directory | Revision Log

---

Revision 114 - (view) (download)

1 :	monnier	16	(* alpha32Rewrite.sml -- rewrite an alpha instruction
2 :			*
3 :			* COPYRIGHT (c) 1997 Bell Labs
4 :			*)
5 :
6 :			functor Alpha32Rewrite(Instr : ALPHA32INSTR) = struct
7 :			structure I=Instr
8 :
9 :			fun rewriteUse(mapr, instr, rs, rt) = let
10 :			fun isRegOp (opnd as I.REGop r) = mapr r=rs
11 :			| isRegOp _ = false
12 :			fun rwOperand(opnd as I.REGop r) = if mapr r=rs then I.REGop rt else opnd
13 :			| rwOperand opnd = opnd
14 :			fun replace r = if mapr r=rs then rt else r
15 :			fun load(ldClass, {ldOp, r, b, d, mem}) =
16 :			if mapr b=rs then ldClass{ldOp=ldOp, r=r, b=rt, d=d, mem=mem}
17 :			else instr
18 :			fun fstore(stClass, {stOp, r, b, d, mem}) =
19 :			if mapr b=rs then stClass{stOp=stOp, r=r, b=rt, d=d, mem=mem}
20 :			else instr
21 :			fun store{stOp, r, b, d, mem} =
22 :			if mapr r=rs then
23 :			if mapr b=rs then
24 :			I.STORE{stOp=stOp, r=rt, b=rt, d=d, mem=mem}
25 :			else
26 :			I.STORE{stOp=stOp, r=rt, b=b, d=d, mem=mem}
27 :			else if mapr b=rs then
28 :			I.STORE{stOp=stOp, r=r, b=rt, d=d, mem=mem}
29 :			else instr
30 :			fun operate(opClass, {oper, ra, rb, rc}) =
31 :			if mapr ra=rs then
32 :			if isRegOp rb then
33 :			opClass{oper=oper, ra=rt, rb=I.REGop rt, rc=rc}
34 :			else opClass{oper=oper, ra=rt, rb=rb, rc=rc}
35 :			else if isRegOp rb then
36 :			opClass{oper=oper, ra=ra, rb=I.REGop rt, rc=rc}
37 :			else instr
38 :			in
39 :			case instr
40 :			of I.LDA{r, b, d} => if mapr b=rs then I.LDA{r=r, b=rt, d=d} else instr
41 :			| I.LDAH{r, b, d} => if mapr b=rs then I.LDAH{r=r, b=rt, d=d} else instr
42 :			| I.LOAD arg => load(I.LOAD, arg)
43 :			| I.FLOAD farg => load(I.FLOAD, farg)
44 :			| I.STORE arg => store arg
45 :			| I.FSTORE farg => fstore(I.FSTORE, farg)
46 :			| I.JMPL({r, b, d}, labs) =>
47 :			if mapr b=rs then I.JMPL({r=r, b=rt, d=d}, labs) else instr
48 :	monnier	106	| I.JSR({r,b,d}, defs, (i,f)) =>
49 :			I.JSR({r=r, b=replace b, d=d}, defs, (map replace i, f))
50 :	monnier	16	| I.BRANCH(I.BR, _, _) => instr
51 :			| I.BRANCH(br, r, lab) => if mapr r=rs then I.BRANCH(br, rt, lab) else instr
52 :			| I.OPERATE arg => operate(I.OPERATE, arg)
53 :			| I.OPERATEV arg => operate(I.OPERATEV, arg)
54 :			| I.COPY{dst, src, tmp, impl} =>
55 :			I.COPY{dst=dst, src=map replace src, tmp=tmp, impl=impl}
56 :			| _ => instr
57 :			end
58 :
59 :			fun frewriteUse(mapr, instr, fs, ft) = let
60 :			fun replace f = if mapr f=fs then ft else f
61 :			fun foperate(opClass, {oper, fa, fb, fc}) =
62 :			if mapr fa=fs then
63 :			opClass{oper=oper, fa=ft, fc=fc, fb=replace fb}
64 :			else if mapr fb=fs then opClass{oper=oper, fa=fa, fb=ft, fc=fc}
65 :			else instr
66 :			in
67 :			case instr
68 :			of I.FBRANCH(br, f, lab) =>
69 :			if mapr f=fs then I.FBRANCH(br, ft, lab) else instr
70 :			| I.FCOPY{dst, src, impl, tmp} =>
71 :			I.FCOPY{dst=dst, src=map(fn f => if mapr f=fs then ft else f) src,
72 :			tmp=tmp, impl=impl}
73 :			| I.FSTORE{stOp, r, b, d, mem} =>
74 :			if mapr r=fs then I.FSTORE{stOp=stOp, r=ft, b=b, d=d, mem=mem} else instr
75 :			| I.FOPERATE arg => foperate(I.FOPERATE, arg)
76 :			| I.FOPERATEV arg => foperate(I.FOPERATEV, arg)
77 :	monnier	106	| I.JSR(opnds, defs, (i,f)) => I.JSR(opnds, defs, (i, map replace f))
78 :	monnier	16	| _ => instr
79 :			end
80 :
81 :			fun rewriteDef(mapr, instr, rs, rt) = let
82 :			fun rewrite r = if mapr r = rs then rt else r
83 :			fun ea (SOME(I.Direct r)) = SOME(I.Direct (rewrite r))
84 :			| ea x = x
85 :			in
86 :			case instr
87 :			of I.LDA{r, b, d} => if mapr r=rs then I.LDA{r=rt, b=b, d=d} else instr
88 :			| I.LDAH{r, b, d} => if mapr r=rs then I.LDAH{r=rt, b=b, d=d} else instr
89 :			| I.LOAD{ldOp, r, b, d, mem} =>
90 :			if mapr r=rs then I.LOAD{ldOp=ldOp, r=rt, b=b, d=d, mem=mem} else instr
91 :			| I.JMPL({r, b, d}, labs) =>
92 :			if mapr r=rs then I.JMPL({r=rt, b=b, d=d}, labs) else instr
93 :	monnier	106	| I.JSR({r, b, d}, (i,f), uses) =>
94 :			I.JSR({r=rewrite r, b=b, d=d}, (map rewrite i, f), uses)
95 :	monnier	16	| I.BRANCH(I.BR, r, lab) =>
96 :			if mapr r=rs then I.BRANCH(I.BR, rt, lab) else instr
97 :			| I.OPERATE{oper, ra, rb, rc} =>
98 :			if mapr rc=rs then I.OPERATE{oper=oper, ra=ra, rb=rb, rc=rt} else instr
99 :			| I.OPERATEV{oper, ra, rb, rc} =>
100 :			if rc=rs then I.OPERATEV{oper=oper, ra=ra, rb=rb, rc=rt} else instr
101 :			| I.COPY{dst, src, impl, tmp} =>
102 :			I.COPY{dst=map rewrite dst, src=src, tmp=ea tmp, impl=impl}
103 :			| _ => instr
104 :			end
105 :
106 :			fun frewriteDef(mapr, instr, fs, ft) = let
107 :			fun rewrite f = if mapr f = fs then ft else f
108 :			fun ea (SOME(I.FDirect f)) = SOME(I.FDirect(rewrite f))
109 :			| ea x = x
110 :			in
111 :			case instr
112 :			of I.DEFFREG f => if mapr f=fs then I.DEFFREG ft else instr
113 :			| I.FLOAD{ldOp, r, b, d, mem} =>
114 :			if mapr r=fs then I.FLOAD{ldOp=ldOp, r=ft, b=b, d=d, mem=mem} else instr
115 :			| I.FOPERATE{oper, fa, fb, fc} =>
116 :			if mapr fc=fs then I.FOPERATE{oper=oper, fa=fa, fb=fb, fc=ft} else instr
117 :			| I.FOPERATEV{oper, fa, fb, fc} =>
118 :			if mapr fc=fs then I.FOPERATEV{oper=oper, fa=fa, fb=fb, fc=ft} else instr
119 :			| I.FCOPY{dst, src, tmp, impl} =>
120 :			I.FCOPY{dst=map rewrite dst, src=src, tmp=ea tmp, impl=impl}
121 :	monnier	106	| I.JSR(opnds, (i,f), uses) => I.JSR(opnds, (i, map rewrite f), uses)
122 :
123 :	monnier	16	| _ => instr
124 :			end
125 :			end
126 :
127 :			(*
128 :	monnier	113	* $Log$
129 :	monnier	16	*)
130 :

---

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