[llvm] clang-format changes to IR library

Author: andrurogerz

llvm/include/llvm/IR/AbstractCallSite.h

@@ -14,11 +14,11 @@
 #ifndef LLVM_IR_ABSTRACTCALLSITE_H
 #define LLVM_IR_ABSTRACTCALLSITE_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 
 namespace llvm {
@@ -103,8 +103,9 @@ class AbstractCallSite {
   ///
   /// All uses added to \p CallbackUses can be used to create abstract call
   /// sites for which AbstractCallSite::isCallbackCall() will return true.
-  LLVM_ABI static void getCallbackUses(const CallBase &CB,
-                              SmallVectorImpl<const Use *> &CallbackUses);
+  LLVM_ABI static void
+  getCallbackUses(const CallBase &CB,
+                  SmallVectorImpl<const Use *> &CallbackUses);
 
   /// Conversion operator to conveniently check for a valid/initialized ACS.
   explicit operator bool() const { return CB != nullptr; }

llvm/include/llvm/IR/Analysis.h

@@ -12,8 +12,8 @@
 #ifndef LLVM_IR_ANALYSIS_H
 #define LLVM_IR_ANALYSIS_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 

llvm/include/llvm/IR/Argument.h

@@ -13,10 +13,10 @@
 #ifndef LLVM_IR_ARGUMENT_H
 #define LLVM_IR_ARGUMENT_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/Compiler.h"
 #include <optional>
 
 namespace llvm {
@@ -38,8 +38,8 @@ class Argument final : public Value {
 
 public:
   /// Argument constructor.
-  LLVM_ABI explicit Argument(Type *Ty, const Twine &Name = "", Function *F = nullptr,
-                    unsigned ArgNo = 0);
+  LLVM_ABI explicit Argument(Type *Ty, const Twine &Name = "",
+                             Function *F = nullptr, unsigned ArgNo = 0);
 
   inline const Function *getParent() const { return Parent; }
   inline       Function *getParent()       { return Parent; }
@@ -108,8 +108,8 @@ class Argument final : public Value {
   /// If this is a byval or inalloca argument, return its alignment.
   /// FIXME: Remove this function once transition to Align is over.
   /// Use getParamAlign() instead.
-  LLVM_ABI LLVM_DEPRECATED("Use getParamAlign() instead", "getParamAlign")
-  uint64_t getParamAlignment() const;
+  LLVM_ABI LLVM_DEPRECATED("Use getParamAlign() instead",
+                           "getParamAlign") uint64_t getParamAlignment() const;
 
   /// If this is a byval or inalloca argument, return its alignment.
   LLVM_ABI MaybeAlign getParamAlign() const;

llvm/include/llvm/IR/Assumptions.h

@@ -15,10 +15,10 @@
 #ifndef LLVM_IR_ASSUMPTIONS_H
 #define LLVM_IR_ASSUMPTIONS_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
@@ -51,12 +51,12 @@ struct KnownAssumptionString {
 
 /// Return true if \p F has the assumption \p AssumptionStr attached.
 LLVM_ABI bool hasAssumption(const Function &F,
-                   const KnownAssumptionString &AssumptionStr);
+                            const KnownAssumptionString &AssumptionStr);
 
 /// Return true if \p CB or the callee has the assumption \p AssumptionStr
 /// attached.
 LLVM_ABI bool hasAssumption(const CallBase &CB,
-                   const KnownAssumptionString &AssumptionStr);
+                            const KnownAssumptionString &AssumptionStr);
 
 /// Return the set of all assumptions for the function \p F.
 LLVM_ABI DenseSet<StringRef> getAssumptions(const Function &F);
@@ -65,10 +65,12 @@ LLVM_ABI DenseSet<StringRef> getAssumptions(const Function &F);
 LLVM_ABI DenseSet<StringRef> getAssumptions(const CallBase &CB);
 
 /// Appends the set of assumptions \p Assumptions to \F.
-LLVM_ABI bool addAssumptions(Function &F, const DenseSet<StringRef> &Assumptions);
+LLVM_ABI bool addAssumptions(Function &F,
+                             const DenseSet<StringRef> &Assumptions);
 
 /// Appends the set of assumptions \p Assumptions to \CB.
-LLVM_ABI bool addAssumptions(CallBase &CB, const DenseSet<StringRef> &Assumptions);
+LLVM_ABI bool addAssumptions(CallBase &CB,
+                             const DenseSet<StringRef> &Assumptions);
 
 } // namespace llvm
 

llvm/include/llvm/IR/Attributes.h

@@ -13,8 +13,8 @@
 #ifndef LLVM_IR_AUTOUPGRADE_H
 #define LLVM_IR_AUTOUPGRADE_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
 #include <vector>
 
 namespace llvm {
@@ -37,8 +37,9 @@ namespace llvm {
   /// for upgrading, and returns true if it requires upgrading. It may return
   /// null in NewFn if the all calls to the original intrinsic function
   /// should be transformed to non-function-call instructions.
-  LLVM_ABI bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn,
-                                bool CanUpgradeDebugIntrinsicsToRecords = true);
+  LLVM_ABI bool
+  UpgradeIntrinsicFunction(Function *F, Function *&NewFn,
+                           bool CanUpgradeDebugIntrinsicsToRecords = true);
 
   /// This is the complement to the above, replacing a specific call to an
   /// intrinsic function with a call to the specified new function.
@@ -52,7 +53,7 @@ namespace llvm {
   /// which need to have both the function updated as well as all calls updated
   /// to the new function. This should only be run in a post-processing fashion
   /// so that it can update all calls to the old function.
-  LLVM_ABI void UpgradeCallsToIntrinsic(Function* F);
+  LLVM_ABI void UpgradeCallsToIntrinsic(Function *F);
 
   /// This checks for global variables which should be upgraded. If it requires
   /// upgrading, returns a pointer to the upgraded variable.
@@ -83,12 +84,13 @@ namespace llvm {
   /// This is an auto-upgrade for bitcast between pointers with different
   /// address spaces: the instruction is replaced by a pair ptrtoint+inttoptr.
   LLVM_ABI Instruction *UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
-                                  Instruction *&Temp);
+                                           Instruction *&Temp);
 
   /// This is an auto-upgrade for bitcast constant expression between pointers
   /// with different address spaces: the instruction is replaced by a pair
   /// ptrtoint+inttoptr.
-  LLVM_ABI Constant *UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy);
+  LLVM_ABI Constant *UpgradeBitCastExpr(unsigned Opc, Constant *C,
+                                        Type *DestTy);
 
   /// Check the debug info version number, if it is out-dated, drop the debug
   /// info. Return true if module is modified.
@@ -110,7 +112,8 @@ namespace llvm {
   LLVM_ABI void UpgradeAttributes(AttrBuilder &B);
 
   /// Upgrade operand bundles (without knowing about their user instruction).
-  LLVM_ABI void UpgradeOperandBundles(std::vector<OperandBundleDef> &OperandBundles);
+  LLVM_ABI void
+  UpgradeOperandBundles(std::vector<OperandBundleDef> &OperandBundles);
 
 } // End llvm namespace
 

llvm/include/llvm/IR/AutoUpgrade.h

@@ -13,7 +13,6 @@
 #ifndef LLVM_IR_BASICBLOCK_H
 #define LLVM_IR_BASICBLOCK_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm-c/Types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Twine.h"
@@ -25,6 +24,7 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Value.h"
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
@@ -138,7 +138,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   LLVM_ABI void insertDbgRecordAfter(DbgRecord *DR, Instruction *I);
 
   /// Insert a DbgRecord into a block at the position given by \p Here.
-  LLVM_ABI void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here);
+  LLVM_ABI void insertDbgRecordBefore(DbgRecord *DR,
+                                      InstListType::iterator Here);
 
   /// Eject any debug-info trailing at the end of a block. DbgRecords can
   /// transiently be located "off the end" of a block if the blocks terminator
@@ -151,8 +152,9 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// happens in RemoveDIs debug-info mode, some special patching-up needs to
   /// occur: inserting into the middle of a sequence of dbg.value intrinsics
   /// does not have an equivalent with DbgRecords.
-  LLVM_ABI void reinsertInstInDbgRecords(Instruction *I,
-                                std::optional<DbgRecord::self_iterator> Pos);
+  LLVM_ABI void
+  reinsertInstInDbgRecords(Instruction *I,
+                           std::optional<DbgRecord::self_iterator> Pos);
 
 private:
   void setParent(Function *parent);
@@ -163,8 +165,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// inserted at either the end of the function (if InsertBefore is null), or
   /// before the specified basic block.
   LLVM_ABI explicit BasicBlock(LLVMContext &C, const Twine &Name = "",
-                      Function *Parent = nullptr,
-                      BasicBlock *InsertBefore = nullptr);
+                               Function *Parent = nullptr,
+                               BasicBlock *InsertBefore = nullptr);
 
 public:
   BasicBlock(const BasicBlock &) = delete;
@@ -236,8 +238,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Requires the basic block to have a parent module.
   LLVM_ABI const DataLayout &getDataLayout() const;
 
-  /// Returns the terminator instruction if the block is well formed or null
-  /// if the block is not well formed.
+  /// Returns the terminator instruction if the block is well formed or
+  /// null if the block is not well formed.
   const Instruction *getTerminator() const LLVM_READONLY {
     if (InstList.empty() || !InstList.back().isTerminator())
       return nullptr;
@@ -285,11 +287,11 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   ///
   /// Deprecated in favour of getFirstNonPHIIt, which returns an iterator that
   /// preserves some debugging information.
-  LLVM_ABI LLVM_DEPRECATED("Use iterators as instruction positions", "getFirstNonPHIIt")
-  const Instruction *getFirstNonPHI() const;
+  LLVM_ABI LLVM_DEPRECATED("Use iterators as instruction positions",
+                           "getFirstNonPHIIt") const
+      Instruction *getFirstNonPHI() const;
   LLVM_ABI LLVM_DEPRECATED("Use iterators as instruction positions instead",
-                  "getFirstNonPHIIt")
-  Instruction *getFirstNonPHI();
+                           "getFirstNonPHIIt") Instruction *getFirstNonPHI();
 
   /// Returns an iterator to the first instruction in this block that is not a
   /// PHINode instruction.
@@ -363,7 +365,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Return a const iterator range over the instructions in the block, skipping
   /// any debug instructions. Skip any pseudo operations as well if \c
   /// SkipPseudoOp is true.
-  LLVM_ABI iterator_range<filter_iterator<BasicBlock::const_iterator,
+  LLVM_ABI
+  iterator_range<filter_iterator<BasicBlock::const_iterator,
                                  std::function<bool(const Instruction &)>>>
   instructionsWithoutDebug(bool SkipPseudoOp = true) const;
 
@@ -375,7 +378,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   instructionsWithoutDebug(bool SkipPseudoOp = true);
 
   /// Return the size of the basic block ignoring debug instructions
-  LLVM_ABI filter_iterator<BasicBlock::const_iterator,
+  LLVM_ABI
+  filter_iterator<BasicBlock::const_iterator,
                   std::function<bool(const Instruction &)>>::difference_type
   sizeWithoutDebug() const;
 
@@ -404,7 +408,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// provided, inserts before that basic block, otherwise inserts at the end.
   ///
   /// \pre \a getParent() is \c nullptr.
-  LLVM_ABI void insertInto(Function *Parent, BasicBlock *InsertBefore = nullptr);
+  LLVM_ABI void insertInto(Function *Parent,
+                           BasicBlock *InsertBefore = nullptr);
 
   /// Return the predecessor of this block if it has a single predecessor
   /// block. Otherwise return a null pointer.
@@ -455,8 +460,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Print the basic block to an output stream with an optional
   /// AssemblyAnnotationWriter.
   LLVM_ABI void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
-             bool ShouldPreserveUseListOrder = false,
-             bool IsForDebug = false) const;
+                      bool ShouldPreserveUseListOrder = false,
+                      bool IsForDebug = false) const;
 
   //===--------------------------------------------------------------------===//
   /// Instruction iterator methods
