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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/cfg-ir/ssa-pp-fn.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/cfg-ir/ssa-pp-fn.sml

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

revision 3473, Wed Dec 2 17:57:53 2015 UTC revision 3506, Fri Dec 18 04:03:54 2015 UTC
# Line 8  Line 8 
8   * Pretty printing for SSA representations   * Pretty printing for SSA representations
9   *)   *)
10    
11  functor SSAPPFn (IL : SSA) : sig  functor SSAPPFn (IR : SSA) : sig
12    
13      val assignToString : IL.assign -> string      val assignToString : IR.assign -> string
14    
15      val output : TextIO.outstream * string * IL.program -> unit      val output : TextIO.outstream * string * IR.program -> unit
16    
17    end = struct    end = struct
18    
19      structure Op = IL.Op      structure Op = IR.Op
20      structure Var = IL.Var      structure Var = IR.Var
21      structure GVar = IL.GlobalVar      structure GVar = IR.GlobalVar
22      structure Ty = IL.Ty      structure Ty = IR.Ty
23    
24      local      local
25        val {getFn, setFn} = IL.Node.newFlag()        val {getFn, setFn} = IR.Node.newFlag()
26      in      in
27      val isMarked = getFn      val isMarked = getFn
28      fun mark nd = setFn(nd, true)      fun mark nd = setFn(nd, true)
# Line 44  Line 44 
44    
45      fun assignToString (y, rhs) = let      fun assignToString (y, rhs) = let
46            val rhs = (case rhs            val rhs = (case rhs
47                   of IL.GLOBAL x => [GVar.toString x, ";"]                   of IR.GLOBAL x => [GVar.toString x, ";"]
48                    | IL.STATE x => [IL.StateVar.toString x, ";"]                    | IR.STATE x => [IR.StateVar.toString x, ";"]
49                    | IL.VAR x => [Var.toString x, ";"]                    | IR.VAR x => [Var.toString x, ";"]
50                    | IL.LIT lit => [Literal.toString lit, ";"]                    | IR.LIT lit => [Literal.toString lit, ";"]
51                    | IL.OP(rator, []) => [Op.toString rator, ";"]                    | IR.OP(rator, []) => [Op.toString rator, ";"]
52                    | IL.OP(rator, args) => [                    | IR.OP(rator, args) => [
53                          Op.toString rator, "(",                          Op.toString rator, "(",
54                          String.concatWith "," (List.map Var.toString args), ");"                          String.concatWith "," (List.map Var.toString args), ");"
55                        ]                        ]
56                    | IL.CONS(xs, ty) => [                    | IR.CONS(xs, ty) => [
57                          "<", Ty.toString ty, ">[",                          "<", Ty.toString ty, ">[",
58                          String.concatWith "," (List.map Var.toString xs), "];"                          String.concatWith "," (List.map Var.toString xs), "];"
59                        ]                        ]
60                    | IL.SEQ(xs, ty) => [                    | IR.SEQ(xs, ty) => [
61                          "<", Ty.toString ty, ">{",                          "<", Ty.toString ty, ">{",
62                          String.concatWith "," (List.map Var.toString xs), "};"                          String.concatWith "," (List.map Var.toString xs), "};"
63                        ]                        ]
64                    | IL.EINAPP(ein, args) => [                    | IR.EINAPP(ein, args) => [
65  (* FIXME *)  (* FIXME *)
66                          "EIN", "(",                          "EIN", "(",
67                          String.concatWith "," (List.map Var.toString args), ");"                          String.concatWith "," (List.map Var.toString args), ");"
# Line 79  Line 79 
79              Op.toString rator, "(", String.concatWith "," (List.map Var.toString xs), ");"              Op.toString rator, "(", String.concatWith "," (List.map Var.toString xs), ");"
80            ]            ]
81    
82      fun labelOf (IL.ND{id, ...}) = "L"^Stamp.toString id      fun labelOf (IR.ND{id, ...}) = "L"^Stamp.toString id
83    
84      fun ppCFG (out, cfg as IL.CFG{entry, exit}) = let      fun ppCFG (out, cfg as IR.CFG{entry, exit}) = let
85            fun goto (out, nd) = (case IL.Node.kind nd            fun goto (out, nd) = (case IR.Node.kind nd
86                   of IL.JOIN _ => (                   of IR.JOIN _ => (
87                        prln(incIndent out, ["goto ", IL.Node.toString nd, "\n"]);                        prln(incIndent out, ["goto ", IR.Node.toString nd, "\n"]);
88                        ppNd (out, false, nd))                        ppNd (out, false, nd))
89                    | _ => ppNd (out, true, nd)                    | _ => ppNd (out, true, nd)
90                  (* end case *))                  (* end case *))
# Line 102  Line 102 
102                        mark nd;                        mark nd;
103                        if noLabel andalso (! compact)                        if noLabel andalso (! compact)
104                          then ()                          then ()
105                          else (case IL.Node.kind nd                          else (case IR.Node.kind nd
106                             of IL.JOIN{preds, mask, ...} => let                             of IR.JOIN{preds, mask, ...} => let
107                                  val preds = ListPair.mapEq                                  val preds = ListPair.mapEq
108                                        (fn (false, nd) => IL.Node.toString nd                                        (fn (false, nd) => IR.Node.toString nd
109                                          | (true, nd) => "*" ^ IL.Node.toString nd)                                          | (true, nd) => "*" ^ IR.Node.toString nd)
110                                        (!mask, !preds)                                        (!mask, !preds)
111  (* +DEBUG*)  (* +DEBUG*)
112  handle ex => (  handle ex => (
113  print(concat["**** Broken CFG at ", IL.Node.toString nd, "\n"]);  print(concat["**** Broken CFG at ", IR.Node.toString nd, "\n"]);
114  List.map IL.Node.toString (!preds))  List.map IR.Node.toString (!preds))
115  (* -DEBUG*)  (* -DEBUG*)
116                                  in                                  in
117                                    prln (out, [                                    prln (out, [
118                                        IL.Node.toString nd, ":  preds = [",                                        IR.Node.toString nd, ":  preds = [",
119                                        String.concatWith "," preds, "]\n"                                        String.concatWith "," preds, "]\n"
120                                      ])                                      ])
121                                  end                                  end
122                              | _ => prln (out, [                              | _ => prln (out, [
123                                    IL.Node.toString nd, ":  preds = [",                                    IR.Node.toString nd, ":  preds = [",
124                                    String.concatWith "," (List.map IL.Node.toString (IL.Node.preds nd)),                                    String.concatWith "," (List.map IR.Node.toString (IR.Node.preds nd)),
125                                    "]\n"                                    "]\n"
126                                  ])                                  ])
127                            (* end case *));                            (* end case *));
128                        case IL.Node.kind nd                        case IR.Node.kind nd
129                         of IL.NULL => ()                         of IR.NULL => ()
130                          | IL.ENTRY{succ} => goto (out, !succ)                          | IR.ENTRY{succ} => goto (out, !succ)
131                          | IL.JOIN{phis, succ, ...} => (                          | IR.JOIN{phis, succ, ...} => (
132                              List.app (prPhi out1) (!phis);                              List.app (prPhi out1) (!phis);
133                              goto (out, !succ))                              goto (out, !succ))
134                          | IL.COND{cond, trueBranch, falseBranch, ...} => (                          | IR.COND{cond, trueBranch, falseBranch, ...} => (
135                              prln (out1, [                              prln (out1, [
136                                  "if ", Var.toString cond,                                  "if ", Var.toString cond,
137                                  " then goto ", IL.Node.toString(!trueBranch),                                  " then goto ", IR.Node.toString(!trueBranch),
138                                  " else goto ", IL.Node.toString(!falseBranch), "\n"                                  " else goto ", IR.Node.toString(!falseBranch), "\n"
139                                ]);                                ]);
140                              ppNd (out, false, !trueBranch);                              ppNd (out, false, !trueBranch);
141                              ppNd (out, false, !falseBranch))                              ppNd (out, false, !falseBranch))
142                          | IL.FOREACH{phis, var, src, body, succ, ...} => (                          | IR.FOREACH{phis, var, src, bodyEntry, succ, ...} => (
143                              prln (out1, [                              prln (out1, [
144                                  "foreach (", Var.toString var, " in ", Var.toString src, ")",                                  "foreach (", Var.toString var, " in ", Var.toString src, ")",
145                                  " on exit goto ", IL.Node.toString(!succ), "\n"                                  " on exit goto ", IR.Node.toString(!succ), "\n"
146                                ]);                                ]);
147                              List.app (prPhi (incIndent out1)) (!phis);                              List.app (prPhi (incIndent out1)) (!phis);
148                                goto (out, !bodyEntry);
149                              goto (out, !succ))                              goto (out, !succ))
150                          | IL.COM{text, succ, ...} => (                          | IR.COM{text, succ, ...} => (
151                              List.app (fn s => prln (out1, ["//", s, "\n"])) text;                              List.app (fn s => prln (out1, ["//", s, "\n"])) text;
152                              goto (out, !succ))                              goto (out, !succ))
153                          | IL.ASSIGN{stm, succ, ...} => (                          | IR.ASSIGN{stm, succ, ...} => (
154                              prln (out1, [assignToString stm, "\n"]);                              prln (out1, [assignToString stm, "\n"]);
155                              goto (out, !succ))                              goto (out, !succ))
156                          | IL.MASSIGN{stm, succ, ...} => (                          | IR.MASSIGN{stm, succ, ...} => (
157                              prln (out1, [massignToString stm, "\n"]);                              prln (out1, [massignToString stm, "\n"]);
158                              goto (out, !succ))                              goto (out, !succ))
159                          | IL.GASSIGN{lhs, rhs, succ, ...} => (                          | IR.GASSIGN{lhs, rhs, succ, ...} => (
160                              prln (out1, [                              prln (out1, [
161                                  GVar.toString lhs, " = ", Var.toString rhs, ";\n"                                  GVar.toString lhs, " = ", Var.toString rhs, ";\n"
162                                ]);                                ]);
163                              goto (out, !succ))                              goto (out, !succ))
164                          | IL.NEW{strand, args, succ, ...} => (                          | IR.NEW{strand, args, succ, ...} => (
165                              prln (out1, [                              prln (out1, [
166                                  "new ", Atom.toString strand, "(",                                  "new ", Atom.toString strand, "(",
167                                  String.concatWith "," (List.map Var.toString args), ");\n"                                  String.concatWith "," (List.map Var.toString args), ");\n"
168                                ]);                                ]);
169                              goto (out, !succ))                              goto (out, !succ))
170                          | IL.SAVE{lhs, rhs, succ, ...} => (                          | IR.SAVE{lhs, rhs, succ, ...} => (
171                              prln (out1, [                              prln (out1, [
172                                  IL.StateVar.toString lhs, " = ", Var.toString rhs, ";\n"                                  IR.StateVar.toString lhs, " = ", Var.toString rhs, ";\n"
173                                ]);                                ]);
174                              goto (out, !succ))                              goto (out, !succ))
175                          | IL.EXIT{kind, live, succ, ...} => let                          | IR.EXIT{kind, succ, ...} => (
                             val live = (case live  
                                    of [] => "()"  
                                     | [x] => String.concat["(", Var.toString x, ")"]  
                                     | xs => String.concat[  
                                           "(",  
                                           String.concatWith "," (List.map Var.toString xs),  
                                           ")"  
                                         ]  
                                   (* end case *))  
                             in  
176                                case kind                                case kind
177                                 of ExitKind.FRAGMENT =>                               of ExitKind.RETURN => prln (out1, ["return\n"])
178                                      prln (out1, ["live vars = ", live, "\n"])                                | ExitKind.ACTIVE => prln (out1, ["active\n"])
179                                  | ExitKind.SINIT =>                                | ExitKind.STABILIZE => prln (out1, ["stabilize\n"])
180                                      prln (out1, ["strand_init ", live, "\n"])                                | ExitKind.DIE => prln (out1, ["die\n"])
181                                  | ExitKind.RETURN =>                                | ExitKind.UNREACHABLE => prln (out1, ["unreachable\n"])
                                     prln (out1, ["return ", live, "\n"])  
                                 | ExitKind.ACTIVE =>  
                                     prln (out1, ["active ", live, "\n"])  
                                 | ExitKind.STABILIZE =>  
                                     prln (out1, ["stabilize ", live, "\n"])  
                                 | ExitKind.DIE =>  
                                     prln (out1, ["die ", live, "\n"])  
                                 | ExitKind.UNREACHABLE =>  
                                     prln (out1, ["unreachable\n"])  
182                                (* end case *);                                (* end case *);
183                                case !succ                                case !succ
184                                 of SOME nd => goto (out, nd)                                 of SOME nd => goto (out, nd)
185                                  | _ => ()                                  | _ => ()
186                                (* end case *)                              (* end case *))
                             end  
187                        (* end case *))                        (* end case *))
188                  end                  end
189            in            in
190              ppNd (out, false, entry);              ppNd (out, false, entry);
191            (* clear marks *)            (* clear marks *)
192              IL.CFG.apply clear cfg              IR.CFG.apply clear cfg
193            end            end
194    
195      fun ppInitially (out, IL.Initially{isArray, rangeInit, iters, create}) = let      fun ppCreate (out, IR.Create{dim, code}) = (
196            val (initArg, strand, args) = create            indent out;
197            fun ppIters (out, []) = (            case dim
198                  ppCFG (out, initArg);             of NONE => pr (out, "COLLECTION\n")
199                  prln (out, [              | SOME dim => prl (out, ["GRID(", Int.toString dim, ")\n"])
200                      "new ", Atom.toString strand, "(",            (* end case *);
201                      String.concatWith "," (List.map Var.toString args), ");\n"            ppCFG (incIndent out, code))
                   ]))  
             | ppIters (out, (param, lo, hi)::iters) = (  
                 indent out; prl(out, [  
                     "for ", typedVar param, " = ", Var.toString lo, " .. ", Var.toString hi, "\n"  
                   ]);  
                 ppIters (incIndent out, iters))  
           in  
             indent out; prl(out, if isArray then ["ARRAY\n"] else ["COLLECTION\n"]);  
             ppCFG (incIndent out, rangeInit);  
             ppIters (incIndent out, iters)  
           end  
