[llvm] clang-format

Author: andrurogerz

llvm/include/llvm/Analysis/AliasAnalysis.h

@@ -37,13 +37,13 @@
 #ifndef LLVM_ANALYSIS_ALIASANALYSIS_H
 #define LLVM_ANALYSIS_ALIASANALYSIS_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/ModRef.h"
 #include <cstdint>
 #include <functional>
@@ -165,7 +165,7 @@ class SimpleCaptureAnalysis final : public CaptureAnalysis {
 
 public:
   LLVM_ABI bool isNotCapturedBefore(const Value *Object, const Instruction *I,
-                           bool OrAt) override;
+                                    bool OrAt) override;
 };
 
 /// Context-sensitive CaptureAnalysis provider, which computes and caches the
@@ -190,7 +190,7 @@ class EarliestEscapeAnalysis final : public CaptureAnalysis {
       : DT(DT), LI(LI) {}
 
   LLVM_ABI bool isNotCapturedBefore(const Value *Object, const Instruction *I,
-                           bool OrAt) override;
+                                    bool OrAt) override;
 
   LLVM_ABI void removeInstruction(Instruction *I);
 };
@@ -340,7 +340,7 @@ class AAResults {
   /// The aggregation is invalidated if any of the underlying analyses is
   /// invalidated.
   LLVM_ABI bool invalidate(Function &F, const PreservedAnalyses &PA,
-                  FunctionAnalysisManager::Invalidator &Inv);
+                           FunctionAnalysisManager::Invalidator &Inv);
 
   //===--------------------------------------------------------------------===//
   /// \name Alias Queries
@@ -350,7 +350,8 @@ class AAResults {
   /// Returns an AliasResult indicating whether the two pointers are aliased to
   /// each other. This is the interface that must be implemented by specific
   /// alias analysis implementations.
-  LLVM_ABI AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
+  LLVM_ABI AliasResult alias(const MemoryLocation &LocA,
+                             const MemoryLocation &LocB);
 
   /// A convenience wrapper around the primary \c alias interface.
   AliasResult alias(const Value *V1, LocationSize V1Size, const Value *V2,
@@ -419,7 +420,7 @@ class AAResults {
   /// If IgnoreLocals is true, then this method returns NoModRef for memory
   /// that points to a local alloca.
   LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc,
-                               bool IgnoreLocals = false);
+                                        bool IgnoreLocals = false);
 
   /// A convenience wrapper around the primary \c getModRefInfoMask
   /// interface.
@@ -524,7 +525,8 @@ class AAResults {
 
   /// Return information about whether two instructions may refer to the same
   /// memory locations.
-  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I1, const Instruction *I2);
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I1,
+                                    const Instruction *I2);
 
   /// Return information about whether a particular call site modifies
   /// or reads the specified memory location \p MemLoc before instruction \p I
@@ -549,7 +551,8 @@ class AAResults {
 
   /// Check if it is possible for execution of the specified basic block to
   /// modify the location Loc.
-  LLVM_ABI bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc);
+  LLVM_ABI bool canBasicBlockModify(const BasicBlock &BB,
+                                    const MemoryLocation &Loc);
 
   /// A convenience wrapper synthesizing a memory location.
   bool canBasicBlockModify(const BasicBlock &BB, const Value *P,
@@ -562,9 +565,10 @@ class AAResults {
   ///
   /// The instructions to consider are all of the instructions in the range of
   /// [I1,I2] INCLUSIVE. I1 and I2 must be in the same basic block.
-  LLVM_ABI bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
-                                 const MemoryLocation &Loc,
-                                 const ModRefInfo Mode);
+  LLVM_ABI bool canInstructionRangeModRef(const Instruction &I1,
+                                          const Instruction &I2,
+                                          const MemoryLocation &Loc,
+                                          const ModRefInfo Mode);
 
   /// A convenience wrapper synthesizing a memory location.
   bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
@@ -575,42 +579,54 @@ class AAResults {
 
   // CtxI can be nullptr, in which case the query is whether or not the aliasing
   // relationship holds through the entire function.
-  LLVM_ABI AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
-                    AAQueryInfo &AAQI, const Instruction *CtxI = nullptr);
+  LLVM_ABI AliasResult alias(const MemoryLocation &LocA,
+                             const MemoryLocation &LocB, AAQueryInfo &AAQI,
+                             const Instruction *CtxI = nullptr);
 
-  LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI,
-                               bool IgnoreLocals = false);
+  LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc,
+                                        AAQueryInfo &AAQI,
+                                        bool IgnoreLocals = false);
   LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I, const CallBase *Call2,
