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

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