auto merge of #8792 : adridu59/rust/master, r=catamorphism

`target_library_in_workspace` is imported but unused:
~/rust/src/librustpkg/tests.rs:21:48: 21:75 warning: unused import [-W unused-imports (default)]

auto merge of #8771 : thestinger/rust/repr, r=catamorphism

reflect: rm unused visit_{var,var_integral,constr}

repr: include mutability qualifier in visit_ptr

repr: print integer/float suffixes

auto merge of #8790 : huonw/rust/unsafearc, r=thestinger

`UnsafeAtomicRcBox` → `UnsafeArc` (#7674), and `AtomicRcBoxData` → `ArcData` to reflect this.

Also, the inner pointer of `UnsafeArc` is now `*mut ArcData`, which avoids some transmutes to `~`: i.e. less chance of mistakes.

auto merge of #8581 : FlaPer87/rust/issue/8232, r=bblum

As for now, rekillable is an unsafe function, instead, it should behave
just like unkillable by encapsulating unsafe code within an unsafe
block.

This patch does that and removes unsafe blocks that were encapsulating
rekillable calls throughout rust's libs.

Fixes #8232

Trailing space

vec: implement `DeepClone`

auto merge of #8772 : thestinger/rust/option, r=anasazi

Closes #6002

There is consensus that the current implementation should be changed or
removed, so removing it seems like the right decision for now.

option: rm implementation of Add

Closes #6002

There is consensus that the current implementation should be changed or
removed, so removing it seems like the right decision for now.

auto merge of #8789 : pnkfelix/rust/fsk-fix-typo-in-rust-mode.el, r=pnkfelix

Fix #6887.  (or rather, a bug injected by my prior commit for fixing that bug.)

auto merge of #8777 : Kimundi/rust/doc_stuff, r=cmr

librustpkg/tests.rs: cleanup unused import

auto merge of #8780 : brson/rust/from_elem, r=thestinger

std: use ArcData rather than c_void in UnsafeArc.

This means that fewer `transmute`s are required, so there is less
chance of a `transmute` not having the corresponding `forget`
(possibly leading to use-after-free, etc).

auto merge of #8779 : brson/rust/macsupp, r=thestinger

This callstack changed when the FFI did. I am still a little frightened by
this suppression.

cc #8253

fix typo in rust-mode.el

Rename UnsafeAtomicRcBox to UnsafeArc. Fixes #7674.

auto merge of #8773 : catamorphism/rust/rustpkg-version-flag, r=anasazi

r? anyone. Now, rustpkg --version does something useful!

Rebased and replaced yield with deschedule

auto merge of #8757 : vadimcn/rust/debug-info-tests, r=brson

Now that new LLVM has landed, the debug info works on Windows as well.   Most existing tests pass, except for the following four, which I left disabled for now:
lexical-scope-in-for-loop
lexical-scope-in-if
lexical-scope-in-match
lexical-scopes-in-block-expression

Also, fixed a small problem with the debug info test runner.

auto merge of #8700 : alexcrichton/rust/better-llvm, r=thestinger

Beforehand, it was unclear whether rust was performing the "recommended set" of
optimizations provided by LLVM for code. This commit changes the way we run
passes to closely mirror that of clang, which in theory does it correctly. The
notable changes include:

* Passes are no longer explicitly added one by one. This would be difficult to
  keep up with as LLVM changes and we don't guaranteed always know the best
  order in which to run passes
* Passes are now managed by LLVM's PassManagerBuilder object. This is then used
  to populate the various pass managers run.
* We now run both a FunctionPassManager and a module-wide PassManager. This is
  what clang does, and I presume that we *may* see a speed boost from the
  module-wide passes just having to do less work. I have no measured this.
* The codegen pass manager has been extracted to its own separate pass manager
  to not get mixed up with the other passes
* All pass managers now include passes for target-specific data layout and
  analysis passes

Some new features include:

* You can now print all passes being run with `-Z print-llvm-passes`
* When specifying passes via `--passes`, the passes are now appended to the
  default list of passes instead of overwriting them.
* The output of `--passes list` is now generated by LLVM instead of maintaining
  a list of passes ourselves
* Loop vectorization is turned on by default as an optimization pass and can be
  disabled with `-Z no-vectorize-loops`

All of these "copies" of clang are based off their [source code](http://clang.llvm.org/doxygen/BackendUtil_8cpp_source.html) in case anyone is curious what my source is. I was hoping that this would fix #8665, but this does not help the performance issues found there. Hopefully i'll allow us to tweak passes or see what's going on to try to debug that problem.

Rewrite pass management with LLVM

Beforehand, it was unclear whether rust was performing the "recommended set" of
optimizations provided by LLVM for code. This commit changes the way we run
passes to closely mirror that of clang, which in theory does it correctly. The
notable changes include:

* Passes are no longer explicitly added one by one. This would be difficult to
  keep up with as LLVM changes and we don't guaranteed always know the best
  order in which to run passes
* Passes are now managed by LLVM's PassManagerBuilder object. This is then used
  to populate the various pass managers run.
* We now run both a FunctionPassManager and a module-wide PassManager. This is
  what clang does, and I presume that we *may* see a speed boost from the
  module-wide passes just having to do less work. I have no measured this.
* The codegen pass manager has been extracted to its own separate pass manager
  to not get mixed up with the other passes
* All pass managers now include passes for target-specific data layout and
  analysis passes

Some new features include:

* You can now print all passes being run with `-Z print-llvm-passes`
* When specifying passes via `--passes`, the passes are now appended to the
  default list of passes instead of overwriting them.
* The output of `--passes list` is now generated by LLVM instead of maintaining
  a list of passes ourselves
* Loop vectorization is turned on by default as an optimization pass and can be
  disabled with `-Z no-vectorize-loops`

auto merge of #8747 : pnkfelix/rust/fsk-issue6887-fix-emacs-compilation-regexp, r=graydon

Fix #6887

Rewrote module tutorial

auto merge of #8739 : fhahn/rust/ticket_2275, r=brson

This is a pull request for #2275

I've created a small python script to generate test files for a list of keywords (as break do else enum extern false fn for if impl let loop match mod mut priv pub ref return self static struct super true trait type unsafe use while), but I'm not really sure where to put it. I've added the created files as well.

I did not use

     fn main() {
        let $KW = "foo"; //~ error
        println($KW); //~ error
    }

as template, because for return, self, ref, loop, mut and break this does not raise an error in the ```println``` line, only in the ```let``` line.

std: Make vec::from_elem failure-safe

Fix valgrind suppression on mac

This callstack changed when the FFI did. I am still a little frightened by
this suppression.

auto merge of #8438 : cmr/rust/default, r=thestinger

Fix deriving-zero test

Add a Default trait.

auto merge of #8712 : catamorphism/rust/rustpkg-issue-7241, r=pcwalton

r? @brson ...multiple workspaces

The test checks that rustpkg uses the first one, rather than complaining
about multiple matches.

Closes #7241

Decrement unkillable counter before failing

Don't make the runtime exit on illegal calls

rustpkg: Implement --version command-line option

Now, rustpkg --version does something useful!

Testing rekillable fails when called from outside an unkillable block

Make rekillable consistent with unkillable

As for now, rekillable is an unsafe function, instead, it should behave
just like unkillable by encapsulating unsafe code within an unsafe
block.

This patch does that and removes unsafe blocks that were encapsulating
rekillable calls throughout rust's libs.

Fixes #8232

rustpkg: Test that different copies of the same package ID can exist in multiple workspaces

The test checks that rustpkg uses the first one, rather than complaining
about multiple matches.

Closes #7241

auto merge of #8766 : brson/rust/vecfromfn, r=alexcrichton

A recently-enabled test of this is causing valgrind failures.

std: Make vec::from_fn failure-safe

auto merge of #8488 : klutzy/rust/mingw-w64, r=brson

This patchset enables rustc to cross-build mingw-w64 outputs.
Tested on mingw + mingw-w64 (mingw-builds, win64/seh/win32-threads/gcc-4.8.1).

I also patched llvm to support Win64 stack unwinding.
https://github.com/klutzy/llvm/commit/ebe22bdbcebc4f8342c4c7c50e3b61fa6c68c1ad

I cross-built test/run-pass/smallest-hello-world.rs and confirmed it works.
However, I also found something went wrong if I don't have custom `#[start]` routine.

auto merge of #8764 : blake2-ppc/rust/doc-condition, r=graydon

As mentioned in PR #8563 it seems this tutorial has no inbound link!

doc: Link condition and error-handling tutorial from main tutorial

auto merge of #8758 : pnkfelix/rust/fsk-more-oldvisit-ports, r=pnkfelix

Further followup on #7081.

There still remains writeback.rs, but I want to wait to investigate that one because I've seen `make check` issues with it in the past.

Add script and tests for using keywords as identifiers

auto merge of #8749 : gifnksm/rust/bigint-cfg, r=pnkfelix

This also fixes #4393.

Support Win64 context switching

This patch saves and restores win64's nonvolatile registers.
This patch also saves stack information of thread environment
block (TEB), which is at %gs:0x08 and %gs:0x10.

rt: Support SEH/SJLJ personality routine

rt: Make valgrind Win64-compatible

std: Add Win64 support

Some extern blobs are duplicated without "stdcall" abi,
since Win64 does not use any calling convention.
(Giving any abi to them causes llvm producing wrong bytecode.)

std: Bind write() on Win64

std: Add Win64 types

Set main_name "WinMain" on Win64

rt: Add {get,record}_sp_limit on Win64

Uses ArbitraryUserPointer area at gs:0x28.

rt: Remove leading underscore on Win64

Win64 convention does not use underscore.

auto merge of #8737 : blake2-ppc/rust/std-str-rsplit, r=huonw

Make CharSplitIterator double-ended which is simple given that the operation is symmetric, once the split-N feature is factored out into its own adaptor.

`.rsplitn_iter()` allows splitting `N` times from the back of a string, so it is a completely new feature. With the double-ended impl, `.split_iter()`, `.line_iter()`, `.word_iter()` all allow picking off elements from either end.

`split_options_iter` is removed with the factoring of the split- and split-N- iterators, instead there is `split_terminator_iter`.

---

Add benchmarks using `#[bench]` and tune CharSplitIterator a bit after Huon Wilson's suggestions

Benchmarks 1-5 do the same split using different implementations of `CharEq`, all splitting an ascii string on ascii space. Benchmarks 6-7 split a unicode string on an ascii char.

Before this PR
test str::bench::split_iter_ascii ... bench: 166 ns/iter (+/- 2)
test str::bench::split_iter_closure ... bench: 113 ns/iter (+/- 1)
test str::bench::split_iter_extern_fn ... bench: 286 ns/iter (+/- 7)
test str::bench::split_iter_not_ascii ... bench: 114 ns/iter (+/- 4)
test str::bench::split_iter_slice ... bench: 220 ns/iter (+/- 12)
test str::bench::split_iter_unicode_ascii ... bench: 217 ns/iter (+/- 3)
test str::bench::split_iter_unicode_not_ascii ... bench: 248 ns/iter (+/- 3)

PR, first commit
test str::bench::split_iter_ascii ... bench: 331 ns/iter (+/- 9)
test str::bench::split_iter_closure ... bench: 114 ns/iter (+/- 2)
test str::bench::split_iter_extern_fn ... bench: 314 ns/iter (+/- 6)
test str::bench::split_iter_not_ascii ... bench: 132 ns/iter (+/- 1)
test str::bench::split_iter_slice ... bench: 157 ns/iter (+/- 3)
test str::bench::split_iter_unicode_ascii ... bench: 502 ns/iter (+/- 64)
test str::bench::split_iter_unicode_not_ascii ... bench: 250 ns/iter (+/- 3)

PR, final version
test str::bench::split_iter_ascii ... bench: 106 ns/iter (+/- 4)
test str::bench::split_iter_closure ... bench: 107 ns/iter (+/- 1)
test str::bench::split_iter_extern_fn ... bench: 267 ns/iter (+/- 6)
test str::bench::split_iter_not_ascii ... bench: 108 ns/iter (+/- 1)
test str::bench::split_iter_slice ... bench: 170 ns/iter (+/- 8)
test str::bench::split_iter_unicode_ascii ... bench: 128 ns/iter (+/- 5)
test str::bench::split_iter_unicode_not_ascii ... bench: 252 ns/iter (+/- 3)

---

There are several ways to deal with `CharEq::only_ascii`. It is a performance optimization, so with that in mind, we allow passing bogus char (outside ascii) as long as they don't match. We use a byte value check to make sure we don't split on these (would split substrings in the middle of encoded char).  (A more principled way would be to only pass the ascii codepoints to the CharEq when it indicates only_ascii, but that undoes some of the performance optimization.)

std::str: Tune CharSplitIterator after benchmarks

Implement Huon Wilson's suggestions (since the benchmarks agree!).

Use `self.sep.matches(byte as char) && byte < 128u8` to match in the
only_ascii case so that mistaken matches outside the ascii range can't
create invalid substrings.

Put the conditional on only_ascii outside the loop.

Placate `make tidy`.

bigint: fix wrong benchmark fn name

auto merge of #8744 : jld/rust/discr64, r=nikomatsakis

This is in preparation for making discriminants not always be int (#1647), but it also makes compiles for a 64-bit target not behave differently — with respect to how many bits of discriminants are preserved — depending on the build host's word size, which is a nice property to have.

We may want to standardize how to abbreviate "discriminant" in a followup change.

Port typeck/check/vtable.rs from oldvisit to <V:Visitor> trait API.

std::str: bench tests for .split_iter()

Port middle/stack_check.rs from oldvisit to <V:Visitor> trait API.

Port middle/moves.rs from oldvisit to <V:Visitor> trait API.

Remove occurrences of `oldvisit` text to improve grepping for old oldvisit.

Port creader.rs from oldvisit to <V:Visitor> trait API.

Un-disabled debug info tests on Windows.

Since we assume that GDB output is UTF-8, make sure it is so on all platforms.
Otherwise it'll choose some "appropriate" platform-specific default (e.g. CP1252 on Windows).

auto merge of #8750 : kballard/rust/str-opt-variant, r=thestinger

Add _opt variants to from_bytes, from_bytes_owned, and from_bytes_slice.
These variants return an Option instead of raising a condition/failing.

auto merge of #8751 : brson/rust/metadata-revert, r=brson

This reverts commit 491bc3568c87dadaba4d342135bd308961c6e0ef, reversing
changes made to 05f1bbba16912f63b562a7847801823872f89ec6.

I've heard reports that this broke something. Don't know details yet.

Revert "auto merge of #8745 : brson/rust/metadata, r=cmr"

This reverts commit 491bc3568c87dadaba4d342135bd308961c6e0ef, reversing
changes made to 05f1bbba16912f63b562a7847801823872f89ec6.

Add _opt variants to str byte-conversion functions

Add _opt variants to from_bytes, from_bytes_owned, and from_bytes_slice.
These variants return an Option instead of raising a condition/failing.

extend file regexp to match files with embedded spaces.

auto merge of #8745 : brson/rust/metadata, r=cmr

This does two things: 1) stops compressing metadata, 2) stops copying the metadata section, instead holding a reference to the buffer returned by the LLVM section iterator.

Not compressing metadata requires something like 7x the storage space, but makes running tests about 9% faster. This has been a time improvement on all platforms I've tested, including windows. I considered leaving compression as an option but it doesn't seem to be worth the complexity since we don't currently have any use cases where we need to save that space.

In order to avoid copying the metadata section I had to hack up extra::ebml a bit to support unsafe buffers. We should probably move it into librustc so that it can evolve to support the compiler without worrying about having a crummy interface.

r? @graydon

auto merge of #8723 : anasazi/rust/temporary-unkillable-io, r=brson

Also added a home_for_io_with_sched variant to consolidate some cases.

This is a temporary step to resolving #8674.

bigint: Add benchmarks

bigint: un-ignore test_shr

bigint: inlining small functions

bigint: remove unnecessary method implements

bigint: cfg(target_arch = ...) => cfg(target_word_size = ...)

revisions to emacs compilation regexp, more readable and robust.

compilation error regexp specific to rustc.

Fix #6887.

auto merge of #8710 : pnkfelix/rust/fsk-issue5516-codepoint-fix, r=alexcrichton

...bytes.

(removing previous note about eff-eye-ex'ing #5516 since it actually does not do so, it just gets us half-way.)

char_len is more succinct than count_chars.

std::str: Double-ended CharSplitIterator

Add new methods `.rsplit_iter()` and `.rsplitn_iter()` for &str.

Separate out CharSplitIterator and CharSplitNIterator,
CharSplitIterator (`split_iter` and `rsplit_iter`) is made double-ended
while `splitn_iter` and `rsplitn_iter` (limited to N splits) are not,
since these don't have the same symmetry.

With CharSplitIterator being double ended, derived iterators like
`line_iter` and `word_iter` are too.

auto merge of #8736 : luqmana/rust/hf, r=yichoi

Fixes #8536.

Don't ever compress metadata

auto merge of #8701 : brson/rust/issue-8698, r=thestinger

Add a test case for the preceding changes.

This would have failed on 32-to-64-bit cross-compiles.

Don't truncate discriminants to host uint for C_uint's sake.

Make enum discriminants u64 instead of the host uint.

auto merge of #8637 : alexcrichton/rust/ifmt-less-hax, r=graydon

Recent improvements to `&mut Trait` have made this work possible, and it solidifies that `ifmt` doesn't always have to return a string, but rather it's based around writers.

auto merge of #8607 : sfackler/rust/extensions, r=brson

The method names in std::rt::io::extensions::WriterByteConversions are
the same as those in std::io::WriterUtils and a resolve error causes
rustc to fail after trying to find an impl of io::Writer instead of
trying to look for rt::io::Writer as well.

Introduce alternate forms of logging

These new macros are all based on format! instead of fmt! and purely exist for
bootstrapping purposes. After the next snapshot, all uses of logging will be
migrated to these macros, and then after the next snapshot after that we can
drop the `2` suffix on everything

auto merge of #8740 : brson/rust/rt-opt, r=thestinger

See #8599

Merge pull request #8733 from sfackler/str-to-bytes

Add OwnedStr::into_bytes

std::rt: Enforce sanity a while longer

I'm not comfortable turning off rtassert! yet

std: Make vec::push_all_move call reserve_at_least

vec::unshift uses this to add elements, scheduler queues use unshift,
and this was causing a lot of reallocation

std::rt: Remove an unnecessary allocation from the main sched loop