Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /trunk/src/compiler/IL/ssa-fn.sml
ViewVC logotype

Annotation of /trunk/src/compiler/IL/ssa-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 188 - (view) (download)

1 : jhr 137 (* ssa-fn.sml
2 : jhr 124 *
3 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4 :     * All rights reserved.
5 : jhr 137 *
6 :     * The IL is a combination of a block-structured tree and an SSA control-flow
7 :     * graph of blocks.
8 : jhr 124 *)
9 :    
10 : jhr 137 signature SSA =
11 :     sig
12 :     structure Op : OPERATORS
13 :    
14 :     datatype var = V of {
15 :     name : string, (* name *)
16 :     id : Stamp.stamp, (* unique ID *)
17 :     useCnt : int ref, (* count of uses *)
18 :     props : PropList.holder
19 :     }
20 :    
21 : jhr 188 datatype block = BLK of {
22 :     id : Stamp.stamp,
23 :     props : PropList.holder,
24 :     preds : block list ref,
25 :     succs : block list ref,
26 :     phi : (var * var list) list ref, (* phi statements *)
27 :     body : assign list ref,
28 :     exit : transfer ref
29 :     }
30 :    
31 :     and rhs
32 :     = VAR of var
33 :     | LIT of Literal.literal
34 :     | OP of Op.rator * var list
35 :     | CONS of var list (* tensor-value construction *)
36 :    
37 :     and transfer
38 :     = EXIT
39 :     | GOTO of block
40 :     | COND of var * block * block
41 :     | DIE
42 :     | STABILIZE
43 :    
44 :     withtype assign = (var * rhs)
45 :    
46 :     (* we layer a block-structured statement tree over the CFG to preserve
47 :     * the high-level control-flow structure for when we need to produce
48 :     * code.
49 : jhr 168 *)
50 :     datatype stmt
51 : jhr 188 = BLOCK of block
52 :     | SEQ of stmt list
53 : jhr 168 | IF of {
54 :     cond : var,
55 : jhr 187 trueBranch : stmt,
56 : jhr 168 falseBranch : stmt
57 :     }
58 :     | WHILE of {
59 : jhr 188 hdr : block,
60 : jhr 168 cond : var,
61 :     body : stmt
62 :     }
63 : jhr 137
64 :     val newVar : string -> var
65 :     val newBlock : unit -> block
66 :    
67 : jhr 187 (*
68 : jhr 168 val entryBlock : stmt -> block
69 :     val nextBlock : stmt -> block
70 : jhr 187 *)
71 : jhr 168
72 : jhr 137 end
73 :    
74 :     functor SSAFn (Op : OPERATORS) : SSA =
75 : jhr 124 struct
76 :    
77 : jhr 187 structure Op = Op
78 :    
79 : jhr 124 datatype var = V of {
80 : jhr 137 name : string, (* name *)
81 :     id : Stamp.stamp, (* unique ID *)
82 :     useCnt : int ref, (* count of uses *)
83 :     props : PropList.holder
84 : jhr 124 }
85 :    
86 : jhr 188 datatype block = BLK of {
87 :     id : Stamp.stamp,
88 :     props : PropList.holder,
89 :     preds : block list ref,
90 :     succs : block list ref,
91 :     phi : (var * var list) list ref, (* phi statements *)
92 :     body : assign list ref,
93 :     exit : transfer ref
94 :     }
95 :    
96 :     and rhs
97 :     = VAR of var
98 :     | LIT of Literal.literal
99 :     | OP of Op.rator * var list
100 :     | CONS of var list (* tensor-value construction *)
101 :    
102 :     and transfer
103 :     = EXIT
104 :     | GOTO of block
105 :     | COND of var * block * block
106 :     | DIE
107 :     | STABILIZE
108 :    
109 :     withtype assign = (var * rhs)
110 :    
111 :     (* we layer a block-structured statement tree over the CFG to preserve
112 :     * the high-level control-flow structure for when we need to produce
113 :     * code.
114 :     *)
115 : jhr 187 datatype stmt
116 : jhr 188 = BLOCK of block
117 :     | SEQ of stmt list
118 : jhr 187 | IF of {
119 :     cond : var,
120 :     trueBranch : stmt,
121 :     falseBranch : stmt
122 :     }
123 :     | WHILE of {
124 : jhr 188 hdr : block,
125 : jhr 187 cond : var,
126 :     body : stmt
127 :     }
128 : jhr 124
129 : jhr 137 (* IL construction code *)
130 :     fun newVar name = V{
131 :     name = name,
132 :     id = Stamp.new(),
133 :     useCnt = ref 0,
134 :     props = PropList.newHolder()
135 :     }
136 :    
137 :     fun newBlock () = BLK{
138 :     id = Stamp.new(),
139 : jhr 188 props = PropList.newHolder(),
140 : jhr 137 preds = ref[],
141 : jhr 188 succs = ref[],
142 : jhr 137 phi = ref[],
143 :     body = ref[],
144 : jhr 188 exit = ref EXIT
145 : jhr 137 }
146 : jhr 187 (*
147 : jhr 137 local
148 : jhr 187 fun setParent (BLK{parent, ...}, s) = (parent := s)
149 : jhr 137 in
150 :    
151 :     fun mkIF (pre, cond, t, f) = let
152 :     val s = IF{pre=pre, cond=cond, trueBranch=t, falseBranch=f}
153 :     in
154 :     setParent (pre, s);
155 :     s
156 :     end
157 :    
158 :     fun mkWHILE (hdr, cond, body) = let
159 :     val s = WHILE{hdr=hdr, cond=cond, body=body}
160 :     in
161 :     setParent (hdr, s);
162 :     s
163 :     end
164 :    
165 :     end (* local *)
166 : jhr 187 *)
167 : jhr 137
168 : jhr 187 (*
169 : jhr 168 fun entryBlock (BLOCK blk) = blk
170 :     | entryBlock (SEQ(s1::_)) = entryBlock s1
171 :     | entryBlock (IF{pre, ...}) = entryBlock pre
172 :     | entryBlock (WHILE{hdr, ...}) = entryBlock hdr
173 :    
174 : jhr 187 fun nextBlock (BLOCK(_, next)) = nextBlock next
175 : jhr 168 | nextBlock (SEQ stms) = nextBlock(List.last stms)
176 :     | nextBlock (IF{pre, ...}) = entryBlock pre
177 :     | nextBlock (WHILE{hdr, ...}) = entryBlock hdr
178 : jhr 187 *)
179 : jhr 168
180 : jhr 124 end

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