-                           AAQueryInfo &AAQIP);
-  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const VAArgInst *V, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const LoadInst *L, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const StoreInst *S, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const FenceInst *S, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
+                                    AAQueryInfo &AAQIP);
+  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call1,
+                                    const CallBase *Call2, AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const VAArgInst *V,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const LoadInst *L,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const StoreInst *S,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const FenceInst *S,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
   LLVM_ABI ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX,
-                           const MemoryLocation &Loc, AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const CatchPadInst *I, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
-  LLVM_ABI ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc,
-                           AAQueryInfo &AAQI);
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const AtomicRMWInst *RMW,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const CatchPadInst *I,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
+  LLVM_ABI ModRefInfo getModRefInfo(const CatchReturnInst *I,
+                                    const MemoryLocation &Loc,
+                                    AAQueryInfo &AAQI);
   LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I,
-                           const std::optional<MemoryLocation> &OptLoc,
-                           AAQueryInfo &AAQIP);
-  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I1, const Instruction *I2,
-                           AAQueryInfo &AAQI);
+                                    const std::optional<MemoryLocation> &OptLoc,
+                                    AAQueryInfo &AAQIP);
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I1,
+                                    const Instruction *I2, AAQueryInfo &AAQI);
   LLVM_ABI ModRefInfo callCapturesBefore(const Instruction *I,
-                                const MemoryLocation &MemLoc, DominatorTree *DT,
-                                AAQueryInfo &AAQIP);
-  LLVM_ABI MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI);
+                                         const MemoryLocation &MemLoc,
+                                         DominatorTree *DT, AAQueryInfo &AAQIP);
+  LLVM_ABI MemoryEffects getMemoryEffects(const CallBase *Call,
+                                          AAQueryInfo &AAQI);
 
 private:
   class Concept;
@@ -905,7 +921,7 @@ LLVM_ABI bool isEscapeSource(const Value *V);
 /// to true, then the memory is only not visible if the object has not been
 /// captured prior to the unwind. Otherwise it is not visible even if captured.
 LLVM_ABI bool isNotVisibleOnUnwind(const Value *Object,
-                          bool &RequiresNoCaptureBeforeUnwind);
+                                   bool &RequiresNoCaptureBeforeUnwind);
 
 /// Return true if the Object is writable, in the sense that any location based
 /// on this pointer that can be loaded can also be stored to without trapping.
