---

yaml
---
r: 50356
b: refs/heads/auto
c: bdf81e1
h: refs/heads/master
v: v3

Author: erickt

[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: ae7e072af756ce256826370ec16f7d51ce1bed86
+refs/heads/auto: bdf81e11841da74277e873b9f3ef5bc2105700be
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/RELEASES.txt

@@ -1,4 +1,4 @@
-Version 0.6 (March 2013)
+Version 0.6 (April 2013)
 ---------------------------
 
    * ~2100 changes, numerous bugfixes

branches/auto/src/libcore/str.rs

@@ -726,7 +726,8 @@ pub fn each_split_within<'a>(ss: &'a str,
 
             (B, Cr, UnderLim) => { B }
             (B, Cr, OverLim)  if (i - last_start + 1) > lim
-                              => { fail!(~"word longer than limit!") }
+                              => fail!(fmt!("word starting with %? longer than limit!",
+                                            self::slice(ss, last_start, i + 1))),
             (B, Cr, OverLim)  => { slice(); slice_start = last_start; B }
             (B, Ws, UnderLim) => { last_end = i; C }
             (B, Ws, OverLim)  => { last_end = i; slice(); A }

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

@@ -64,6 +64,7 @@ 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)))
 }
@@ -72,11 +73,13 @@ 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);
 }
@@ -85,6 +88,7 @@ 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);
 }
@@ -117,6 +121,7 @@ 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/driver/driver.rs

