Inline assembly, part 2

[luqmana]

Continuation of #5317. Actually use operands properly now, including any number of output operands.

Which means you can do things like call printf:

fn main() {
    unsafe {
        do str::as_c_str(~"The answer is %d.\n") |c| {
            let a = 42;
            asm!("mov $0, %rdi\n\t\
                  mov $1, %rsi\n\t\
                  xorl %eax, %eax\n\t\
                  call _printf"
                 :
                 : "r"(c), "r"(a)
                 :
                 : "volatile", "alignstack"
                 );
        }
    }
}

% rustc foo.rs
% ./foo
The answer is 42.

Or just add 2 numbers:

fn add(a: int, b: int) -> int {
    let mut c = 0;
    unsafe {
        asm!("add $2, $0"
             : "=r"(c)
             : "0"(a), "r"(b)
             );
    }
    c
}

fn main() {
    io::println(fmt!("%d", add(1, 2)));
}

% rustc foo.rs
% ./foo
3

Multiple outputs!

fn addsub(a: int, b: int) -> (int, int) {
    let mut c = 0;
    let mut d = 0;
    unsafe {
        asm!("add $4, $0\n\t\
              sub $4, $1"
             : "=r"(c), "=r"(d)
             : "0"(a), "1"(a), "r"(b)
             );
    }
    (c, d)
}

fn main() {
    io::println(fmt!("%?", addsub(5, 1)));
}

% rustc foo.rs
% ./foo
(6, 4)

This also classifies inline asm as RvalueStmtExpr instead of the somewhat arbitrary kind I made it initially.

[pcwalton]

You need to fully specialize on the types of the ins and outs, I believe. This will cause hard-to-debug errors if you use inline asm in generics. It's ok to be a followup though, but it should be filed…