---

yaml
---
r: 117877
b: refs/heads/auto
c: bccdba0
h: refs/heads/master
i:
  117875: ddf7b41
v: v3

Author: SimonSapin

[refs]

@@ -13,7 +13,7 @@ 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: 5c81a186e9d835ca66865bd9807524b805a06d8d
+refs/heads/auto: bccdba02960b3cd428addbc2c856065ebb81eb04
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/rust.md

@@ -1829,6 +1829,8 @@ type int8_t = i8;
 
 ### Static-only attributes
 
+- `address_insignificant` - references to this static may alias with
+  references to other statics, potentially of unrelated type.
 - `thread_local` - on a `static mut`, this signals that the value of this
   static may change depending on the current thread. The exact consequences of
   this are implementation-defined.
@@ -2139,22 +2141,13 @@ These types help drive the compiler's analysis
 ### Inline attributes
 
 The inline attribute is used to suggest to the compiler to perform an inline
-expansion and place a copy of the function or static in the caller rather than
-generating code to call the function or access the static where it is defined.
+expansion and place a copy of the function in the caller rather than generating
+code to call the function where it is defined.
 
 The compiler automatically inlines functions based on internal heuristics.
 Incorrectly inlining functions can actually making the program slower, so it
 should be used with care.
 
-Immutable statics are always considered inlineable
-unless marked with `#[inline(never)]`.
-It is undefined
-whether two different inlineable statics
-have the same memory address.
-In other words,
-the compiler is free
-to collapse duplicate inlineable statics together.
-
 `#[inline]` and `#[inline(always)]` always causes the function to be serialized
 into crate metadata to allow cross-crate inlining.
 

branches/auto/src/librustc/metadata/tydecode.rs

@@ -346,9 +346,10 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         assert_eq!(next(st), '[');
         let def = parse_def(st, NominalType, |x,y| conv(x,y));
         let substs = parse_substs(st, |x,y| conv(x,y));
