[polly] Fix some Clang-tidy and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

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

[Eugene.Zelenko]

More fixes.

[grosser]

Hi Eugene,

thank you for all these fixes. They look indeed great.

Most of them seem to be clear improvements, so I would be very happy to
see them committed. Applying a large change of uncommented refactoring -
the state the patch seems to be in ATM - will fix the current issues,
but unfortunately will fail to teach me and other developers about good
coding style and which tools we can use to ensure we follow in the
future a coding style that matches the changes you propose.

To teach this, we would -- in the optimal case -- split this larger
patch into individual thematic patches and add for each patch a
description of what has changed, why the new form is preferable over the
old form, and how the change was created (automatically by a specific
tool or manually).

You do not happen to have a git patch sequence which documents the
individual thematic changes you performed? In case you have not, would
it be possible to create such a sequence and use the commit messages to
add context information that helps to educate people about the changes
you propose? I believe this would be of great help to ensure your
changes will improve the code style of Polly also in the longer term.

Best,
Tobias

[Eugene.Zelenko]

I don't think this patch is too complicated to deserve to be split :-) But may be next explanations will be helpful.

Majority of fixes are Clang-tidy modernize-use-nullptr and modernize-use-override and Include What You Use (most of #include changes).

I occasionally fixed -Wextra-semi and some formatting, including Clang-tidy llvm-namespace-comment.

[grosser]

Hi,

the primary reason I ask for a split is to use this opportunity to educate people:
why certain changes are beneficial.

[grosser]

[resending complete message]

The primary reason I ask to commit these changes separately is to educate people:

• why certain changes are beneficial and what they mean
• how these issues were found through automatic tooling.

Your answer indicates that you used a couple of independent tools to find these issues. It seems such changes are - besides being cleanups - independent and independently beneficial. Hence, it seems to make sense to apply them individually, also for people to see which change was performed by which tool. I assume a brief 2-3 sentence commit message that sets the context is enough for everybody to grasp the individual issues. Would it be possible for you to provide such kind of information without too much overhead?

[Eugene.Zelenko]

Frankly, it'll be better to commit all changes ones without repeating same job.

But I could describe all changes in commit message, so other people could learn.

[grosser]

In D21488#463490, @Eugene.Zelenko wrote:

Frankly, it'll be better to commit all changes ones without repeating same job.

But I could describe all changes in commit message, so other people could learn.

Hi Eugene,

I still believe that separating commits out into independent changes makes a lot of sense, as otherwise understanding this large set of changes is difficult as each change needs to be matched to the specific improvement that you performed and it is unclear which changes have been performed automatically and where you manually changed the code. In general rebasing and splitting patches should not be too difficult, especially as most of these changes are performed with automatic tools. I already started in r273435 with the 'modern-use-nullptr' fixes, which were indeed very easy to apply with clang-tidy. I also split-off two independent manual changes in r273436 and r273437. If you feel motivated to continue this work, that would be great. Otherwise, it would be great if you could give me the necessary information/command line flags to reproduce your changes. I tried to use llvm-namespace-comment to reproduce the namespace changes, but the suggested line endings are different to the ones proposed in your patch. I get for example "} namespace" instead of "} end anonymous namespace" and "} namespace polly" instead of "} end namespace polly". I used the latest version of clang-tidy with -checks='-*,llvm-namespace-comment'.

Best,
Tobias

[Eugene.Zelenko]

For source files I modified, I run Clang-tidy with next arguments (I assume this as minor clean-ups):

-checks="-*,misc-suspicious-string-compare,misc-unused-using-decls,modernize-redundant-void-arg,modernize-deprecated-headers,modernize-use-bool-literals,modernize-use-nullptr,modernize-use-override,readability-container-size-empty,readability-redundant-control-flow,readability-redundant-string-cstr,readability-redundant-string-init,readability-simplify-boolean-expr,readability-redundant-string-init" -config="{CheckOptions: [:+misc-suspicious-string-compare.WarnOnLogicalNotComparison+,+value:+'1']}" -header-filter=".*"

So Polly code base is very clean. I caught one readability-container-size-empty warning in lib/Analysis/ScopDetection.cpp.

I fixed namespace ending comments manually and I used comment form prevailing in LLVM/Clang source files.

I applied Include What You Use manually, since sometimes it provide false positives or stuff is used implicitly, so it's not very clear how correct suggestions were.

Extra semicolon could be caught with -Wextra-semi, but I found them manually.

[Eugene.Zelenko]

Forgot to mention: you need to run Clang-tidy on single source file if you you want to fix warnings in headers (-header-filter=".*"). Otherwise multiple fixes may be applied to same file, especially if you use run-clang-tidy.py -j <number processes>.

[grosser]

I committed the extra semicolon fixes in r273607.

[grosser]

The namespace comments have been fixed in r273621.

include/polly/CodeGen/BlockGenerators.h

 #include "polly/CodeGen/IRBuilder.h"
 #include "polly/Support/ScopHelper.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "isl/map.h"
+#include <utility>
+#include <vector>
 
-struct isl_ast_build;
 struct isl_id_to_ast_expr;
 
 namespace llvm {
-class Pass;
-class Region;
+
 class ScalarEvolution;
-}
 
+} // end namespace llvm
+
 namespace polly {
+
 using namespace llvm;
+
 class ScopStmt;
 class MemoryAccess;
 class ScopArrayInfo;

   void finalizeSCoP(Scop &S);
 
   /// @brief An empty destructor
-  virtual ~BlockGenerator(){};
+  virtual ~BlockGenerator() {}
 
   BlockGenerator(const BlockGenerator &) = default;
 

   /// @param BlockGen A generator for basic blocks.
   RegionGenerator(BlockGenerator &BlockGen) : BlockGenerator(BlockGen) {}
 
-  virtual ~RegionGenerator(){};
+  ~RegionGenerator() override {}
 
   /// @brief Copy the region statement @p Stmt.
   ///

   ///              their new values (for values recalculated in the new ScoP,
   ///              but not within this basic block)
   /// @param BBMap A mapping from old values to their new values in this block.
-  virtual void generateScalarStores(ScopStmt &Stmt, LoopToScevMapT &LTS,
-                                    ValueMapT &BBMAp) override;
+  void generateScalarStores(ScopStmt &Stmt, LoopToScevMapT &LTS,
 
   /// @brief Copy a single PHI instruction.
   ///

   /// @param BBMap     A mapping from old values to their new values
   ///                  (for values recalculated within this basic block).
   /// @param LTS       A map from old loops to new induction variables as SCEVs.
-  virtual void copyPHIInstruction(ScopStmt &Stmt, PHINode *Inst,
-                                  ValueMapT &BBMap,
-                                  LoopToScevMapT &LTS) override;
+  void copyPHIInstruction(ScopStmt &Stmt, PHINode *Inst, ValueMapT &BBMap,
+                          LoopToScevMapT &LTS) override;
 };
-}
-#endif
+
+} // end namespace polly
+
+#endif // POLLY_BLOCK_GENERATORS_H

