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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 511 - (download) (annotate)
Tue Feb 8 17:01:43 2011 UTC (8 years, 5 months ago) by jhr
File size: 4779 byte(s)
  Backporting changes from pure-cfg branch.  These include the "actor" ==> "strand"
  changes.
(* ssa-pp-fn.sml
 *
 * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
 * All rights reserved.
 *
 * Pretty printing for SSA representations
 *)

functor SSAPPFn (IL : SSA) : sig

    val assignToString : IL.assign -> string

    val output : TextIO.outstream * string * IL.program -> unit

  end = struct

    structure Op = IL.Op
    structure Var = IL.Var
    structure Ty = IL.Ty

    fun indent (outS, i) = TextIO.output(outS, StringCvt.padLeft #" " i "")
    fun incIndent (outS, i) = (outS, i+2)
    fun pr ((outS, _), s) = TextIO.output(outS, s)
    fun prl (out, l) = pr(out, concat l)

    fun typedVar x = String.concat [
	    Ty.toString(Var.ty x), " ", Var.toString x, "#", Int.toString(Var.useCount x)
	  ]

    fun assignToString (y, rhs) = let
	  val rhs = (case rhs
		 of IL.VAR x => [Var.toString x, ";"]
		  | IL.LIT lit => [Literal.toString lit, ";"]
		  | IL.OP(rator, []) => [Op.toString rator, ";"]
		  | IL.OP(rator, args) => [
			Op.toString rator, "(",
			String.concatWith "," (List.map Var.toString args), ");"
		      ]
		  | IL.CONS xs => ["[", String.concatWith "," (List.map Var.toString xs), "];"]
		(* end case *))
	  in
	    String.concat(typedVar y :: " = " :: rhs)
	  end

    fun labelOf (IL.STM{id, ...}) = "L"^Stamp.toString id

    fun ppStmt (out, stm as IL.STM{id, kind, next, ...}) = let
	  val out1 = incIndent out
	  fun prPhi (y, xs) = (
		indent out1;
		prl (out1, [
		    typedVar y, " = phi(",
		    String.concatWith "," (List.map Var.toString xs), ")\n"
		  ]))
	  in
	    indent out;
	    prl (out, [
		IL.Stmt.toString stm, "(", IL.Node.toString(IL.Stmt.entry stm), "):  # preds = [",
		String.concatWith "," (List.map IL.Node.toString (IL.Node.preds(IL.Stmt.entry stm))),
		"]\n"
	      ]);
	    case kind
	     of IL.S_SIMPLE(IL.ND{kind, ...}) => (case kind
		   of IL.NULL => raise Fail "unexpected S_SIMPLE with NULL node"
		    | IL.ENTRY _ => (indent out1; pr(out1, "entry;\n"))
		    | IL.JOIN{phis, ...} => List.app prPhi (!phis)
		    | IL.COND _ => raise Fail "unexpected S_SIMPLE with COND node"
		    | IL.BLOCK{body=ref [], ...} => (indent out1; pr (out, "empty;\n"))
		    | IL.BLOCK{body, ...} => (
			List.app
			  (fn assign => (indent out1; prl(out1, [assignToString assign, "\n"])))
			    (!body))
		    | IL.NEW{strand, args, ...} => (
			indent out1;
			prl (out1, [
			    "new ", Atom.toString strand, "(",
			    String.concatWith "," (List.map Var.toString args), ");\n"
			  ]))
		    | IL.DIE _ => (indent out1; pr(out1, "die;\n"))
		    | IL.STABILIZE _ => (indent out1; pr(out1, "stabilize;\n"))
		    | IL.EXIT _ => (indent out1; pr(out1, "exit;\n"))
		  (* end case *))
	      | IL.S_IF{cond=IL.ND{kind=IL.COND{cond, ...}, ...}, thenBranch, elseBranch} => (
		  indent out1;  prl(out1, ["if ", Var.toString cond, " then\n"]);
		  ppStmt (incIndent out1, thenBranch);
		  indent out1; pr(out1, "else\n");
		  ppStmt (incIndent out1, elseBranch);
		  indent out1; pr(out1, "endif;\n"))
	      | IL.S_LOOP _ => raise Fail "LOOP"
	    (* end case *);
	    ppNext (out, next)
	  end

    and ppNext (out, NONE) = ()
      | ppNext (out, SOME stm) = ppStmt (out, stm)

    fun ppMethod (out, IL.Method{name, stateIn, stateOut, body}) = let
	  val out1 = incIndent out
	  fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs
	  in
	    indent out; prl(out, ["method ", Atom.toString name, "\n"]);
	    indent out1; pr(out1, "state in: "); prVars stateIn; pr(out1, "\n");
	    ppStmt (incIndent out1, body);
	    indent out1; pr(out1, "state out:"); prVars stateOut; pr(out1, "\n");
	    indent out; prl(out, ["end ", Atom.toString name, "\n"])
	  end

    and ppStrand (out, IL.Strand{name, params, state, stateInit, methods}) = let
	  val out1 = incIndent out
	  fun prVars xs = List.app (fn x => prl(out, [" ", typedVar x, ";"])) xs
	  in
	    indent out;
	    prl(out, [
		"strand ", Atom.toString name, " (",
		String.concatWith ", " (List.map typedVar params), ")\n"
	      ]);
	    indent out1; pr(out1, "state: "); prVars state; pr(out1, "\n");
	    ppStmt (incIndent out1, stateInit);
	    List.app (fn m => ppMethod(out1, m)) methods;
	    indent out; prl(out, ["end ", Atom.toString name, "\n"])
	  end

    fun output (outS, msg, IL.Program{globals, globalInit, strands}) = let
	  val out = (outS, 0)
	  val out1 = incIndent out
	  in
	    pr (out, concat["##### ", msg, " ####\n"]);
	    pr (out, "## globals\n");
	    List.app
	      (fn x => (indent out1; prl(out1, ["global ", typedVar x, "\n"]))) 
		globals;
	    pr (out, "## global initialization\n");
	    ppStmt (out1, globalInit);
	    pr (out, "## strands\n");
	    List.app (fn strand => ppStrand(out1, strand)) strands;
	    pr (out, "#### end program ####\n")
	  end

  end

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