---

yaml
---
r: 3123
b: refs/heads/master
c: 52d4f48
h: refs/heads/master
i:
  3121: 0031b29
  3119: 89f72a6
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 92bd35075bafc2835cc7dd1075f29e246c0c7c1c
+refs/heads/master: 52d4f48144e864b9b8e8d82b757bd8969f1fa8a8

trunk/mk/stage3.mk

@@ -1,13 +1,8 @@
-stage3/std.o: $(STDLIB_CRATE) $(STDLIB_INPUTS) \
+stage3/$(CFG_STDLIB): $(STDLIB_CRATE) $(STDLIB_INPUTS) \
               stage2/rustc$(X) stage2/$(CFG_STDLIB) stage2/intrinsics.bc \
               $(LREQ) $(MKFILES)
-	@$(call E, compile: $@)
-	$(STAGE2) -c --shared -o $@ $<
-
-stage3/$(CFG_STDLIB): stage2/std.o stage2/glue.o
-	@$(call E, link: $@)
-	$(Q)gcc $(CFG_GCCISH_CFLAGS) stage2/glue.o $(CFG_GCCISH_LINK_FLAGS) -o \
-        $@ $< -Lstage2 -Lrt -lrustrt
+	@$(call E, compile_and_link: $@)
+	$(STAGE2)  --shared -o $@ $<
 
 stage3/librustc.o: $(COMPILER_CRATE) $(COMPILER_INPUTS) $(SREQ2)
 	@$(call E, compile: $@)

trunk/src/comp/back/abi.rs

@@ -104,7 +104,7 @@ const int closure_elt_bindings = 2;
 
 const int closure_elt_ty_params = 3;
 
-const uint ivec_default_length = 8u;
+const uint ivec_default_length = 4u;
 
 const uint ivec_elt_len = 0u;
 

trunk/src/comp/back/link.rs

