deque: add documentation
treemap: rm old FIXME
treemap: use each_mut instead of mutate
impl Clone for ~T, ~[T], ~str
Clonify some of run-pass
add constructor to TrieSet (was missing)
core: fix trie chunk function
auto merge of #5400 : thestinger/rust/misc, r=brson
add a test for the chunk function
Inline asm exprs should be RvalueStmtExpr.
Actually pass inline asm operands around.
Properly handle input operands for inline asm.
Initial support for output operands in asm.
Implicitly use addr_of for output operands in asm.
Actually use no or multiple operands properly.
Tidy.
Don't use by_val for passing asm operands.
Fix type_use for inline asm.
auto merge of #5404 : bstrie/rust/decopy, r=pcwalton

Also turn `copy` into `.clone()` in much of run-pass.
auto merge of #5359 : luqmana/rust/inline-asm, r=pcwalton

Continuation of #5317. Actually use operands properly now, including any number of output operands.

Which means you can do things like call printf:
```Rust
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)
                 : "rdi", "rsi", "eax"
                 : "volatile","alignstack"
                 );
        }
    }
}
```

```
% rustc foo.rs
% ./foo
The answer is 42.
```

Or just add 2 numbers:
```Rust
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!
```Rust
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. There are a few XXX's regarding what to do in the liveness and move passes.