Add intrinsics::unreachable

[kmcallister]

I'm not sure how to add an automated test for this.

[thestinger]

A simple run-pass test making use of it would be nice, even though it can't be directly tested.

[alexcrichton]

What happens in a program like this?

use std::intrinsics;
fn main() {
    unsafe { intrinsics::unreachable(); }
}

[thestinger]

That has undefined behaviour, it's the point of the intrinsic. It's the same thing as __builtin_unreachable with gcc and clang.

[kmcallister]

My use case is something like

pub fn exit(n: uint) -> ! {
    static NR_EXIT: uint = 60;
    unsafe {
        asm!("syscall"
            :: "{rax}"(NR_EXIT), "{rdi}"(n));
        intrinsics::unreachable()
    }
}

which compiles on x86-64 Linux to just

0000000000000000 <_ZN4exit20he7def17266e9100bdaaE>:
   0:   b8 3c 00 00 00          mov    $0x3c,%eax
   5:   0f 05                   syscall 

Without the intrinsic I need something like loop { } to fulfill the bottom return type, which wastes 2 bytes in the object code, plus more for alignment.

[kmcallister]

Not sure why the Travis build failed. The log shows rustc dying with SIGBUS.

[Kimundi]

Travis always fails its llvm 3.4 build atm. The 3.3 one succeeded though, which is the important one.

[huonw]

Does this avoid crashing horribly? (iirc there have been crashes due to LLVM assertions about unreachability previously)

fn foo() {
    unreachable();
    println!("foo");
}

[kmcallister]

It doesn't crash rustc, no.

[kmcallister]

@huonw, @thestinger: Any more thoughts about this?

[kmcallister]

Any way I can get the contents of /c/bot/slave/auto-win64-64-nopt-t/build/src/test/run-make/intrinsic-unreachable/ without my own Windows machine? It may have failed just because of using test and wc in the Makefile; what kind of environment do these Makefiles use on Windows?

[alexcrichton]

Not at this point sadly, the bots clean out all previous runs when they make a new build. You could update the test, however, to print it out and we can push to try.

[vadimcn]

@kmcallister: Please note that on Win64, the 'unreachable' instruction actually emits code.

[kmcallister]

Aha!

[ghost]

FWIW, matching an empty enum will produce an unreachable instruction:

use std::any::Void;
use std::intrinsics::transmute;

fn main() {
    let x: Void = unsafe { transmute(()) };
    match x {}
}

%"enum.core::any::Void<[]>[#3]" = type {}

; Function Attrs: uwtable
define internal void @_ZN4main20h31af98ebf3d86da3gaaE() unnamed_addr #0 {
entry-block:
  %x = alloca %"enum.core::any::Void<[]>[#3]"
  unreachable

so the unreachable intrinsic could be implemented in the library itself. Or not implemented at all if the above hack is deemed sufficient.

[tbu-]

I'm not sure whether tests should feature idiomatic code, but in this case I think it'd be better if you'd mark this function unsafe.

[kmcallister]

Rebased and addressed @tbu-'s comment. r? @thestinger