include/polly/CodeGen/LoopGenerators.h

 // as LLVM-IR.
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef POLLY_LOOP_GENERATORS_H
 #define POLLY_LOOP_GENERATORS_H
 
 #include "polly/CodeGen/IRBuilder.h"
 #include "polly/Support/ScopHelper.h"
-
 #include "llvm/ADT/SetVector.h"
-#include "llvm/IR/ValueMap.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Type.h"
 
 namespace llvm {
+
+class Pass;
 class Value;
-class Pass;
-class BasicBlock;
-}
 
+} // end namespace llvm
+
 namespace polly {
+
 using namespace llvm;
 
 /// @brief Create a scalar do/for-style loop.

                   PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
                   DominatorTree &DT, BasicBlock *&ExitBlock,
                   ICmpInst::Predicate Predicate,
-                  ScopAnnotator *Annotator = NULL, bool Parallel = false,
+                  ScopAnnotator *Annotator = nullptr, bool Parallel = false,
                   bool UseGuard = true);
 
 /// @brief The ParallelLoopGenerator allows to create parallelized loops

                      SetVector<Value *> UsedValues, ValueMapT &VMap,
                      Function **SubFn);
 };
+
 } // end namespace polly
-#endif
+
+#endif // POLLY_LOOP_GENERATORS_H