@@ -762,8 +762,7 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
   optflag(~"", ~"test", ~"Build a test harness"),
   optopt(~"", ~"target",
                         ~"Target triple cpu-manufacturer-kernel[-os]
-                          to compile for (see
-         http://sources.redhat.com/autobook/autobook/autobook_17.html
+                          to compile for (see chapter 3.4 of http://www.sourceware.org/autobook/
                           for detail)", ~"TRIPLE"),
   optopt(~"", ~"android-cross-path",
          ~"The path to the Android NDK", "PATH"),

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

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

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

@@ -0,0 +1,154 @@
+// 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.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+# Translation of inline assembly.
+*/
+
+use core::prelude::*;
+
+use lib;
+use middle::trans::build::*;
+use middle::trans::callee;
+use middle::trans::common::*;
+use middle::ty;
+
+use syntax::ast;
+
+// Take an inline assembly expression and splat it out via LLVM
+pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
+
+    let mut bcx = bcx;
+    let mut constraints = ~[];
+    let mut cleanups = ~[];
+    let mut aoutputs = ~[];
+
+    // Prepare the output operands
+    let outputs = do ia.outputs.map |&(c, out)| {
+        constraints.push(copy *c);
+
+        let aoutty = ty::arg {
+            mode: ast::expl(ast::by_copy),
+            ty: expr_ty(bcx, out)
+        };
+        aoutputs.push(unpack_result!(bcx, {
+            callee::trans_arg_expr(bcx, aoutty, out, &mut cleanups, None, callee::DontAutorefArg)
+        }));
+
+        let e = match out.node {
+            ast::expr_addr_of(_, e) => e,
+            _ => fail!(~"Expression must be addr of")
+        };
+
+        let outty = ty::arg {
+            mode: ast::expl(ast::by_copy),
+            ty: expr_ty(bcx, e)
+        };
+
+        unpack_result!(bcx, {
+            callee::trans_arg_expr(bcx, outty, e, &mut cleanups, None, callee::DontAutorefArg)
+        })
+
+    };
+
+    for cleanups.each |c| {
+        revoke_clean(bcx, *c);
+    }
+    cleanups.clear();
+
+    // Now the input operands
+    let inputs = do ia.inputs.map |&(c, in)| {
+        constraints.push(copy *c);
+
+        let inty = ty::arg {
+            mode: ast::expl(ast::by_copy),
+            ty: expr_ty(bcx, in)
+        };
+
+        unpack_result!(bcx, {
+            callee::trans_arg_expr(bcx, inty, in, &mut cleanups, None, callee::DontAutorefArg)
+        })
+
+    };
+
+    for cleanups.each |c| {
+        revoke_clean(bcx, *c);
+    }
+
+    let mut constraints = str::connect(constraints, ",");
+
+    let mut clobbers = getClobbers();
+    if *ia.clobbers != ~"" && clobbers != ~"" {
+        clobbers = *ia.clobbers + ~"," + clobbers;
+    } else {
+        clobbers += *ia.clobbers;
+    };
+
+    // Add the clobbers to our constraints list
+    if clobbers != ~"" && constraints != ~"" {
+        constraints += ~"," + clobbers;
+    } else {
+        constraints += clobbers;
+    }
+
+    debug!("Asm Constraints: %?", constraints);
+
+    let numOutputs = outputs.len();
+
+    // Depending on how many outputs we have, the return type is different
+    let output = if numOutputs == 0 {
+        T_void()
+    } else if numOutputs == 1 {
+        val_ty(outputs[0])
+    } else {
+        T_struct(outputs.map(|o| val_ty(*o)))
+    };
+
+    let dialect = match ia.dialect {
+        ast::asm_att   => lib::llvm::AD_ATT,
+        ast::asm_intel => lib::llvm::AD_Intel
+    };
+
+    let r = do str::as_c_str(*ia.asm) |a| {
+        do str::as_c_str(constraints) |c| {
+            InlineAsmCall(bcx, a, c, inputs, output, ia.volatile, ia.alignstack, dialect)
+        }
+    };
+
+    // Again, based on how many outputs we have
+    if numOutputs == 1 {
+        let op = PointerCast(bcx, aoutputs[0], T_ptr(val_ty(outputs[0])));
+        Store(bcx, r, op);
+    } else {
+        for aoutputs.eachi |i, o| {
+            let v = ExtractValue(bcx, r, i);
+            let op = PointerCast(bcx, *o, T_ptr(val_ty(outputs[i])));
+            Store(bcx, v, op);
+        }
+    }
+
+    return bcx;
+
+}
+
+// Default per-arch clobbers
+// Basically what clang does
+
+#[cfg(target_arch = "arm")]
+#[cfg(target_arch = "mips")]
+fn getClobbers() -> ~str {
+    ~""
+}
+
+#[cfg(target_arch = "x86")]
+#[cfg(target_arch = "x86_64")]
+fn getClobbers() -> ~str {
+    ~"~{dirflag},~{fpsr},~{flags}"
+}

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

@@ -128,6 +128,7 @@ use metadata::csearch;
 use middle::borrowck::root_map_key;
 use middle::trans::_match;
 use middle::trans::adt;
+use middle::trans::asm;
 use middle::trans::base;
 use middle::trans::base::*;
 use middle::trans::build::*;
@@ -548,108 +549,8 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block {
         ast::expr_paren(a) => {
             return trans_rvalue_stmt_unadjusted(bcx, a);
         }
-        ast::expr_inline_asm(asm, ref ins, ref outs,
-                             clobs, volatile, alignstack) => {
-            let mut constraints = ~[];
-            let mut cleanups = ~[];
-            let mut aoutputs = ~[];
-
-            let outputs = do outs.map |&(c, out)| {
-                constraints.push(copy *c);
-
-                let aoutty = ty::arg {
-                    mode: ast::expl(ast::by_copy),
-                    ty: expr_ty(bcx, out)
-                };
-                aoutputs.push(unpack_result!(bcx, {
-                    callee::trans_arg_expr(bcx, aoutty, out, &mut cleanups,
-                                           None, callee::DontAutorefArg)
-                    }));
-
-                let e = match out.node {
-                    ast::expr_addr_of(_, e) => e,
-                    _ => fail!(~"Expression must be addr of")
-                };
-
-                let outty = ty::arg {
-                    mode: ast::expl(ast::by_copy),
-                    ty: expr_ty(bcx, e)
-                };
-
-                unpack_result!(bcx, {
-                    callee::trans_arg_expr(bcx, outty, e, &mut cleanups,
-                                           None, callee::DontAutorefArg)
-                })
-
-            };
-
-            for cleanups.each |c| {
-                revoke_clean(bcx, *c);
-            }
-            cleanups = ~[];
-
-            let inputs = do ins.map |&(c, in)| {
-                constraints.push(copy *c);
-
-                let inty = ty::arg {
-                    mode: ast::expl(ast::by_copy),
-                    ty: expr_ty(bcx, in)
-                };
-
-                unpack_result!(bcx, {
-                    callee::trans_arg_expr(bcx, inty, in, &mut cleanups,
-                                           None, callee::DontAutorefArg)
-                })
-
-            };
-
-            for cleanups.each |c| {
-                revoke_clean(bcx, *c);
-            }
-
-            let mut constraints = str::connect(constraints, ",");
-
-            // Add the clobbers
-            if *clobs != ~"" {
-                if constraints == ~"" {
-                    constraints += *clobs;
-                } else {
-                    constraints += ~"," + *clobs;
-                }
-            } else {
-                constraints += *clobs;
-            }
-
-            debug!("Asm Constraints: %?", constraints);
-
-            let output = if outputs.len() == 0 {
-                T_void()
-            } else if outputs.len() == 1 {
-                val_ty(outputs[0])
-            } else {
-                T_struct(outputs.map(|o| val_ty(*o)))
-            };
-
-            let r = do str::as_c_str(*asm) |a| {
-                do str::as_c_str(constraints) |c| {
-                    InlineAsmCall(bcx, a, c, inputs, output, volatile,
-                                  alignstack, lib::llvm::AD_ATT)
-                }
-            };
-
-            if outputs.len() == 1 {
-                let op = PointerCast(bcx, aoutputs[0],
-                                     T_ptr(val_ty(outputs[0])));
-                Store(bcx, r, op);
-            } else {
-                for aoutputs.eachi |i, o| {
-                    let v = ExtractValue(bcx, r, i);
-                    let op = PointerCast(bcx, *o, T_ptr(val_ty(outputs[i])));
-                    Store(bcx, v, op);
-                }
-            }
-
-            return bcx;
+        ast::expr_inline_asm(ref a) => {
+            return asm::trans_inline_asm(bcx, a);
         }
         _ => {
             bcx.tcx().sess.span_bug(

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

@@ -360,11 +360,11 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
         mark_for_method_call(cx, e.id, e.callee_id);
       }
 
-      expr_inline_asm(_, ref ins, ref outs, _, _, _) => {
-        for ins.each |&(_, in)| {
+      expr_inline_asm(ref ia) => {
+        for ia.inputs.each |&(_, in)| {
           node_type_needs(cx, use_repr, in.id);
         }
-        for outs.each |&(_, out)| {
+        for ia.outputs.each |&(_, out)| {
           node_type_needs(cx, use_repr, out.id);
         }
       }