---

yaml
---
r: 51306
b: refs/heads/incoming
c: 1e1efbf
h: refs/heads/master
v: v3

Author: jdm

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 9b9ffd5b4196d409dd76c224442ee0fee91fd9e4
+refs/heads/incoming: 1e1efbf2c355c4ddb1356abe535d79525bad72ba
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/librustc/back/link.rs

@@ -818,7 +818,11 @@ pub fn link_binary(sess: Session,
     do cstore::iter_crate_data(cstore) |crate_num, _| {
         let link_args = csearch::get_link_args_for_crate(cstore, crate_num);
         do vec::consume(link_args) |_, link_arg| {
-            cc_args.push(link_arg);
+            // Linker arguments that don't begin with - are likely file names,
+            // so they should not be necessary.
+            if link_arg.starts_with("-") {
+              cc_args.push(link_arg);
+            }
         }
     }
 

branches/incoming/src/librustc/middle/check_const.rs

@@ -91,8 +91,8 @@ pub fn check_expr(sess: Session,
                   v: visit::vt<bool>) {
     if is_const {
         match e.node {
-          expr_unary(deref, _) => { }
-          expr_unary(box(_), _) | expr_unary(uniq(_), _) => {
+          expr_unary(box(_), _) | expr_unary(uniq(_), _) |
+          expr_unary(deref, _) => {
             sess.span_err(e.span,
                           ~"disallowed operator in constant expression");
             return;

branches/incoming/src/librustc/middle/trans/consts.rs

@@ -10,7 +10,6 @@
 
 use core::prelude::*;
 
-use back::abi;
 use lib::llvm::{llvm, ValueRef, TypeRef, Bool, True, False};
 use metadata::csearch;
 use middle::const_eval;
@@ -95,56 +94,30 @@ pub fn const_vec(cx: @CrateContext, e: @ast::expr, es: &[@ast::expr])
     }
 }
 
-fn const_addr_of(cx: @CrateContext, cv: ValueRef) -> ValueRef {
+pub fn const_deref(cx: @CrateContext, v: ValueRef) -> ValueRef {
     unsafe {
-        let gv = do str::as_c_str("const") |name| {
-            llvm::LLVMAddGlobal(cx.llmod, val_ty(cv), name)
+        let v = match cx.const_globals.find(&(v as int)) {
+            Some(v) => v,
+            None => v
         };
-        llvm::LLVMSetInitializer(gv, cv);
-        llvm::LLVMSetGlobalConstant(gv, True);
-        gv
-    }
-}
-
-fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef {
-    let v = match cx.const_globals.find(&(v as int)) {
-        Some(v) => v,
-        None => v
-    };
-    unsafe {
         fail_unless!(llvm::LLVMIsGlobalConstant(v) == True);
-        llvm::LLVMGetInitializer(v)
+        let v = llvm::LLVMGetInitializer(v);
+        v
     }
 }
 
-fn const_deref_newtype(cx: @CrateContext, v: ValueRef, t: ty::t)
-    -> ValueRef {
-    let repr = adt::represent_type(cx, t);
-    adt::const_get_field(cx, repr, v, 0, 0)
-}
-
-fn const_deref(cx: @CrateContext, v: ValueRef, t: ty::t, explicit: bool)
-    -> (ValueRef, ty::t) {
-    match ty::deref(cx.tcx, t, explicit) {
-        Some(ref mt) => {
-            fail_unless!(mt.mutbl != ast::m_mutbl);
-            let dv = match ty::get(t).sty {
-                ty::ty_ptr(*) | ty::ty_rptr(*) => {
-                     const_deref_ptr(cx, v)
-                }
-                ty::ty_enum(*) | ty::ty_struct(*) => {
-                    const_deref_newtype(cx, v, t)
-                }
-                _ => {
-                    cx.sess.bug(fmt!("Unexpected dereferenceable type %s",
-                                     ty_to_str(cx.tcx, t)))
-                }
-            };
-            (dv, mt.ty)
-        }
-        None => {
-            cx.sess.bug(fmt!("Can't dereference const of type %s",
-                             ty_to_str(cx.tcx, t)))
+pub fn const_autoderef(cx: @CrateContext, ty: ty::t, v: ValueRef)
+    -> (ty::t, ValueRef) {
+    let mut t1 = ty;
+    let mut v1 = v;
+    loop {
+        // Only rptrs can be autoderef'ed in a const context.
+        match ty::get(t1).sty {
+            ty::ty_rptr(_, mt) => {
+                t1 = mt.ty;
+                v1 = const_deref(cx, v1);
+            }
+            _ => return (t1,v1)
         }
     }
 }
@@ -169,68 +142,15 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef {
 }
 
 pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
-    let mut llconst = const_expr_unadjusted(cx, e);
-    let ety = ty::expr_ty(cx.tcx, e);
-    match cx.tcx.adjustments.find(&e.id) {
-        None => { }
-        Some(@ty::AutoAddEnv(ty::re_static, ast::BorrowedSigil)) => {
-            llconst = C_struct(~[llconst, C_null(T_opaque_box_ptr(cx))])
-        }
-        Some(@ty::AutoAddEnv(ref r, ref s)) => {
-            cx.sess.span_bug(e.span, fmt!("unexpected const function: \
-                                           region %? sigil %?", *r, *s))
-        }
-        Some(@ty::AutoDerefRef(ref adj)) => {
-            let mut ty = ety;
-            let mut maybe_ptr = None;
-            for adj.autoderefs.times {
-                let (dv, dt) = const_deref(cx, llconst, ty, false);
-                maybe_ptr = Some(llconst);
-                llconst = dv;
-                ty = dt;
-            }
-
-            match adj.autoref {
-                None => { }
-                Some(ref autoref) => {
-                    fail_unless!(autoref.region == ty::re_static);
-                    fail_unless!(autoref.mutbl != ast::m_mutbl);
-                    // Don't copy data to do a deref+ref.
-                    let llptr = match maybe_ptr {
-                        Some(ptr) => ptr,
-                        None => const_addr_of(cx, llconst)
-                    };
-                    match autoref.kind {
-                        ty::AutoPtr => {
-                            llconst = llptr;
-                        }
-                        ty::AutoBorrowVec => {
-                            let size = machine::llsize_of(cx,
-                                                          val_ty(llconst));
-                            fail_unless!(abi::slice_elt_base == 0);
-                            fail_unless!(abi::slice_elt_len == 1);
-                            llconst = C_struct(~[llptr, size]);
-                        }
-                        _ => {
-                            cx.sess.span_bug(e.span,
-                                             fmt!("unimplemented const \
-                                                   autoref %?", autoref))
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let ety_adjusted = ty::expr_ty_adjusted(cx.tcx, e);
-    let llty = type_of::sizing_type_of(cx, ety_adjusted);
+    let ety = ty::expr_ty_adjusted(cx.tcx, e);
+    let llty = type_of::sizing_type_of(cx, ety);
+    let llconst = const_expr_unchecked(cx, e);
     let csize = machine::llsize_of_alloc(cx, val_ty(llconst));
     let tsize = machine::llsize_of_alloc(cx, llty);
     if csize != tsize {
         unsafe {
-            // XXX these values could use some context
             llvm::LLVMDumpValue(llconst);
-            llvm::LLVMDumpValue(C_undef(llty));
+            llvm::LLVMDumpValue(C_null(llty));
         }
         cx.sess.bug(fmt!("const %s of type %s has size %u instead of %u",
                          expr_repr(cx.tcx, e), ty_to_str(cx.tcx, ety),
@@ -239,7 +159,7 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     llconst
 }
 
-fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
+fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     unsafe {
         let _icx = cx.insn_ctxt("const_expr");
         return match /*bad*/copy e.node {
@@ -303,10 +223,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             return match u {
               ast::box(_)  |
               ast::uniq(_) |
-              ast::deref  => {
-                let (dv, _dt) = const_deref(cx, te, ty, true);
-                dv
-              }
+              ast::deref  => const_deref(cx, te),
               ast::not    => {
                 match ty::get(ty).sty {
                     ty::ty_bool => {
@@ -326,18 +243,20 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_field(base, field, _) => {
-              let bt = ty::expr_ty_adjusted(cx.tcx, base);
+              let bt = ty::expr_ty(cx.tcx, base);
               let brepr = adt::represent_type(cx, bt);
               let bv = const_expr(cx, base);
+              let (bt, bv) = const_autoderef(cx, bt, bv);
               do expr::with_field_tys(cx.tcx, bt, None) |discr, field_tys| {
                   let ix = ty::field_idx_strict(cx.tcx, field, field_tys);
                   adt::const_get_field(cx, brepr, bv, discr, ix)
               }
           }
 
           ast::expr_index(base, index) => {
-              let bt = ty::expr_ty_adjusted(cx.tcx, base);
+              let bt = ty::expr_ty(cx.tcx, base);
               let bv = const_expr(cx, base);
+              let (bt, bv) = const_autoderef(cx, bt, bv);
               let iv = match const_eval::eval_const_expr(cx.tcx, index) {
                   const_eval::const_int(i) => i as u64,
                   const_eval::const_uint(u) => u,
@@ -356,7 +275,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                           let llunitty = type_of::type_of(cx, unit_ty);
                           let unit_sz = machine::llsize_of(cx, llunitty);
 
-                          (const_deref_ptr(cx, const_get_elt(cx, bv, [0])),
+                          (const_deref(cx, const_get_elt(cx, bv, [0])),
                            llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]),
                                                unit_sz))
                       },
@@ -436,7 +355,13 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_addr_of(ast::m_imm, sub) => {
-              const_addr_of(cx, const_expr(cx, sub))
+            let cv = const_expr(cx, sub);
+            let gv = do str::as_c_str("const") |name| {
+                llvm::LLVMAddGlobal(cx.llmod, val_ty(cv), name)
+            };
+            llvm::LLVMSetInitializer(gv, cv);
+            llvm::LLVMSetGlobalConstant(gv, True);
+            gv
           }
           ast::expr_tup(es) => {
               let ety = ty::expr_ty(cx.tcx, e);
@@ -495,12 +420,26 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             fail_unless!(pth.types.len() == 0);
             match cx.tcx.def_map.find(&e.id) {
                 Some(ast::def_fn(def_id, _purity)) => {
-                    if !ast_util::is_local(def_id) {
+                    let f = if !ast_util::is_local(def_id) {
                         let ty = csearch::get_type(cx.tcx, def_id).ty;
                         base::trans_external_path(cx, def_id, ty)
                     } else {
                         fail_unless!(ast_util::is_local(def_id));
                         base::get_item_val(cx, def_id.node)
+                    };
+                    let ety = ty::expr_ty_adjusted(cx.tcx, e);
+                    match ty::get(ety).sty {
+                        ty::ty_bare_fn(*) | ty::ty_ptr(*) => {
+                            llvm::LLVMConstPointerCast(f, T_ptr(T_i8()))
+                        }
+                        ty::ty_closure(*) => {
+                            C_struct(~[f, C_null(T_opaque_box_ptr(cx))])
+                        }
+                        _ => {
+                            cx.sess.span_bug(e.span, fmt!(
+                                "unexpected const fn type: %s",
+                                ty_to_str(cx.tcx, ety)))
+                        }
                     }
                 }
                 Some(ast::def_const(def_id)) => {

branches/incoming/src/libsyntax/print/pprust.rs

@@ -1192,11 +1192,6 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
       ast::expr_addr_of(m, expr) => {
         word(s.s, ~"&");
         print_mutability(s, m);
-        // Avoid `& &e` => `&&e`.
-        match (m, &expr.node) {
-            (ast::m_imm, &ast::expr_addr_of(*)) => space(s.s),
-            _ => { }
-        }
         print_expr(s, expr);
       }
       ast::expr_lit(lit) => print_literal(s, lit),