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

SCM Repository

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

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

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

revision 1115, Thu May 5 04:42:18 2011 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# Line 18  Line 18 
18      structure Var = IL.Var      structure Var = IL.Var
19      structure Ty = IL.Ty      structure Ty = IL.Ty
20    
21        local
22          val {getFn, setFn} = IL.Node.newFlag()
23        in
24        val isMarked = getFn
25        fun mark nd = setFn(nd, true)
26        fun clear nd = setFn(nd, false)
27        end
28    
29      (* if true, the output is in compact form *)
30        val compact = ref true
31    
32      fun indent (outS, i) = TextIO.output(outS, StringCvt.padLeft #" " i "")      fun indent (outS, i) = TextIO.output(outS, StringCvt.padLeft #" " i "")
33      fun incIndent (outS, i) = (outS, i+2)      fun incIndent (outS, i) = (outS, i+2)
34      fun pr ((outS, _), s) = TextIO.output(outS, s)      fun pr ((outS, _), s) = TextIO.output(outS, s)
35      fun prl (out, l) = pr(out, concat l)      fun prl (out, l) = pr(out, concat l)
36        fun prln (out, l) = (indent out; prl(out, l))
37    
38      fun typedVar x = String.concat [      fun typedVar x = String.concat [
39              Ty.toString(Var.ty x), " ", Var.toString x, "#", Int.toString(Var.useCount x)              Ty.toString(Var.ty x), " ", Var.toString x, "#", Int.toString(Var.useCount x)
# Line 36  Line 48 
48                          Op.toString rator, "(",                          Op.toString rator, "(",
49                          String.concatWith "," (List.map Var.toString args), ");"                          String.concatWith "," (List.map Var.toString args), ");"
50                        ]                        ]
51                    | IL.CONS xs => ["[", String.concatWith "," (List.map Var.toString xs), "];"]                    | IL.APPLY(f, args) => [
52                            ILBasis.toString f, "(",
53                            String.concatWith "," (List.map Var.toString args), ");"
54                          ]
55                      | IL.CONS(ty, xs) => [
56                            "<", Ty.toString ty, ">[",
57                            String.concatWith "," (List.map Var.toString xs), "];"
58                          ]
59                  (* end case *))                  (* end case *))
60            in            in
61              String.concat(typedVar y :: " = " :: rhs)              String.concat(typedVar y :: " = " :: rhs)
62            end            end
63    
64      fun labelOf (IL.STM{id, ...}) = "L"^Stamp.toString id      fun labelOf (IL.ND{id, ...}) = "L"^Stamp.toString id
65    
66      fun ppStmt (out, stm as IL.STM{id, kind, next, ...}) = let      fun ppCFG (out, cfg as IL.CFG{entry, exit}) = let
67              fun goto (out, nd) = if (List.length(IL.Node.preds nd) > 1)
68                    then (
69                      prln(incIndent out, ["goto ", IL.Node.toString nd, "\n"]);
70                      ppNd (out, false, nd))
71                    else ppNd (out, true, nd)
72              and ppNd (out, noLabel, nd) = let
73            val out1 = incIndent out            val out1 = incIndent out
74            fun prPhi (y, xs) = (                  fun prPhi (y, xs) =
75                  indent out1;                        prln (out1, [
                 prl (out1, [  
76                      typedVar y, " = phi(",                      typedVar y, " = phi(",
77                      String.concatWith "," (List.map Var.toString xs), ")\n"                      String.concatWith "," (List.map Var.toString xs), ")\n"
78                    ]))                          ])
79            in            in
80              indent out;                    if isMarked nd
81              prl (out, [                      then ()
82                  IL.Stmt.toString stm, "(", IL.Node.toString(IL.Stmt.entry stm), "):  # preds = [",                      else (
83                  String.concatWith "," (List.map IL.Node.toString (IL.Node.preds(IL.Stmt.entry stm))),                        mark nd;
84                          if noLabel andalso (! compact)
85                            then ()
86                            else prln (out, [
87                                IL.Node.toString nd, ":  preds = [",
88                                String.concatWith "," (List.map IL.Node.toString (IL.Node.preds nd)),
89                  "]\n"                  "]\n"
90                ]);                ]);
91              case kind                        case IL.Node.kind nd
92               of IL.S_SIMPLE(IL.ND{kind, ...}) => (case kind                         of IL.NULL => ()
93                     of IL.NULL => raise Fail "unexpected S_SIMPLE with NULL node"                          | IL.ENTRY{succ} => goto (out, !succ)
94                      | IL.ENTRY _ => (indent out1; pr(out1, "entry;\n"))                          | IL.JOIN{phis, succ, ...} => (
95                      | IL.JOIN{phis, ...} => List.app prPhi (!phis)                              List.app prPhi (!phis);
96                      | IL.COND _ => raise Fail "unexpected S_SIMPLE with COND node"                              goto (out, !succ))
97                      | IL.BLOCK{body=ref [], ...} => (indent out1; pr (out, "empty;\n"))                          | IL.COND{cond, trueBranch, falseBranch, ...} => (
98                      | IL.BLOCK{body, ...} => (                              prln (out1, [
99                          List.app                                  "if ", Var.toString cond,
100                            (fn assign => (indent out1; prl(out1, [assignToString assign, "\n"])))                                  " then goto ", IL.Node.toString(!trueBranch),
101                              (!body))                                  " else goto ", IL.Node.toString(!falseBranch), "\n"
102                      | IL.NEW{strand, args, ...} => (                                ]);
103                          indent out1;                              ppNd (out, false, !trueBranch);
104                          prl (out1, [                              ppNd (out, false, !falseBranch))
105                            | IL.COM{text, succ, ...} => (
106                                List.app (fn s => prln (out1, ["//", s, "\n"])) text;
107                                goto (out, !succ))
108                            | IL.ASSIGN{stm, succ, ...} => (
109                                prln (out1, [assignToString stm, "\n"]);
110                                goto (out, !succ))
111                            | IL.NEW{strand, args, succ, ...} => (
112                                prln (out1, [
113                              "new ", Atom.toString strand, "(",                              "new ", Atom.toString strand, "(",
114                              String.concatWith "," (List.map Var.toString args), ");\n"                              String.concatWith "," (List.map Var.toString args), ");\n"
115                            ]))                                ]);
116                      | IL.DIE _ => (indent out1; pr(out1, "die;\n"))                              goto (out, !succ))
117                      | IL.STABILIZE _ => (indent out1; pr(out1, "stabilize;\n"))                          | IL.EXIT{kind, live, ...} => let
118                      | IL.EXIT _ => (indent out1; pr(out1, "exit;\n"))                              val live = (case live
119                                       of [] => "()"
120                                        | [x] => String.concat["(", Var.toString x, ")"]
121                                        | xs => String.concat[
122                                              "(",
123                                              String.concatWith "," (List.map Var.toString xs),
124                                              ")"
125                                            ]
126                    (* end case *))                    (* end case *))
127                | IL.S_IF{cond=IL.ND{kind=IL.COND{cond, ...}, ...}, thenBranch, elseBranch} => (                              in
128                    indent out1;  prl(out1, ["if ", Var.toString cond, " then\n"]);                                case kind
129                    ppStmt (incIndent out1, thenBranch);                                 of ExitKind.FRAGMENT =>
130                    indent out1; pr(out1, "else\n");                                      prln (out1, ["live vars = ", live, "\n"])
131                    ppStmt (incIndent out1, elseBranch);                                  | ExitKind.RETURN =>
132                    indent out1; pr(out1, "endif;\n"))                                      prln (out1, ["return ", live, "\n"])
133                | IL.S_LOOP _ => raise Fail "LOOP"                                  | ExitKind.ACTIVE =>
134              (* end case *);                                      prln (out1, ["active ", live, "\n"])
135              ppNext (out, next)                                  | ExitKind.STABILIZE =>
136                                        prln (out1, ["stabilize ", live, "\n"])
137                                    | ExitKind.DIE =>
138                                        prln (out1, ["die ", live, "\n"])
139                                  (* end case *)
140                                end
141                          (* end case *))
142                    end
143              in
144                ppNd (out, false, entry);
145              (* clear marks *)
146                IL.CFG.apply clear cfg
147            end            end
148    
149      and ppNext (out, NONE) = ()      fun ppInitially (out, IL.Initially{isArray, rangeInit, iters, create}) = let
150        | ppNext (out, SOME stm) = ppStmt (out, stm)            val (initArg, strand, args) = create
151              fun ppIters (out, []) = (
152                    ppCFG (out, initArg);
153                    prln (out, [
154                        "new ", Atom.toString strand, "(",
155                        String.concatWith "," (List.map Var.toString args), ");\n"
156                      ]))
157                | ppIters (out, (param, lo, hi)::iters) = (
158                    indent out; prl(out, [
159                        "for ", typedVar param, " = ", Var.toString lo, " .. ", Var.toString hi, "\n"
160                      ]);
161                    ppIters (incIndent out, iters))
162              in
163                indent out; prl(out, if isArray then ["ARRAY\n"] else ["COLLECTION\n"]);
164                ppCFG (incIndent out, rangeInit);
165                ppIters (incIndent out, iters)
166              end
167    
168      fun ppMethod (out, IL.Method{name, stateIn, stateOut, body}) = let      fun ppMethod (out, IL.Method{name, stateIn, body}) = let
169            val out1 = incIndent out            val out1 = incIndent out
170            fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs            fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs
171            in            in
172              indent out; prl(out, ["method ", Atom.toString name, "\n"]);              indent out; prl(out, ["method ", Atom.toString name, "\n"]);
173              indent out1; pr(out1, "state in: "); prVars stateIn; pr(out1, "\n");              indent out1; pr(out1, "state in: "); prVars stateIn; pr(out1, "\n");
174              ppStmt (incIndent out1, body);              ppCFG (incIndent out1, body);
175              indent out1; pr(out1, "state out:"); prVars stateOut; pr(out1, "\n");              indent out1; pr(out1, "state out:"); prVars(IL.CFG.liveAtExit body); pr(out1, "\n");
176              indent out; prl(out, ["end ", Atom.toString name, "\n"])              indent out; prl(out, ["end ", Atom.toString name, "\n"])
177            end            end
178    
179      and ppStrand (out, IL.Strand{name, params, state, stateInit, methods}) = let      and ppStrand (out, IL.Strand{name, params, state, stateInit, methods}) = let
180            val out1 = incIndent out            val out1 = incIndent out
181            fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs            fun prVars xs = List.app
182                    (fn (true, x) => prl(out, [" output ", typedVar x, ";"])
183                      | (_, x) => prl(out, [" ", typedVar x, ";"]))
184                    xs
185            in            in
186              indent out;              indent out;
187              prl(out, [              prl(out, [
# Line 115  Line 189 
189                  String.concatWith ", " (List.map typedVar params), ")\n"                  String.concatWith ", " (List.map typedVar params), ")\n"
190                ]);                ]);
191              indent out1; pr(out1, "state: "); prVars state; pr(out1, "\n");              indent out1; pr(out1, "state: "); prVars state; pr(out1, "\n");
192              ppStmt (incIndent out1, stateInit);              ppCFG (incIndent out1, stateInit);
193              List.app (fn m => ppMethod(out1, m)) methods;              List.app (fn m => ppMethod(out1, m)) methods;
194              indent out; prl(out, ["end ", Atom.toString name, "\n"])              indent out; prl(out, ["end ", Atom.toString name, "\n"])
195            end            end
196    
197      fun output (outS, msg, IL.Program{globals, globalInit, strands}) = let      fun output (outS, msg, IL.Program{globalInit, initially, strands}) = let
198            val out = (outS, 0)            val out = (outS, 0)
199            val out1 = incIndent out            val out1 = incIndent out
200            in            in
# Line 128  Line 202 
202              pr (out, "## globals\n");              pr (out, "## globals\n");
203              List.app              List.app
204                (fn x => (indent out1; prl(out1, ["global ", typedVar x, "\n"])))                (fn x => (indent out1; prl(out1, ["global ", typedVar x, "\n"])))
205                  globals;                  (IL.CFG.liveAtExit globalInit);
206              pr (out, "## global initialization\n");              pr (out, "## global initialization\n");
207              ppStmt (out1, globalInit);              ppCFG (out1, globalInit);
208                pr (out, "## initially\n");
209                ppInitially (out1, initially);
210              pr (out, "## strands\n");              pr (out, "## strands\n");
211              List.app (fn strand => ppStrand(out1, strand)) strands;              List.app (fn strand => ppStrand(out1, strand)) strands;
212              pr (out, "#### end program ####\n")              pr (out, "#### end program ####\n")

Legend:
Removed from v.1115  
changed lines
  Added in v.1116

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