---

yaml
---
r: 166440
b: refs/heads/batch
c: 0eafc32
h: refs/heads/master
v: v3

Author: tshepang

[refs]

@@ -29,5 +29,5 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: 3772ce55e0bba39c9c019d757f76ece7f00cbaee
+refs/heads/batch: 0eafc3228be26f7aee95b094398a667436c4a605
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970

branches/batch/mk/cfg/x86_64-unknown-dragonfly.mk

@@ -7,9 +7,9 @@ CFG_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-dragonfly=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_x86_64-unknown-dragonfly=$(1)-*.dylib.dSYM
-CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt -m64
+CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt
 CFG_GCCISH_DEF_FLAG_x86_64-unknown-dragonfly := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-no-whole-archive

branches/batch/src/doc/guide.md

@@ -1604,10 +1604,6 @@ let a = [1i, 2i, 3i];     // a: [int, ..3]
 let mut m = [1i, 2i, 3i]; // mut m: [int, ..3]
 ```
 
-You can create an array with a given number of elements, all initialized to the
-same value, with `[val, ..N]` syntax. The compiler ensures that arrays are
-always initialized.
-
 There's a shorthand for initializing each element of an array to the same
 value. In this example, each element of `a` will be initialized to `0i`:
 

branches/batch/src/doc/reference.md

@@ -640,7 +640,7 @@ names, and invoked through a consistent syntax: `name!(...)`. Examples include:
 * `stringify!` : pretty-print the Rust expression given as an argument
 * `include!` : include the Rust expression in the given file
 * `include_str!` : include the contents of the given file as a string
-* `include_bytes!` : include the contents of the given file as a binary blob
+* `include_bin!` : include the contents of the given file as a binary blob
 * `error!`, `warn!`, `info!`, `debug!` : provide diagnostic information.
 
 All of the above extensions are expressions with values.

branches/batch/src/etc/snapshot.py

@@ -37,7 +37,6 @@ def scrub(b):
     "macos": ["bin/rustc"],
     "winnt": ["bin/rustc.exe"],
     "freebsd": ["bin/rustc"],
-    "dragonfly": ["bin/rustc"],
     }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll",
@@ -87,8 +86,6 @@ def get_kernel(triple):
         return "macos"
     if os_name == "freebsd":
         return "freebsd"
-    if os_name == "dragonfly":
-        return "dragonfly"
     return "linux"
 
 def get_cpu(triple):

branches/batch/src/libcore/clone.rs

@@ -36,7 +36,7 @@ pub trait Clone {
     /// but can be overridden to reuse the resources of `a` to avoid unnecessary
     /// allocations.
     #[inline(always)]
-    #[unstable = "this function is rarely used"]
+    #[unstable = "this function rarely unused"]
     fn clone_from(&mut self, source: &Self) {
         *self = source.clone()
     }

branches/batch/src/libcore/macros.rs

@@ -61,6 +61,16 @@ macro_rules! assert {
     );
 }
 
+/// Runtime assertion, only without `--cfg ndebug`
+#[macro_export]
+macro_rules! debug_assert {
+    ($(a:tt)*) => ({
+        if cfg!(not(ndebug)) {
+            assert!($($a)*);
+        }
+    })
+}
+
 /// Runtime assertion for equality, for details see std::macros
 #[macro_export]
 macro_rules! assert_eq {
@@ -83,7 +93,7 @@ macro_rules! debug_assert_eq {
     })
 }
 
-/// Runtime assertion, disableable at compile time with `--cfg ndebug`
+/// Runtime assertion, disableable at compile time
 #[macro_export]
 macro_rules! debug_assert {
     ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })

branches/batch/src/liblibc/lib.rs

@@ -1095,7 +1095,6 @@ pub mod types {
                 pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
-                use types::common::c95::{c_void};
                 use types::os::arch::c95::{c_char, c_int, c_uint};
 
                 pub type socklen_t = u32;
@@ -1168,17 +1167,6 @@ pub mod types {
                     pub sun_family: sa_family_t,
                     pub sun_path: [c_char, ..104]
                 }
-                #[repr(C)]
-                #[deriving(Copy)] pub struct ifaddrs {
-                    pub ifa_next: *mut ifaddrs,
-                    pub ifa_name: *mut c_char,
-                    pub ifa_flags: c_uint,
-                    pub ifa_addr: *mut sockaddr,
-                    pub ifa_netmask: *mut sockaddr,
-                    pub ifa_dstaddr: *mut sockaddr,
-                    pub ifa_data: *mut c_void
-                }
-
             }
         }
 

branches/batch/src/librustc_back/rpath.rs

@@ -215,7 +215,22 @@ mod test {
     }
 
     #[test]
-    #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg(target_os = "freebsd")]
+    fn test_rpath_relative() {
+        let config = &mut RPathConfig {
+            used_crates: Vec::new(),
+            has_rpath: true,
+            is_like_osx: false,
+            out_filename: Path::new("bin/rustc"),
+            get_install_prefix_lib_path: || panic!(),
+            realpath: |p| Ok(p.clone())
+        };
+        let res = get_rpath_relative_to_output(config, &Path::new("lib/libstd.so"));
+        assert_eq!(res, "$ORIGIN/../lib");
+    }
+
+    #[test]
+    #[cfg(target_os = "dragonfly")]
     fn test_rpath_relative() {
         let config = &mut RPathConfig {
             used_crates: Vec::new(),

branches/batch/src/librustc_back/target/dragonfly_base.rs

@@ -17,18 +17,13 @@ pub fn opts() -> TargetOptions {
         dynamic_linking: true,
         executables: true,
         morestack: true,
-        linker_is_gnu: true,
         has_rpath: true,
         pre_link_args: vec!(
             "-L/usr/local/lib".to_string(),
-            "-L/usr/lib/gcc47".to_string(),
-            // GNU-style linkers will use this to omit linking to libraries
-            // which don't actually fulfill any relocations, but only for
-            // libraries which follow this flag.  Thus, use it before
-            // specifying libraries to link to.
-            "-Wl,--as-needed".to_string(),
+            "-L/usr/local/lib/gcc47".to_string(),
+            "-L/usr/local/lib/gcc44".to_string(),
         ),
-        position_independent_executables: true,
+
         .. Default::default()
     }
 }

branches/batch/src/librustc_back/target/x86_64_unknown_dragonfly.rs

@@ -11,18 +11,13 @@
 use target::Target;
 
 pub fn target() -> Target {
-    let mut base = super::dragonfly_base::opts();
-    base.pre_link_args.push("-m64".to_string());
-
     Target {
-        data_layout: "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\
-                     f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-\
-                     s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(),
+        data_layout: "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(),
         llvm_target: "x86_64-unknown-dragonfly".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_word_size: "32".to_string(),
         arch: "x86_64".to_string(),
         target_os: "dragonfly".to_string(),
-        options: base,
+        options: super::dragonfly_base::opts()
     }
 }

branches/batch/src/librustc_trans/trans/_match.rs

@@ -1554,8 +1554,7 @@ pub fn store_for_loop_binding<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                           -> Block<'blk, 'tcx> {
     let _icx = push_ctxt("match::store_for_loop_binding");
 
-    if simple_identifier(&*pat).is_some() &&
-       bcx.sess().opts.debuginfo != FullDebugInfo {
+    if simple_identifier(&*pat).is_some() {
         // Generate nicer LLVM for the common case of a `for` loop pattern
         // like `for x in blahblah { ... }`.
         let binding_type = node_id_type(bcx, pat.id);

branches/batch/src/librustc_trans/trans/base.rs

@@ -55,7 +55,7 @@ use trans::cleanup::CleanupMethods;
 use trans::cleanup;
 use trans::closure;
 use trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_integral};
-use trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_undef};
+use trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_uint, C_undef};
 use trans::common::{CrateContext, ExternMap, FunctionContext};
 use trans::common::{NodeInfo, Result};
 use trans::common::{node_id_type, return_type_is_void};
@@ -73,7 +73,7 @@ use trans::glue;
 use trans::inline;
 use trans::intrinsic;
 use trans::machine;
-use trans::machine::{llsize_of, llsize_of_real};
+use trans::machine::{llsize_of, llsize_of_real, llalign_of_min};
 use trans::meth;
 use trans::monomorphize;
 use trans::tvec;
@@ -394,6 +394,30 @@ pub fn malloc_raw_dyn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
 }
 
+pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>)
+                                       -> Result<'blk, 'tcx> {
+    let _icx = push_ctxt("malloc_raw_dyn_proc");
+    let ccx = bcx.ccx();
+
+    // Grab the TypeRef type of ptr_ty.
+    let ptr_ty = ty::mk_uniq(bcx.tcx(), t);
+    let ptr_llty = type_of(ccx, ptr_ty);
+
+    let llty = type_of(bcx.ccx(), t);
+    let size = llsize_of(bcx.ccx(), llty);
+    let llalign = C_uint(ccx, llalign_of_min(bcx.ccx(), llty));
+
+    // Allocate space and store the destructor pointer:
+    let Result {bcx, val: llbox} = malloc_raw_dyn(bcx, ptr_llty, t, size, llalign);
+    let dtor_ptr = GEPi(bcx, llbox, &[0u, abi::BOX_FIELD_DROP_GLUE]);
+    let drop_glue_field_ty = type_of(ccx, ty::mk_nil_ptr(bcx.tcx()));
+    let drop_glue = PointerCast(bcx, glue::get_drop_glue(ccx, ty::mk_uniq(bcx.tcx(), t)),
+                                drop_glue_field_ty);
+    Store(bcx, drop_glue, dtor_ptr);
+
+    Result::new(bcx, llbox)
+}
+
 // Type descriptor and type glue stuff
 
 pub fn get_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
@@ -959,14 +983,23 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                           llfn: ValueRef,
                           llargs: &[ValueRef],
                           fn_ty: Ty<'tcx>,
-                          call_info: Option<NodeInfo>)
+                          call_info: Option<NodeInfo>,
+                          // FIXME(15064) is_lang_item is a horrible hack, please remove it
+                          // at the soonest opportunity.
+                          is_lang_item: bool)
                           -> (ValueRef, Block<'blk, 'tcx>) {
     let _icx = push_ctxt("invoke_");
     if bcx.unreachable.get() {
         return (C_null(Type::i8(bcx.ccx())), bcx);
     }
 
-    let attributes = get_fn_llvm_attributes(bcx.ccx(), fn_ty);
+    // FIXME(15064) Lang item methods may (in the reflect case) not have proper
+    // types, so doing an attribute lookup will fail.
+    let attributes = if is_lang_item {
+        llvm::AttrBuilder::new()
+    } else {
+        get_fn_llvm_attributes(bcx.ccx(), fn_ty)
+    };
 
     match bcx.opt_node_id {
         None => {

branches/batch/src/librustc_trans/trans/callee.rs

@@ -778,7 +778,8 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
                                       llfn,
                                       llargs[],
                                       callee_ty,
-                                      call_info);
+                                      call_info,
+                                      dest.is_none());
         bcx = b;
         llresult = llret;
 

branches/batch/src/librustc_trans/trans/closure.rs

@@ -137,6 +137,26 @@ fn tuplify_box_ty<'tcx>(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>) -> Ty<'tcx> {
     ty::mk_tup(tcx, vec!(ty::mk_uint(), ty::mk_nil_ptr(tcx), ptr, ptr, t))
 }
 
+fn allocate_cbox<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
+                             store: ty::TraitStore,
+                             cdata_ty: Ty<'tcx>)
+                             -> Result<'blk, 'tcx> {
+    let _icx = push_ctxt("closure::allocate_cbox");
+    let tcx = bcx.tcx();
+
+    // Allocate and initialize the box:
+    let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
+    match store {
+        ty::UniqTraitStore => {
+            malloc_raw_dyn_proc(bcx, cbox_ty)
+        }
+        ty::RegionTraitStore(..) => {
+            let llbox = alloc_ty(bcx, cbox_ty, "__closure");
+            Result::new(bcx, llbox)
+        }
+    }
+}
+
 pub struct ClosureResult<'blk, 'tcx: 'blk> {
     llbox: ValueRef,        // llvalue of ptr to closure
     cdata_ty: Ty<'tcx>,     // type of the closure data
@@ -148,7 +168,8 @@ pub struct ClosureResult<'blk, 'tcx: 'blk> {
 // heap allocated closure that copies the upvars into environment.
 // Otherwise, it is stack allocated and copies pointers to the upvars.
 pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                     bound_values: Vec<EnvValue<'tcx>>)
+                                     bound_values: Vec<EnvValue<'tcx>> ,
+                                     store: ty::TraitStore)
                                      -> ClosureResult<'blk, 'tcx> {
     let _icx = push_ctxt("closure::store_environment");
     let ccx = bcx.ccx();
@@ -172,7 +193,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     }
 
     // allocate closure in the heap
-    let llbox = alloc_ty(bcx, cbox_ty, "__closure");
+    let Result {bcx, val: llbox} = allocate_cbox(bcx, store, cdata_ty);
 
     let llbox = PointerCast(bcx, llbox, llboxptr_ty);
     debug!("tuplify_box_ty = {}", ty_to_string(tcx, cbox_ty));
@@ -206,7 +227,8 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 // collects the upvars and packages them up for store_environment.
 fn build_closure<'blk, 'tcx>(bcx0: Block<'blk, 'tcx>,
                              freevar_mode: ast::CaptureClause,
-                             freevars: &Vec<ty::Freevar>)
+                             freevars: &Vec<ty::Freevar>,
+                             store: ty::TraitStore)
                              -> ClosureResult<'blk, 'tcx> {
     let _icx = push_ctxt("closure::build_closure");
 
@@ -220,7 +242,7 @@ fn build_closure<'blk, 'tcx>(bcx0: Block<'blk, 'tcx>,
         env_vals.push(EnvValue {action: freevar_mode, datum: datum});
     }
 
-    store_environment(bcx, env_vals)
+    store_environment(bcx, env_vals, store)
 }
 
 // Given an enclosing block context, a new function context, a closure type,
@@ -434,7 +456,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         llbox,
         cdata_ty,
         bcx
-    } = build_closure(bcx, freevar_mode, &freevars);
+    } = build_closure(bcx, freevar_mode, &freevars, store);
 
     trans_closure(ccx,
                   decl,

branches/batch/src/librustc_trans/trans/controlflow.rs

@@ -286,7 +286,6 @@ pub fn trans_for<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     debug!("iterator type is {}, datum type is {}",
            ppaux::ty_to_string(bcx.tcx(), iterator_type),
            ppaux::ty_to_string(bcx.tcx(), iterator_datum.ty));
-
     let lliterator = load_ty(bcx, iterator_datum.val, iterator_datum.ty);
 
     // Create our basic blocks and set up our loop cleanups.
@@ -366,8 +365,6 @@ pub fn trans_for<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                                        llpayload,
                                        binding_cleanup_scope_id);
 
-    debuginfo::create_for_loop_var_metadata(body_bcx_in, pat);
-
     // Codegen the body.
     body_bcx_out = trans_block(body_bcx_out, body, expr::Ignore);
     body_bcx_out =