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

SCM Repository

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

Annotation of /branches/lamont_dev/src/compiler/IL/ssa-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 197 - (view) (download)
Original Path: trunk/src/compiler/IL/ssa-fn.sml

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 192 functor SSAFn (Op : OPERATORS) (*: SSA*) =
11 :     struct
12 : jhr 137
13 : jhr 192 structure Op = Op
14 : jhr 137
15 : jhr 197 datatype program = Program of {
16 :     globals : var list,
17 :     globalInit : stmt,
18 :     actors : actor list
19 :     (* initialization *)
20 :     }
21 :    
22 :     and actor = Actor of {
23 :     name : Atom.atom,
24 :     params : var list,
25 :     state : var list,
26 :     stateInit : stmt,
27 :     methods : method list
28 :     }
29 :    
30 :     and method = Method of Atom.atom * stmt
31 :    
32 :     and stmt = STM of {
33 : jhr 188 id : Stamp.stamp,
34 :     props : PropList.holder,
35 : jhr 192 preds : stmt list ref,
36 :     phis : (var * var list) list ref, (* phi statements *)
37 :     kind : stmt_kind ref
38 : jhr 188 }
39 :    
40 : jhr 192 and stmt_kind
41 :     = BLOCK of {
42 :     succ : stmt,
43 :     body : assign list
44 :     }
45 :     | IF of {
46 :     cond : var,
47 :     thenBranch : stmt,
48 :     elseBranch : stmt
49 :     }
50 :     | LOOP of {
51 :     hdr : stmt,
52 :     cond : var,
53 :     body : stmt,
54 :     exit : stmt
55 :     }
56 :     | NEW of {
57 :     actor : Atom.atom,
58 :     args : var list,
59 :     succ : stmt
60 :     }
61 :     | DIE
62 :     | STABILIZE
63 :     | EXIT
64 :    
65 : jhr 188 and rhs
66 :     = VAR of var
67 :     | LIT of Literal.literal
68 :     | OP of Op.rator * var list
69 :     | CONS of var list (* tensor-value construction *)
70 :    
71 : jhr 192 and 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 192 withtype assign = (var * rhs)
79 : jhr 188
80 : jhr 192 fun same (STM{id=a, ...}, STM{id=b, ...}) = Stamp.same(a, b)
81 :     fun compare (STM{id=a, ...}, STM{id=b, ...}) = Stamp.compare(a, b)
82 :     fun hash (STM{id, ...}) = Stamp.hash id
83 : jhr 188
84 : jhr 192 fun succs (STM{kind, ...}) = (case !kind
85 :     of BLOCK{succ, ...} => [succ]
86 :     | IF{thenBranch, elseBranch, ...} => [thenBranch, elseBranch]
87 :     | LOOP{exit, ...} => [exit]
88 :     | NEW{succ, ...} => [succ]
89 :     | _ => []
90 :     (* end case *))
91 : jhr 188
92 : jhr 192 (* set the successor of a statement *)
93 :     fun setSucc (STM{kind, ...}, stm) = (case !kind
94 :     of BLOCK{succ, body} => kind := BLOCK{succ=stm, body=body}
95 :     | IF{thenBranch, elseBranch, ...} => (
96 :     setSucc(thenBranch, stm);
97 :     setSucc(elseBranch, stm))
98 :     | LOOP{hdr, cond, body, exit} => kind := LOOP{hdr=hdr, cond=cond, body=body, exit=stm}
99 :     | NEW{actor, args, succ} => kind := NEW{actor=actor, args=args, succ=stm}
100 :     | _ => () (* no successor *)
101 :     (* end case *))
102 : jhr 188
103 : jhr 192 fun preds (STM{preds, ...}) = !preds
104 : jhr 124
105 : jhr 192 fun addPred (STM{preds, ...}, stm) =
106 :     if not(List.exists (fn b => same(stm, b)) (!preds))
107 :     then preds := stm :: !preds
108 :     else ();
109 : jhr 137
110 : jhr 192 fun mkSTM kind = STM{
111 : jhr 137 id = Stamp.new(),
112 : jhr 188 props = PropList.newHolder(),
113 : jhr 192 preds = ref [],
114 :     phis = ref [],
115 :     kind = ref kind
116 : jhr 137 }
117 :    
118 : jhr 192 val dummy = mkSTM EXIT
119 : jhr 137
120 : jhr 192 fun mkBLOCK args = mkSTM(BLOCK args)
121 :     fun mkIF args = mkSTM(IF args)
122 :     fun mkLOOP args = mkSTM(LOOP args)
123 : jhr 197 fun mkNEW args = mkSTM(NEW args)
124 : jhr 192 fun mkDIE () = mkSTM DIE
125 :     fun mkSTABILIZE () = mkSTM STABILIZE
126 :     fun mkEXIT () = mkSTM EXIT
127 : jhr 137
128 : jhr 197 fun newVar name = V{
129 :     name = name,
130 :     id = Stamp.new(),
131 :     useCnt = ref 0,
132 :     props = PropList.newHolder()
133 :     }
134 :    
135 : jhr 124 end

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