[LLVM] Fix -Wextra-semi

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

Please check it in if it's OK, because I don't have SVN write access.

[hans]

Looks good to me.

llvm/trunk/include/llvm/Analysis/LazyCallGraph.h

class Node {
     /// \brief Internal helper to remove a callee from this node.
     void removeEdgeInternal(Function &Callee);
 
   public:
     typedef LazyCallGraph::iterator iterator;
 
     Function &getFunction() const {
       return F;
-    };
+    }
 
     iterator begin() const {
       return iterator(*G, Callees.begin(), Callees.end());
     }
     iterator end() const { return iterator(*G, Callees.end(), Callees.end()); }
 
     /// Equality is defined as address equality.
     bool operator==(const Node &N) const { return this == &N; }

llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.h

public:
   }
 
   /// \brief Tests whether a library function is available.
   bool has(LibFunc::Func F) const {
     return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
   }
   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
     return Impl->isFunctionVectorizable(F, VF);
-  };
+  }
   bool isFunctionVectorizable(StringRef F) const {
     return Impl->isFunctionVectorizable(F);
-  };
+  }
   StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
     return Impl->getVectorizedFunction(F, VF);
-  };
+  }
 
   /// \brief Tests if the function is both available and a candidate for
   /// optimized code generation.
   bool hasOptimizedCodeGen(LibFunc::Func F) const {
     if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
       return false;
     switch (F) {
     default: break;

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

namespace llvm {
   class BitcodeDiagnosticInfo : public DiagnosticInfo {
     const Twine &Msg;
     std::error_code EC;
 
   public:
     BitcodeDiagnosticInfo(std::error_code EC, DiagnosticSeverity Severity,
                           const Twine &Msg);
     void print(DiagnosticPrinter &DP) const override;
-    std::error_code getError() const { return EC; };
+    std::error_code getError() const { return EC; }
 
     static bool classof(const DiagnosticInfo *DI) {
       return DI->getKind() == DK_Bitcode;
     }
   };
 
 } // End llvm namespace
 
 namespace std {
 template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {};
 }
 
 #endif

llvm/trunk/include/llvm/CodeGen/MachineScheduler.h

PostGenericScheduler(const MachineSchedContext *C):
     GenericSchedulerBase(C), Top(SchedBoundary::TopQID, "TopQ") {}
 
   ~PostGenericScheduler() override {}
 
   void initPolicy(MachineBasicBlock::iterator Begin,
                   MachineBasicBlock::iterator End,
                   unsigned NumRegionInstrs) override {
     /* no configurable policy */
-  };
+  }
 
   /// PostRA scheduling does not track pressure.
   bool shouldTrackPressure() const override { return false; }
 
   void initialize(ScheduleDAGMI *Dag) override;
 
   void registerRoots() override;
 

llvm/trunk/include/llvm/CodeGen/ScheduleDAG.h

public:
 
     /// \brief Boundary nodes are placeholders for the boundary of the
     /// scheduling region.
     ///
     /// BoundaryNodes can have DAG edges, including Data edges, but they do not
     /// correspond to schedulable entities (e.g. instructions) and do not have a
     /// valid ID. Consequently, always check for boundary nodes before accessing
     /// an assoicative data structure keyed on node ID.
-    bool isBoundaryNode() const { return NodeNum == BoundaryID; };
+    bool isBoundaryNode() const { return NodeNum == BoundaryID; }
 
     /// setNode - Assign the representative SDNode for this SUnit.
     /// This may be used during pre-regalloc scheduling.
     void setNode(SDNode *N) {
       assert(!Instr && "Setting SDNode of SUnit with MachineInstr!");
       Node = N;
     }
 

llvm/trunk/include/llvm/ExecutionEngine/ExecutionEngine.h

public:
   /// InstallLazyFunctionCreator - If an unknown function is needed, the
   /// specified function pointer is invoked to create it.  If it returns null,
   /// the JIT will abort.
   void InstallLazyFunctionCreator(FunctionCreator C) {
     LazyFunctionCreator = C;
   }
 
 protected:
-  ExecutionEngine(const DataLayout DL) : DL(std::move(DL)){};
+  ExecutionEngine(const DataLayout DL) : DL(std::move(DL)){}
   explicit ExecutionEngine(DataLayout DL, std::unique_ptr<Module> M);
   explicit ExecutionEngine(std::unique_ptr<Module> M);
 
   void emitGlobals();
 
   void EmitGlobalVariable(const GlobalVariable *GV);
 
   GenericValue getConstantValue(const Constant *C);

llvm/trunk/include/llvm/ExecutionEngine/RuntimeDyld.h

template <typename Derived> struct LoadedObjectInfoHelper : LoadedObjectInfo {
     std::unique_ptr<llvm::LoadedObjectInfo> clone() const override {
       return llvm::make_unique<Derived>(static_cast<const Derived &>(*this));
     }
   };
 
   /// \brief Memory Management.
   class MemoryManager {
   public:
-    virtual ~MemoryManager() {};
+    virtual ~MemoryManager() {}
 
     /// Allocate a memory block of (at least) the given size suitable for
     /// executable code. The SectionID is a unique identifier assigned by the
     /// RuntimeDyld instance, and optionally recorded by the memory manager to
     /// access a loaded section.
     virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                          unsigned SectionID,
                                          StringRef SectionName) = 0;
public:
 
   private:
     virtual void anchor();
   };
 
   /// \brief Symbol resolution.
   class SymbolResolver {
   public:
-    virtual ~SymbolResolver() {};
+    virtual ~SymbolResolver() {}
 
     /// This method returns the address of the specified function or variable.
     /// It is used to resolve symbols during module linking.
     ///
     /// If the returned symbol's address is equal to ~0ULL then RuntimeDyld will
     /// skip all relocations for that symbol, and the client will be responsible
     /// for handling them manually.
     virtual SymbolInfo findSymbol(const std::string &Name) = 0;

llvm/trunk/include/llvm/IR/DebugInfoMetadata.h

public:
   TypedDINodeRef(
       const TypedDINodeRef<U> &X,
       typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
           nullptr)
       : MD(X) {}
 
   operator Metadata *() const { return const_cast<Metadata *>(MD); }
 
-  bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; };
-  bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; };
+  bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; }
+  bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; }
 
   /// \brief Create a reference.
   ///
   /// Get a reference to \c N, using an \a MDString reference if available.
   static TypedDINodeRef get(const T *N);
 
   template <class MapTy> T *resolve(const MapTy &Map) const {
     if (!MD)

llvm/trunk/include/llvm/IR/DiagnosticPrinter.h

 };
 
 /// \brief Basic diagnostic printer that uses an underlying raw_ostream.
 class DiagnosticPrinterRawOStream : public DiagnosticPrinter {
 protected:
   raw_ostream &Stream;
 
 public:
-  DiagnosticPrinterRawOStream(raw_ostream &Stream) : Stream(Stream) {};
+  DiagnosticPrinterRawOStream(raw_ostream &Stream) : Stream(Stream) {}
 
   // Simple types.
   DiagnosticPrinter &operator<<(char C) override;
   DiagnosticPrinter &operator<<(unsigned char C) override;
   DiagnosticPrinter &operator<<(signed char C) override;
   DiagnosticPrinter &operator<<(StringRef Str) override;
   DiagnosticPrinter &operator<<(const char *Str) override;
   DiagnosticPrinter &operator<<(const std::string &Str) override;

llvm/trunk/include/llvm/MC/MCLinkerOptimizationHint.h

class MCLOHContainer {
   mutable uint64_t EmitSize;
 
   /// Keep track of all LOH directives.
   SmallVector<MCLOHDirective, 32> Directives;
 
 public:
   typedef SmallVectorImpl<MCLOHDirective> LOHDirectives;
 
-  MCLOHContainer() : EmitSize(0) {};
+  MCLOHContainer() : EmitSize(0) {}
 
   /// Const accessor to the directives.
   const LOHDirectives &getDirectives() const {
     return Directives;
   }
 
   /// Add the directive of the given kind \p Kind with the given arguments
   /// \p Args to the container.

llvm/trunk/include/llvm/MC/MCTargetAsmParser.h

virtual void convertToMapAndConstraints(unsigned Kind,
                                           const OperandVector &Operands) = 0;
 
   virtual const MCExpr *applyModifierToExpr(const MCExpr *E,
                                             MCSymbolRefExpr::VariantKind,
                                             MCContext &Ctx) {
     return nullptr;
   }
 
-  virtual void onLabelParsed(MCSymbol *Symbol) { };
+  virtual void onLabelParsed(MCSymbol *Symbol) { }
 };
 
 } // End llvm namespace
 
 #endif