202    
203      fun ppMethod (out, IL.Method{name, body}) = let      fun ppMethod (out, name) body = let
204            val out1 = incIndent out            val out1 = incIndent out
           fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs  
205            in            in
206              indent out; prl(out, ["method ", StrandUtil.nameToString name, "\n"]);              indent out; prl(out, ["method ", name, "\n"]);
207              ppCFG (incIndent out1, body);              ppCFG (incIndent out1, body);
208              indent out; prl(out, ["end ", StrandUtil.nameToString name, "\n"])              indent out; prl(out, ["end ", name, "\n"])
209            end            end
210    
211      and ppStrand (out, IL.Strand{name, params, state, stateInit, methods}) = let      and ppStrand (out, IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM}) = let
212            val out1 = incIndent out            val out1 = incIndent out
213            fun stateVar x = let            fun stateVar x = let
214                  val l = [Ty.toString(IL.StateVar.ty x), " ", IL.StateVar.toString x, ";"]                  val l = [Ty.toString(IR.StateVar.ty x), " ", IR.StateVar.toString x, ";"]
215                  val l = if IL.StateVar.isOutput x then "output " :: l else l                  val l = if IR.StateVar.isOutput x then "output " :: l else l
216                  in                  in
217                    prl (out1, l)                    prl (out1, l)
218                  end                  end
# Line 251  Line 220 
220              indent out;              indent out;
221              prl(out, [              prl(out, [
222                  "strand ", Atom.toString name, " (",                  "strand ", Atom.toString name, " (",
223                  String.concatWith ", " (List.map typedVar params), ")\n"                  String.concatWithMap ", " typedVar params, ")\n"
224                ]);                ]);
225              indent out1; pr(out1, "state: "); List.app stateVar state; pr(out1, "\n");              indent out1; pr(out1, "state: "); List.app stateVar state; pr(out1, "\n");
226              ppCFG (incIndent out1, stateInit);              ppCFG (incIndent out1, stateInit);
227              List.app (fn m => ppMethod(out1, m)) methods;              Option.app (ppMethod (out1, "initially")) initM;
228                ppMethod (out1, "update") updateM;
229                Option.app (ppMethod (out1, "stabilize")) stabilizeM;
230              indent out; prl(out, ["end ", Atom.toString name, "\n"])              indent out; prl(out, ["end ", Atom.toString name, "\n"])
231            end            end
232    
233      fun ppGlobal outS gv = let      fun ppGlobal prefix outS gv = (
           val prefix = if GVar.isInput gv then "input " else "global "  
           in  
234              indent outS;              indent outS;
235              prl(outS, [              prl(outS, [
236                  prefix, Ty.toString(GVar.ty gv), " ", GVar.uniqueName gv, "\n"                prefix, " ", Ty.toString(GVar.ty gv), " ", GVar.uniqueName gv, "\n"
237                ])              ]))
           end  
