ExitStatus Debug instance is misleading

[infinity0]

On UNIX, c_int is an alias for i32 or i16 depending on the platform. ExitStatus is a wrapper around c_int. However its Debug instance only exposes the last few bits:

test.c

#include <stdio.h>
void main() {
    printf("%s\n", (void*)123);
}

running:

$ gcc test.c && ./a.out
Segmentation fault
exit code 139

test.rs

use std::process::Command;

#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct X(i16);
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct XX(X);

pub fn main() {
  let e = Command::new("./a.out").status().unwrap();
  let i = XX(X(139));
  println!("exit with {:?}", e);
  println!("exit with {}", e);
  println!("test reproduce {:?}", i);
}

running:

$ rustc test.rs && ./test
exit with ExitStatus(ExitStatus(11))
exit with signal: 11
test reproduce XX(X(139))

The Debug output makes it look like a regular exit, not a signal exit. This is relevant because this is what rustbuild's rustc wrapper does in src/bootstrap/bin/rustc.rs, making rustc builds harder to debug.

As you can see I tried to recreate the weirdness with XX which as far as I can tell, follows the structure of how ExitStatus is defined. However I didn't recreate the platform-dependent logic in libstd/sys/mod.rs which also includes missing_debug_implementations which might be interfering with the derivation logic.

[infinity0]

Looking into this in a bit more detail, my interpretation in the OP is wrong, but the C/POSIX standards are confusing for these things. Apparently exit status of a UNIX process an as output of waitpid in the parent, takes entirely different values to the exit status given as an input to exit(). If you amend test.c in the OP to this:

#include <stdio.h>
void main() {
    exit(11);
}

then run the rust code again, it will output:

$ rustc test.rs && ./test
exit with ExitStatus(ExitStatus(2816))
exit with exit code: 11
test reproduce XX(X(139))

In other words, exit(11) i.e. exit(0x0b) as an input in the child program gets translated into ExitStatus(2816) i.e. ExitStatus(0x0b00) as an output in the parent program, and the exit code (for non-signal termination) is stored in the higher bits. The value 139 is something else constructed by bash, from man bash:

       The return value of a simple command is its exit status, or 128+n if the command is terminated by signal n.

I am not sure what to do about this bug report. The Debug instance is misleading, but it is not a direct fault of rust, but of the various systems it's running on top of.

For sure I will file another PR to patch up rustbuild's rustc wrapper to use Display instead of Debug.