[NinoFloris]

Adds ModularRange, an interval on the ring of integers modulo 2^n. It replaces the existing range arithmetic in RBO, and optimize bools. A signed comparison is the unsigned comparison of the value with the sign bit flipped. Either produces the same kind of interval. A comparison pair becomes one intersection instead of per-signedness case analysis, and wraparound is a property of the interval instead of a guard.

For example x >= 10 && x <= 100 is [10, 100], x != 5 is [6, 4] wrapping through zero, and intersecting [6, 4] with [7, 5] gives [7, 4], the values other than 5 and 6.

The representation follows the replaced code. It works in target_size_t, so the 32-bit JIT does no 64-bit arithmetic for it.

It is intended as a code cleanup and should produce no diffs. Each consumer keeps the shapes it accepted before:

• optimize bools still requires two relational tests, no equalities, of the same signedness on a plain local that enclose at least two nonnegative values from both sides, or x >= 0 paired with a never-negative bound.
• RBO still answers the same implication questions over the same constant tests.

Prospective

The expanded functionality for optimize bools (~30 lines of gates removed and a few lines added) can then be handled in a follow-up to enable:

• equality tests, x != a && x != a + 1 and x > a && x == a + 1
• negative bounds, lo <= x <= hi with negative lo
• overlapping ranges, x > 10 && x > 100 to x > 100
• single values, x >= 10 && x <= 10 to x == 10, and constant results, x >= 20 && x < 10 to false
• offset bases, tests on x + c and x - c rather than a plain local
• mixed signedness, a signed test paired with an unsigned one
• LCL_FLD as the second operand
• symbolic pairs beyond a literal x >= 0, such as x > -1 && x < length or x < 0 && x < length

The follow-up also resolves the TODO whose code this PR replaces:

runtime/src/coreclr/jit/optimizebools.cpp

Lines 508 to 515 in 8586c68

	if ((*pRangeStart >= *pRangeEnd) || (*pRangeStart < 0) || (*pRangeEnd < 0) || !FitsIn(type, *pRangeStart) ||
	!FitsIn(type, *pRangeEnd))
	{
	// TODO: If ranges don't intersect we might be able to fold the condition to true/false.
	// Also, check again if any of the ranges are negative (in case of overflow after normalization)
	// and fits into the given type.
	return false;
	}

I ran into these shortcomings trying to unblock #119689.
This is the generalized form of what the experiment in #136739 needed.

Notes

Range check is not converted here. Its constant arithmetic almost fits, but two of its contracts complicate it: checked arithmetic reads a known result as proof that the operation cannot overflow, so a wrapped sum must stay unknown, and RangeOps keeps a known limit when only the other one overflows. A ring interval cannot express either, and adding those checks basically comes down to the current code.

More sharing may be possible, but I don't expect these to be zero-diff changes:

• fgOptimizeRelationalComparisonWithFullRangeConst in morph, 108 lines.
• fgOptimizeRelationalComparisonWithConst, 97 lines. Though it seems more geared towards optimal codegen, can make an attempt.

[azure-pipelines]

Azure Pipelines:
Successfully started running 6 pipeline(s).
9 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.

[NinoFloris]

https://dev.azure.com/dnceng-public/public/_build/results?buildId=1664106&view=ms.vss-build-web.run-extensions-tab