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 3470, Mon Nov 30 17:51:33 2015 UTC revision 3475, Wed Dec 2 18:48:58 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 *))
91            and ppNd (out, noLabel, nd) = let            and ppNd (out, noLabel, nd) = let
92                  val out1 = incIndent out                  val out1 = incIndent out
93                  fun prPhi (y, xs) =                  fun prPhi out (y, xs) =
94                        prln (out1, [                        prln (out, [
95                            typedVar y, " = phi(",                            typedVar y, " = phi(",
96                            String.concatWith "," (List.mapPartial (Option.map Var.toString) xs), ")\n"                            String.concatWith "," (List.mapPartial (Option.map Var.toString) xs), ")\n"
97                          ])                          ])
# 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 (!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.COM{text, succ, ...} => (                          | IR.FOREACH{phis, var, src, body, succ, ...} => (
143                                prln (out1, [
144                                    "foreach (", Var.toString var, " in ", Var.toString src, ")",
145                                    " on exit goto ", IR.Node.toString(!succ), "\n"
146                                  ]);
147                                List.app (prPhi (incIndent out1)) (!phis);
148                                goto (out, !succ))
149                            | IR.COM{text, succ, ...} => (
150                              List.app (fn s => prln (out1, ["//", s, "\n"])) text;                              List.app (fn s => prln (out1, ["//", s, "\n"])) text;
151                              goto (out, !succ))                              goto (out, !succ))
152                          | IL.ASSIGN{stm, succ, ...} => (                          | IR.ASSIGN{stm, succ, ...} => (
153                              prln (out1, [assignToString stm, "\n"]);                              prln (out1, [assignToString stm, "\n"]);
154                              goto (out, !succ))                              goto (out, !succ))
155                          | IL.MASSIGN{stm, succ, ...} => (                          | IR.MASSIGN{stm, succ, ...} => (
156                              prln (out1, [massignToString stm, "\n"]);                              prln (out1, [massignToString stm, "\n"]);
157                              goto (out, !succ))                              goto (out, !succ))
158                          | IL.GASSIGN{lhs, rhs, succ, ...} => (                          | IR.GASSIGN{lhs, rhs, succ, ...} => (
159                              prln (out1, [                              prln (out1, [
160                                  GVar.toString lhs, " = ", Var.toString rhs, ";\n"                                  GVar.toString lhs, " = ", Var.toString rhs, ";\n"
161                                ]);                                ]);
162                              goto (out, !succ))                              goto (out, !succ))
163                          | IL.NEW{strand, args, succ, ...} => (                          | IR.NEW{strand, args, succ, ...} => (
164                              prln (out1, [                              prln (out1, [
165                                  "new ", Atom.toString strand, "(",                                  "new ", Atom.toString strand, "(",
166                                  String.concatWith "," (List.map Var.toString args), ");\n"                                  String.concatWith "," (List.map Var.toString args), ");\n"
167                                ]);                                ]);
168                              goto (out, !succ))                              goto (out, !succ))
169                          | IL.SAVE{lhs, rhs, succ, ...} => (                          | IR.SAVE{lhs, rhs, succ, ...} => (
170                              prln (out1, [                              prln (out1, [
171                                  IL.StateVar.toString lhs, " = ", Var.toString rhs, ";\n"                                  IR.StateVar.toString lhs, " = ", Var.toString rhs, ";\n"
172                                ]);                                ]);
173                              goto (out, !succ))                              goto (out, !succ))
174                          | IL.EXIT{kind, live, succ, ...} => let                          | IR.EXIT{kind, live, succ, ...} => let
175                              val live = (case live                              val live = (case live
176                                     of [] => "()"                                     of [] => "()"
177                                      | [x] => String.concat["(", Var.toString x, ")"]                                      | [x] => String.concat["(", Var.toString x, ")"]
# Line 201  Line 208 
208            in            in
209              ppNd (out, false, entry);              ppNd (out, false, entry);
210            (* clear marks *)            (* clear marks *)
211              IL.CFG.apply clear cfg              IR.CFG.apply clear cfg
212            end            end
213    
214      fun ppInitially (out, IL.Initially{isArray, rangeInit, iters, create}) = let      fun ppInitially (out, IR.Initially{isArray, rangeInit, iters, create}) = let
215            val (initArg, strand, args) = create            val (initArg, strand, args) = create
216            fun ppIters (out, []) = (            fun ppIters (out, []) = (
217                  ppCFG (out, initArg);                  ppCFG (out, initArg);
# Line 223  Line 230 
230              ppIters (incIndent out, iters)              ppIters (incIndent out, iters)
231            end            end
232    
233      fun ppMethod (out, IL.Method{name, body}) = let      fun ppMethod (out, IR.Method{name, body}) = let
234            val out1 = incIndent out            val out1 = incIndent out
235            fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs            fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs
236            in            in
# Line 232  Line 239 
239              indent out; prl(out, ["end ", StrandUtil.nameToString name, "\n"])              indent out; prl(out, ["end ", StrandUtil.nameToString name, "\n"])
240            end            end
241    
242      and ppStrand (out, IL.Strand{name, params, state, stateInit, methods}) = let      and ppStrand (out, IR.Strand{name, params, state, stateInit, methods}) = let
243            val out1 = incIndent out            val out1 = incIndent out
244            fun stateVar x = let            fun stateVar x = let
245                  val l = [Ty.toString(IL.StateVar.ty x), " ", IL.StateVar.toString x, ";"]                  val l = [Ty.toString(IR.StateVar.ty x), " ", IR.StateVar.toString x, ";"]
246                  val l = if IL.StateVar.isOutput x then "output " :: l else l                  val l = if IR.StateVar.isOutput x then "output " :: l else l
247                  in                  in
248                    prl (out1, l)                    prl (out1, l)
249                  end                  end
# Line 261  Line 268 
268                ])                ])
269            end            end
270    
271      fun output (outS, msg, IL.Program{props, globals, inputInit, globalInit, initially, strands}) = let      fun output (outS, msg, IR.Program{props, globals, inputInit, globalInit, initially, strands}) = let
272            val out = (outS, 0)            val out = (outS, 0)
273            val out1 = incIndent out            val out1 = incIndent out
274            in            in

Legend:
Removed from v.3470  
changed lines
  Added in v.3475

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