---

yaml
---
r: 49865
b: refs/heads/auto
c: 2fef18a
h: refs/heads/master
i:
  49863: 14fc9e5
v: v3

Author: bors

[refs]

@@ -14,5 +14,5 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 1e1efbf2c355c4ddb1356abe535d79525bad72ba
+refs/heads/auto: 2fef18abf2b6a9b3c336b1da5b8a08a22438ad4c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

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

@@ -818,11 +818,7 @@ 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| {
-            // 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);
-            }
+            cc_args.push(link_arg);
         }
     }
 

branches/auto/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(box(_), _) | expr_unary(uniq(_), _) |
-          expr_unary(deref, _) => {
+          expr_unary(deref, _) => { }
+          expr_unary(box(_), _) | expr_unary(uniq(_), _) => {
             sess.span_err(e.span,
                           ~"disallowed operator in constant expression");
             return;

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

@@ -10,6 +10,7 @@
 
 use core::prelude::*;
 
+use back::abi;
 use lib::llvm::{llvm, ValueRef, TypeRef, Bool, True, False};
 use metadata::csearch;
 use middle::const_eval;
@@ -94,30 +95,56 @@ pub fn const_vec(cx: @CrateContext, e: @ast::expr, es: &[@ast::expr])
     }
 }
 
-pub fn const_deref(cx: @CrateContext, v: ValueRef) -> ValueRef {
+fn const_addr_of(cx: @CrateContext, cv: ValueRef) -> ValueRef {
     unsafe {
-        let v = match cx.const_globals.find(&(v as int)) {
-            Some(v) => v,
-            None => v
+        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
+    }
+}
+
+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);
-        let v = llvm::LLVMGetInitializer(v);
-        v
+        llvm::LLVMGetInitializer(v)
     }
 }
 
-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)
+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)))
         }
     }
 }
@@ -142,15 +169,68 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef {
 }
 
 pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
-    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 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 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_null(llty));
+            llvm::LLVMDumpValue(C_undef(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),
@@ -159,7 +239,7 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     llconst
 }
 
-fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
+fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
     unsafe {
         let _icx = cx.insn_ctxt("const_expr");
         return match /*bad*/copy e.node {
@@ -223,7 +303,10 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             return match u {
               ast::box(_)  |
               ast::uniq(_) |
-              ast::deref  => const_deref(cx, te),
+              ast::deref  => {
+                let (dv, _dt) = const_deref(cx, te, ty, true);
+                dv
+              }
               ast::not    => {
                 match ty::get(ty).sty {
                     ty::ty_bool => {
@@ -243,20 +326,18 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_field(base, field, _) => {
-              let bt = ty::expr_ty(cx.tcx, base);
+              let bt = ty::expr_ty_adjusted(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(cx.tcx, base);
+              let bt = ty::expr_ty_adjusted(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,
@@ -275,7 +356,7 @@ fn const_expr_unchecked(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(cx, const_get_elt(cx, bv, [0])),
+                          (const_deref_ptr(cx, const_get_elt(cx, bv, [0])),
                            llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]),
                                                unit_sz))
                       },
@@ -355,13 +436,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_addr_of(ast::m_imm, 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
+              const_addr_of(cx, const_expr(cx, sub))
           }
           ast::expr_tup(es) => {
               let ety = ty::expr_ty(cx.tcx, e);
@@ -420,26 +495,12 @@ fn const_expr_unchecked(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)) => {
-                    let f = if !ast_util::is_local(def_id) {
+                    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)) => {