JIT: Compute async liveness for address exposed locals by jakobbotsch · Pull Request #124001 · dotnet/runtime

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch · 2026-02-04T12:39:15Z

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

Based on #123500

…ive-set

…inopts-async-live-set

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

dotnet-policy-service · 2026-02-04T12:40:13Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR enables precise liveness computation for address-exposed locals during async transformations. Building on #123500 (which introduced full liveness computation for MinOpts with async), this change recognizes that local addresses cannot be taken across async suspension points, allowing the JIT to track address-exposed locals directly instead of conservatively treating them as always live.

Changes:

Refactored the Liveness class template to support multiple liveness computation modes via compile-time template parameters (TrackAddressExposedLocals, IsEarly, EliminateDeadCode)
Replaced fgLocalVarLiveness() with specialized functions: fgSsaLiveness(), fgAsyncLiveness(), and fgPostLowerLiveness()
Extracted lvaComputePreciseRefCounts() from lvaComputeRefCounts() to allow reuse in async transformations

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/coreclr/jit/liveness.cpp	Major refactoring of liveness computation to use template-based specialization; added `fgSsaLiveness()`, `fgAsyncLiveness()`, `fgPostLowerLiveness()`; renamed member variables for clarity; inlined `LiveVarAnalysis` into `DoLiveVarAnalysis()`
src/coreclr/jit/async.cpp	Updated to use `fgAsyncLiveness()` and `lvaComputePreciseRefCounts()`; simplified `AsyncLiveness` class by removing `m_hasLiveness` field; added cleanup logic for unoptimized codegen
src/coreclr/jit/compiler.h	Added declarations for new liveness functions and `lvaComputePreciseRefCounts()`; removed obsolete `fgLocalVarLivenessChanged` and `fgIsDoingEarlyLiveness` fields
src/coreclr/jit/lclvars.cpp	Extracted `lvaComputePreciseRefCounts()` as a separate function for reuse
src/coreclr/jit/ssabuilder.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`
src/coreclr/jit/lower.cpp	Updated calls from `fgLocalVarLiveness()` to `fgPostLowerLiveness()`
src/coreclr/jit/compiler.cpp	Updated call from `fgLocalVarLiveness()` to `fgSsaLiveness()`

…xposed-liveness

jakobbotsch · 2026-02-06T14:03:45Z

/azp run Fuzzlyn

azure-pipelines · 2026-02-06T14:04:02Z

Azure Pipelines successfully started running 1 pipeline(s).

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 2 comments.

jakobbotsch · 2026-02-06T18:15:04Z

cc @dotnet/jit-contrib PTAL @AndyAyersMS

This starts tracking address exposed locals for the liveness we do in the runtime async pass. It is based on a few observations:

The async transformation does not need liveness to be correct except at async suspension points. Concretely, with this PR the liveness can be wrong for address exposed locals between suspension points. In other words, we may consider locals to be dead that are actually live. It would be wrong to use any of this liveness for anything (like DCE), but we do not do that after recent PRs.
At async suspension points we know that the address of each local is not taken anymore. At those points the local is hence only live if we can see a "proper" use before a def after the call.
A "proper" use is either a normal LCL_VAR/LCL_FLD, but it can also be a LCL_ADDR now (retaking the address of a local after a suspension point). No change is needed for this as the LIR liveness already processes LCL_ADDRs and generally considers these to be uses.

Diffs.

This should still give correct liveness at async suspension points given that local addresses cannot be taken across those. Based on dotnet#123500

jakobbotsch added 20 commits January 30, 2026 09:37

Optimize
9984b85

Switch to actual liveness
3159721

Merge branch 'main' of github.com:dotnet/runtime into minopts-async-l…
ca19413
…ive-set

Fixes after merge, further cleanups
f710b0e

More
5aca215

Remove unnecessary code
e2c1306

Fixes
41477c1

Run jit-format
f93c87e

Unnecessary change
06c8ca3

Further cleanups
35d1a65

Fix
c56f1b4

Fix func header
c9c7184

Further liveness cleanups
6f4c5d5

Rename
91b6a0e

Remove LiveVarAnalysis class
de37c04

Remove fgIsDoingEarlyLiveness
cc86708

Run jit-format
055ddd6

Merge remote-tracking branch 'origin/further-liveness-cleanup' into m…
bd0a2d7
…inopts-async-live-set

Fix after merge
6324131

JIT: Compute async liveness for address exposed locals
71460a0
This should still give correct liveness at async suspension points given that local addresses cannot be taken across those.

CopilotAI review requested due to automatic review settings February 4, 2026 12:39

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label Feb 4, 2026

dotnet-policy-serviceBot assigned jakobbotsch Feb 4, 2026

Copilotstarted reviewing on behalf of jakobbotsch February 4, 2026 12:40 View session

CopilotAI reviewed Feb 4, 2026
View reviewed changes

Merge branch 'main' of github.com:dotnet/runtime into async-address-e…
11a999d
…xposed-liveness

build-analysisBot mentioned this pull request Feb 6, 2026
Tests failing on tvos with "The app 'net.dot.System.Runtime.Tests' terminated with signal 11" #124072
Closed

jakobbotsch marked this pull request as ready for review February 6, 2026 18:00

CopilotAI review requested due to automatic review settings February 6, 2026 18:00

Copilotstarted reviewing on behalf of jakobbotsch February 6, 2026 18:01 View session

CopilotAI reviewed Feb 6, 2026
View reviewed changes

Comment threadsrc/coreclr/jit/liveness.cpp
Comment threadsrc/coreclr/jit/liveness.cpp

jakobbotsch requested a review from AndyAyersMS February 6, 2026 18:15

AndyAyersMS approved these changes Feb 6, 2026
View reviewed changes

This was referenced Feb 6, 2026
Test failure: baseservices/exceptions/stackoverflow/stackoverflowtester/stackoverflowtester.cmd #110173
Open
crossgen2 failure running on tests: Assertion failed: value1.Context == value2.Context #124014
Closed

jakobbotsch merged commit 4c4c14a into dotnet:mainFeb 9, 2026
127 of 138 checks passed

jakobbotsch deleted the async-address-exposed-liveness branch February 9, 2026 11:32

dotnet-maestroBot mentioned this pull request Feb 10, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#4727
Merged

jakobbotsch mentioned this pull request Feb 16, 2026
[RuntimeAsync] Implement suspension-aware liveness and dead-code elimination #115261
Closed

github-actionsBot locked and limited conversation to collaborators Mar 12, 2026

jakobbotsch added the runtime-async label Mar 24, 2026