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

Annotation of /sml/trunk/src/MLRISC/mltree/mltree-hash.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1013 - (view) (download)

1 : jhr 1013 (* mltree-hash.sml
2 :     *
3 :     * COPYRIGHT (c) 2002 Bell Labs, Lucent Technologies.
4 :     *)
5 :    
6 : george 985 functor MLTreeHash
7 :     (structure T : MLTREE
8 :     (* Hashing extensions *)
9 :     val hashSext : T.hasher -> T.sext -> word
10 :     val hashRext : T.hasher -> T.rext -> word
11 :     val hashFext : T.hasher -> T.fext -> word
12 :     val hashCCext : T.hasher -> T.ccext -> word
13 :     ) : MLTREE_HASH =
14 :     struct
15 :     structure T = T
16 :     structure I = T.I
17 :     structure Constant = T.Constant
18 :     structure B = T.Basis
19 :     structure C = CellsBasis
20 :     structure W = Word
21 :    
22 :     val w = W.fromInt
23 :     val i2s = Int.toString
24 :     val toLower = String.map Char.toLower
25 :    
26 :     fun error msg = MLRiscErrorMsg.error("LabelExp",msg)
27 :     fun wv(C.CELL{id, ...}) = w id
28 :     fun wvs is =
29 :     let fun f([],h) = h
30 :     | f(i::is,h) = f(is,wv i+h)
31 :     in f(is,0w0) end
32 :    
33 :     (*
34 :     * Hashing
35 :     *)
36 :     val hashLabel = Label.hash
37 :     fun hasher() = {stm=hashStm, rexp=hashRexp, fexp=hashFexp, ccexp=hashCCexp}
38 :     and hashCtrl ctrl = wv ctrl
39 :     and hashStm stm =
40 :     case stm of
41 :     T.MV(t,dst,rexp) => 0w123 + w t + wv dst + hashRexp rexp
42 :     | T.CCMV(dst,ccexp) => 0w1234 + wv dst + hashCCexp ccexp
43 :     | T.FMV(fty,dst,fexp) => 0w12345 + w fty + wv dst + hashFexp fexp
44 :     | T.COPY(ty,dst,src) => 0w234 + w ty + wvs dst + wvs src
45 :     | T.FCOPY(fty,dst,src) => 0w456 + w fty + wvs dst + wvs src
46 :     | T.JMP(ea,labels) => 0w45 + hashRexp ea
47 :     | T.CALL{funct,targets,defs,uses,region,pops} =>
48 :     hashRexp funct + hashMlriscs defs + hashMlriscs uses
49 :     | T.RET _ => 0w567
50 :     | T.STORE(ty,ea,data,mem) => 0w888 + w ty + hashRexp ea + hashRexp data
51 :     | T.FSTORE(fty,ea,data,mem) => 0w7890 + w fty + hashRexp ea + hashFexp data
52 :     | T.BCC(a,lab) => 0w233 + hashCCexp a + hashLabel lab
53 :     | T.IF(a,b,c) => 0w233 + hashCCexp a + hashStm b + hashStm c
54 :     | T.ANNOTATION(stm, a) => hashStm stm
55 :     | T.PHI{preds,block} => w block
56 :     | T.SOURCE => 0w123
57 :     | T.SINK => 0w423
58 :     | T.REGION(stm,ctrl) => hashStm stm + hashCtrl ctrl
59 :     | T.RTL{hash,...} => hash
60 :     | T.SEQ ss => hashStms(ss, 0w23)
61 :     | T.ASSIGN(ty,lhs,rhs) => w ty + hashRexp lhs + hashRexp rhs
62 :     | _ => error "hashStm"
63 :    
64 :     and hashStms([],h) = h
65 :     | hashStms(s::ss,h) = hashStms(ss,hashStm s + h)
66 :    
67 :     and hashMlrisc(T.CCR ccexp) = hashCCexp ccexp
68 :     | hashMlrisc(T.GPR rexp) = hashRexp rexp
69 :     | hashMlrisc(T.FPR fexp) = hashFexp fexp
70 :    
71 :     and hashMlriscs [] = 0w123
72 :     | hashMlriscs(m::ms) = hashMlrisc m + hashMlriscs ms
73 :    
74 :     and hash2(ty,x,y) = w ty + hashRexp x + hashRexp y
75 :    
76 :     and hashRexp rexp =
77 :     case rexp
78 :     of T.REG(ty, src) => w ty + wv src
79 :     | T.LI i => I.hash i
80 :     | T.LABEL l => hashLabel l
81 :     | T.LABEXP le => hashRexp rexp
82 :     | T.CONST c => Constant.hash c
83 :     | T.NEG(ty, x) => w ty + hashRexp x + 0w24
84 :     | T.ADD x => hash2 x + 0w234
85 :     | T.SUB x => hash2 x + 0w456
86 :     | T.MULS x => hash2 x + 0w2131
87 :     | T.DIVS x => hash2 x + 0w156
88 :     | T.QUOTS x => hash2 x + 0w1565
89 :     | T.REMS x => hash2 x + 0w231
90 :     | T.MULU x => hash2 x + 0w123
91 :     | T.DIVU x => hash2 x + 0w1234
92 :     | T.REMU x => hash2 x + 0w211
93 :     | T.NEGT(ty, x) => w ty + hashRexp x + 0w1224
94 :     | T.ADDT x => hash2 x + 0w1219
95 :     | T.SUBT x => hash2 x + 0w999
96 :     | T.MULT x => hash2 x + 0w7887
97 :     | T.DIVT x => hash2 x + 0w88884
98 :     | T.QUOTT x => hash2 x + 0w8884
99 :     | T.REMT x => hash2 x + 0w99
100 :     | T.ANDB x => hash2 x + 0w12312
101 :     | T.ORB x => hash2 x + 0w558
102 :     | T.XORB x => hash2 x + 0w234
103 :     | T.EQVB x => hash2 x + 0w734
104 :     | T.NOTB(ty, x) => w ty + hashRexp x
105 :     | T.SRA x => hash2 x + 0w874
106 :     | T.SRL x => hash2 x + 0w223
107 :     | T.SLL x => hash2 x + 0w499
108 :     | T.COND(ty,e,e1,e2) => w ty + hashCCexp e + hashRexp e1 + hashRexp e2
109 :     | T.SX(ty, ty', rexp) => 0w232 + w ty + w ty' + hashRexp rexp
110 :     | T.ZX(ty, ty', rexp) => 0w737 + w ty + w ty' + hashRexp rexp
111 :     | T.CVTF2I(ty, round, ty', fexp) =>
112 :     w ty + B.hashRoundingMode round + w ty' + hashFexp fexp
113 :     | T.LOAD(ty, ea, mem) => w ty + hashRexp ea + 0w342
114 :     | T.LET(stm, rexp) => hashStm stm + hashRexp rexp
115 :     | T.PRED(e, ctrl) => hashRexp e + hashCtrl ctrl
116 :     | T.MARK(e, _) => hashRexp e
117 :     | T.REXT(ty, rext) => w ty + hashRext (hasher()) rext
118 :     | T.??? => 0w485
119 :     | T.OP(ty,oper,es) => hashRexps(es, w ty + hashOper oper)
120 :     | T.ARG _ => 0w23
121 :     | T.$(ty, k, e) => w ty + hashRexp e
122 :     | T.PARAM n => w n
123 :     | T.BITSLICE(ty, sl, e) => w ty + hashRexp e
124 :    
125 :     and hashOper(T.OPER{hash, ...}) = hash
126 :    
127 :     and hashRexps([],h) = h
128 :     | hashRexps(e::es,h) = hashRexps(es,hashRexp e + h)
129 :    
130 :     and hash2'(ty,x,y) = w ty + hashFexp x + hashFexp y
131 :    
132 :     and hashFexp fexp =
133 :     case fexp of
134 :     T.FREG(fty, src) => w fty + wv src
135 :     | T.FLOAD(fty, ea, mem) => w fty + hashRexp ea
136 :     | T.FADD x => hash2' x + 0w123
137 :     | T.FMUL x => hash2' x + 0w1234
138 :     | T.FSUB x => hash2' x + 0w12345
139 :     | T.FDIV x => hash2' x + 0w234
140 :     | T.FCOPYSIGN x => hash2' x + 0w883
141 :     | T.FCOND(fty,c,x,y) => w fty + hashCCexp c + hashFexp x + hashFexp y
142 :     | T.FABS(fty, fexp) => w fty + hashFexp fexp + 0w2345
143 :     | T.FNEG(fty, fexp) => w fty + hashFexp fexp + 0w23456
144 :     | T.FSQRT(fty, fexp) => w fty + hashFexp fexp + 0w345
145 :     | T.CVTI2F(fty, ty, rexp) => w fty + w ty + hashRexp rexp
146 :     | T.CVTF2F(fty, fty', fexp) => w fty + hashFexp fexp + w fty'
147 :     | T.FMARK(e, _) => hashFexp e
148 :     | T.FPRED(e, ctrl) => hashFexp e + hashCtrl ctrl
149 :     | T.FEXT(fty, fext) => w fty + hashFext (hasher()) fext
150 :    
151 :     and hashFexps([],h) = h
152 :     | hashFexps(e::es,h) = hashFexps(es,hashFexp e + h)
153 :    
154 :     and hashCCexp ccexp =
155 :     case ccexp of
156 :     T.CC(cc, src) => B.hashCond cc + wv src
157 :     | T.FCC(fcc, src) => B.hashFcond fcc + wv src
158 :     | T.CMP(ty, cond, x, y) =>
159 :     w ty + B.hashCond cond + hashRexp x + hashRexp y
160 :     | T.FCMP(fty, fcond, x, y) =>
161 :     w fty + B.hashFcond fcond + hashFexp x + hashFexp y
162 :     | T.NOT x => 0w2321 + hashCCexp x
163 :     | T.AND(x,y) => 0w2321 + hashCCexp x + hashCCexp y
164 :     | T.OR(x,y) => 0w8721 + hashCCexp x + hashCCexp y
165 :     | T.XOR(x,y) => 0w6178 + hashCCexp x + hashCCexp y
166 :     | T.EQV(x,y) => 0w178 + hashCCexp x + hashCCexp y
167 :     | T.TRUE => 0w0
168 :     | T.FALSE => 0w1232
169 :     | T.CCMARK(e, _) => hashCCexp e
170 :     | T.CCEXT(ty,ccext) => w ty + hashCCext (hasher()) ccext
171 :    
172 :     and hashCCexps([],h) = h
173 :     | hashCCexps(e::es,h) = hashCCexps(es,hashCCexp e + h)
174 :    
175 :    
176 :     val hash = hashRexp
177 : jhr 1013 end

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