+        let store = parse_trait_store(st, |x,y| conv(x,y));
         let bounds = parse_bounds(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
-        return ty::mk_trait(st.tcx, def, substs, bounds.builtin_bounds);
+        return ty::mk_trait(st.tcx, def, substs, store, bounds.builtin_bounds);
       }
       'p' => {
         let did = parse_def(st, TypeParameter, |x,y| conv(x,y));

branches/auto/src/librustc/metadata/tyencode.rs

@@ -232,10 +232,12 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
         ty::ty_trait(box ty::TyTrait {
                 def_id,
                 ref substs,
+                store,
                 bounds
             }) => {
             mywrite!(w, "x[{}|", (cx.ds)(def_id));
             enc_substs(w, cx, substs);
+            enc_trait_store(w, cx, store);
             let bounds = ty::ParamBounds {builtin_bounds: bounds,
                                           trait_bounds: Vec::new()};
             enc_bounds(w, cx, &bounds);

branches/auto/src/librustc/middle/const_eval.rs

@@ -506,6 +506,7 @@ pub fn lit_to_const(lit: &Lit) -> const_val {
         LitBinary(ref data) => {
             const_binary(Rc::new(data.iter().map(|x| *x).collect()))
         }
+        LitByte(n) => const_uint(n as u64),
         LitChar(n) => const_uint(n as u64),
         LitInt(n, _) => const_int(n),
         LitUint(n, _) => const_uint(n),

branches/auto/src/librustc/middle/kind.rs

@@ -361,12 +361,9 @@ fn check_bounds_on_type_parameters(cx: &mut Context, e: &Expr) {
 fn check_trait_cast(cx: &mut Context, source_ty: ty::t, target_ty: ty::t, span: Span) {
     check_cast_for_escaping_regions(cx, source_ty, target_ty, span);
     match ty::get(target_ty).sty {
-        ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ ty, .. }) => match ty::get(ty).sty {
-            ty::ty_trait(box ty::TyTrait { bounds, .. }) => {
-                check_trait_cast_bounds(cx, span, source_ty, bounds);
-            }
-            _ => {}
-        },
+        ty::ty_trait(box ty::TyTrait { bounds, .. }) => {
+            check_trait_cast_bounds(cx, span, source_ty, bounds);
+        }
         _ => {}
     }
 }
@@ -533,8 +530,9 @@ pub fn check_cast_for_escaping_regions(
 {
     // Determine what type we are casting to; if it is not a trait, then no
     // worries.
-    if !ty::type_is_trait(target_ty) {
-        return;
+    match ty::get(target_ty).sty {
+        ty::ty_trait(..) => {}
+        _ => { return; }
     }
 
     // Collect up the regions that appear in the target type.  We want to

branches/auto/src/librustc/middle/lint.rs

@@ -805,6 +805,7 @@ fn check_type_limits(cx: &Context, e: &ast::Expr) {
                     } else { t };
                     let (min, max) = uint_ty_range(uint_type);
                     let lit_val: u64 = match lit.node {
+                        ast::LitByte(_v) => return,  // _v is u8, within range by definition
                         ast::LitInt(v, _) => v as u64,
                         ast::LitUint(v, _) => v,
                         ast::LitIntUnsuffixed(v) => v as u64,
@@ -980,6 +981,9 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
                     n_box += 1;
                 }
                 ty::ty_uniq(_) |
+                ty::ty_trait(box ty::TyTrait {
+                    store: ty::UniqTraitStore, ..
+                }) |
                 ty::ty_closure(box ty::ClosureTy {
                     store: ty::UniqTraitStore,
                     ..
@@ -1084,6 +1088,7 @@ fn check_unused_attribute(cx: &Context, attr: &ast::Attribute) {
 
         // FIXME: #14406 these are processed in trans, which happens after the
         // lint pass
+        "address_insignificant",
         "cold",
         "inline",
         "link",

branches/auto/src/librustc/middle/mem_categorization.rs

@@ -174,6 +174,7 @@ pub enum deref_kind {
 pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
     match ty::get(t).sty {
         ty::ty_uniq(_) |
+        ty::ty_trait(box ty::TyTrait { store: ty::UniqTraitStore, .. }) |
         ty::ty_closure(box ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
             Some(deref_ptr(OwnedPtr))
         }
@@ -182,6 +183,13 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             let kind = ty::BorrowKind::from_mutbl(mt.mutbl);
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }
+        ty::ty_trait(box ty::TyTrait {
+                store: ty::RegionTraitStore(r, mutbl),
+                ..
+            }) => {
+            let kind = ty::BorrowKind::from_mutbl(mutbl);
+            Some(deref_ptr(BorrowedPtr(kind, r)))
+        }
 
         ty::ty_closure(box ty::ClosureTy {
                 store: ty::RegionTraitStore(r, _),

branches/auto/src/librustc/middle/reachable.rs

@@ -26,20 +26,15 @@ use std::collections::HashSet;
 use syntax::abi;
 use syntax::ast;
 use syntax::ast_map;
-use syntax::ast_util::is_local;
-use syntax::ast_util;
-use syntax::attr::{InlineAlways, InlineHint, InlineNever, InlineNone};
+use syntax::ast_util::{is_local};
 use syntax::attr;
 use syntax::visit::Visitor;
 use syntax::visit;
 
 // Returns true if the given set of attributes contains the `#[inline]`
 // attribute.
 fn attributes_specify_inlining(attrs: &[ast::Attribute]) -> bool {
-    match attr::find_inline_attr(attrs) {
-        InlineNone | InlineNever => false,
-        InlineAlways | InlineHint => true,
-    }
+    attr::contains_name(attrs, "inline")
 }
 
 // Returns true if the given set of generics implies that the item it's
@@ -123,8 +118,8 @@ impl<'a> Visitor<()> for ReachableContext<'a> {
                         match def {
                             // If this path leads to a static, then we may have
                             // to do some work to figure out whether the static
-                            // is indeed reachable. (Inlineable statics are
-                            // never reachable.)
+                            // is indeed reachable (address_insignificant
+                            // statics are *never* reachable).
                             def::DefStatic(..) => {
                                 self.worklist.push(def_id.node);
                             }
@@ -286,10 +281,9 @@ impl<'a> ReachableContext<'a> {
 
                     // Statics with insignificant addresses are not reachable
                     // because they're inlined specially into all other crates.
-                    ast::ItemStatic(_, mutbl, ref init) => {
-                        if !ast_util::static_has_significant_address(
-                                mutbl,
-                                item.attrs.as_slice()) {
+                    ast::ItemStatic(_, _, ref init) => {
+                        if attr::contains_name(item.attrs.as_slice(),
+                                               "address_insignificant") {
                             self.reachable_symbols.remove(&search_item);
                         }
                         visit::walk_expr(self, &**init, ());

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

@@ -292,11 +292,12 @@ impl Case {
     fn find_ptr(&self) -> Option<uint> {
         self.tys.iter().position(|&ty| {
             match ty::get(ty).sty {
-                ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
-                    ty::ty_vec(_, None) | ty::ty_str| ty::ty_trait(..) => false,
+                ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
+                    ty::ty_vec(_, None) | ty::ty_str => false,
                     _ => true,
                 },
-                ty::ty_box(..) | ty::ty_bare_fn(..) => true,
+                ty::ty_uniq(..) | ty::ty_box(..) |
+                ty::ty_bare_fn(..) => true,
                 // Is that everything?  Would closures or slices qualify?
                 _ => false
             }

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

@@ -1794,9 +1794,6 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t) -> Vec<(uint, u6
         match ty::get(ret_ty).sty {
             // `~` pointer return values never alias because ownership
             // is transferred
-            ty::ty_uniq(it)  if match ty::get(it).sty {
-                ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
-            } => {}
             ty::ty_uniq(_) => {
                 attrs.push((lib::llvm::ReturnIndex as uint, lib::llvm::NoAliasAttribute as u64));
             }
@@ -1806,9 +1803,9 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t) -> Vec<(uint, u6
         // We can also mark the return value as `nonnull` in certain cases
         match ty::get(ret_ty).sty {
             // These are not really pointers but pairs, (pointer, len)
-            ty::ty_uniq(it) |
+            ty::ty_rptr(_, ty::mt { ty: it, .. }) |
             ty::ty_rptr(_, ty::mt { ty: it, .. }) if match ty::get(it).sty {
-                ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
+                ty::ty_str | ty::ty_vec(..) => true, _ => false
             } => {}
             ty::ty_uniq(_) | ty::ty_rptr(_, _) => {
                 attrs.push((lib::llvm::ReturnIndex as uint, lib::llvm::NonNullAttribute as u64));
@@ -1997,7 +1994,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
             let sym = exported_name(ccx, id, ty, i.attrs.as_slice());
 
             let v = match i.node {
-                ast::ItemStatic(_, mutbl, ref expr) => {
+                ast::ItemStatic(_, _, ref expr) => {
                     // If this static came from an external crate, then
                     // we need to get the symbol from csearch instead of
                     // using the current crate's name/version
@@ -2032,24 +2029,28 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
 
                         // Apply the `unnamed_addr` attribute if
                         // requested
-                        if !ast_util::static_has_significant_address(
-                                mutbl,
-                                i.attrs.as_slice()) {
+                        if attr::contains_name(i.attrs.as_slice(),
+                                               "address_insignificant") {
+                            if ccx.reachable.contains(&id) {
+                                ccx.sess().span_bug(i.span,
+                                    "insignificant static is reachable");
+                            }
                             lib::llvm::SetUnnamedAddr(g, true);
 
                             // This is a curious case where we must make
                             // all of these statics inlineable. If a
-                            // global is not tagged as `#[inline(never)]`,
-                            // then LLVM won't coalesce globals unless they
-                            // have an internal linkage type. This means that
+                            // global is tagged as
+                            // address_insignificant, then LLVM won't
+                            // coalesce globals unless they have an
+                            // internal linkage type. This means that
                             // external crates cannot use this global.
                             // This is a problem for things like inner
                             // statics in generic functions, because the
                             // function will be inlined into another
                             // crate and then attempt to link to the
                             // static in the original crate, only to
                             // find that it's not there. On the other
-                            // side of inlining, the crates knows to
+                            // side of inlininig, the crates knows to
                             // not declare this static as
                             // available_externally (because it isn't)
                             inlineable = true;

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

@@ -67,7 +67,7 @@ pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool {
         ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
         type_is_newtype_immediate(ccx, ty) || ty::type_is_bot(ty) ||
         ty::type_is_simd(tcx, ty);
-    if simple && !ty::type_is_trait(ty) {
+    if simple {
         return true;
     }
     match ty::get(ty).sty {

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

@@ -43,6 +43,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit)
     -> ValueRef {
     let _icx = push_ctxt("trans_lit");
     match lit.node {
+        ast::LitByte(b) => C_integral(Type::uint_from_ty(cx, ast::TyU8), b as u64, false),
         ast::LitChar(i) => C_integral(Type::char(cx), i as u64, false),
         ast::LitInt(i, t) => C_integral(Type::int_from_ty(cx, t), i as u64, true),
         ast::LitUint(u, t) => C_integral(Type::uint_from_ty(cx, t), u, false),
@@ -143,9 +144,7 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
             let dv = match ty::get(t).sty {
                 ty::ty_ptr(mt) | ty::ty_rptr(_, mt) => {
                     match ty::get(mt.ty).sty {
-                        ty::ty_vec(_, None) | ty::ty_str | ty::ty_trait(..) => {
-                            cx.sess().bug("unexpected unsized type")
-                        }
+                        ty::ty_vec(_, None) | ty::ty_str => cx.sess().bug("unexpected slice"),
                         _ => const_deref_ptr(cx, v),
                     }
                 }

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

@@ -157,7 +157,9 @@ pub fn appropriate_rvalue_mode(ccx: &CrateContext, ty: ty::t) -> RvalueMode {
      * on whether type is immediate or not.
      */
 
-    if type_is_immediate(ccx, ty) {
+    if type_is_zero_size(ccx, ty) {
+        ByValue
+    } else if type_is_immediate(ccx, ty) {
         ByValue
     } else {
         ByRef