@@ -918,7 +934,8 @@ LLVM_ABI bool isNotVisibleOnUnwind(const Value *Object,
 /// using the dereferenceable(N) attribute. It does not necessarily hold for
 /// parts that are only known to be dereferenceable due to the presence of
 /// loads.
-LLVM_ABI bool isWritableObject(const Value *Object, bool &ExplicitlyDereferenceableOnly);
+LLVM_ABI bool isWritableObject(const Value *Object,
+                               bool &ExplicitlyDereferenceableOnly);
 
 /// A manager for alias analyses.
 ///

llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h

@@ -24,8 +24,8 @@
 #ifndef LLVM_ANALYSIS_ALIASANALYSISEVALUATOR_H
 #define LLVM_ANALYSIS_ALIASANALYSISEVALUATOR_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 class AAResults;

llvm/include/llvm/Analysis/AliasSetTracker.h

@@ -18,14 +18,14 @@
 #ifndef LLVM_ANALYSIS_ALIASSETTRACKER_H
 #define LLVM_ANALYSIS_ALIASSETTRACKER_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <vector>
 
@@ -114,7 +114,8 @@ class AliasSet : public ilist_node<AliasSet> {
   bool isForwardingAliasSet() const { return Forward; }
 
   /// Merge the specified alias set into this alias set.
-  LLVM_ABI void mergeSetIn(AliasSet &AS, AliasSetTracker &AST, BatchAAResults &BatchAA);
+  LLVM_ABI void mergeSetIn(AliasSet &AS, AliasSetTracker &AST,
+                           BatchAAResults &BatchAA);
 
   // Alias Set iteration - Allow access to all of the memory locations which are
   // part of this alias set.
@@ -148,10 +149,10 @@ class AliasSet : public ilist_node<AliasSet> {
   /// If the specified memory location "may" (or must) alias one of the members
   /// in the set return the appropriate AliasResult. Otherwise return NoAlias.
   LLVM_ABI AliasResult aliasesMemoryLocation(const MemoryLocation &MemLoc,
-                                    BatchAAResults &AA) const;
+                                             BatchAAResults &AA) const;
 
   LLVM_ABI ModRefInfo aliasesUnknownInst(const Instruction *Inst,
-                                BatchAAResults &AA) const;
+                                         BatchAAResults &AA) const;
 };
 
 inline raw_ostream& operator<<(raw_ostream &OS, const AliasSet &AS) {
@@ -190,9 +191,11 @@ class AliasSetTracker {
   LLVM_ABI void add(VAArgInst *VAAI);
   LLVM_ABI void add(AnyMemSetInst *MSI);
   LLVM_ABI void add(AnyMemTransferInst *MTI);
-  LLVM_ABI void add(Instruction *I);       // Dispatch to one of the other add methods...
-  LLVM_ABI void add(BasicBlock &BB);       // Add all instructions in basic block
-  LLVM_ABI void add(const AliasSetTracker &AST); // Add alias relations from another AST
+  LLVM_ABI void
+  add(Instruction *I); // Dispatch to one of the other add methods...
+  LLVM_ABI void add(BasicBlock &BB); // Add all instructions in basic block
+  LLVM_ABI void
+  add(const AliasSetTracker &AST); // Add alias relations from another AST
   LLVM_ABI void addUnknown(Instruction *I);
 
   LLVM_ABI void clear();

llvm/include/llvm/Analysis/AssumeBundleQueries.h

@@ -14,9 +14,9 @@
 #ifndef LLVM_ANALYSIS_ASSUMEBUNDLEQUERIES_H
 #define LLVM_ANALYSIS_ASSUMEBUNDLEQUERIES_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 class AssumptionCache;
@@ -39,8 +39,9 @@ enum AssumeBundleArg {
 ///
 /// Return true iff the queried attribute was found.
 /// If ArgVal is set. the argument will be stored to ArgVal.
-LLVM_ABI bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn, StringRef AttrName,
-                          uint64_t *ArgVal = nullptr);
+LLVM_ABI bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn,
+                                   StringRef AttrName,
+                                   uint64_t *ArgVal = nullptr);
 inline bool hasAttributeInAssume(AssumeInst &Assume, Value *IsOn,
                                  Attribute::AttrKind Kind,
                                  uint64_t *ArgVal = nullptr) {
@@ -87,7 +88,8 @@ using RetainedKnowledgeMap =
 /// many queries are going to be made on the same llvm.assume.
 /// String attributes are not inserted in the map.
 /// If the IR changes the map will be outdated.
-LLVM_ABI void fillMapFromAssume(AssumeInst &Assume, RetainedKnowledgeMap &Result);
+LLVM_ABI void fillMapFromAssume(AssumeInst &Assume,
+                                RetainedKnowledgeMap &Result);
 
 /// Represent one information held inside an operand bundle of an llvm.assume.
 /// AttrKind is the property that holds.
@@ -122,7 +124,7 @@ struct RetainedKnowledge {
 /// Retreive the information help by Assume on the operand at index Idx.
 /// Assume should be an llvm.assume and Idx should be in the operand bundle.
 LLVM_ABI RetainedKnowledge getKnowledgeFromOperandInAssume(AssumeInst &Assume,
-                                                  unsigned Idx);
+                                                           unsigned Idx);
 
 /// Retreive the information help by the Use U of an llvm.assume. the use should
 /// be in the operand bundle.
@@ -146,16 +148,16 @@ LLVM_ABI bool isAssumeWithEmptyBundle(const AssumeInst &Assume);
 
 /// Return a valid Knowledge associated to the Use U if its Attribute kind is
 /// in AttrKinds.
-LLVM_ABI RetainedKnowledge getKnowledgeFromUse(const Use *U,
-                                      ArrayRef<Attribute::AttrKind> AttrKinds);
+LLVM_ABI RetainedKnowledge
+getKnowledgeFromUse(const Use *U, ArrayRef<Attribute::AttrKind> AttrKinds);
 
 /// Return a valid Knowledge associated to the Value V if its Attribute kind is
 /// in AttrKinds and it matches the Filter.
 LLVM_ABI RetainedKnowledge getKnowledgeForValue(
     const Value *V, ArrayRef<Attribute::AttrKind> AttrKinds,
     AssumptionCache *AC = nullptr,
     function_ref<bool(RetainedKnowledge, Instruction *,
-                            const CallBase::BundleOpInfo *)>
+                      const CallBase::BundleOpInfo *)>
         Filter = [](auto...) { return true; });
 
 /// Return a valid Knowledge associated to the Value V if its Attribute kind is
@@ -168,8 +170,8 @@ LLVM_ABI RetainedKnowledge getKnowledgeValidInContext(
 
 /// This extracts the Knowledge from an element of an operand bundle.
 /// This is mostly for use in the assume builder.
-LLVM_ABI RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume,
-                                         const CallBase::BundleOpInfo &BOI);
+LLVM_ABI RetainedKnowledge
+getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI);
 
 } // namespace llvm
 

llvm/include/llvm/Analysis/AssumptionCache.h

@@ -15,14 +15,14 @@
 #ifndef LLVM_ANALYSIS_ASSUMPTIONCACHE_H
 #define LLVM_ANALYSIS_ASSUMPTIONCACHE_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {