SIGSEGV on MIPS when dividing two 128-bit integers

[japaric]

STR

#![feature(i128_type)]

fn main() {
    let x: u128 = 1844674407370955161400;
    let y: u128 = 18002795302052819272;
    let z = x / y;

    println!("{}", x);
    println!("{}", y);
    println!("{}", z);
}

$ cargo run
1844674407370955161400
18002795302052819272
102

$ cross run --target mips-unknown-linux-gnu
     Running `/target/mips-unknown-linux-gnu/debug/hello`
Segmentation fault (core dumped)

This operation / intrinsic is implemented in Rust. Other 32-bit targets don't have this problem.

$ cross run --target arm-unknown-linux-gnueabi
1844674407370955161400
18002795302052819272
102

Meta

$ rustc -V
rustc 1.18.0-nightly (3b5754e5c 2017-04-10)

cc @est31 I suspect this is some ABI problem.

[nagisa]

cc me

[nagisa]

The result of the division is correct. Invalid memory access happens during printing of the value.

[nagisa]

Okay it might not be correct in that the 2 halves may be swapped. Printing sigsegvs for code as simple as

Println!("{}", 102u128<<64)

[nagisa]

Division is confirmed to be correct. There's two issues though. Parsing and printing i128 is broken for values over 64 bits.

[nikomatsakis]

triage: P-high

Assigning to @nagisa.

[nagisa]

I have tried the new nightly which i think also includes the division fix from the other PR and it still sigsegvs. Will investigate more.

[nagisa]

#![feature(i128_type)]

fn x(i: u128) -> isize {
    (i % 10000) as isize
}

fn main() {
    let y = (0x1u128 << 64);
    println!("{}", x(y));
}

prints a -10000, which is obviously wrong (the expected result would be 1616).

#![feature(i128_type)]
fn x(i: u128) -> u128 {
    (i % 10000)

}

fn main() {
    let y = (0x1u128 << 64);
    println!("{:x} {:x}", (x(y) >> 64) as u64, x(y) as u64);
}

prints 1 ffffffffffffd8f0.

ABI is fine (identity works), so the blame falls squarely onto implementation of the intrinsics. i686 works fine as well, so it is not a 32-bit vs 64-bit problem.