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

SCM Repository

[diderot] Diff of /branches/vis12-cl/src/compiler/IL/ssa-sig.sml
ViewVC logotype

Diff of /branches/vis12-cl/src/compiler/IL/ssa-sig.sml

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

revision 2683, Mon Aug 25 18:56:17 2014 UTC revision 2804, Sat Nov 8 17:33:59 2014 UTC
# Line 40  Line 40 
40      structure Ty : SSA_TYPES      structure Ty : SSA_TYPES
41      structure Op : OPERATORS where type ty = Ty.ty      structure Op : OPERATORS where type ty = Ty.ty
42    
   (***** strand state variables *****)  
   
     datatype state_var = SV of {  
         id : Stamp.stamp,               (* variable's unique ID *)  
         name : string,                  (* variable's name *)  
         ty : Ty.ty,                     (* variable's type *)  
         output : bool,                  (* true for output variables *)  
         props : PropList.holder  
       }  
   
43    (***** CFG *****)    (***** CFG *****)
44    
45      datatype cfg = CFG of {      datatype cfg = CFG of {
# Line 84  Line 74 
74              text : string list,              text : string list,
75              succ : node ref              succ : node ref
76            }            }
77        | ASSIGN of {                     (* assignment *)        | ASSIGN of {                     (* local-variable assignment *)
78              pred : node ref,              pred : node ref,
79              stm : assign,              stm : assign,
80              succ : node ref              succ : node ref
# Line 94  Line 84 
84              stm : massign,              stm : massign,
85              succ : node ref              succ : node ref
86            }            }
87          | GASSIGN of {                    (* global variable assignment *)
88                pred: node ref,
89                lhs : global_var,
90                rhs : var,
91                succ : node ref
92              }
93        | NEW of {                        (* create new strand instance *)        | NEW of {                        (* create new strand instance *)
94              pred : node ref,              pred : node ref,
95              strand : Atom.atom,              strand : Atom.atom,
# Line 113  Line 109 
109            }            }
110    
111      and rhs      and rhs
112        = STATE of state_var              (* read strand state variable *)        = GLOBAL of global_var            (* read global variable *)
113          | STATE of state_var              (* read strand state variable *)
114        | VAR of var        | VAR of var
115        | LIT of Literal.literal        | LIT of Literal.literal
116        | OP of Op.rator * var list        | OP of Op.rator * var list
# Line 137  Line 134 
134        | VB_PHI of var list              (* defined by a phi node *)        | VB_PHI of var list              (* defined by a phi node *)
135        | VB_PARAM                        (* parameter to a strand *)        | VB_PARAM                        (* parameter to a strand *)
136    
137      (***** global variables *****)
138        and global_var = GV of {
139            id : Stamp.stamp,               (* variable's unique ID *)
140            name : string,                  (* variable's name *)
141            ty : Ty.ty,                     (* variable's type *)
142            bind : var ref,                 (* binding *)
143            useCnt : int ref,               (* count of uses *)
144            input : bool,                   (* true for input variables *)
145            props : PropList.holder
146          }
147    
148      (***** strand state variables *****)
149        and state_var = SV of {
150            id : Stamp.stamp,               (* variable's unique ID *)
151            name : string,                  (* variable's name *)
152            ty : Ty.ty,                     (* variable's type *)
153            output : bool,                  (* true for output variables *)
154            props : PropList.holder
155          }
156    
157      withtype assign = (var * rhs)      withtype assign = (var * rhs)
158           and massign = (var list * Op.rator * var list)           and massign = (var list * Op.rator * var list)
159           and phi = (var * var list)           and phi = (var * var list)
160    
161      datatype assignment = ASSGN of assign | MASSGN of massign      datatype assignment
162          = ASSGN of assign
163          | MASSGN of massign
164          | GASSGN of (global_var * var)
165          | SAV of (state_var * var)
166    
167    (***** Program representation *****)    (***** Program representation *****)
168    
169      datatype program = Program of {      datatype program = Program of {
170          props : StrandUtil.program_prop list,          props : StrandUtil.program_prop list,
171          globalInit : cfg,          globals : global_var list,      (* global variables (both input and non-input) *)
172            inputInit : cfg,                (* CFG to initialize input globals (if any) *)
173            globalInit : cfg,               (* CFG to initialize other globals (if any) *)
174          initially : initially,          initially : initially,
175          strands : strand list          strands : strand list
176        }        }
# Line 173  Line 195 
195          body : cfg              (* method body *)          body : cfg              (* method body *)
196        }        }
197    
198      (* operations on global variables *)
199        structure GlobalVar : sig
200            val new : bool * string * Ty.ty -> global_var
201            val name : global_var -> string
202            val ty : global_var -> Ty.ty
203            val binding : global_var -> var
204            val setBinding : global_var * var -> unit
205            val useCount : global_var -> int
206            val isInput : global_var -> bool
207            val same : global_var * global_var -> bool
208            val compare : global_var * global_var -> order
209            val hash : global_var -> word
210            val toString : global_var -> string
211          (* properties *)
212            val newProp : (global_var -> 'a) -> {
213                    getFn : global_var -> 'a,
214                    peekFn : global_var -> 'a option,
215                    setFn : global_var * 'a -> unit,
216                    clrFn : global_var -> unit
217                  }
218            val newFlag : unit -> {
219                    getFn : global_var -> bool,
220                    setFn : global_var * bool -> unit
221                  }
222          (* collections *)
223            structure Map : ORD_MAP where type Key.ord_key = global_var
224            structure Set : ORD_SET where type Key.ord_key = global_var
225            structure Tbl : MONO_HASH_TABLE where type Key.hash_key = global_var
226          end
227    
228    (* operations on strand-state variables *)    (* operations on strand-state variables *)
229      structure StateVar : sig      structure StateVar : sig
230          val new : bool * string * Ty.ty -> state_var          val new : bool * string * Ty.ty -> state_var
# Line 217  Line 269 
269         * be in preorder with parents before children.         * be in preorder with parents before children.
270         *)         *)
271          val sort : cfg -> node list          val sort : cfg -> node list
272        (* apply a function to all of the nodes in the graph rooted at the entry to the statement *)        (* apply a function to all of the nodes in the graph rooted at the entry to the CFG *)
273          val apply : (node -> unit) -> cfg -> unit          val apply : (node -> unit) -> cfg -> unit
274  (*  (*
275        (* rewrite a CFG by applying a partial function to the nodes in the graph.  If NONE is returned,        (* rewrite a CFG by applying a partial function to the nodes in the graph.  If NONE is returned,
# Line 238  Line 290 
290          val prependNode : node * cfg -> cfg          val prependNode : node * cfg -> cfg
291        (* append a node to a CFG *)        (* append a node to a CFG *)
292          val appendNode : cfg * node -> cfg          val appendNode : cfg * node -> cfg
293          (* insert a block of assignments at the beginning of the CFG.  If the CFG has an ENTRY
294           * node, then the block is inserted immediatly following the entry.
295           *)
296            val prependBlock : assignment list * cfg -> cfg
297          (* insert a block of assignments at the end of the CFG argument  If the CFG has an EXIT
298           * node, then the block is inserted immediatly following the exit.
299           *)
300            val appendBlock : cfg * assignment list -> cfg
301        (* update the exit of a CFG by modifying the live variable list *)        (* update the exit of a CFG by modifying the live variable list *)
302          val updateExit : cfg * (var list -> var list) -> cfg          val updateExit : cfg * (var list -> var list) -> cfg
303        end        end
# Line 277  Line 337 
337          val mkCOM : string list -> node          val mkCOM : string list -> node
338          val mkASSIGN : assign -> node          val mkASSIGN : assign -> node
339          val mkMASSIGN : massign -> node          val mkMASSIGN : massign -> node
340            val mkGASSIGN : (global_var * var) -> node
341          val mkNEW : {strand : Atom.atom, args : var list} -> node          val mkNEW : {strand : Atom.atom, args : var list} -> node
342          val mkSAVE : (state_var * var) -> node          val mkSAVE : (state_var * var) -> node
343          val mkEXIT : ExitKind.kind * var list -> node          val mkEXIT : ExitKind.kind * var list -> node

Legend:
Removed from v.2683  
changed lines
  Added in v.2804

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