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 176 - (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 168 (* a statement is a CFG fragment with a single entrypoint and
22 :     * a single continuation.
23 :     *)
24 :     datatype stmt
25 :     = BLOCK of stmt
26 :     | SEQ of stmt list
27 :     | IF of {
28 :     pre : stmt,
29 :     cond : var,
30 :     trueBranch : stmt
31 :     falseBranch : stmt
32 :     }
33 :     | WHILE of {
34 :     hdr : block,
35 :     cond : var,
36 :     body : stmt
37 :     }
38 : jhr 137
39 : jhr 168 and block = BLK of {
40 :     parent : stmt ref, (* parent statement of this block *)
41 :     id : Stamp.stamp, (* unique ID *)
42 :     preds : block list ref, (* list of predecessor blocks in the CFG *)
43 :     phi : (var * var list) list ref, (* phi statements *)
44 :     body : simple_stmt list ref,
45 :     succs : block list ref (* successor blocks in the CFG *)
46 :     }
47 : jhr 137
48 : jhr 168 and simple_stmt
49 :     = ASSIGN of var * rhs
50 :     | DIE
51 :     | STABILIZE
52 :     | RETURN
53 : jhr 137
54 :     and rhs
55 :     = VAR of var
56 : jhr 176 | LIT of Literal.literal
57 : jhr 137 | OP of Op.rator * var list
58 : jhr 176 | CONS of var list (* tensor-value construction *)
59 : jhr 137
60 :     val newVar : string -> var
61 :     val newBlock : unit -> block
62 :    
63 : jhr 168 val entryBlock : stmt -> block
64 :     val nextBlock : stmt -> block
65 :    
66 : jhr 137 end
67 :    
68 :     functor SSAFn (Op : OPERATORS) : SSA =
69 : jhr 124 struct
70 :    
71 :     datatype var = V of {
72 : jhr 137 name : string, (* name *)
73 :     id : Stamp.stamp, (* unique ID *)
74 :     useCnt : int ref, (* count of uses *)
75 :     props : PropList.holder
76 : jhr 124 }
77 :    
78 : jhr 137 datatype stmt
79 : jhr 168 = EXIT
80 :     | SEQ of block * stmt
81 : jhr 137 | IF of {
82 : jhr 168 pre : stmt,
83 : jhr 137 cond : var,
84 : jhr 168 trueBranch : stmt,
85 :     falseBranch : stmt,
86 :     next : stmt (* ?? *)
87 : jhr 124 }
88 : jhr 137 | WHILE of {
89 : jhr 168 hdr : stmt,
90 : jhr 137 cond : var,
91 : jhr 168 body : stmt,
92 :     exit : stmt (* ?? *)
93 : jhr 137 }
94 : jhr 124
95 : jhr 137 and block = BLK of {
96 :     parent : stmt ref, (* parent statement of this block *)
97 :     id : Stamp.stamp, (* unique ID *)
98 :     preds : block list ref, (* list of predecessor blocks in the CFG *)
99 :     phi : (var * var list) list ref, (* phi statements *)
100 :     body : simple_stmt list ref,
101 :     succs : block list ref (* successor blocks in the CFG *)
102 :     }
103 : jhr 124
104 : jhr 137 and simple_stmt
105 :     = ASSIGN of var * rhs
106 :     | DIE
107 :     | STABILIZE
108 :     | RETURN
109 : jhr 124
110 : jhr 137 and rhs
111 : jhr 129 = VAR of var
112 :     | OP of Op.rator * var list
113 : jhr 124
114 : jhr 137 (* block properties *)
115 :     fun parentOf (BLK{parent, ...}) = !parent
116 :     fun predsOf (BLK{preds, ...}) = !preds
117 :     fun succsOf (BLK{succs, ...}) = !succs
118 :    
119 :     (* IL construction code *)
120 :     fun newVar name = V{
121 :     name = name,
122 :     id = Stamp.new(),
123 :     useCnt = ref 0,
124 :     props = PropList.newHolder()
125 :     }
126 :    
127 :     fun newBlock () = BLK{
128 :     parent = ref(SEQ[]),
129 :     id = Stamp.new(),
130 :     preds = ref[],
131 :     phi = ref[],
132 :     body = ref[],
133 :     succs = ref[]
134 :     }
135 :    
136 :     local
137 :     fun setParent (BKL{parent, ...}, s) = (parent := s)
138 :     in
139 :     fun mkBLOCK blk = let
140 :     val s = BLOCK blk
141 :     in
142 :     setParent (blk, s);
143 :     s
144 :     end
145 :    
146 :     fun mkIF (pre, cond, t, f) = let
147 :     val s = IF{pre=pre, cond=cond, trueBranch=t, falseBranch=f}
148 :     in
149 :     setParent (pre, s);
150 :     s
151 :     end
152 :    
153 :     fun mkWHILE (hdr, cond, body) = let
154 :     val s = WHILE{hdr=hdr, cond=cond, body=body}
155 :     in
156 :     setParent (hdr, s);
157 :     s
158 :     end
159 :    
160 :     end (* local *)
161 :    
162 : jhr 168 fun entryBlock (BLOCK blk) = blk
163 :     | entryBlock (SEQ(s1::_)) = entryBlock s1
164 :     | entryBlock (IF{pre, ...}) = entryBlock pre
165 :     | entryBlock (WHILE{hdr, ...}) = entryBlock hdr
166 :    
167 :     fun nextBlock (SEQ(, next)) = nextBlock next
168 :     | nextBlock (SEQ stms) = nextBlock(List.last stms)
169 :     | nextBlock (IF{pre, ...}) = entryBlock pre
170 :     | nextBlock (WHILE{hdr, ...}) = entryBlock hdr
171 :    
172 : jhr 124 end

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