@@ -610,7 +615,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// If \p KeepOneInputPHIs is true then don't remove PHIs that are left with
   /// zero or one incoming values, and don't simplify PHIs with all incoming
   /// values the same.
-  LLVM_ABI void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs = false);
+  LLVM_ABI void removePredecessor(BasicBlock *Pred,
+                                  bool KeepOneInputPHIs = false);
 
   LLVM_ABI bool canSplitPredecessors() const;
 
@@ -633,7 +639,7 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Also note that this doesn't preserve any passes. To split blocks while
   /// keeping loop information consistent, use the SplitBlock utility function.
   LLVM_ABI BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "",
-                              bool Before = false);
+                                       bool Before = false);
   BasicBlock *splitBasicBlock(Instruction *I, const Twine &BBName = "",
                               bool Before = false) {
     return splitBasicBlock(I->getIterator(), BBName, Before);
@@ -656,7 +662,8 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Also note that this doesn't preserve any passes. To split blocks while
   /// keeping loop information consistent, use the SplitBlockBefore utility
   /// function.
-  LLVM_ABI BasicBlock *splitBasicBlockBefore(iterator I, const Twine &BBName = "");
+  LLVM_ABI BasicBlock *splitBasicBlockBefore(iterator I,
+                                             const Twine &BBName = "");
   BasicBlock *splitBasicBlockBefore(Instruction *I, const Twine &BBName = "") {
     return splitBasicBlockBefore(I->getIterator(), BBName);
   }
@@ -680,12 +687,13 @@ class BasicBlock final : public Value, // Basic blocks are data objects also
   /// Transfer a range of instructions that belong to \p FromBB from \p
   /// FromBeginIt to \p FromEndIt, to this basic block at \p ToIt.
   LLVM_ABI void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB,
-              BasicBlock::iterator FromBeginIt, BasicBlock::iterator FromEndIt);
+                       BasicBlock::iterator FromBeginIt,
+                       BasicBlock::iterator FromEndIt);
 
   /// Erases a range of instructions from \p FromIt to (not including) \p ToIt.
   /// \Returns \p ToIt.
   LLVM_ABI BasicBlock::iterator erase(BasicBlock::iterator FromIt,
-                             BasicBlock::iterator ToIt);
+                                      BasicBlock::iterator ToIt);
 
   /// Returns true if there are any uses of this basic block other than
   /// direct branches, switches, etc. to it.

