RFR: 8315066: Add unsigned bounds and known bits to TypeInt/Long [v21]

[Emanuel Peter]

On Thu, 19 Sep 2024 14:21:08 GMT, Quan Anh Mai <qamai at openjdk.org> wrote:

>> Hi,
>> 
>> This patch adds unsigned bounds and known bits constraints to TypeInt and TypeLong. This opens more transformation opportunities in an elegant manner as well as helps avoid some ad-hoc rules in Hotspot.
>> 
>> In general, a `TypeInt/Long` represents a set of values `x` that satisfies: `x s>= lo && x s<= hi && x u>= ulo && x u<= uhi && (x & zeros) == 0 && (x & ones) == ones`. These constraints are not independent, e.g. an int that lies in [0, 3] in signed domain must also lie in [0, 3] in unsigned domain and have all bits but the last 2 being unset. As a result, we must canonicalize the constraints (tighten the constraints so that they are optimal) before constructing a `TypeInt/Long` instance.
>> 
>> This is extracted from #15440 , node value transformations are left for later PRs. I have also added unit tests to verify the soundness of constraint normalization.
>> 
>> Please kindly review, thanks a lot.
>> 
>> Testing
>> 
>> - [x] GHA
>> - [x] Linux x64, tier 1-4
>
> Quan Anh Mai has updated the pull request incrementally with one additional commit since the last revision:
> 
>   address reviews

src/hotspot/share/opto/rangeinference.cpp line 93:

> 91:   // different from the corresponding bit in lo, since result is larger than lo
> 92:   // the bit must be 0 in lo and 1 in result. As result should be the smallest
> 93:   // value, this bit should be the last one possible.

The first sentence is a bit strange gramatically. Maybe just drop `The principle here is that`.
I also wonder if you want to first mention the paragraph below which says what you want.


  // The algorithm depends on whether the first violation violates zeros or
  // ones, if it violates zeros, we have the bit being 1 in zero_violation and
  // 0 in one_violation. Since all higher bits are 0 in zero_violation and
  // one_violation, we have zero_violation > one_violation. Similarly, if the
  // first violation violates ones, we have zero_violation < one_violation.


And only then make an example or two about larger / smaller.

Generally it is nice to know first where we are heading, and then also the intuition, and only then the details / examples :)

src/hotspot/share/opto/rangeinference.cpp line 118:

> 116:     // have all lower bits being 0. This value satisfies zeros, because all
> 117:     // bits before the first violation have already satisfied zeros, and all
> 118:     // bits after the first violation are 0. To satisfy 1, simply | this value

Suggestion:

    // bits after the first violation are 0. To satisfy ones, simply OR this value

src/hotspot/share/opto/rangeinference.cpp line 131:

> 129:     // This value must satisfy zeros, because all bits before the 2nd bit have
> 130:     // already satisfied zeros, and all bits after the 2nd bit are all 0 now.
> 131:     // Just | this value with ones to obtain the final result.

Suggestion:

    // Just OR this value with ones to obtain the final result.

src/hotspot/share/opto/rangeinference.cpp line 144:

> 142:     //           1 1 0 0 1 0 1 0
> 143:     return lo | bits._ones;
> 144:   } else {

Suggestion:

  } else {
    // The first bit that does not satisfy the bit requirement is a 1 but should be a 0.

src/hotspot/share/opto/rangeinference.cpp line 146:

> 144:   } else {
> 145:     // This is more difficult because trying to unset a bit requires us to flip
> 146:     // some bits before it.

Suggestion:

    // some bits before it (the more significant bits).

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1767027307
PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1767018301
PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1767030195
PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1767034123
PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1767032614