---

yaml
---
r: 49965
b: refs/heads/auto
c: d8ab47e
h: refs/heads/master
i:
  49963: e3bb737
v: v3

Author: luqmana

[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: 6d078db952cf76b35bbd8577fe6a9f5d9e12c566
+refs/heads/auto: d8ab47e7f9ed4c30c9ff3d4e2351b19992a380dd
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

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

@@ -873,6 +873,7 @@ pub fn add_comment(bcx: block, text: &str) {
 }
 
 pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char,
+                     inputs: &[ValueRef],
                      volatile: bool, alignstack: bool,
                      dia: AsmDialect) -> ValueRef {
     unsafe {
@@ -883,11 +884,15 @@ pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char,
         let alignstack = if alignstack { lib::llvm::True }
                          else          { lib::llvm::False };
 
-        let llfty = T_fn(~[], T_void());
+        let argtys = do inputs.map |v| {
+            io::println(fmt!("ARG TYPE: %?", val_str(cx.ccx().tn, *v)));
+            val_ty(*v)
+        };
+        let llfty = T_fn(argtys, T_void());
         let v = llvm::LLVMInlineAsm(llfty, asm, cons, volatile,
                                     alignstack, dia as c_uint);
 
-        Call(cx, v, ~[])
+        Call(cx, v, inputs)
     }
 }
 

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

@@ -558,12 +558,51 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block {
             return trans_rvalue_stmt_unadjusted(bcx, a);
         }
         ast::expr_inline_asm(asm, ref ins, ref outs,
-                             cons, volatile, alignstack) => {
-            // XXX: cons doesn't actual contain ALL the stuff we should
-            // be passing since the constraints for in/outputs aren't included
+                             clobs, volatile, alignstack) => {
+            let mut constraints = ~[];
+            let mut cleanups = ~[];
+
+            // TODO: Handle outputs
+
+            let inputs = do ins.map |&(c, in)| {
+
+                constraints.push(copy *c);
+
+                let inty = ty::arg {
+                    mode: ast::expl(ast::by_val),
+                    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;
+            }
+
+            io::println(fmt!("Inputs: %?\nConstraints: %?\n", ins, constraints));
+
             do str::as_c_str(*asm) |a| {
-                do str::as_c_str(*cons) |c| {
-                    InlineAsmCall(bcx, a, c, volatile, alignstack,
+                do str::as_c_str(constraints) |c| {
+                    InlineAsmCall(bcx, a, c, inputs, volatile, alignstack,
                                   lib::llvm::AD_ATT);
                 }
             }