---

yaml
---
r: 50387
b: refs/heads/auto
c: dd088af
h: refs/heads/master
i:
  50385: 3255fcd
  50383: cc6451b
v: v3

Author: brson

[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: 777ad8b20452d94111f9c834d0f277575a564ca3
+refs/heads/auto: dd088afd4323cbaad3c6e3692e7d52658d1f2de6
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/configure

@@ -881,6 +881,10 @@ do
                 ;;
         esac
         need_ok "LLVM configure failed"
+
+        # Hack the tools Makefile to turn off the clang build
+        sed -i 's/clang//g' tools/Makefile
+
         cd $CFG_BUILD_DIR
     fi
 

branches/auto/doc/tutorial.md

@@ -875,7 +875,8 @@ the compiler that unsafety does not leak outside of the unsafe block, and is
 used to create safe concepts on top of low-level code.
 
 ~~~~
-use core::libc::{calloc, free, size_t};
+use core::libc::funcs::c95::stdlib::{calloc, free};
+use core::libc::types::os::arch::c95::size_t;
 
 fn main() {
     unsafe {
@@ -908,7 +909,9 @@ The unsafe code from above can be contained behind a safe API that prevents
 memory leaks or use-after-free:
 
 ~~~~
-use core::libc::{calloc, free, c_void, size_t};
+use core::libc::funcs::c95::stdlib::{calloc, free};
+use core::libc::types::common::c95::c_void;
+use core::libc::types::os::arch::c95::size_t;
 
 struct Blob { priv ptr: *c_void }
 
@@ -982,9 +985,7 @@ when it is collected.
 
 If an object doesn't contain garbage-collected boxes, it consists of a single
 ownership tree and is given the `Owned` trait which allows it to be sent
-between tasks. Custom destructors can only be implemented directly on types
-that are `Owned`, but garbage-collected boxes can still *contain* types with
-custom destructors.
+between tasks.
 
 # Boxes
 
@@ -1035,10 +1036,10 @@ let z = x; // no new memory allocated, x can no longer be used
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with
-owned boxes, where the holder of an owned box is the owner of the pointed-to
-memory, borrowed pointers never imply ownership. A pointer can be borrowed to
-any object, and the compiler verifies that it cannot outlive the lifetime of
-the object.
+owned pointers, where the holder of an owned pointer is the owner of the
+pointed-to memory, borrowed pointers never imply ownership. A pointer can be
+borrowed to any object, and the compiler verifies that it cannot outlive the
+lifetime of the object.
 
 As an example, consider a simple struct type, `Point`:
 

branches/auto/src/libcore/unstable/lang.rs

@@ -64,7 +64,6 @@ pub unsafe fn fail_borrowed() {
 
 // FIXME #4942: Make these signatures agree with exchange_alloc's signatures
 #[lang="exchange_malloc"]
-#[inline(always)]
 pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     transmute(exchange_alloc::malloc(transmute(td), transmute(size)))
 }
@@ -73,13 +72,11 @@ pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[lang="exchange_free"]
-#[inline(always)]
 pub unsafe fn exchange_free(ptr: *c_char) {
     exchange_alloc::free(transmute(ptr))
 }
 
 #[lang="malloc"]
-#[inline(always)]
 pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_malloc(td, size);
 }
@@ -88,7 +85,6 @@ pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
 #[lang="free"]
-#[inline(always)]
 pub unsafe fn local_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);
 }
@@ -121,7 +117,6 @@ pub unsafe fn check_not_borrowed(a: *u8) {
 }
 
 #[lang="strdup_uniq"]
-#[inline(always)]
 pub unsafe fn strdup_uniq(ptr: *c_uchar, len: uint) -> ~str {
     str::raw::from_buf_len(ptr, len)
 }

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

@@ -1306,11 +1306,11 @@ pub impl Liveness {
             self.propagate_through_expr(e, succ)
           }
 
-          expr_inline_asm(ref ia) =>{
-            let succ = do ia.inputs.foldr(succ) |&(_, expr), succ| {
+          expr_inline_asm(_, ref ins, ref outs, _, _, _) =>{
+            let succ = do ins.foldr(succ) |&(_, expr), succ| {
                 self.propagate_through_expr(expr, succ)
             };
-            do ia.outputs.foldr(succ) |&(_, expr), succ| {
+            do outs.foldr(succ) |&(_, expr), succ| {
                 self.propagate_through_expr(expr, succ)
             }
           }
@@ -1580,19 +1580,14 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
         visit::visit_expr(expr, self, vt);
       }
 
-      expr_inline_asm(ref ia) => {
-        for ia.inputs.each |&(_, in)| {
+      expr_inline_asm(_, ref ins, ref outs, _, _, _) => {
+        for ins.each |&(_, in)| {
           (vt.visit_expr)(in, self, vt);
         }
 
         // Output operands must be lvalues
-        for ia.outputs.each |&(_, out)| {
-          match out.node {
-            expr_addr_of(_, inner) => {
-              self.check_lvalue(inner, vt);
-            }
-            _ => {}
-          }
+        for outs.each |&(_, out)| {
+          self.check_lvalue(out, vt);
           (vt.visit_expr)(out, self, vt);
         }
 

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

@@ -11,8 +11,7 @@
 use core::prelude::*;
 
 use back::abi;
-use lib::llvm::{llvm, SetLinkage, InternalLinkage, PrivateLinkage,
-                ValueRef, TypeRef, Bool, True, False};
+use lib::llvm::{llvm, ValueRef, TypeRef, Bool, True, False};
 use metadata::csearch;
 use middle::const_eval;
 use middle::trans::adt;
@@ -105,7 +104,6 @@ fn const_addr_of(cx: @CrateContext, cv: ValueRef) -> ValueRef {
         };
         llvm::LLVMSetInitializer(gv, cv);
         llvm::LLVMSetGlobalConstant(gv, True);
-        SetLinkage(gv, PrivateLinkage);
         gv
     }
 }
@@ -485,7 +483,6 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                 };
                 llvm::LLVMSetInitializer(gv, cv);
                 llvm::LLVMSetGlobalConstant(gv, True);
-                SetLinkage(gv, PrivateLinkage);
                 let p = const_ptrcast(cx, gv, llunitty);
                 C_struct(~[p, sz])
               }