Add discriminators to DILocations when multiple functions are inlined into a single point. #132613
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
r? @chenyukang rustbot has assigned @chenyukang. Use |
rustbot
added
S-waiting-on-review
This comment has been minimized.
This comment has been minimized.
|
@bors try |
bors
added a commit
to rust-lang-ci/rust
that referenced
this pull request
Nov 5, 2024
Add discriminators to DILocations when multiple functions are inlined into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling. Fixes rust-lang#131944
|
☀️ Try build successful - checks-actions |
|
@bors try |
bors
added a commit
to rust-lang-ci/rust
that referenced
this pull request
Nov 5, 2024
Add discriminators to DILocations when multiple functions are inlined into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling. Fixes rust-lang#131944 try-job: x86_64-msvc try-job: i686-msvc
This comment was marked as resolved.
This comment was marked as resolved.
This comment was marked as resolved.
This comment was marked as resolved.
This comment has been minimized.
This comment has been minimized.
|
💔 Test failed - checks-actions |
bors
added
S-waiting-on-author
|
(I edited the PR description to include a few "selected" try-jobs which should bring about reasonable target variance, rest is probably full build) |
|
@bors try |
bors
added a commit
to rust-lang-ci/rust
that referenced
this pull request
Nov 7, 2024
Add discriminators to DILocations when multiple functions are inlined into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling. Fixes rust-lang#131944 try-job: x86_64-msvc try-job: i686-msvc try-job: x86_64-mingw try-job: aarch64-apple try-job: test-various try-job: dist-various-1 try-job: armhf-gnu
This comment has been minimized.
This comment has been minimized.
|
💔 Test failed - checks-actions |
jieyouxu
reviewed
Nov 7, 2024
|
@bors try |
bors
added a commit
to rust-lang-ci/rust
that referenced
this pull request
Nov 7, 2024
Add discriminators to DILocations when multiple functions are inlined into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling. Fixes rust-lang#131944 try-job: x86_64-msvc try-job: i686-msvc try-job: x86_64-mingw try-job: aarch64-apple try-job: test-various try-job: dist-various-1 try-job: armhf-gnu
This comment has been minimized.
This comment has been minimized.
|
💔 Test failed - checks-actions |
bors
added
the
S-waiting-on-bors
rustbot
added
the
beta-nominated
|
@bors rollup=never |
|
☔ The latest upstream changes (presumably #132584) made this pull request unmergeable. Please resolve the merge conflicts. |
bors
added
S-waiting-on-author
|
Unfortunately needs a rebase, r=me after that. @bors delegate |
|
Er maybe @bors delegate+ |
… into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling. Fixes rust-lang#131944
|
@bors r+ rollup=never p=1 (fixes a P-critical, but also make it easier to bisect) |
bors
added
S-waiting-on-bors
|
☀️ Test successful - checks-actions |
|
Finished benchmarking commit (b026d85): comparison URL. Overall result: no relevant changes - no action needed@rustbot label: -perf-regression Instruction countThis benchmark run did not return any relevant results for this metric. Max RSS (memory usage)Results (primary -1.7%, secondary -3.2%)This is a less reliable metric that may be of interest but was not used to determine the overall result at the top of this comment.
CyclesThis benchmark run did not return any relevant results for this metric. Binary sizeResults (primary 0.0%)This is a less reliable metric that may be of interest but was not used to determine the overall result at the top of this comment.
Bootstrap: 781.253s -> 780.559s (-0.09%) |
mati865
pushed a commit
to mati865/rust
that referenced
this pull request
Nov 12, 2024
Add discriminators to DILocations when multiple functions are inlined into a single point. LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM. This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling.
|
Beta backport visited during triage meeting on Zulip. We're not completely clear about the value added by backporting this. Is this regression really critical? Also the patch fixing this is a bit suspect of causing another ICE (#132900). So let's postpone the backport decision for a week (release in 2 weeks from now) waiting to have more info. |
bors
added a commit
to rust-lang-ci/rust
that referenced
this pull request
Nov 20, 2024
Drop debug info instead of panicking if we exceed LLVM's capability to represent it Recapping a bit of history here: In rust-lang#128861 I made debug info correctly represent parameters to inline functions by removing a fake lexical block that had been inserted to suppress LLVM assertions and by deduplicating those parameters. LLVM, however, expects to see a single parameter _with distinct locations_, particularly distinct inlinedAt values on the DILocations. This generally worked because no matter how deep the chain of inlines it takes two different call sites in the original function to result in the same function being present multiple times, and a function call requires a non-zero number of characters, but macros threw a wrench in that in rust-lang#131944. At the time I thought the issue there was limited to proc-macros, where an arbitrary amount of code can be generated at a single point in the source text. In rust-lang#132613 I added discriminators to DILocations that would otherwise be the same to repair rust-lang#131944[^1]. This works, but LLVM's capacity for discriminators is not infinite (LLVM actually only allocates 12 bits for this internally). At the time I thought it would be very rare for anyone to hit the limit, but rust-lang#132900 proved me wrong. In the relatively-minimized test case it also became clear to me that the issue affects regular macros too, because the call to the inlined function will (without collapse_debuginfo on the macro) be attributed to the (repeated, if the macro is used more than once) textual callsite in the macro definition. This PR fixes the panic by dropping debug info when we exceed LLVM's maximum discriminator value. There's also a preceding commit for a related but distinct issue: macros that use collapse_debuginfo should in fact have their inlinedAts collapsed to the macro callsite and thus not need discriminators at all (and not panic/warn accordingly when the discriminator limit is exhausted). Fixes rust-lang#132900 r? `@jieyouxu` [^1]: Editor's note: `fix` is a magic keyword in PR description that apparently will close the linked issue (it's closed already in this case, but still).
rustbot
removed
the
beta-nominated
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
LLVM does not expect to ever see multiple dbg_declares for the same variable at the same location with different values. proc-macros make it possible for arbitrary code, including multiple calls that get inlined, to happen at any given location in the source code. Add discriminators when that happens so these locations are different to LLVM.
This may interfere with the AddDiscriminators pass in LLVM, which is added by the unstable flag -Zdebug-info-for-profiling.
Fixes #131944