Elide bounds checks in descending formatting loops

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[tannergooding]

Adds conservative monotonically-decreasing induction-variable analysis to range-check elimination. The proof distinguishes dominating entries from backedges, accounts for overflow and subtraction, and rejects nested or irreducible phi shapes it cannot prove safely.

This lets pre-decrement loops establish both bounds for adjacent writes while retaining bounds protection when the induction variable can underflow.

---

Updates the UInt32 and UInt64 decimal formatters to use exact spans and safe descending pair writes through MemoryMarshal.CreateSpan and the existing WriteTwoDigits helper. This removes the hot destination bounds check involved in #132840 without architecture-specific or unsafe call-site code.

Local x64 BenchmarkDotNet results:

Benchmark	Before	After	Change
UTF-16 TryFormatL	36.78 ns	34.41 ns	-6.4%
UTF-8 TryFormatUtf8L	36.74 ns	34.23 ns	-6.8%

Arm64 AltJit disassembly confirms the destination range check is removed from the pair-write loop. Digit-table validation remains independent of this change.

Note

This pull request description was drafted by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

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

[Copilot]

Copilot review overview

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both…

What changed in this PR

This PR extends CoreCLR JIT range-check elimination with a conservative monotonicity direction concept (increasing vs decreasing) and updates the UInt32/UInt64 decimal formatting fast paths to use descending two-digit writes via MemoryMarshal.CreateSpan + the existing WriteTwoDigits helper, with accompanying JIT regression tests.

Changes:

• Add Monotonicity (None/Increasing/Decreasing) to range analysis and update phi-merge/widening logic to support descending induction variables.
• Rewrite UInt32ToDecChars/UInt64ToDecChars fast paths to write exact spans in a descending loop using WriteTwoDigits.
• Add JIT opt tests covering descending pair writes and underflow/overflow cases to validate bounds-check behavior.

File	Description
src/​coreclr/​jit/​rangecheck.h	Introduces Monotonicity and threads it through range computation/merge APIs.
src/​coreclr/​jit/​rangecheck.cpp	Implements decreasing-monotonicity proof logic and updates widening/overflow handling to consider GT_SUB and descending loops.
src/​libraries/​System.Private.CoreLib/​src/​System/​Number.Formatting.cs	Updates UInt32/UInt64 decimal formatting loops to use descending two-digit span writes and adjusts destination length checks.
src/​tests/​JIT/​opt/​RangeChecks/​ElidedBoundsChecks.cs	Adds a descending pair-write loop test using MemoryMarshal.CreateSpan and validates results without reintroducing range-check helpers.
src/​tests/​JIT/​opt/​RangeChecks/​Overflow.cs	Adds a descending-underflow scenario to ensure bounds checks are not incorrectly elided when the IV can wrap.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: 1

New issues introduced by this change (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but…

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — In RangeCheck::Widen, the monotonic recomputation assigns *pRange = GetRangeWorker(...). If both… View resolved comment

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

Issues resolved since last review (1)

Severity	Finding
	src/​coreclr/​jit/​rangecheck.cpp — The BetweenBounds doc comment still says it assumes an increasing loop / symbolic upper bound, but… View resolved comment

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

src/coreclr/jit/assertionprop.cpp:4478

• The doc comment says this returns true when range analysis proves the relop’s “non-throwing relation”, but this helper is also used for the throwing forms (e.g., start + width > limit), where “proven in-bounds” means the relop is always false. Updating the comment to describe what is actually proven (the access is in-bounds) will avoid future misuse/confusion when adding new operator shapes.

// Returns:
// True if range analysis proves the non-throwing relation represented by the relop.
//

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None

[azure-pipelines]

Azure Pipelines:
Successfully started running 5 pipeline(s).
11 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[tannergooding]

SuperPMI shows net code-size improvements on every reported target:

Target	Overall code size
browser-wasm	-971 bytes
linux-arm64	-808,040 bytes
windows-arm64	-683,920 bytes
osx-arm64	-49,628 bytes
linux-x64	-606,226 bytes
windows-x64	-60,969 bytes

The absolute totals are corpus-dependent. In particular, Linux x64 includes coreclr_tests, libraries_tests, and libraries_tests_no_tiered_compilation, which are absent from the Windows x64 run and account for -535,396 bytes. Across the collections shared by both, Linux x64 is -70,830 bytes versus Windows x64 at -60,969 bytes.

Some representative wins:

• Arm64 UInt32ToDecChars<byte>(..., digits) is -164 bytes (-43.62%), and UInt64ToDecChars<byte>(..., digits) is -164 bytes (-41.41%).
• Arm64 Tier1 UInt32ToDecChars<char> goes from 240 to 232 bytes and 60 to 58 instructions; its reported PerfScore improves from 38.86 to 37.36 on Windows.
• Windows x64 UInt32ToDecChars<byte>(..., digits) is -97 bytes (-34.77%), while the corresponding UInt64 method is -97 bytes (-32.23%).
• The more general range-check improvements also show up in TimeSpanFormat.TryFormatStandard<char> (-402 bytes / -14.46% on Windows x64) and AssemblyNameFormatter.AppendDisplayName (-708 bytes on Arm64, -446 bytes on Windows x64).

Note

This comment was prepared with GitHub Copilot assistance.

[Copilot]

Copilot review overview

🔵 Needs a closer look

Review tier: Lite
Findings: None