Teach trans to allocate, initialize and load from local variables.

graydon · graydon · commit b8cca0971fc2 · 2010-10-19T14:54:10.000-07:00
diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
@@ -78,7 +78,7 @@ type local = rec(option[@ty] ty,
 
 type decl = spanned[decl_];
 tag decl_ {
-    decl_local(local);
+    decl_local(@local);
     decl_item(@item);
 }
 
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
@@ -629,7 +629,7 @@ io fn parse_let(parser p) -> @ast.decl {
                               init = init,
                               id = p.next_def_id());
 
-    ret @spanned(lo, hi, ast.decl_local(local));
+    ret @spanned(lo, hi, ast.decl_local(@local));
 }
 
 io fn parse_auto(parser p) -> @ast.decl {
@@ -648,7 +648,7 @@ io fn parse_auto(parser p) -> @ast.decl {
                               init = init,
                               id = p.next_def_id());
 
-    ret @spanned(lo, hi, ast.decl_local(local));
+    ret @spanned(lo, hi, ast.decl_local(@local));
 }
 
 io fn parse_stmt(parser p) -> @ast.stmt {
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
@@ -103,7 +103,7 @@ type ast_fold[ENV] =
 
      // Decl folds.
      (fn(&ENV e, &span sp,
-         &ast.local local) -> @decl)              fold_decl_local,
+         @ast.local local) -> @decl)              fold_decl_local,
 
      (fn(&ENV e, &span sp,
          @item item) -> @decl)                    fold_decl_item,
@@ -238,7 +238,7 @@ fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl {
                     init_ = some[@ast.expr](fold_expr(env, fld, e));
                 }
             }
-            let ast.local local_ = rec(ty=ty_, init=init_ with local);
+            let @ast.local local_ = @rec(ty=ty_, init=init_ with *local);
             ret fld.fold_decl_local(env_, d.span, local_);
         }
 
@@ -356,7 +356,7 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
 
         case (ast.expr_name(?n, ?r, ?t)) {
             auto n_ = fold_name(env_, fld, n);
-            ret fld.fold_expr_name(env_, e.span, n, r, t);
+            ret fld.fold_expr_name(env_, e.span, n_, r, t);
         }
     }
 