include/polly/ScopDetection.h

 
 #include "polly/ScopDetectionDiagnostic.h"
 #include "polly/Support/ScopHelper.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Pass.h"
+#include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
+#include <string>
+#include <utility>
+#include <vector>
 
 using namespace llvm;
 
 namespace llvm {
+
 class LoopInfo;
 class Loop;
 class ScalarEvolution;
 class SCEV;
-class SCEVAddRecExpr;
 class SCEVUnknown;
 class CallInst;
 class Instruction;
 class Value;
 class IntrinsicInst;
-}
 
+} // end namespace llvm
+
 namespace polly {
+
 typedef std::set<const SCEV *> ParamSetType;
 
 // Description of the shape of an array.

 
   /// @brief Verify if all valid Regions in this Function are still valid
   /// after some transformations.
-  void verifyAnalysis() const;
+  void verifyAnalysis() const override;
 
   /// @brief Verify if R is still a valid part of Scop after some
   /// transformations.

 
   /// @name FunctionPass interface
   //@{
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-  virtual void releaseMemory();
-  virtual bool runOnFunction(Function &F);
-  virtual void print(raw_ostream &OS, const Module *) const;
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  void releaseMemory() override;
+  bool runOnFunction(Function &F) override;
+  void print(raw_ostream &OS, const Module *) const override;
   //@}
 };
 
 } // end namespace polly
 
 namespace llvm {
+
 class PassRegistry;
+
 void initializeScopDetectionPass(llvm::PassRegistry &);
-}
 
-#endif
+} // end namespace llvm
+
+#endif // POLLY_SCOP_DETECTION_H

include/polly/ScopDetectionDiagnostic.h

 // to diagnose the error and generate a helpful error message.
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef POLLY_SCOP_DETECTION_DIAGNOSTIC_H
 #define POLLY_SCOP_DETECTION_DIAGNOSTIC_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include <cstddef>
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 using namespace llvm;
 
 namespace llvm {
+
+class BasicBlock;
+class Loop;
+class Region;
 class SCEV;
-class BasicBlock;
 class Value;
-class Region;
-}
 
+} // end namespace llvm
+
 namespace polly {
 
 /// @brief Type to hold region delimitors (entry & exit block).

   /// regions amenable to Polly.
   ///
   /// @return A short message representing this error.
-  virtual std::string getEndUserMessage() const {
-    return "Unspecified error.";
-  };
+  virtual std::string getEndUserMessage() const { return "Unspecified error."; }
 
   /// @brief Get the source location of this error.
   ///

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual std::string getEndUserMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  std::string getEndUserMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual const DebugLoc &getDebugLoc() const override {
-    return Inst->getDebugLoc();
-  };
+  const DebugLoc &getDebugLoc() const override { return Inst->getDebugLoc(); }
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
+  std::string getMessage() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual std::string getEndUserMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
+  std::string getMessage() const override;
+  std::string getEndUserMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
   //@}
 };
 

 
   /// @name RejectReason interface
   //@{
-  virtual std::string getMessage() const override;
-  virtual const DebugLoc &getDebugLoc() const override;
-  virtual std::string getEndUserMessage() const override;
+  std::string getMessage() const override;
+  const DebugLoc &getDebugLoc() const override;
+  std::string getEndUserMessage() const override;
   //@}
 };
 
-} // namespace polly
+} // end namespace polly
 
 #endif // POLLY_SCOP_DETECTION_DIAGNOSTIC_H