llvm/trunk/lib/Analysis/ScalarEvolution.cpp

for (auto &AssumeVH : AC->assumptions()) {
     if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
       return true;
   }
 
   struct ClearWalkingBEDominatingCondsOnExit {
     ScalarEvolution &SE;
 
     explicit ClearWalkingBEDominatingCondsOnExit(ScalarEvolution &SE)
-        : SE(SE){};
+        : SE(SE){}
 
     ~ClearWalkingBEDominatingCondsOnExit() {
       SE.WalkingBEDominatingConds = false;
     }
   };
 
   // We don't want more than one activation of the following loop on the stack
   // -- that can lead to O(n!) time complexity.

llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

void operator()(ObjectLinkingLayerBase::ObjSetHandleT H,
                     const ObjListT &Objects,
                     const LoadedObjInfoListT &Infos) const {
       M.UnfinalizedSections[H] = std::move(M.SectionsAllocatedSinceLastLoad);
       M.SectionsAllocatedSinceLastLoad = SectionAddrSet();
       assert(Objects.size() == Infos.size() &&
              "Incorrect number of Infos for Objects.");
       for (unsigned I = 0; I < Objects.size(); ++I)
         M.MemMgr.notifyObjectLoaded(&M, *Objects[I]);
-    };
+    }
 
   private:
     OrcMCJITReplacement &M;
   };
 
   class NotifyFinalizedT {
   public:
     NotifyFinalizedT(OrcMCJITReplacement &M) : M(M) {}

llvm/trunk/lib/IR/DiagnosticInfo.cpp

void operator=(const std::string &Val) {
     if (!Val.empty()) {
       Pattern = std::make_shared<Regex>(Val);
       std::string RegexError;
       if (!Pattern->isValid(RegexError))
         report_fatal_error("Invalid regular expression '" + Val +
                                "' in -pass-remarks: " + RegexError,
                            false);
     }
-  };
+  }
 };
 
 static PassRemarksOpt PassRemarksOptLoc;
 static PassRemarksOpt PassRemarksMissedOptLoc;
 static PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable emitOptimizationRemark()

