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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/src/compiler/IL/ssa.sml revision 124, Mon Jun 28 20:40:26 2010 UTC trunk/src/compiler/IL/ssa-fn.sml revision 176, Mon Jul 26 19:47:48 2010 UTC
# Line 1  Line 1 
1  (* ssa.sml  (* ssa-fn.sml
2   *   *
3   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4   * All rights reserved.   * All rights reserved.
5     *
6     * The IL is a combination of a block-structured tree and an SSA control-flow
7     * graph of blocks.
8     *)
9    
10    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      (* 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    
39        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    
48        and simple_stmt
49          = ASSIGN of var * rhs
50          | DIE
51          | STABILIZE
52          | RETURN
53    
54        and rhs
55          = VAR of var
56          | LIT of Literal.literal
57          | OP of Op.rator * var list
58          | CONS of var list                (* tensor-value construction *)
59    
60        val newVar : string -> var
61        val newBlock : unit -> block
62    
63        val entryBlock : stmt -> block
64        val nextBlock : stmt -> block
65    
66  structure SSA =    end
67    
68    functor SSAFn (Op : OPERATORS) : SSA =
69    struct    struct
70    
71      datatype var = V of {      datatype var = V of {
72          name : string          name : string,                  (* name *)
73            id : Stamp.stamp,               (* unique ID *)
74            useCnt : int ref,               (* count of uses *)
75            props : PropList.holder
76          }
77    
78      datatype stmt
79        = EXIT
80        | SEQ of block * stmt
81        | IF of {
82            pre : stmt,
83            cond : var,
84            trueBranch : stmt,
85            falseBranch : stmt,
86            next : stmt             (* ?? *)
87          }
88        | WHILE of {
89            hdr : stmt,
90            cond : var,
91            body : stmt,
92            exit : stmt             (* ?? *)
93          }
94    
95      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    
104      datatype block = BLK of {    and simple_stmt
105          id : label,      = ASSIGN of var * rhs
106          preds : block list ref,      | DIE
107          phi : (var * var list) list ref,      | STABILIZE
108          stms : stm list ref,      | RETURN
109          xfer : transfer ref  
110        and rhs
111          = VAR of var
112          | OP of Op.rator * var list
113    
114      (* 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      and stm      fun newBlock () = BLK{
128        = ASSIGN of var * exp              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      and xfer      end (* local *)
       = GOTO of label                   (* unconditional transfer *)  
       | COND of var * label * label     (* conditional transfer *)  
       | DIE                             (* actor termination *)  
       | STABILIZE                       (* actor stabilization node *)  
       | EXIT                            (* exit node *)  
161    
162      and exp      fun entryBlock (BLOCK blk) = blk
163        = VAR of exp        | 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    end    end

Legend:
Removed from v.124  
changed lines
  Added in v.176

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