include/polly/ScopInfo.h

 
 #include "polly/ScopDetection.h"
 #include "polly/Support/SCEVAffinator.h"
-
+#include "polly/Support/ScopHelper.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/RegionPass.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/ValueHandle.h"
 #include "isl/aff.h"
 #include "isl/ctx.h"
 #include "isl/set.h"
-
+#include <cassert>
+#include <cstddef>
 #include <deque>
 #include <forward_list>
+#include <functional>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
 
 using namespace llvm;
 
 namespace llvm {
+
 class AssumptionCache;
 class Loop;
 class LoopInfo;
 class PHINode;
 class ScalarEvolution;
 class SCEV;
-class SCEVAddRecExpr;
 class Type;
-}
 
+} // end namespace llvm
+
 struct isl_ctx;
 struct isl_map;
 struct isl_basic_map;

 struct isl_union_map;
 struct isl_space;
 struct isl_ast_build;
-struct isl_constraint;
 struct isl_pw_aff;
 struct isl_pw_multi_aff;
 struct isl_schedule;

   /// @brief The set of derived indirect SAIs for this origin SAI.
   const SmallPtrSetImpl<ScopArrayInfo *> &getDerivedSAIs() const {
     return DerivedSAIs;
-  };
+  }
 
   /// @brief Return the number of dimensions.
   unsigned getNumberOfDimensions() const {

   __isl_give isl_id *getBasePtrId() const;
 
   /// @brief Is this array info modeling an llvm::Value?
-  bool isValueKind() const { return Kind == MK_Value; };
+  bool isValueKind() const { return Kind == MK_Value; }
 
   /// @brief Is this array info modeling special PHI node memory?
   ///

   /// original PHI node as virtual base pointer, we have this additional
   /// attribute to distinguish the PHI node specific array modeling from the
   /// normal scalar array modeling.
-  bool isPHIKind() const { return Kind == MK_PHI; };
+  bool isPHIKind() const { return Kind == MK_PHI; }
 
   /// @brief Is this array info modeling an MK_ExitPHI?
-  bool isExitPHIKind() const { return Kind == MK_ExitPHI; };
+  bool isExitPHIKind() const { return Kind == MK_ExitPHI; }
 
   /// @brief Is this array info modeling an array?
-  bool isArrayKind() const { return Kind == MK_Array; };
+  bool isArrayKind() const { return Kind == MK_Array; }
 
   /// @brief Dump a readable representation to stderr.
   void dump() const;

 
     LoopStackElement(Loop *L, __isl_give isl_schedule *S,
                      unsigned NumBlocksProcessed)
-        : L(L), Schedule(S), NumBlocksProcessed(NumBlocksProcessed){};
+        : L(L), Schedule(S), NumBlocksProcessed(NumBlocksProcessed) {}
   } LoopStackElementTy;
 
   /// @brief The loop stack used for schedule construction.

   ///
   AccFuncSetType *getAccessFunctions(const BasicBlock *BB) {
     AccFuncMapType::iterator at = AccFuncMap.find(BB);
-    return at != AccFuncMap.end() ? &(at->second) : 0;
+    return at != AccFuncMap.end() ? &(at->second) : nullptr;
   }
 
   ScalarEvolution *getSE() const;

   static char ID; // Pass identification, replacement for typeid
 
   ScopInfoRegionPass() : RegionPass(ID) {}
-  ~ScopInfoRegionPass() {}
+  ~ScopInfoRegionPass() override {}
 
   /// @brief Build ScopBuilder object, which constructs Polly IR of static
   ///        control part for the current SESE-Region.

 } // end namespace polly
 
 namespace llvm {
+
 class PassRegistry;
+
 void initializeScopInfoRegionPassPass(llvm::PassRegistry &);
-}
 
-#endif
+} // end namespace llvm
+
+#endif // POLLY_SCOP_INFO_H

