JIT: Only zero GC slots of address-exposed structs under SkipLocalsInit by EgorBo · Pull Request #129179 · dotnet/runtime

EgorBo · 2026-06-09T16:25:20Z

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


EgorBo · 2026-06-09T16:25:20Z

Closes#129174

Under SkipLocalsInit, a struct local with GC fields only needs its GC slots zeroed in the prolog for GC safety; its non-GC bytes can be left uninitialized. genZeroInitFrame already has a per-slot path that does this, but genCheckUseBlockInit counted the full struct size, pushing such structs over the block-init threshold so the whole struct was zeroed. Count only the GC-pointer slots for these structs so GC-sparse structs use the per-slot path. Fully-GC structs are unchanged (GC count == full size). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR adjusts CoreCLR JIT prolog zero-init heuristics so that, under SkipLocalsInit (!compInitMem), GC-sparse structs contribute to the block-init decision based on their GC slot count rather than their full stack size. This aims to avoid switching to block initialization (which would zero the whole struct) when only GC-pointer slots need to be zeroed for GC safety.

Changes:

Add a local helper (getInitSlotCount) in CodeGen::genCheckUseBlockInit to compute the effective prolog-zeroed “int-slot” count for a local.
For !compInitMem struct locals with GC pointers, count only GetLayout()->GetGCPtrCount() (scaled to int-sized slots) when computing genInitStkLclCnt.
Use this helper in both places where initStkLclCnt is accumulated for stack-resident must-init locals.

Copilot review noted that fgVarNeedsExplicitZeroInit assumes a large GC-sparse struct is fully block-initialized in the prolog, which the new GC-slot-only counting breaks (a removed/suppressed explicit zero-init or a value-numbered field could then wrongly assume the non-GC bytes are zero). Fix by restricting the GC-slot-only prolog init to address-exposed, GC-sparse structs that have no suppressed/removed explicit init (lvSuppressedZeroInit), via the shared helpers lvaGetPrologZeroInitSlotCount / fgVarPrologFullyZeroInits. Value numbering and the async mutated-set analysis now consult fgVarPrologFullyZeroInits before treating such a local as fully zero; explicit zero-inits removed by optRemoveRedundantZeroInits set lvSuppressedZeroInit and so stay on full block init. SPMI: clean replay on benchmarks.run + libraries.pmi; asmdiffs -18,831 (libraries.pmi) / -2,387 (benchmarks.run) with only minor (<=6 byte) regressions.

Copilot

Pull request overview

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

+// lvaGetPrologZeroInitSlotCount : Number of int-sized stack slots the prolog zeroes for a must-init local.
+//
+// Arguments:
+// lclNum - local var number
+//
+// Returns:
+// The int-sized (4-byte) slot count: just the GC-pointer slots for a GC-slot-only init (see
+// fgVarPrologFullyZeroInits), otherwise the full size. Used by CodeGen::genCheckUseBlockInit.
+//


+// Returns:
+// true if the prolog (when it zero-inits this local) zeroes all of its bytes; false if only its GC
+// slots are zeroed (an address-exposed GC-sparse struct under SkipLocalsInit, see genZeroInitFrame).
+//


CopilotAI review requested due to automatic review settings June 9, 2026 16:25

Copilotstarted reviewing on behalf of EgorBo June 9, 2026 16:25 View session

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