---

yaml
---
r: 83185
b: refs/heads/auto
c: 0e4d1fc
h: refs/heads/master
i:
  83183: 6ae3eed
v: v3

Author: bors

[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: 7ab0b0cd41fc4bf567694ebedb2d927da9bf2551
+refs/heads/auto: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/middle/borrowck/check_loans.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -839,11 +839,6 @@ fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>,
                         expr.span,
                         []);
       }
-      ast::ExprInlineAsm(ref ia) => {
-          for &(_, out) in ia.outputs.iter() {
-              this.check_assignment(out);
-          }
-      }
       _ => { }
     }
 }

branches/auto/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -309,23 +309,6 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
           visit::walk_expr(this, ex, ());
       }
 
-      ast::ExprInlineAsm(ref ia) => {
-          for &(_, out) in ia.outputs.iter() {
-              let out_cmt = this.bccx.cat_expr(out);
-              match opt_loan_path(out_cmt) {
-                  Some(out_lp) => {
-                      gather_moves::gather_assignment(this.bccx, this.move_data,
-                                                      ex.id, ex.span,
-                                                      out_lp, out.id);
-                  }
-                  None => {
-                      // See the comment for ExprAssign.
-                  }
-              }
-          }
-          visit::walk_expr(this, ex, ());
-      }
-
       _ => {
           visit::walk_expr(this, ex, ());
       }

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

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -1227,15 +1227,12 @@ impl Liveness {
             self.propagate_through_expr(e, succ)
           }
 