include/polly/ScopPass.h

 using namespace llvm;
 
 namespace polly {
+
 class Scop;
 
 /// ScopPass - This class adapts the RegionPass interface to allow convenient

   Scop *S;
 
 protected:
-  explicit ScopPass(char &ID) : RegionPass(ID), S(0) {}
+  explicit ScopPass(char &ID) : RegionPass(ID), S(nullptr) {}
 
   /// runOnScop - This method must be overloaded to perform the
   /// desired Polyhedral transformation or analysis.

   virtual bool runOnScop(Scop &S) = 0;
 
   /// @brief Print method for SCoPs.
-  virtual void printScop(raw_ostream &OS, Scop &S) const {};
+  virtual void printScop(raw_ostream &OS, Scop &S) const {}
 
   /// getAnalysisUsage - Subclasses that override getAnalysisUsage
   /// must call this.
   ///
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const override;
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
 
 private:
   bool runOnRegion(Region *R, RGPassManager &RGM) override;
   void print(raw_ostream &OS, const Module *) const override;
 };
 
-} // End llvm namespace
+} // end namespace polly
 
-#endif
+#endif // POLLY_SCOP_PASS_H

lib/Analysis/ScopDetection.cpp

 //===----------------------------------------------------------------------===//
 
 #include "polly/ScopDetection.h"
-#include "polly/CodeGen/CodeGeneration.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopDetectionDiagnostic.h"

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/PostDominators.h"
-#include "llvm/Analysis/RegionIterator.h"
+#include "llvm/Analysis/MemoryLocation.h"
+#include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
-#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Metadata.h"
+#include "llvm/PassAnalysisSupport.h"
+#include "llvm/PassSupport.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-#include <set>
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <memory>
 #include <stack>
+#include <string>
+#include <vector>
 
 using namespace llvm;
 using namespace polly;

       : DiagnosticInfo(PluginDiagnosticKind, DS_Note), F(F), FileName(FileName),
         EntryLine(EntryLine), ExitLine(ExitLine) {}
 
-  virtual void print(DiagnosticPrinter &DP) const;
+  void print(DiagnosticPrinter &DP) const override;
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == PluginDiagnosticKind;

 
 bool ScopDetection::addOverApproximatedRegion(Region *AR,
                                               DetectionContext &Context) const {
-
   // If we already know about Ar we can exit.
   if (!Context.NonAffineSubRegionSet.insert(AR))
     return true;

 
 bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
                              DetectionContext &Context) const {
-
   InvariantLoadsSetTy AccessILS;
   if (!isAffineExpr(&Context.CurRegion, Scope, S, *SE, &AccessILS))
     return false;

 bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
                                   Value *Condition, bool IsLoopBranch,
                                   DetectionContext &Context) const {
-
   if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Condition)) {
     auto Opcode = BinOp->getOpcode();
     if (Opcode == Instruction::And || Opcode == Instruction::Or) {

   Function *CalledFunction = CI.getCalledFunction();
 
   // Indirect calls are not supported.
-  if (CalledFunction == 0)
+  if (CalledFunction == nullptr)
     return false;
 
   if (AllowModrefCall) {

   for (const auto &Pair : Context.Accesses[BasePointer]) {
     std::vector<const SCEV *> MaxTerms;
     SCEVRemoveMax::remove(*SE, Pair.second, &MaxTerms);
-    if (MaxTerms.size() > 0) {
+    if (!MaxTerms.empty()) {
       Terms.insert(Terms.begin(), MaxTerms.begin(), MaxTerms.end());
       continue;
     }

 bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
                                   const SCEVUnknown *BP,
                                   DetectionContext &Context) const {
-
   if (!BP)
     return invalid<ReportNoBasePtr>(Context, /*Assert=*/true, Inst);
 

 
   return LastValidRegion.release();
 }
+
 static bool regionWithoutLoops(Region &R, LoopInfo *LI) {
   for (const BasicBlock *BB : R.blocks())
     if (R.contains(LI->getLoopFor(BB)))