---

yaml
---
r: 50350
b: refs/heads/auto
c: 36909c7
h: refs/heads/master
v: v3

Author: pcwalton

[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: f81459211d0cf2738ed02f5c7fe24f56c8032960
+refs/heads/auto: 36909c7575e2ddfe2925423aceb62d82ae8208b2
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

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

@@ -128,7 +128,6 @@ 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::*;
@@ -549,8 +548,108 @@ 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(ref a) => {
-            return asm::trans_inline_asm(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;
         }
         _ => {
             bcx.tcx().sess.span_bug(

branches/auto/src/librustc/middle/trans/expr.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 ia) => {
-        for ia.inputs.each |&(_, in)| {
+      expr_inline_asm(_, ref ins, ref outs, _, _, _) => {
+        for ins.each |&(_, in)| {
           node_type_needs(cx, use_repr, in.id);
         }
-        for ia.outputs.each |&(_, out)| {
+        for outs.each |&(_, out)| {
           node_type_needs(cx, use_repr, out.id);
         }
       }

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

@@ -2336,13 +2336,13 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         let region_lb = ty::re_scope(expr.id);
         instantiate_path(fcx, pth, tpt, expr.span, expr.id, region_lb);
       }
-      ast::expr_inline_asm(ref ia) => {
+      ast::expr_inline_asm(_, ref ins, ref outs, _, _, _) => {
           fcx.require_unsafe(expr.span, ~"use of inline assembly");
 
-          for ia.inputs.each |&(_, in)| {
+          for ins.each |&(_, in)| {
               check_expr(fcx, in);
           }
-          for ia.outputs.each |&(_, out)| {
+          for outs.each |&(_, out)| {
               check_expr(fcx, out);
           }
           fcx.write_nil(id);

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -80,7 +80,6 @@ pub mod middle {
         pub mod reachable;
         pub mod machine;
         pub mod adt;
-        pub mod asm;
     }
     pub mod ty;
     pub mod resolve;

branches/auto/src/librustc/rustc.rc

@@ -593,7 +593,10 @@ pub enum expr_ {
     expr_ret(Option<@expr>),
     expr_log(@expr, @expr),
 
-    expr_inline_asm(inline_asm),
+    expr_inline_asm(@~str,              // asm
+                    ~[(@~str, @expr)],  // inputs
+                    ~[(@~str, @expr)],  // outputs
+                    @~str, bool, bool), // clobbers, volatile, align stack
 
     expr_mac(mac),
 
@@ -927,27 +930,6 @@ impl to_bytes::IterBytes for Ty {
     }
 }
 
-#[auto_encode]
-#[auto_decode]
-#[deriving(Eq)]
-pub enum asm_dialect {
-    asm_att,
-    asm_intel
-}
-
-#[auto_encode]
-#[auto_decode]
-#[deriving(Eq)]
-pub struct inline_asm {
-    asm: @~str,
-    clobbers: @~str,
-    inputs: ~[(@~str, @expr)],
-    outputs: ~[(@~str, @expr)],
-    volatile: bool,
-    alignstack: bool,
-    dialect: asm_dialect
-}
-
 #[auto_encode]
 #[auto_decode]
 #[deriving(Eq)]