---

yaml
---
r: 282012
b: refs/heads/stable
c: 77f3484
h: refs/heads/master

Author: eddyb

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 3c795e08d6f4a532f12f3f8e1837db5e0647f8b0
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: de5f8244f20e434d2e0d351c7f4b55e604b4f3b3
+refs/heads/stable: 77f34841489767804ffe3d0f20d5469ecc5cf417
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/librustc_llvm/lib.rs

@@ -212,21 +212,21 @@ impl Attributes {
         self
     }
 
-    pub fn apply_llfn(&self, idx: c_uint, llfn: ValueRef) {
+    pub fn apply_llfn(&self, idx: usize, llfn: ValueRef) {
         unsafe {
-            LLVMAddFunctionAttribute(llfn, idx, self.regular.bits());
+            LLVMAddFunctionAttribute(llfn, idx as c_uint, self.regular.bits());
             if self.dereferenceable_bytes != 0 {
-                LLVMAddDereferenceableAttr(llfn, idx,
+                LLVMAddDereferenceableAttr(llfn, idx as c_uint,
                                            self.dereferenceable_bytes);
             }
         }
     }
 
-    pub fn apply_callsite(&self, idx: c_uint, callsite: ValueRef) {
+    pub fn apply_callsite(&self, idx: usize, callsite: ValueRef) {
         unsafe {
-            LLVMAddCallSiteAttribute(callsite, idx, self.regular.bits());
+            LLVMAddCallSiteAttribute(callsite, idx as c_uint, self.regular.bits());
             if self.dereferenceable_bytes != 0 {
-                LLVMAddDereferenceableCallSiteAttr(callsite, idx,
+                LLVMAddDereferenceableCallSiteAttr(callsite, idx as c_uint,
                                                    self.dereferenceable_bytes);
             }
         }
@@ -240,49 +240,6 @@ pub enum AttributeSet {
     FunctionIndex = !0
 }
 
-pub struct AttrBuilder {
-    attrs: Vec<(usize, Attributes)>
-}
-
-impl AttrBuilder {
-    pub fn new() -> AttrBuilder {
-        AttrBuilder {
-            attrs: Vec::new()
-        }
-    }
-
-    pub fn arg(&mut self, idx: usize) -> &mut Attributes {
-        let mut found = None;
-        for (i, &(idx2, _)) in self.attrs.iter().enumerate() {
-            if idx == idx2 {
-                found = Some(i);
-                break;
-            }
-        }
-        let i = found.unwrap_or_else(|| {
-            self.attrs.push((idx, Attributes::default()));
-            self.attrs.len() - 1
-        });
-        &mut self.attrs[i].1
-    }
-
-    pub fn ret(&mut self) -> &mut Attributes {
-        self.arg(ReturnIndex as usize)
-    }
-
-    pub fn apply_llfn(&self, llfn: ValueRef) {
-        for &(idx, ref attr) in &self.attrs {
-            attr.apply_llfn(idx as c_uint, llfn);
-        }
-    }
-
-    pub fn apply_callsite(&self, callsite: ValueRef) {
-        for &(idx, ref attr) in &self.attrs {
-            attr.apply_callsite(idx as c_uint, callsite);
-        }
-    }
-}
-
 // enum for the LLVM IntPredicate type
 #[derive(Copy, Clone)]
 pub enum IntPredicate {

branches/stable/src/librustc_trans/trans/abi.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use llvm;
+use llvm::{self, ValueRef};
 use trans::common::{return_type_is_void, type_is_fat_ptr};
 use trans::context::CrateContext;
 use trans::cabi_x86;
@@ -24,6 +24,7 @@ use trans::machine::{llsize_of_alloc, llsize_of_real};
 use trans::type_::Type;
 use trans::type_of;
 
+use rustc_front::hir;
 use middle::ty::{self, Ty};
 
 pub use syntax::abi::Abi;
@@ -204,22 +205,102 @@ impl FnType {
             }
         };
 
-        let ret = match sig.output {
+        let mut ret = match sig.output {
             ty::FnConverging(ret_ty) if !return_type_is_void(ccx, ret_ty) => {
                 arg_of(ret_ty)
             }
             _ => ArgType::new(Type::void(ccx), Type::void(ccx))
         };
 
+        if let ty::FnConverging(ret_ty) = sig.output {
+            if !type_is_fat_ptr(ccx.tcx(), ret_ty) {
+                // The `noalias` attribute on the return value is useful to a
+                // function ptr caller.
+                if let ty::TyBox(_) = ret_ty.sty {
+                    // `Box` pointer return values never alias because ownership
+                    // is transferred
+                    ret.attrs.set(llvm::Attribute::NoAlias);
+                }
+
+                // We can also mark the return value as `dereferenceable` in certain cases
+                match ret_ty.sty {
+                    // These are not really pointers but pairs, (pointer, len)
+                    ty::TyRef(_, ty::TypeAndMut { ty, .. }) |
+                    ty::TyBox(ty) => {
+                        let llty = type_of::sizing_type_of(ccx, ty);
+                        let llsz = llsize_of_real(ccx, llty);
+                        ret.attrs.set_dereferenceable(llsz);
+                    }
+                    _ => {}
+                }
+            }
+        }
+
         let mut args = Vec::with_capacity(inputs.len() + extra_args.len());
+
+        // Handle safe Rust thin and fat pointers.
+        let rust_ptr_attrs = |ty: Ty<'tcx>, arg: &mut ArgType| match ty.sty {
+            // `Box` pointer parameters never alias because ownership is transferred
+            ty::TyBox(inner) => {
+                arg.attrs.set(llvm::Attribute::NoAlias);
+                Some(inner)
+            }
+
+            ty::TyRef(b, mt) => {
+                use middle::ty::{BrAnon, ReLateBound};
+
+                // `&mut` pointer parameters never alias other parameters, or mutable global data
+                //
+                // `&T` where `T` contains no `UnsafeCell<U>` is immutable, and can be marked as
+                // both `readonly` and `noalias`, as LLVM's definition of `noalias` is based solely
+                // on memory dependencies rather than pointer equality
+                let interior_unsafe = mt.ty.type_contents(ccx.tcx()).interior_unsafe();
+
+                if mt.mutbl != hir::MutMutable && !interior_unsafe {
+                    arg.attrs.set(llvm::Attribute::NoAlias);
+                }
+
+                if mt.mutbl == hir::MutImmutable && !interior_unsafe {
+                    arg.attrs.set(llvm::Attribute::ReadOnly);
+                }
+
+                // When a reference in an argument has no named lifetime, it's
+                // impossible for that reference to escape this function
+                // (returned or stored beyond the call by a closure).
+                if let ReLateBound(_, BrAnon(_)) = *b {
+                    arg.attrs.set(llvm::Attribute::NoCapture);
+                }
+
+                Some(mt.ty)
+            }
+            _ => None
+        };
+
         for ty in inputs.iter().chain(extra_args.iter()) {
-            let arg = arg_of(ty);
+            let mut arg = arg_of(ty);
+
             if type_is_fat_ptr(ccx.tcx(), ty) {
-                let original = arg.original_ty.field_types();
-                let sizing = arg.ty.field_types();
-                args.extend(original.into_iter().zip(sizing)
-                                    .map(|(o, s)| ArgType::new(o, s)));
+                let original_tys = arg.original_ty.field_types();
+                let sizing_tys = arg.ty.field_types();
+                assert_eq!((original_tys.len(), sizing_tys.len()), (2, 2));
+
+                let mut data = ArgType::new(original_tys[0], sizing_tys[0]);
+                let mut info = ArgType::new(original_tys[1], sizing_tys[1]);
+
+                if let Some(inner) = rust_ptr_attrs(ty, &mut data) {
+                    data.attrs.set(llvm::Attribute::NonNull);
+                    if ccx.tcx().struct_tail(inner).is_trait() {
+                        info.attrs.set(llvm::Attribute::NonNull);
+                    }
+                }
+                args.push(data);
+                args.push(info);
             } else {
+                if let Some(inner) = rust_ptr_attrs(ty, &mut arg) {
+                    let llty = type_of::sizing_type_of(ccx, inner);
+                    let llsz = llsize_of_real(ccx, llty);
+                    arg.attrs.set_dereferenceable(llsz);
+                }
                 args.push(arg);
             }
         }
@@ -327,18 +408,29 @@ impl FnType {
         }
     }
 
-    pub fn llvm_attrs(&self) -> llvm::AttrBuilder {
-        let mut attrs = llvm::AttrBuilder::new();
+    pub fn apply_attrs_llfn(&self, llfn: ValueRef) {
+        let mut i = if self.ret.is_indirect() { 1 } else { 0 };
+        self.ret.attrs.apply_llfn(i, llfn);
+        i += 1;
+        for arg in &self.args {
+            if !arg.is_ignore() {
+                if arg.pad.is_some() { i += 1; }
+                arg.attrs.apply_llfn(i, llfn);
+                i += 1;
+            }
+        }
+    }
+
+    pub fn apply_attrs_callsite(&self, callsite: ValueRef) {
         let mut i = if self.ret.is_indirect() { 1 } else { 0 };
-        *attrs.arg(i) = self.ret.attrs;
+        self.ret.attrs.apply_callsite(i, callsite);
         i += 1;
         for arg in &self.args {
             if !arg.is_ignore() {
                 if arg.pad.is_some() { i += 1; }
-                *attrs.arg(i) = arg.attrs;
+                arg.attrs.apply_callsite(i, callsite);
                 i += 1;
             }
         }
-        attrs
     }
 }