Add rustup.sh to the repo

Just to have it somewhere to point to. Updating it will not
automatically update the one on static.rust-lang.org.
improve clone_from_slice performance
add intmax
Add assume intrinsic

Adds an `assume` intrinsic that gets translated to llvm.assume. It is
used on a boolean expression and allows the optimizer to assume that
the expression is true.

This implements #18051.
Improve documentation of assume intrinsic.
Guide: articulate the advantages of ownership over garbage collection.

Explain the primary disadvantage of garbage collection is runtime
overhead and unpredictable pauses.  Elucidate where the name "race
condition" comes from.  Emphasize that Rust can guarantee your code is
free of race conditions and other memory errors, with no runtime
overhead.
Fix issue #17848 (Questionable advice in bug report instructions)
Add test for issue #17594
Guide: Change >= to > in closure
Use local cache when there are unbound type variables and where clauses in scope.

Fixes #18209.
Fixed single quote around string slice and simplify example

This patch contains a fix for:
- single quote around string slice
- string: String is confusing for newbies and it's more readble if the
  argument name is different that the argument type name
auto merge of #18224 : nikomatsakis/rust/issue-17594, r=alexcrichton

Add test for issue #17594

Fixes #17594
Add run-pass-valgrind tests

Closes #16914
Move some tests to run-pass-valgrind
Make rpass-valgrind work with pretty
Remove support for .rc files from test.mk
Part of #6993. Moved a bunch of uses of Ident to Name
Error if we should be able to Valgrind but can't
auto merge of #17868 : nick29581/rust/valgrind, r=alexcrichton

r? @alexcrichton
Fix codegen breaking aliasing rules for functions with sret results

This reverts commit a0ec902e239b2219edf1a18b036dd32c18d3be42 "Avoid
unnecessary temporary on assignments".

Leaving out the temporary for the functions return value can lead to a
situation that conflicts with rust's aliasing rules.

Given this:

````rust
fn func(f: &mut Foo) -> Foo { /* ... */ }

fn bar() {
    let mut foo = Foo { /* ... */ };

    foo = func(&mut foo);
}
````

We effectively get two mutable references to the same variable `foo` at
the same time. One for the parameter `f`, and one for the hidden
out-pointer. So we can't just `trans_into` the destination directly, but
must use `trans` to get a new temporary slot from which the result can
be copied.