-          ExprInlineAsm(ref ia) => {
+          ExprInlineAsm(ref ia) =>{
             let succ = do ia.inputs.rev_iter().fold(succ) |succ, &(_, expr)| {
                 self.propagate_through_expr(expr, succ)
             };
             do ia.outputs.rev_iter().fold(succ) |succ, &(_, expr)| {
-                // see comment on lvalues in
-                // propagate_through_lvalue_components()
-                let succ = self.write_lvalue(expr, succ, ACC_WRITE);
-                self.propagate_through_lvalue_components(expr, succ)
+                self.propagate_through_expr(expr, succ)
             }
           }
 
@@ -1481,7 +1478,12 @@ fn check_expr(this: &mut Liveness, expr: @Expr) {
 
         // Output operands must be lvalues
         for &(_, out) in ia.outputs.iter() {
-          this.check_lvalue(out);
+          match out.node {
+            ExprAddrOf(_, inner) => {
+              this.check_lvalue(inner);
+            }
+            _ => {}
+          }
           this.visit_expr(out, ());
         }
 

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

@@ -18,8 +18,6 @@ use lib;
 use middle::trans::build::*;
 use middle::trans::callee;
 use middle::trans::common::*;
-use middle::trans::expr::*;
-use middle::trans::type_of::*;
 use middle::ty;
 
 use middle::trans::type_::Type;
@@ -32,15 +30,34 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
     let mut bcx = bcx;
     let mut constraints = ~[];
     let mut cleanups = ~[];
-    let mut output_types = ~[];
+    let mut aoutputs = ~[];
 
     // Prepare the output operands
     let outputs = do ia.outputs.map |&(c, out)| {
         constraints.push(c);
 
-        let out_datum = unpack_datum!(bcx, trans_to_datum(bcx, out));
-        output_types.push(type_of(bcx.ccx(), out_datum.ty));
-        out_datum.val
+        aoutputs.push(unpack_result!(bcx, {
+            callee::trans_arg_expr(bcx,
+                                   expr_ty(bcx, out),
+                                   ty::ByCopy,
+                                   out,
+                                   &mut cleanups,
+                                   callee::DontAutorefArg)
+        }));
+
+        let e = match out.node {
+            ast::ExprAddrOf(_, e) => e,
+            _ => fail2!("Expression must be addr of")
+        };
+
+        unpack_result!(bcx, {
+            callee::trans_arg_expr(bcx,
+                                   expr_ty(bcx, e),
+                                   ty::ByCopy,
+                                   e,
+                                   &mut cleanups,
+                                   callee::DontAutorefArg)
+        })
 
     };
 
@@ -75,7 +92,7 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
         clobbers = format!("{},{}", ia.clobbers, clobbers);
     } else {
         clobbers.push_str(ia.clobbers);
-    }
+    };
 
     // Add the clobbers to our constraints list
     if clobbers.len() != 0 && constraints.len() != 0 {
@@ -90,12 +107,12 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
     let numOutputs = outputs.len();
 
     // Depending on how many outputs we have, the return type is different
-    let output_type = if numOutputs == 0 {
+    let output = if numOutputs == 0 {
         Type::void()
     } else if numOutputs == 1 {
-        output_types[0]
+        val_ty(outputs[0])
     } else {
-        Type::struct_(output_types, false)
+        Type::struct_(outputs.map(|o| val_ty(*o)), false)
     };
 
     let dialect = match ia.dialect {
@@ -105,17 +122,19 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
 
     let r = do ia.asm.with_c_str |a| {
         do constraints.with_c_str |c| {
-            InlineAsmCall(bcx, a, c, inputs, output_type, ia.volatile, ia.alignstack, dialect)
+            InlineAsmCall(bcx, a, c, inputs, output, ia.volatile, ia.alignstack, dialect)
         }
     };
 
     // Again, based on how many outputs we have
     if numOutputs == 1 {
-        Store(bcx, r, outputs[0]);
+        let op = PointerCast(bcx, aoutputs[0], val_ty(outputs[0]).ptr_to());
+        Store(bcx, r, op);
     } else {
-        for (i, o) in outputs.iter().enumerate() {
+        for (i, o) in aoutputs.iter().enumerate() {
             let v = ExtractValue(bcx, r, i);
-            Store(bcx, v, *o);
+            let op = PointerCast(bcx, *o, val_ty(outputs[i]).ptr_to());
+            Store(bcx, v, op);
         }
     }
 

branches/auto/src/libstd/managed.rs

@@ -17,6 +17,13 @@ use ptr::to_unsafe_ptr;
 pub static RC_MANAGED_UNIQUE : uint = (-2) as uint;
 pub static RC_IMMORTAL : uint = 0x77777777;
 
+/// Returns the refcount of a shared box (as just before calling this)
+#[inline]
+pub fn refcount<T>(t: @T) -> uint {
+    use unstable::raw::Repr;
+    unsafe { (*t.repr()).ref_count }
+}
+
 /// Determine if two shared boxes point to the same object
 #[inline]
 pub fn ptr_eq<T>(a: @T, b: @T) -> bool {

branches/auto/src/libstd/sys.rs

@@ -13,22 +13,12 @@
 #[allow(missing_doc)];
 
 use c_str::ToCStr;
-use cast;
 use libc::size_t;
 use libc;
 use repr;
 use rt::task;
 use str;
 
-/// Returns the refcount of a shared box (as just before calling this)
-#[inline]
-pub fn refcount<T>(t: @T) -> uint {
-    unsafe {
-        let ref_ptr: *uint = cast::transmute_copy(&t);
-        *ref_ptr - 1
-    }
-}
-
 pub fn log_str<T>(t: &T) -> ~str {
     use rt::io;
     use rt::io::Decorator;

branches/auto/src/libsyntax/ext/asm.rs

@@ -75,18 +75,16 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
                     }
 
                     let (constraint, _str_style) = p.parse_str();
-
-                    if constraint.starts_with("+") {
-                        cx.span_unimpl(*p.last_span,
-                                       "'+' (read+write) output operand constraint modifier");
-                    } else if !constraint.starts_with("=") {
-                        cx.span_err(*p.last_span, "output operand constraint lacks '='");
-                    }
-
                     p.expect(&token::LPAREN);
                     let out = p.parse_expr();
                     p.expect(&token::RPAREN);
 
+                    let out = @ast::Expr {
+                        id: ast::DUMMY_NODE_ID,
+                        span: out.span,
+                        node: ast::ExprAddrOf(ast::MutMutable, out)
+                    };
+
                     outputs.push((constraint, out));
                 }
             }
@@ -100,13 +98,6 @@ pub fn expand_asm(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
                     }
 
                     let (constraint, _str_style) = p.parse_str();
-
-                    if constraint.starts_with("=") {
-                        cx.span_err(*p.last_span, "input operand constraint contains '='");
-                    } else if constraint.starts_with("+") {
-                        cx.span_err(*p.last_span, "input operand constraint contains '+'");
-                    }
-
                     p.expect(&token::LPAREN);
                     let input = p.parse_expr();
                     p.expect(&token::RPAREN);