@@ -375,7 +375,7 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {
     alt (s.node) {
         case (ast.stmt_decl(?d)) {
             auto dd = fold_decl(env_, fld, d);
-            ret fld.fold_stmt_decl(env_, s.span, d);
+            ret fld.fold_stmt_decl(env_, s.span, dd);
         }
 
         case (ast.stmt_ret(?oe)) {
@@ -390,12 +390,12 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {
 
         case (ast.stmt_log(?e)) {
             auto ee = fold_expr(env_, fld, e);
-            ret fld.fold_stmt_log(env_, s.span, e);
+            ret fld.fold_stmt_log(env_, s.span, ee);
         }
 
         case (ast.stmt_expr(?e)) {
             auto ee = fold_expr(env_, fld, e);
-            ret fld.fold_stmt_expr(env_, s.span, e);
+            ret fld.fold_stmt_expr(env_, s.span, ee);
         }
     }
     ret s;
@@ -621,7 +621,7 @@ fn identity_fold_expr_name[ENV](&ENV env, &span sp,
 // Decl identities.
 
 fn identity_fold_decl_local[ENV](&ENV e, &span sp,
-                                 &ast.local local) -> @decl {
+                                 @ast.local local) -> @decl {
     ret @respan(sp, ast.decl_local(local));
 }
 
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
@@ -18,7 +18,8 @@ tag scope {
     scope_block(ast.block);
 }
 
-type env = list[scope];
+type env = rec(list[scope] scopes,
+               session.session sess);
 
 fn lookup_name(&env e, ast.ident i) -> option[def] {
 
@@ -97,7 +98,7 @@ fn lookup_name(&env e, ast.ident i) -> option[def] {
         ret none[def];
     }
 
-    ret std.list.find[scope,def](e, bind in_scope(i, _));
+    ret std.list.find[scope,def](e.scopes, bind in_scope(i, _));
 }
 
 fn fold_expr_name(&env e, &span sp, &ast.name n,
@@ -110,33 +111,39 @@ fn fold_expr_name(&env e, &span sp, &ast.name n,
             log "resolved name " + n.node.ident;
         }
         case (none[def]) {
-            log "unresolved name " + n.node.ident;
+            e.sess.err("unresolved name: " + n.node.ident);
         }
     }
 
     ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, t));
 }
 
 fn update_env_for_crate(&env e, @ast.crate c) -> env {
-    ret cons[scope](scope_crate(c), @e);
+    ret rec(scopes = cons[scope](scope_crate(c), @e.scopes) with e);
 }
 
 fn update_env_for_item(&env e, @ast.item i) -> env {
-    ret cons[scope](scope_item(i), @e);
+    ret rec(scopes = cons[scope](scope_item(i), @e.scopes) with e);
 }
 
 fn update_env_for_block(&env e, &ast.block b) -> env {
-    ret cons[scope](scope_block(b), @e);
+    ret rec(scopes = cons[scope](scope_block(b), @e.scopes) with e);
 }
 
 fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate {
+
     let fold.ast_fold[env] fld = fold.new_identity_fold[env]();
+
     fld = @rec( fold_expr_name = bind fold_expr_name(_,_,_,_,_),
                 update_env_for_crate = bind update_env_for_crate(_,_),
                 update_env_for_item = bind update_env_for_item(_,_),
                 update_env_for_block = bind update_env_for_block(_,_)
                 with *fld );
-    ret fold.fold_crate[env](nil[scope], fld, crate);
+
+    auto e = rec(scopes = nil[scope],
+                 sess = sess);
+
+    ret fold.fold_crate[env](e, fld, crate);
 }
 
 // Local Variables:
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
@@ -12,7 +12,9 @@ import driver.session;
 import back.x86;
 import back.abi;
 
+import util.common;
 import util.common.istr;
+import util.common.new_def_hash;
 import util.common.new_str_hash;
 
 import lib.llvm.llvm;
@@ -49,6 +51,7 @@ state type trans_ctxt = rec(session.session sess,
 state type fn_ctxt = rec(ValueRef llfn,
                          ValueRef lloutptr,
                          ValueRef lltaskptr,
+                         hashmap[ast.def_id, ValueRef] lllocals,
                          @trans_ctxt tcx);
 
 type terminator = fn(@fn_ctxt cx, builder build);
@@ -126,11 +129,23 @@ fn T_i64() -> TypeRef {
     ret llvm.LLVMInt64Type();
 }
 
+fn T_f32() -> TypeRef {
+    ret llvm.LLVMFloatType();
+}
+
+fn T_f64() -> TypeRef {
+    ret llvm.LLVMDoubleType();
+}
+
 fn T_int() -> TypeRef {
     // FIXME: switch on target type.
     ret T_i32();
 }
 
+fn T_char() -> TypeRef {
+    ret T_i32();
+}
+
 fn T_fn(vec[TypeRef] inputs, TypeRef output) -> TypeRef {
     ret llvm.LLVMFunctionType(output,
                               _vec.buf[TypeRef](inputs),
@@ -180,6 +195,10 @@ fn T_str(uint n) -> TypeRef {
     ret T_vec(T_i8(), n);
 }
 
+fn T_box(TypeRef t) -> TypeRef {
+    ret T_struct(vec(T_int(), t));
+}
+
 fn T_crate() -> TypeRef {
     ret T_struct(vec(T_int(),      // ptrdiff_t image_base_off
                      T_int(),      // uintptr_t self_addr
@@ -206,6 +225,49 @@ fn T_taskptr() -> TypeRef {
     ret T_ptr(T_task());
 }
 
+fn type_of(@trans_ctxt cx, @ast.ty t) -> TypeRef {
+    alt (t.node) {
+        case (ast.ty_nil) { ret T_nil(); }
+        case (ast.ty_bool) { ret T_i1(); }
+        case (ast.ty_int) { ret T_int(); }
+        case (ast.ty_uint) { ret T_int(); }
+        case (ast.ty_machine(?tm)) {
+            alt (tm) {
+                case (common.ty_i8) { ret T_i8(); }
+                case (common.ty_u8) { ret T_i8(); }
+                case (common.ty_i16) { ret T_i16(); }
+                case (common.ty_u16) { ret T_i16(); }
+                case (common.ty_i32) { ret T_i32(); }
+                case (common.ty_u32) { ret T_i32(); }
+                case (common.ty_i64) { ret T_i64(); }
+                case (common.ty_u64) { ret T_i64(); }
+                case (common.ty_f32) { ret T_f32(); }
+                case (common.ty_f64) { ret T_f64(); }
+            }
+        }
+        case (ast.ty_char) { ret T_char(); }
+        case (ast.ty_str) { ret T_str(0u); }
+        case (ast.ty_box(?t)) {
+            ret T_ptr(T_box(type_of(cx, t)));
+        }
+        case (ast.ty_vec(?t)) {
+            ret T_ptr(T_vec(type_of(cx, t), 0u));
+        }
+        case (ast.ty_tup(?elts)) {
+            let vec[TypeRef] tys = vec();
+            for (tup(bool, @ast.ty) elt in elts) {
+                tys += type_of(cx, elt._1);
+            }
+            ret T_struct(tys);
+        }
+        case (ast.ty_path(?pth,  ?def)) {
+            // FIXME: implement.
+            cx.sess.unimpl("ty_path in trans.type_of");
+        }
+    }
+    fail;
+}
+
 // LLVM constant constructors.
 
 fn C_null(TypeRef t) -> ValueRef {
@@ -356,7 +418,7 @@ fn trans_lit(@block_ctxt cx, &ast.lit lit) -> result {
             ret res(cx, C_int(u as int));
         }
         case (ast.lit_char(?c)) {
-            ret res(cx, C_integral(c as int, T_i32()));
+            ret res(cx, C_integral(c as int, T_char()));
         }
         case (ast.lit_bool(?b)) {
             ret res(cx, C_bool(b));
@@ -572,6 +634,25 @@ fn trans_expr(@block_ctxt cx, &ast.expr e) -> result {
 
             ret res(next_cx, sub.val);
         }
+
+        case (ast.expr_name(?n, ?dopt, _)) {
+            alt (dopt) {
+                case (some[ast.def](?def)) {
+                    alt (def) {
+                        case (ast.def_local(?did)) {
+                            auto llptr = cx.fcx.lllocals.get(did);
+                            ret res(cx, cx.build.Load(llptr));
+                        }
+                        case (_) {
+                            cx.fcx.tcx.sess.unimpl("def variant in trans");
+                        }
+                    }
+                }
+                case (none[ast.def]) {
+                    cx.fcx.tcx.sess.err("unresolved expr_name in trans");
+                }
+            }
+        }
     }
     cx.fcx.tcx.sess.unimpl("expr variant in trans_expr");
     fail;
@@ -616,6 +697,20 @@ fn trans_stmt(@block_ctxt cx, &ast.stmt s) -> result {
             sub.bcx = trans_expr(cx, *e).bcx;
         }
 
+        case (ast.stmt_decl(?d)) {
+            alt (d.node) {
+                case (ast.decl_local(?local)) {
+                    alt (local.init) {
+                        case (some[@ast.expr](?e)) {
+                            log "storing init of local " + local.ident;
+                            auto llptr = cx.fcx.lllocals.get(local.id);
+                            sub = trans_expr(cx, *e);
+                            sub.val = sub.bcx.build.Store(sub.val, llptr);
+                        }
+                    }
+                }
+            }
+        }
         case (_) {
             cx.fcx.tcx.sess.unimpl("stmt variant");
         }
@@ -685,9 +780,41 @@ fn trans_block_cleanups(@block_ctxt cx) -> @block_ctxt {
     ret bcx;
 }
 
+iter block_locals(&ast.block b) -> @ast.local {
+    // FIXME: putting from inside an iter block doesn't work, so we can't
+    // use the index here.
+    for (@ast.stmt s in b.node.stmts) {
+        alt (s.node) {
+            case (ast.stmt_decl(?d)) {
+                alt (d.node) {
+                    case (ast.decl_local(?local)) {
+                        put local;
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn trans_block(@block_ctxt cx, &ast.block b) -> result {
     auto bcx = cx;
 
+    for each (@ast.local local in block_locals(b)) {
+        log "declaring local " + local.ident;
+        auto ty = T_nil();
+        alt (local.ty) {
+            case (some[@ast.ty](?t)) {
+                ty = type_of(cx.fcx.tcx, t);
+            }
+            case (none[@ast.ty]) {
+                cx.fcx.tcx.sess.err("missing type for local " + local.ident);
+            }
+        }
+        auto val = bcx.build.Alloca(ty);
+        log "built alloca: " + val_str(val);
+        cx.fcx.lllocals.insert(local.id, val);
+    }
+
     for (@ast.stmt s in b.node.stmts) {
         bcx = trans_stmt(bcx, *s).bcx;
     }
@@ -709,9 +836,11 @@ fn new_fn_ctxt(@trans_ctxt cx,
     cx.fns.insert(cx.path, llfn);
     let ValueRef lloutptr = llvm.LLVMGetParam(llfn, 0u);
     let ValueRef lltaskptr = llvm.LLVMGetParam(llfn, 1u);
+    let hashmap[ast.def_id, ValueRef] lllocals = new_def_hash[ValueRef]();
     ret @rec(llfn=llfn,
              lloutptr=lloutptr,
              lltaskptr=lltaskptr,
+             lllocals=lllocals,
              tcx=cx);
 }
 
@@ -758,6 +887,7 @@ fn trans_exit_task_glue(@trans_ctxt cx) {
     auto fcx = @rec(llfn=llfn,
                     lloutptr=lloutptr,
                     lltaskptr=lltaskptr,
+                    lllocals=new_def_hash[ValueRef](),
                     tcx=cx);
 
     auto bcx = new_top_block_ctxt(fcx);
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ type local = rec(option[@ty] ty,`
`78`	`78`
`79`	`79`	`type decl = spanned[decl_];`
`80`	`80`	`tag decl_ {`
`81`		`- decl_local(local);`
	`81`	`+ decl_local(@local);`
`82`	`82`	`decl_item(@item);`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -629,7 +629,7 @@ io fn parse_let(parser p) -> @ast.decl {`
`629`	`629`	`init = init,`
`630`	`630`	`id = p.next_def_id());`
`631`	`631`
`632`		`- ret @spanned(lo, hi, ast.decl_local(local));`
	`632`	`+ ret @spanned(lo, hi, ast.decl_local(@local));`
`633`	`633`	`}`
`634`	`634`
`635`	`635`	`io fn parse_auto(parser p) -> @ast.decl {`
`@@ -648,7 +648,7 @@ io fn parse_auto(parser p) -> @ast.decl {`
`648`	`648`	`init = init,`
`649`	`649`	`id = p.next_def_id());`
`650`	`650`
`651`		`- ret @spanned(lo, hi, ast.decl_local(local));`
	`651`	`+ ret @spanned(lo, hi, ast.decl_local(@local));`
`652`	`652`	`}`
`653`	`653`
`654`	`654`	`io fn parse_stmt(parser p) -> @ast.stmt {`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ type ast_fold[ENV] =`
`103`	`103`
`104`	`104`	`// Decl folds.`
`105`	`105`	`(fn(&ENV e, &span sp,`
`106`		`- &ast.local local) -> @decl) fold_decl_local,`
	`106`	`+ @ast.local local) -> @decl) fold_decl_local,`
`107`	`107`
`108`	`108`	`(fn(&ENV e, &span sp,`
`109`	`109`	`@item item) -> @decl) fold_decl_item,`
`@@ -238,7 +238,7 @@ fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl {`
`238`	`238`	`init_ = some[@ast.expr](fold_expr(env, fld, e));`
`239`	`239`	`}`
`240`	`240`	`}`
`241`		`- let ast.local local_ = rec(ty=ty_, init=init_ with local);`
	`241`	`+ let @ast.local local_ = @rec(ty=ty_, init=init_ with *local);`
`242`	`242`	`ret fld.fold_decl_local(env_, d.span, local_);`
`243`	`243`	`}`
`244`	`244`
`@@ -356,7 +356,7 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {`
`356`	`356`
`357`	`357`	`case (ast.expr_name(?n, ?r, ?t)) {`
`358`	`358`	`auto n_ = fold_name(env_, fld, n);`
`359`		`- ret fld.fold_expr_name(env_, e.span, n, r, t);`
	`359`	`+ ret fld.fold_expr_name(env_, e.span, n_, r, t);`
`360`	`360`	`}`
`361`	`361`	`}`
`362`	`362`
`@@ -375,7 +375,7 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {`
`375`	`375`	`alt (s.node) {`
`376`	`376`	`case (ast.stmt_decl(?d)) {`
`377`	`377`	`auto dd = fold_decl(env_, fld, d);`
`378`		`- ret fld.fold_stmt_decl(env_, s.span, d);`
	`378`	`+ ret fld.fold_stmt_decl(env_, s.span, dd);`
`379`	`379`	`}`
`380`	`380`
`381`	`381`	`case (ast.stmt_ret(?oe)) {`
`@@ -390,12 +390,12 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {`
`390`	`390`
`391`	`391`	`case (ast.stmt_log(?e)) {`
`392`	`392`	`auto ee = fold_expr(env_, fld, e);`
`393`		`- ret fld.fold_stmt_log(env_, s.span, e);`
	`393`	`+ ret fld.fold_stmt_log(env_, s.span, ee);`
`394`	`394`	`}`
`395`	`395`
`396`	`396`	`case (ast.stmt_expr(?e)) {`
`397`	`397`	`auto ee = fold_expr(env_, fld, e);`
`398`		`- ret fld.fold_stmt_expr(env_, s.span, e);`
	`398`	`+ ret fld.fold_stmt_expr(env_, s.span, ee);`
`399`	`399`	`}`
`400`	`400`	`}`
`401`	`401`	`ret s;`
`@@ -621,7 +621,7 @@ fn identity_fold_expr_name[ENV](&ENV env, &span sp,`
`621`	`621`	`// Decl identities.`
`622`	`622`
`623`	`623`	`fn identity_fold_decl_local[ENV](&ENV e, &span sp,`
`624`		`- &ast.local local) -> @decl {`
	`624`	`+ @ast.local local) -> @decl {`
`625`	`625`	`ret @respan(sp, ast.decl_local(local));`
`626`	`626`	`}`
`627`	`627`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,8 @@ tag scope {`
`18`	`18`	`scope_block(ast.block);`
`19`	`19`	`}`
`20`	`20`
`21`		`-type env = list[scope];`
	`21`	`+type env = rec(list[scope] scopes,`
	`22`	`+ session.session sess);`
`22`	`23`
`23`	`24`	`fn lookup_name(&env e, ast.ident i) -> option[def] {`
`24`	`25`
`@@ -97,7 +98,7 @@ fn lookup_name(&env e, ast.ident i) -> option[def] {`
`97`	`98`	`ret none[def];`
`98`	`99`	`}`
`99`	`100`
`100`		`- ret std.list.find[scope,def](e, bind in_scope(i, _));`
	`101`	`+ ret std.list.find[scope,def](e.scopes, bind in_scope(i, _));`
`101`	`102`	`}`
`102`	`103`
`103`	`104`	`fn fold_expr_name(&env e, &span sp, &ast.name n,`
`@@ -110,33 +111,39 @@ fn fold_expr_name(&env e, &span sp, &ast.name n,`
`110`	`111`	`log "resolved name " + n.node.ident;`
`111`	`112`	`}`
`112`	`113`	`case (none[def]) {`
`113`		`- log "unresolved name " + n.node.ident;`
	`114`	`+ e.sess.err("unresolved name: " + n.node.ident);`
`114`	`115`	`}`
`115`	`116`	`}`
`116`	`117`
`117`	`118`	`ret @fold.respan[ast.expr_](sp, ast.expr_name(n, d_, t));`
`118`	`119`	`}`
`119`	`120`
`120`	`121`	`fn update_env_for_crate(&env e, @ast.crate c) -> env {`
`121`		`- ret cons[scope](scope_crate(c), @e);`
	`122`	`+ ret rec(scopes = cons[scope](scope_crate(c), @e.scopes) with e);`
`122`	`123`	`}`
`123`	`124`
`124`	`125`	`fn update_env_for_item(&env e, @ast.item i) -> env {`
`125`		`- ret cons[scope](scope_item(i), @e);`
	`126`	`+ ret rec(scopes = cons[scope](scope_item(i), @e.scopes) with e);`
`126`	`127`	`}`
`127`	`128`
`128`	`129`	`fn update_env_for_block(&env e, &ast.block b) -> env {`
`129`		`- ret cons[scope](scope_block(b), @e);`
	`130`	`+ ret rec(scopes = cons[scope](scope_block(b), @e.scopes) with e);`
`130`	`131`	`}`
`131`	`132`
`132`	`133`	`fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate {`
	`134`	`+`
`133`	`135`	`let fold.ast_fold[env] fld = fold.new_identity_fold[env]();`
	`136`	`+`
`134`	`137`	`fld = @rec( fold_expr_name = bind fold_expr_name(_,_,_,_,_),`
`135`	`138`	`update_env_for_crate = bind update_env_for_crate(_,_),`
`136`	`139`	`update_env_for_item = bind update_env_for_item(_,_),`
`137`	`140`	`update_env_for_block = bind update_env_for_block(_,_)`
`138`	`141`	`with *fld );`
`139`		`- ret fold.fold_crate[env](nil[scope], fld, crate);`
	`142`	`+`
	`143`	`+ auto e = rec(scopes = nil[scope],`
	`144`	`+ sess = sess);`
	`145`	`+`
	`146`	`+ ret fold.fold_crate[env](e, fld, crate);`
`140`	`147`	`}`
`141`	`148`
`142`	`149`	`// Local Variables:`