llvm/include/llvm/IR/BasicBlock.h

@@ -13,8 +13,8 @@
 #ifndef LLVM_IR_CMPPREDICATE_H
 #define LLVM_IR_CMPPREDICATE_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/IR/InstrTypes.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 /// An abstraction over a floating-point predicate, and a pack of an integer
@@ -56,7 +56,7 @@ class CmpPredicate {
   ///   ult + ult -> ult
   ///   ult + slt -> std::nullopt
   LLVM_ABI static std::optional<CmpPredicate> getMatching(CmpPredicate A,
-                                                 CmpPredicate B);
+                                                          CmpPredicate B);
 
   /// Attempts to return a signed CmpInst::Predicate from the CmpPredicate. If
   /// the CmpPredicate has samesign, return ICmpInst::getSignedPredicate,

llvm/include/llvm/IR/CmpPredicate.h

@@ -15,10 +15,10 @@
 #ifndef LLVM_IR_COMDAT_H
 #define LLVM_IR_COMDAT_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm-c/Types.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 

llvm/include/llvm/IR/Comdat.h

@@ -13,10 +13,10 @@
 #ifndef LLVM_IR_CONSTANT_H
 #define LLVM_IR_CONSTANT_H
 
-#include "llvm/Support/Compiler.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
@@ -187,12 +187,12 @@ class Constant : public User {
   ///
   LLVM_ABI void handleOperandChange(Value *, Value *);
 
-  LLVM_ABI static Constant *getNullValue(Type* Ty);
+  LLVM_ABI static Constant *getNullValue(Type *Ty);
 
   /// @returns the value for an integer or vector of integer constant of the
   /// given type that has all its bits set to true.
   /// Get the all ones value
-  LLVM_ABI static Constant *getAllOnesValue(Type* Ty);
+  LLVM_ABI static Constant *getAllOnesValue(Type *Ty);
 
   /// Return the value for an integer or pointer constant, or a vector thereof,
   /// with the given scalar value.
@@ -227,7 +227,8 @@ class Constant : public User {
 
   /// Try to replace undefined constant C or undefined elements in C with
   /// Replacement. If no changes are made, the constant C is returned.
-  LLVM_ABI static Constant *replaceUndefsWith(Constant *C, Constant *Replacement);
+  LLVM_ABI static Constant *replaceUndefsWith(Constant *C,
+                                              Constant *Replacement);
 
   /// Merges undefs of a Constant with another Constant, along with the
   /// undefs already present. Other doesn't have to be the same type as C, but