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

[Quan Anh Mai]

On Wed, 18 Sep 2024 14:33:05 GMT, Emanuel Peter <epeter at openjdk.org> wrote:

>> Quan Anh Mai has updated the pull request incrementally with one additional commit since the last revision:
>> 
>>   refine comments
>
> src/hotspot/share/opto/rangeinference.hpp line 75:
> 
>> 73: 
>> 74: template <class S, class U>
>> 75: class CanonicalizedTypeIntPrototype {
> 
> Ah, is this basically an **Optional**, like `std::optional`? Maybe add a comment above the class for that!
> 
> Honestly, you could also just define a `Optional<T>` class. Maybe even in a separate `optional.hpp` file. I'm sure we can use this construct again.

I have thought about that but implementing an `Optional` itself is not very trivial, so I stick to these which has the additional benefit of being specific to what it is used for. This is my prototype which I have not thought out too closely yet.

    template <class T>
    class Optional {
    private:
      // A union may have no member active, which is needed here 
      // A char[sizeof(T)] would need std::launder to work properly
      union {
        T _value;
      };
      bool _present;

    public:
      Optional() : _present(false) {}

      Optional(const T& val) : _present(true) {
        ::new(&_value) T(val);
      }

      template <class... Ts>
      explicit Optional(InPlace tag, Ts... args) : _present(true) {
        ::new(&_value) T(args...);
      }

      Optional(const Optional<T>& o) : _present(o._present) {
        if (_present) {
          ::new(&_value) T(o._value);
        }
      }

      Optional& operator=(const Optional<T>& o) {
        if (_present) {
          _value.~T();
        }

        _present = o._present;
        if (_present) {
          ::new(&_value) T(o._value);
        }
      }

      ~Optional() {
        if (_present) {
          _value.~T();
        }
      }

      bool has_value() const {
        return _present;
      }

      T& value() {
        assert(_present, "empty optional");
        return _value;
      }

      const T& value() const {
        assert(_present, "empty optional");
        return _value;
      }
    };

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

PR Review Comment: https://git.openjdk.org/jdk/pull/17508#discussion_r1765622150