Refactor subrange assertion generation and propagation #55186

Move it into its own function. No diffs.

They are not useful: they do not tell us anything about the value. They can be harmful: code operating on the assertions can wrongly remove a checked cast because of an assertion for a non-checked one.

This change completely refactors the way subrange assertions are generated and consumed. It rationalizes and generalizes the model for subrange assertions which are generated and propagated for casts, makes AssertionDsc::Range into an actual abstraction, eliminates bugs related to wrong assertions generated for TYP_BOOL (without CQ loss), enables propagation for checked casts to non-small types both on 64 and 32 bit, all the while making the AssertionDsc structure smaller. There are quite a few moving parts, but at the heart of this change are following items: 1. Make ranges symbolic, i. e. made up of symbolic upper and lower bounds, represented by the new SymbolicIntegerValue enum class. This is necessary to not regress memory consumption and throughput of operations on 32 bit while handling long subranges. 2. Split the concept of "input" and "output" for a cast node. To properly handle checked cast and make the code "obviously correct", it is necessary to split the two values, one the cast node produces and one it consumes, apart. The old code only handles the "easy" case of the "input" and "output" ranges matching (such is the case for small types), the new code must be, and is, robust in reasoning about, e. g. CAST_OVF(uint <- ulong) vs CAST_OVF(int <- long). The ranges that represent these values are consistently in the "signed" format, making handling them easy. 3. Tweak the propagation code to not remove representation-changing casts, make it explicit and obvious in what cases (and why) it retypes the local under the cast. As a side-effect of the above changes, TYP_BOOL is now treated as TYP_UBYTE in propagation, as it should be. Actually, the old code didn't remove redundant casts to TYP_BOOL, the new code does, which is also where the bulk of the positive diffs come from. The old code also generated "useless" ranges like [INT_MIN..INT_MAX], the new code only generates ranges that could be used in subsequent propagation. Also, some miscellaneous cleanup, such as adding function headers, was performed.

In global assertion propagation, tentative assertions are created for casts, with the expectation that proving them via implication will allow for removing the cast. The old code did this through the common path with local assertions, however, this cannot be done the same way anymore because the two types of assertions are fundamnetally different. In local assertion propagation, subranges are derived from ASGs, where the cast is on the RHS and the local - LHS, so the "output" range for the cast must be used - local is assigned value the cast **produces**. In contrast, global subrange assertions say that the value the cast **consumes** is within the correct bounds for the cast to become a no-op or non-overflowing. Because of this fundamnetal distinction, I chose to make global assertions for casts in a new method instead of plumbing it through "optCreateAssertion". Note that it would be possible to do it via "optCreateAssertion" as well - global propagation always passes OAK_SUBRANGE to it, while local - OAK_EQUAL, but I decided against that option for the reason that it seems unintuitive to me that it would work the way it would. These tentative assertions are a very special case, so I think it is better to treat them that way. This leads to some minor code duplication, but I think that's ok. No diffs for this commit, though that's expected as "proving" the generated assertion is quite rare.

Make IntegralRange the owner of the logic for various methods relating to it and decouple it from AssertionDsc. IntegralRange will be useful in the future for other code that deals with cast removal, e. g. in fgMorphCast. Also some miscellaneous formatting fixups.

Using a static array results in smaller and more efficient code on all compilers.

This change is for completeness, since "fgMorphCast" decomposes casts from FP types to small types today and as such assertions are generated for them anyway. No diffs for this commit as expected.

To avoid regressions.

They did not handle "long" cases and as such were too conservative.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Refactor subrange assertion generation and propagation #55186

Refactor subrange assertion generation and propagation #55186

Commits on Sep 17, 2021