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

SCM Repository

[diderot] Annotation of /trunk/src/compiler/IL/check-il-fn.sml
ViewVC logotype

Annotation of /trunk/src/compiler/IL/check-il-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 413 - (view) (download)

1 : jhr 369 (* check-il-fn.sml
2 :     *
3 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *
6 :     * Correctness checker for SSA-based ILs.
7 :     *)
8 :    
9 : jhr 405 signature OPERATOR_TY =
10 :     sig
11 :     type rator
12 :     type ty
13 : jhr 369
14 : jhr 410 (* returns the signature of an operator as (rng, dom). *)
15 : jhr 405 val sigOf : rator -> ty * ty list
16 :    
17 : jhr 410 (* return the type of a CONS, where the argument types
18 :     * are given. Returns NONE if the argument types are
19 :     * invalid for the IL.
20 :     *)
21 :     val typeOfCons : ty list -> ty option
22 :    
23 : jhr 405 end
24 :    
25 :     functor CheckILFn (
26 :    
27 :     structure IL : SSA
28 :     structure OpTy : OPERATOR_TY
29 :     where type rator = IL.Op.rator
30 :     where type ty = IL.Ty.ty
31 :    
32 :     ) : sig
33 :    
34 : jhr 413 (* check the program for type errors, etc. The first argument will be used to
35 :     * identify the phase that the check follows and the return result will be true
36 :     * if any errors were detected.
37 :     *)
38 :     fun check : string * IL.program -> bool
39 :    
40 : jhr 369 end = struct
41 :    
42 : jhr 405 structure IL = IL
43 :     structure Ty = IL.Ty
44 :     structure V = IL.Var
45 :     structure VSet = V.Set
46 :    
47 : jhr 410 datatype token
48 : jhr 412 = NL | S of string | V of IL.var | VTYS of IL.var list | TY of Ty.ty | TYS of Ty.ty list
49 : jhr 410
50 :     fun err errBuf toks = let
51 : jhr 412 fun tok2str NL = "\n ** "
52 :     | tok2str (S s) = s
53 :     | tok2str (V x) = V.toString x
54 :     | tok2str (VTYS xs) = tok2str(TYS(List.map V.ty xs))
55 :     | tok2str (TY ty) = Ty.toString ty
56 : jhr 410 | tok2str (TYS []) = "()"
57 : jhr 412 | tok2str (TYS[ty]) = Ty.toString ty
58 : jhr 410 | tok2str (TYS tys) = String.concat[
59 : jhr 412 "(", String.concatWith " * " (List.map Ty.toString tys), ")"
60 : jhr 410 ]
61 :     in
62 :     errBuf := concat ("**** Error: " :: List.map tok2str toks)
63 :     :: !errBuf
64 :     end
65 :    
66 : jhr 412 fun chkAssign errFn (bvs, y, rhs) = let
67 :     fun checkVar x = if VSet.member(bvs, x)
68 :     then ()
69 :     else errFn [
70 :     S "variable ", V x, S " is not bound in", NL,
71 :     S(IL.assignToString(y, rhs))
72 :     ]
73 :     fun tyError (ty1, ty2) = errFn [
74 :     S "type mismatch in \"", S(IL.assignToString (y, rhs)), S "\"",
75 :     NL, S "lhs: ", TY ty1, NL, S "rhs: ", TY ty2
76 :     ]
77 :     in
78 :     (* check that y is not bound twice *)
79 :     if VSet.member(bvs, y)
80 :     then errFn [
81 :     S "variable ", V y, S " is bound twice in", NL,
82 :     S(IL.assignToString (y, rhs))
83 :     ]
84 :     else ();
85 :     case rhs
86 :     of IL.VAR x => (
87 :     checkVar x;
88 :     if Ty.same(V.ty y, V.ty x)
89 : jhr 405 then ()
90 : jhr 412 else tyError (V.ty y, V.ty x))
91 :     | IL.LIT lit => let
92 :     val ty = (case lit
93 :     of Literal.Int _ => Ty.IntTy
94 :     | Literal.Float _ => Ty.realTy
95 :     | Literal.String _ => Ty.StringTy
96 :     | Literal.Bool _ => Ty.BoolTy
97 :     (* end case *))
98 :     in
99 :     if Ty.same(V.ty y, ty)
100 : jhr 410 then ()
101 : jhr 412 else tyError (V.ty y, ty)
102 :     end
103 :     | IL.OP(rator, xs) => let
104 :     val (resTy, argTys) = OpTy.sigOf rator
105 :     in
106 :     List.app checkVar xs;
107 :     if Ty.same(V.ty y, resTy)
108 :     then ()
109 :     else tyError (V.ty y, resTy);
110 :     if ListPair.allEq (fn (x, ty) => Ty.same(V.ty x, ty)) (xs, argTys)
111 :     then ()
112 :     else errFn [
113 :     S "argument type mismatch in \"", S(IL.assignToString (y, rhs)), S "\"",
114 :     NL, S "expected: ", TYS argTys,
115 :     NL, S "found: ", VTYS xs
116 :     ]
117 :     end
118 :     | IL.CONS xs => (
119 :     List.app checkVar xs;
120 :     case OpTy.typeOfCons (List.map V.ty xs)
121 :     of NONE => errFn [S "invalid ", S(IL.assignToString(y, rhs))]
122 :     | SOME ty => if Ty.same(V.ty y, ty)
123 :     then ()
124 :     else tyError (V.ty y, ty)
125 :     (* end case *))
126 :     (* end case *);
127 :     VSet.add(bvs, y)
128 :     end
129 : jhr 405
130 : jhr 410 fun checkPhi errFn (bvs, y, xs) = let
131 : jhr 405 val ty = V.ty y
132 :     in
133 :     (* check that y is not bound twice *)
134 : jhr 412 if VSet.member(bvs, y)
135 :     then errFn [
136 :     S "variable ", V y, S " is bound twice in", NL,
137 :     S(IL.phiToString (y, xs))
138 :     ]
139 : jhr 405 else ();
140 :     (* check that rhs vars have the correct type *)
141 :     if List.all (fn x => Ty.same(V.ty x, ty)) xs
142 :     then ()
143 : jhr 412 else errFn [
144 :     S "type mismatch in \"", S(IL.phiToString (y, xs)), S "\"",
145 :     NL, S "lhs: ", TY ty, NL, S "rhs: ", VTYS xs
146 :     ]
147 : jhr 405 end
148 :    
149 : jhr 413 fun check (phase, IL.Program{globals, globalInit, actors}) = let
150 :     val errBuf = ref []
151 :     val errFn = errFn errBuf
152 :     fun final () = (case !errBuf
153 :     of [] => false
154 :     | errs => (
155 :     Log.msg(concat["********** IL Errors detected after ", phase, " **********\n"]);
156 :     List.app (fn msg => Log.msg(msg ^ "\n")) (List.rev errs);
157 :     true)
158 :     (* end case *))
159 :     in
160 :     (* FIXME: check the program *)
161 :     final()
162 :     end
163 :    
164 : jhr 369 end

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