llvm/trunk/lib/Target/X86/X86CallFrameOptimization.cpp

public:
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
 private:
   // Information we know about a particular call site
   struct CallContext {
     CallContext()
         : Call(nullptr), SPCopy(nullptr), ExpectedDist(0),
-          MovVector(4, nullptr), NoStackParams(false), UsePush(false){};
+          MovVector(4, nullptr), NoStackParams(false), UsePush(false){}
 
     // Actuall call instruction
     MachineInstr *Call;
 
     // A copy of the stack pointer
     MachineInstr *SPCopy;
 
     // The total displacement of all passed parameters

llvm/trunk/lib/Target/X86/X86MachineFunctionInfo.h

 private:
   /// ForwardedMustTailRegParms - A list of virtual and physical registers
   /// that must be forwarded to every musttail call.
   SmallVector<ForwardedRegister, 1> ForwardedMustTailRegParms;
 
 public:
   X86MachineFunctionInfo() = default;
 
-  explicit X86MachineFunctionInfo(MachineFunction &MF) {};
+  explicit X86MachineFunctionInfo(MachineFunction &MF) {}
 
   bool getForceFramePointer() const { return ForceFramePointer;}
   void setForceFramePointer(bool forceFP) { ForceFramePointer = forceFP; }
 
   bool getHasPushSequences() const { return HasPushSequences; }
   void setHasPushSequences(bool HasPush) { HasPushSequences = HasPush; }
 
   bool getRestoreBasePointer() const { return RestoreBasePointerOffset!=0; }

llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp

private:
   SmallDenseMap<Value*, int> ScalarToTreeEntry;
 
   /// A list of scalars that we found that we need to keep as scalars.
   ValueSet MustGather;
 
   /// This POD struct describes one external user in the vectorized tree.
   struct ExternalUser {
     ExternalUser (Value *S, llvm::User *U, int L) :
-      Scalar(S), User(U), Lane(L){};
+      Scalar(S), User(U), Lane(L){}
     // Which scalar in our function.
     Value *Scalar;
     // Which user that uses the scalar.
     llvm::User *User;
     // Which lane does the scalar belong to.
     int Lane;
   };
   typedef SmallVector<ExternalUser, 16> UserList;