[Attributor] Removing unnecessary `virtual` keywords.

[sstefan1]

Summary

Some function in the Attributor framework are unnecessarily marked virtual. This patch removes virtual keyword

[jdoerfert]

LGTM

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

struct AAReturnedValues : public AbstractAttribute {
   ///
   /// This method will evaluate \p Pred on returned values and return
   /// true if (1) all returned values are known, and (2) \p Pred returned true
   /// for all returned values.
   virtual bool
   checkForallReturnedValues(std::function<bool(Value &)> &Pred) const = 0;
 
   /// See AbstractAttribute::getAttrKind()
-  virtual Attribute::AttrKind getAttrKind() const override { return ID; }
+  Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::Returned;
 };
 
 struct AANoUnwind : public AbstractAttribute {
   /// An abstract interface for all nosync attributes.
   AANoUnwind(Value &V, InformationCache &InfoCache)
       : AbstractAttribute(V, InfoCache) {}
 
   /// See AbstractAttribute::getAttrKind()/
-  virtual Attribute::AttrKind getAttrKind() const override { return ID; }
+  Attribute::AttrKind getAttrKind() const override { return ID; }
 
   static constexpr Attribute::AttrKind ID = Attribute::NoUnwind;
 
   /// Returns true if nounwind is assumed.
   virtual bool isAssumedNoUnwind() const = 0;
 
   /// Returns true if nounwind is known.
   virtual bool isKnownNoUnwind() const = 0;
 };
 
 struct AANoSync : public AbstractAttribute {
   /// An abstract interface for all nosync attributes.
   AANoSync(Value &V, InformationCache &InfoCache)
       : AbstractAttribute(V, InfoCache) {}
 
   /// See AbstractAttribute::getAttrKind().
-  virtual Attribute::AttrKind getAttrKind() const override {
+  Attribute::AttrKind getAttrKind() const override {
     return ID;
   }
 
   static constexpr Attribute::AttrKind ID =
       Attribute::AttrKind(Attribute::NoSync);
 
   /// Returns true if "nosync" is assumed.
   virtual bool isAssumedNoSync() const = 0;
 
   /// Returns true if "nosync" is known.
   virtual bool isKnownNoSync() const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

struct AANoUnwindFunction : AANoUnwind, BooleanState {
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getManifestPosition().
-  virtual ManifestPosition getManifestPosition() const override {
+  ManifestPosition getManifestPosition() const override {
     return MP_FUNCTION;
   }
 
-  virtual const std::string getAsStr() const override {
+  const std::string getAsStr() const override {
     return getAssumed() ? "nounwind" : "may-unwind";
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A) override;
 
   /// See AANoUnwind::isAssumedNoUnwind().
-  virtual bool isAssumedNoUnwind() const override { return getAssumed(); }
+  bool isAssumedNoUnwind() const override { return getAssumed(); }
 
   /// See AANoUnwind::isKnownNoUnwind().
-  virtual bool isKnownNoUnwind() const override { return getKnown(); }
+  bool isKnownNoUnwind() const override { return getKnown(); }
 };
 
 ChangeStatus AANoUnwindFunction::updateImpl(Attributor &A) {
   Function &F = getAnchorScope();
 
   // The map from instruction opcodes to those instructions in the function.
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
   auto Opcodes = {
void initialize(Attributor &A) override {
     for (Instruction *RI : OpcodeInstMap[Instruction::Ret]) {
       SmallPtrSet<ReturnInst *, 1> RISet({cast<ReturnInst>(RI)});
       collectValuesRecursively(A, cast<ReturnInst>(RI)->getReturnValue(), RISet,
                                ReturnedValues);
     }
   }
 
   /// See AbstractAttribute::manifest(...).
-  virtual ChangeStatus manifest(Attributor &A) override;
+  ChangeStatus manifest(Attributor &A) override;
 
   /// See AbstractAttribute::getState(...).
-  virtual AbstractState &getState() override { return *this; }
+  AbstractState &getState() override { return *this; }
 
   /// See AbstractAttribute::getState(...).
-  virtual const AbstractState &getState() const override { return *this; }
+  const AbstractState &getState() const override { return *this; }
 
   /// See AbstractAttribute::getManifestPosition().
-  virtual ManifestPosition getManifestPosition() const override {
+  ManifestPosition getManifestPosition() const override {
     return MP_ARGUMENT;
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A) override;
 
   /// Return the number of potential return values, -1 if unknown.
   size_t getNumReturnValues() const {
     return isValidState() ? ReturnedValues.size() : -1;
   }
 
   /// Return an assumed unique return value if a single candidate is found. If
   /// there cannot be one, return a nullptr. If it is not clear yet, return the
   /// Optional::NoneType.
   Optional<Value *> getAssumedUniqueReturnValue() const;
 
   /// See AbstractState::checkForallReturnedValues(...).
-  virtual bool
+  bool
   checkForallReturnedValues(std::function<bool(Value &)> &Pred) const override;
 
   /// Pretty print the attribute similar to the IR representation.
-  virtual const std::string getAsStr() const override;
+  const std::string getAsStr() const override;
 
   /// See AbstractState::isAtFixpoint().
   bool isAtFixpoint() const override { return IsFixed; }
 
   /// See AbstractState::isValidState().
   bool isValidState() const override { return IsValidState; }
 
   /// See AbstractState::indicateOptimisticFixpoint(...).