std: Render large exit codes as hex on Windows #57473
Conversation
|
r? @Kimundi (rust_highfive has picked a reviewer for you, use r? to override) |
rust-highfive
added
the
S-waiting-on-review
|
I think it is a good heuristic. cc @retep998 |
|
Generally the system exit codes are due to an unhandled exception, and unhandled exceptions have an |
|
📌 Commit 415f514687e406f9f63a15604d1f3cb2fd92029d has been approved by |
bors
added
S-waiting-on-bors
| @@ -393,7 +393,11 @@ impl From<c::DWORD> for ExitStatus { | |||
|
|
|||
| impl fmt::Display for ExitStatus { | |||
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { | |||
| write!(f, "exit code: {}", self.0) | |||
| if self.0 & 0x80000000 != 0 { | |||
There was a problem hiding this comment.
It would be nice to have a comment explaining this heuristic briefly.
There was a problem hiding this comment.
@varkor Apparently, ExitProcess is a newtype for u32 on Windows. And Windows uses sometimes system error codes, sometimes NTSTATUS.
The self.0 & 0x80000000 != 0 for u32 acts like self.0 < 0 for i32, but I'd render informational status codes (the ones within 0x40000000 − 0x7FFFFFFF range) as hexadecimal as well.
There was a problem hiding this comment.
I'm not sure why only large codes are printed in hexadecimal. What's the problem with printing all codes in hexadecimal? We wouldn't need any heuristics and comments then.
(Small codes are documented and searchable in both hexadecimal and decimal forms.)
There was a problem hiding this comment.
Are there any examples of exceptions crashing the process that have an informational status codes though?
There was a problem hiding this comment.
@petrochenkov Because system error codes are decimal. For example, 12000 - 12175 is reserved for Internet Error codes. So, displaying it in hexadecimal would be the opposite of this PR.
|
💡 This pull request was already approved, no need to approve it again.
|
|
📌 Commit 415f514687e406f9f63a15604d1f3cb2fd92029d has been approved by |
On Windows process exit codes are never signals but rather always 32-bit integers. Most faults like segfaults and such end up having large integers used to represent them, like STATUS_ACCESS_VIOLATION being 0xC0000005. Currently, however, when an `ExitStatus` is printed this ends up getting rendered as 3221225477 which is somewhat more difficult to debug. This commit adds a branch in `Display for ExitStatus` on Windows which handles exit statuses where the high bit is set and prints those exit statuses as hex instead of with decimals. This will hopefully preserve the current display for small exit statuses (like `exit code: 22`), but assist in quickly debugging segfaults/access violations/etc. I've found at least that the hex codes are easier to search for than decimal. I wasn't able to find any official documentation saying that all system exit codes have the high bit set, but I figure it's a good enough heuristic for now.
alexcrichton
force-pushed
the
hex-display-on-windows
branch
from
415f514 to
bbb5448
Compare
|
@bors: r=Kimundi |
|
📌 Commit bbb5448 has been approved by |
…, r=Kimundi std: Render large exit codes as hex on Windows On Windows process exit codes are never signals but rather always 32-bit integers. Most faults like segfaults and such end up having large integers used to represent them, like STATUS_ACCESS_VIOLATION being 0xC0000005. Currently, however, when an `ExitStatus` is printed this ends up getting rendered as 3221225477 which is somewhat more difficult to debug. This commit adds a branch in `Display for ExitStatus` on Windows which handles exit statuses where the high bit is set and prints those exit statuses as hex instead of with decimals. This will hopefully preserve the current display for small exit statuses (like `exit code: 22`), but assist in quickly debugging segfaults/access violations/etc. I've found at least that the hex codes are easier to search for than decimal. I wasn't able to find any official documentation saying that all system exit codes have the high bit set, but I figure it's a good enough heuristic for now.
…, r=Kimundi std: Render large exit codes as hex on Windows On Windows process exit codes are never signals but rather always 32-bit integers. Most faults like segfaults and such end up having large integers used to represent them, like STATUS_ACCESS_VIOLATION being 0xC0000005. Currently, however, when an `ExitStatus` is printed this ends up getting rendered as 3221225477 which is somewhat more difficult to debug. This commit adds a branch in `Display for ExitStatus` on Windows which handles exit statuses where the high bit is set and prints those exit statuses as hex instead of with decimals. This will hopefully preserve the current display for small exit statuses (like `exit code: 22`), but assist in quickly debugging segfaults/access violations/etc. I've found at least that the hex codes are easier to search for than decimal. I wasn't able to find any official documentation saying that all system exit codes have the high bit set, but I figure it's a good enough heuristic for now.
Rollup of 16 pull requests Successful merges: - #57351 (Don't actually create a full MIR stack frame when not needed) - #57353 (Optimise floating point `is_finite` (2x) and `is_infinite` (1.6x).) - #57412 (Improve the wording) - #57436 (save-analysis: use a fallback when access levels couldn't be computed) - #57453 (lldb_batchmode.py: try `import _thread` for Python 3) - #57454 (Some cleanups for core::fmt) - #57461 (Change `String` to `&'static str` in `ParseResult::Failure`.) - #57473 (std: Render large exit codes as hex on Windows) - #57474 (save-analysis: Get path def from parent in case there's no def for the path itself.) - #57494 (Speed up item_bodies for large match statements involving regions) - #57496 (re-do docs for core::cmp) - #57508 (rustdoc: Allow inlining of reexported crates and crate items) - #57547 (Use `ptr::eq` where applicable) - #57557 (resolve: Mark extern crate items as used in more cases) - #57560 (hygiene: Do not treat `Self` ctor as a local variable) - #57564 (Update the const fn tracking issue to the new metabug) Failed merges: r? @ghost
On Windows process exit codes are never signals but rather always 32-bit
integers. Most faults like segfaults and such end up having large
integers used to represent them, like STATUS_ACCESS_VIOLATION being
0xC0000005. Currently, however, when an
ExitStatusis printed thisends up getting rendered as 3221225477 which is somewhat more difficult
to debug.
This commit adds a branch in
Display for ExitStatuson Windows whichhandles exit statuses where the high bit is set and prints those exit
statuses as hex instead of with decimals. This will hopefully preserve
the current display for small exit statuses (like
exit code: 22), butassist in quickly debugging segfaults/access violations/etc. I've
found at least that the hex codes are easier to search for than decimal.
I wasn't able to find any official documentation saying that all system
exit codes have the high bit set, but I figure it's a good enough
heuristic for now.