@@ -209,7 +209,7 @@ mod write {
  *
  * There are a few issues to handle:
  *
- *  - Linkers operate on a flat namespace, so we have to flatten names.
+ *  - Linnkers operate on a flat namespace, so we have to flatten names.
  *    We do this using the C++ namespace-mangling technique. Foo::bar
  *    symbols and such.
  *
@@ -221,15 +221,15 @@ mod write {
  *    symbols in the same process before you're even hitting birthday-paradox
  *    collision probability.
  *
- *  - Symbols in dirrerent crates but with same names "within" the crate need
+ *  - Symbols in different crates but with same names "within" the crate need
  *    to get different linkage-names.
  *
  * So here is what we do:
  *
  *  - Separate the meta tags into two sets: exported and local. Only work with
  *    the exported ones when considering linkage.
  *
- *  - Consider two exported tags as special (and madatory): name and vers.
+ *  - Consider two exported tags as special (and mandatory): name and vers.
  *    Every crate gets them; if it doesn't name them explicitly we infer them
  *    as basename(crate) and "0.1", respectively. Call these CNAME, CVERS.
  *

trunk/src/comp/driver/rustc.rs

@@ -399,37 +399,34 @@ fn main(vec[str] args) {
         let str prog = "gcc";
         // The invocations of gcc share some flags across platforms
 
-        let vec[str] common_cflags =
-            ["-fno-strict-aliasing", "-fPIC", "-Wall", "-fno-rtti",
-             "-fno-exceptions", "-g"];
-        let vec[str] common_libs =
-            [stage, "-Lrustllvm", "-Lrt", "-lrustrt", "-lrustllvm", "-lstd",
-             "-lm"];
+        let vec[str] common_args = [stage, "-Lrt", "-lrustrt",
+         "-fno-strict-aliasing", "-fPIC", "-Wall",
+         "-fno-rtti", "-fno-exceptions", "-g", glu, "-o",
+         saved_out_filename, saved_out_filename + ".o"];
+
+       auto shared_cmd;
+
         alt (sess.get_targ_cfg().os) {
             case (session::os_win32) {
-                gcc_args =
-                    common_cflags +
-                        ["-march=i686", "-O2", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-shared";
+                gcc_args = common_args + ["-march=i686", "-O2"];
             }
             case (session::os_macos) {
-                gcc_args =
-                    common_cflags +
-                        ["-arch i386", "-O0", "-m32", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-dynamiclib";
+                gcc_args = common_args + ["-arch i386", "-O0", "-m32"];
             }
             case (session::os_linux) {
-                gcc_args =
-                    common_cflags +
-                        ["-march=i686", "-O2", "-m32", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-shared";
+                gcc_args = common_args + ["-march=i686", "-O2", "-m32"];
             }
         }
-        // We run 'gcc' here
+        if (sopts.shared) {
+           gcc_args += [shared_cmd];
+        } else {
+           gcc_args += ["-Lrustllvm", "-lrustllvm", "-lstd", "-lm", main];
+        }
 
+        // We run 'gcc' here
         run::run_program(prog, gcc_args);
         // Clean up on Darwin
 

trunk/src/comp/front/parser.rs

@@ -2181,13 +2181,7 @@ fn parse_crate_directive(&parser p) -> ast::crate_directive {
         auto hi = p.get_hi_pos();
         expect(p, token::RBRACE);
         ret spanned(lo, hi, ast::cdir_let(id, x, v));
-    } else if (is_word(p, "use")) {
-        auto vi = parse_view_item(p);
-        ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
-    } else if (is_word(p, "import")) {
-        auto vi = parse_view_item(p);
-        ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
-    } else if (is_word(p, "export")) {
+    } else if (is_view_item(p)) {
         auto vi = parse_view_item(p);
         ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
     } else {

trunk/src/comp/middle/alias.rs

@@ -77,12 +77,18 @@ fn visit_item(@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) {
 }
 
 fn visit_expr(@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) {
-    auto handled = false;
+    auto handled = true;
     alt (ex.node) {
-        case (ast::expr_call(?f, ?args, _)) { check_call(*cx, f, args, sc); }
+        case (ast::expr_call(?f, ?args, _)) {
+            check_call(*cx, f, args, sc);
+            handled = false;
+        }
+        case (ast::expr_be(?cl, _)) {
+            check_tail_call(*cx, cl);
+            visit::visit_expr(cl, sc, v);
+        }
         case (ast::expr_alt(?input, ?arms, _)) {
             check_alt(*cx, input, arms, sc, v);
-            handled = true;
         }
         case (ast::expr_put(?val, _)) {
             alt (val) {
@@ -97,44 +103,36 @@ fn visit_expr(@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) {
                 }
                 case (_) { }
             }
-            handled = true;
         }
         case (ast::expr_for_each(?decl, ?call, ?block, _)) {
             check_for_each(*cx, decl, call, block, sc, v);
-            handled = true;
         }
         case (ast::expr_for(?decl, ?seq, ?block, _)) {
             check_for(*cx, decl, seq, block, sc, v);
-            handled = true;
         }
         case (ast::expr_path(?pt, ?ann)) {
             check_var(*cx, ex, pt, ann, false, sc);
+            handled = false;
         }
         case (ast::expr_move(?dest, ?src, _)) {
             check_assign(cx, dest, src, sc, v);
-            handled = true;
         }
         case (ast::expr_assign(?dest, ?src, _)) {
             check_assign(cx, dest, src, sc, v);
-            handled = true;
         }
         case (ast::expr_assign_op(_, ?dest, ?src, _)) {
             check_assign(cx, dest, src, sc, v);
-            handled = true;
         }
-        case (_) { }
+        case (_) { handled = false; }
     }
     if (!handled) { visit::visit_expr(ex, sc, v); }
 }
 
 fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
    rec(vec[def_num] root_vars, vec[ty::t] unsafe_ts) {
     auto fty = ty::expr_ty(*cx.tcx, f);
-    auto arg_ts =
-        alt (ty::struct(*cx.tcx, fty)) {
-            case (ty::ty_fn(_, ?args, _, _, _)) { args }
-            case (ty::ty_native_fn(_, ?args, _)) { args }
-        };
+    auto arg_ts = fty_args(cx, fty);
+
     let vec[def_num] roots = [];
     let vec[tup(uint, def_num)] mut_roots = [];
     let vec[ty::t] unsafe_ts = [];
@@ -175,11 +173,11 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
     if (vec::len(unsafe_ts) > 0u) {
         alt (f.node) {
             case (ast::expr_path(_, ?ann)) {
-                if (def_is_local(cx.dm.get(ann.id))) {
-                    cx.tcx.sess.span_err(f.span,
-                                         #fmt("function may alias with \
-                         argument %u, which is not immutably rooted",
-                                              unsafe_t_offsets.(0)));
+                if (def_is_local(cx.dm.get(ann.id), true)) {
+                    cx.tcx.sess.span_err
+                        (f.span, #fmt("function may alias with argument \
+                         %u, which is not immutably rooted",
+                         unsafe_t_offsets.(0)));
                 }
             }
             case (_) { }
@@ -221,8 +219,47 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
     ret rec(root_vars=roots, unsafe_ts=unsafe_ts);
 }
 
-fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms, &scope sc,
-             &vt[scope] v) {
+fn check_tail_call(&ctx cx, &@ast::expr call) {
+    auto args;
+    auto f = alt (call.node) {
+        case (ast::expr_call(?f, ?args_, _)) { args = args_; f }
+    };
+    auto i = 0u;
+    for (ty::arg arg_t in fty_args(cx, ty::expr_ty(*cx.tcx, f))) {
+        if (arg_t.mode != ty::mo_val) {
+            auto mut_a = arg_t.mode == ty::mo_alias(true);
+            auto ok = true;
+            alt (args.(i).node) {
+                case (ast::expr_path(_, ?ann)) {
+                    auto def = cx.dm.get(ann.id);
+                    auto dnum = ast::def_id_of_def(def)._1;
+                    alt (cx.local_map.find(dnum)) {
+                        case (some(arg(ast::alias(?mut)))) {
+                            if (mut_a && !mut) {
+                                cx.tcx.sess.span_warn
+                                    (args.(i).span, "passing an immutable \
+                                     alias by mutable alias");
+                            }
+                        }
+                        case (_) {
+                            ok = !def_is_local(def, false);
+                        }
+                    }
+                }
+                case (_) { ok = false; }
+            }
+            if (!ok) {
+                cx.tcx.sess.span_warn
+                    (args.(i).span, "can not pass a local value by alias to \
+                                     a tail call");
+            }
+        }
+        i += 1u;
+    }
+}
+
+fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms,
+             &scope sc, &vt[scope] v) {
     visit::visit_expr(input, sc, v);
     auto root = expr_root(cx, input, true);
     auto roots =
@@ -317,7 +354,7 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
 fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::ann ann, bool assign,
              &scope sc) {
     auto def = cx.dm.get(ann.id);
-    if (!def_is_local(def)) { ret; }
+    if (!def_is_local(def, true)) { ret; }
     auto my_defnum = ast::def_id_of_def(def)._1;
     auto var_t = ty::expr_ty(*cx.tcx, ex);
     for (restrict r in sc) {
@@ -594,15 +631,23 @@ fn ty_can_unsafely_include(&ctx cx, ty::t needle, ty::t haystack, bool mut) ->
     ret helper(*cx.tcx, needle, haystack, mut);
 }
 
-fn def_is_local(&ast::def d) -> bool {
+fn def_is_local(&ast::def d, bool objfields_count) -> bool {
     ret alt (d) {
-            case (ast::def_local(_)) { true }
-            case (ast::def_arg(_)) { true }
-            case (ast::def_obj_field(_)) { true }
-            case (ast::def_binding(_)) { true }
-            case (_) { false }
-        };
+        case (ast::def_local(_)) { true }
+        case (ast::def_arg(_)) { true }
+        case (ast::def_obj_field(_)) { objfields_count }
+        case (ast::def_binding(_)) { true }
+        case (_) { false }
+    };
 }
+
+fn fty_args(&ctx cx, ty::t fty) -> vec[ty::arg] {
+    ret alt (ty::struct(*cx.tcx, fty)) {
+        case (ty::ty_fn(_, ?args, _, _, _)) { args }
+        case (ty::ty_native_fn(_, ?args, _)) { args }
+    };
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;