238    
239      fun output (outS, msg, IL.Program{props, globals, inputInit, globalInit, initially, strands}) = let      fun ppInput outS inp = prl (outS, ["input ", Inputs.toString inp, "\n"])
240    
241        fun output (outS, msg, prog) = let
242              val IR.Program{
243                      props, consts, inputs, globals,
244                      constInit, globalInit, strand, create, update
245                    } = prog
246            val out = (outS, 0)            val out = (outS, 0)
247            val out1 = incIndent out            val out1 = incIndent out
248            in            in
# Line 278  Line 252 
252                  String.concatWithMap " " Properties.toString props, "\n"                  String.concatWithMap " " Properties.toString props, "\n"
253                ]);                ]);
254              pr (out, "## globals\n");              pr (out, "## globals\n");
255              List.app (ppGlobal out1) globals;              List.app (ppGlobal "const" out1) consts;
256                List.app (ppInput out1) inputs;
257                List.app (ppGlobal "global" out1) globals;
258              pr (out, "## input initialization\n");              pr (out, "## input initialization\n");
259              ppCFG (out1, inputInit);              ppCFG (out1, constInit);
260              pr (out, "## global initialization\n");              pr (out, "## global initialization\n");
261              ppCFG (out1, globalInit);              ppCFG (out1, globalInit);
262              pr (out, "## initially\n");              pr (out, "## strand\n");
263              ppInitially (out1, initially);              ppStrand (out1, strand);
264              pr (out, "## strands\n");              pr (out, "## initial strand creation\n");
265              List.app (fn strand => ppStrand(out1, strand)) strands;              ppCreate (out1, create);
266                case update
267                 of SOME cfg => (
268                      pr (out, "## global update\n");
269                      ppCFG (out1, cfg))
270                  | NONE => ()
271                (* end case *);
272              pr (out, "#### end program ####\n")              pr (out, "#### end program ####\n")
273            end            end
274    

Legend:
Removed from v.3473  
changed lines
  Added in v.3506

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