[Attributor][NFC][AAPotentialValues] Change interface of PotentialValuesState

[okura]

Summary

Previously PotentialValuesState inherited BooleanState.
We have to add getAssumed to the state in order to use clampStateAndIndicateChange (which will be used in AAPotentialValuesArgument).
However BooleanState::getAssumed is not a virtual function and we cannot override it.
Therefore, I changed the state not to inherit BooleanState and add getAssumed to it.

[jdoerfert]

This is NFC, feel free to add that to the commit message as a tag. LGTM.

llvm/include/llvm/Transforms/IPO/Attributor.h

 /// The assumed boolean state indicates whether the corresponding set is full
 /// set or not. If the assumed state is false, this is the worst state. The
 /// worst state (invalid state) of set of potential values is when the set
 /// contains every possible value (i.e. we cannot in any way limit the value
 /// that the target position can take). That never happens naturally, we only
 /// force it. As for the conditions under which we force it, see
 /// AAPotentialValues.
 template <typename MemberTy, typename KeyInfo = DenseMapInfo<MemberTy>>
-struct PotentialValuesState : BooleanState {
+struct PotentialValuesState : AbstractState {
   using SetTy = DenseSet<MemberTy, KeyInfo>;
 
-  PotentialValuesState() : BooleanState(true) {}
+  PotentialValuesState() : IsValidState(true) {}
 
-  PotentialValuesState(bool IsValid) : BooleanState(IsValid) {}
+  PotentialValuesState(bool IsValid) : IsValidState(IsValid) {}
+
+  /// See AbstractState::isValidState(...)
+  bool isValidState() const { return IsValidState.isValidState(); }
+
+  /// See AbstractState::isAtFixpoint(...)
+  bool isAtFixpoint() const { return IsValidState.isAtFixpoint(); }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() {
+    return IsValidState.indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() {
+    return IsValidState.indicateOptimisticFixpoint();
+  }
+
+  /// Return the assumed state
+  PotentialValuesState &getAssumed() { return *this; }
+  const PotentialValuesState &getAssumed() const { return *this; }
 
   /// Return this set. We should check whether this set is valid or not by
   /// isValidState() before calling this function.
   const SetTy &getAssumedSet() const {
     assert(isValidState() && "This set shoud not be used when it is invalid!");
     return Set;
   }
 
void intersectWith(const PotentialValuesState &R) {
     SetTy IntersectSet;
     for (const MemberTy &C : Set) {
       if (R.Set.count(C))
         IntersectSet.insert(C);
     }
     Set = IntersectSet;
   }
 
+  /// A helper state which indicate whether this state is valid or not.
+  BooleanState IsValidState;
+
   /// Container for potential values
   SetTy Set;
 };
 
 using PotentialConstantIntValuesState = PotentialValuesState<APInt>;
 
 raw_ostream &operator<<(raw_ostream &OS,
                         const PotentialConstantIntValuesState &R);