[llvm] manual fix-ups to IDS codemod of IR library

Author: andrurogerz

llvm/include/llvm/IR/Analysis.h

@@ -57,8 +57,8 @@ template <typename IRUnitT> class AllAnalysesOn {
 
 template <typename IRUnitT> AnalysisSetKey AllAnalysesOn<IRUnitT>::SetKey;
 
-extern template class AllAnalysesOn<Module>;
-extern template class AllAnalysesOn<Function>;
+extern template class LLVM_TEMPLATE_ABI AllAnalysesOn<Module>;
+extern template class LLVM_TEMPLATE_ABI AllAnalysesOn<Function>;
 
 /// Represents analyses that only rely on functions' control flow.
 ///

llvm/include/llvm/IR/Attributes.h

@@ -373,38 +373,38 @@ class AttributeSet {
 
   /// Add an argument attribute. Returns a new set because attribute sets are
   /// immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet addAttribute(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeSet addAttribute(LLVMContext &C,
                                           Attribute::AttrKind Kind) const;
 
   /// Add a target-dependent attribute. Returns a new set because attribute sets
   /// are immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
+  [[nodiscard]] LLVM_ABI AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
                                           StringRef Value = StringRef()) const;
 
   /// Add attributes to the attribute set. Returns a new set because attribute
   /// sets are immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet addAttributes(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeSet addAttributes(LLVMContext &C,
                                            AttributeSet AS) const;
 
   /// Remove the specified attribute from this set. Returns a new set because
   /// attribute sets are immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet removeAttribute(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeSet removeAttribute(LLVMContext &C,
                                              Attribute::AttrKind Kind) const;
 
   /// Remove the specified attribute from this set. Returns a new set because
   /// attribute sets are immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet removeAttribute(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeSet removeAttribute(LLVMContext &C,
                                              StringRef Kind) const;
 
   /// Remove the specified attributes from this set. Returns a new set because
   /// attribute sets are immutable.
-  LLVM_ABI [[nodiscard]] AttributeSet
+  [[nodiscard]] LLVM_ABI AttributeSet
   removeAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const;
 
   /// Try to intersect this AttributeSet with Other. Returns std::nullopt if
   /// the two lists are inherently incompatible (imply different behavior, not
   /// just analysis).
-  LLVM_ABI [[nodiscard]] std::optional<AttributeSet>
+  [[nodiscard]] LLVM_ABI std::optional<AttributeSet>
   intersectWith(LLVMContext &C, AttributeSet Other) const;
 
   /// Return the number of attributes in this set.
@@ -554,24 +554,24 @@ class AttributeList {
   // TODO: remove non-AtIndex versions of these methods.
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   addAttributeAtIndex(LLVMContext &C, unsigned Index,
                       Attribute::AttrKind Kind) const;
 
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   addAttributeAtIndex(LLVMContext &C, unsigned Index, StringRef Kind,
                       StringRef Value = StringRef()) const;
 
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute A) const;
 
   /// Add attributes to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList addAttributesAtIndex(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList addAttributesAtIndex(LLVMContext &C,
                                                    unsigned Index,
                                                    const AttrBuilder &B) const;
 
@@ -643,7 +643,7 @@ class AttributeList {
 
   /// Add an attribute to the attribute list at the given arg indices. Returns a
   /// new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList addParamAttribute(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList addParamAttribute(LLVMContext &C,
                                                 ArrayRef<unsigned> ArgNos,
                                                 Attribute A) const;
 
@@ -656,13 +656,13 @@ class AttributeList {
 
   /// Remove the specified attribute at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   removeAttributeAtIndex(LLVMContext &C, unsigned Index,
                          Attribute::AttrKind Kind) const;
 
   /// Remove the specified attribute at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   removeAttributeAtIndex(LLVMContext &C, unsigned Index, StringRef Kind) const;
   [[nodiscard]] AttributeList removeAttribute(LLVMContext &C, unsigned Index,
                                               StringRef Kind) const {
@@ -671,13 +671,13 @@ class AttributeList {
 
   /// Remove the specified attributes at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   removeAttributesAtIndex(LLVMContext &C, unsigned Index,
                           const AttributeMask &AttrsToRemove) const;
 
   /// Remove all attributes at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList removeAttributesAtIndex(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList removeAttributesAtIndex(LLVMContext &C,
                                                       unsigned Index) const;
 
   /// Remove the specified attribute at the function index from this
@@ -773,37 +773,37 @@ class AttributeList {
 
   /// \brief Add the dereferenceable attribute to the attribute set at the given
   /// index. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList addDereferenceableRetAttr(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList addDereferenceableRetAttr(LLVMContext &C,
                                                         uint64_t Bytes) const;
 
   /// \brief Add the dereferenceable attribute to the attribute set at the given
   /// arg index. Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList addDereferenceableParamAttr(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList addDereferenceableParamAttr(LLVMContext &C,
                                                           unsigned ArgNo,
                                                           uint64_t Bytes) const;
 
   /// Add the dereferenceable_or_null attribute to the attribute set at
   /// the given arg index. Returns a new list because attribute lists are
   /// immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo,
                                     uint64_t Bytes) const;
 
   /// Add the range attribute to the attribute set at the return value index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList addRangeRetAttr(LLVMContext &C,
+  [[nodiscard]] LLVM_ABI AttributeList addRangeRetAttr(LLVMContext &C,
                                               const ConstantRange &CR) const;
 
   /// Add the allocsize attribute to the attribute set at the given arg index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_ABI [[nodiscard]] AttributeList
+  [[nodiscard]] LLVM_ABI AttributeList
   addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg,
                         const std::optional<unsigned> &NumElemsArg) const;
 
   /// Try to intersect this AttributeList with Other. Returns std::nullopt if
   /// the two lists are inherently incompatible (imply different behavior, not
   /// just analysis).
-  LLVM_ABI [[nodiscard]] std::optional<AttributeList>
+  [[nodiscard]] LLVM_ABI std::optional<AttributeList>
   intersectWith(LLVMContext &C, AttributeList Other) const;
 
   //===--------------------------------------------------------------------===//

llvm/include/llvm/IR/BuiltinGCs.h

@@ -14,6 +14,8 @@
 #ifndef LLVM_IR_BUILTINGCS_H
 #define LLVM_IR_BUILTINGCS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 /// FIXME: Collector instances are not useful on their own. These no longer

llvm/include/llvm/IR/DebugProgramInstruction.h

@@ -118,6 +118,10 @@ template <typename T> class DbgRecordParamRef {
   }
 };
 
+extern template class LLVM_TEMPLATE_ABI DbgRecordParamRef<DIExpression>;
+extern template class LLVM_TEMPLATE_ABI DbgRecordParamRef<DILabel>;
+extern template class LLVM_TEMPLATE_ABI DbgRecordParamRef<DILocalVariable>;
+
 /// Base class for non-instruction debug metadata records that have positions
 /// within IR. Features various methods copied across from the Instruction
 /// class to aid ease-of-use. DbgRecords should always be linked into a

llvm/include/llvm/IR/DerivedTypes.h

@@ -702,9 +702,9 @@ class PointerType : public Type {
 
   /// This constructs a pointer to an object of the specified type in a numbered
   /// address space.
-  LLVM_ABI [[deprecated("PointerType::get with pointee type is pending removal. Use "
+  [[deprecated("PointerType::get with pointee type is pending removal. Use "
                "Context overload.")]]
-  static PointerType *get(Type *ElementType, unsigned AddressSpace);
+  LLVM_ABI static PointerType *get(Type *ElementType, unsigned AddressSpace);
   /// This constructs an opaque pointer to an object in a numbered address
   /// space.
   LLVM_ABI static PointerType *get(LLVMContext &C, unsigned AddressSpace);

llvm/include/llvm/IR/Dominators.h

@@ -44,9 +44,9 @@ class Value;
 class raw_ostream;
 template <class GraphType> struct GraphTraits;
 
-extern template class DomTreeNodeBase<BasicBlock>;
-extern template class DominatorTreeBase<BasicBlock, false>; // DomTree
-extern template class DominatorTreeBase<BasicBlock, true>; // PostDomTree
+extern template class LLVM_TEMPLATE_ABI DomTreeNodeBase<BasicBlock>;
+extern template class LLVM_TEMPLATE_ABI DominatorTreeBase<BasicBlock, false>; // DomTree
+extern template class LLVM_TEMPLATE_ABI DominatorTreeBase<BasicBlock, true>; // PostDomTree
 
 extern template class cfg::Update<BasicBlock *>;
 
@@ -59,34 +59,34 @@ using BBUpdates = ArrayRef<llvm::cfg::Update<BasicBlock *>>;
 using BBDomTreeGraphDiff = GraphDiff<BasicBlock *, false>;
 using BBPostDomTreeGraphDiff = GraphDiff<BasicBlock *, true>;
 
-extern template void Calculate<BBDomTree>(BBDomTree &DT);
-extern template void CalculateWithUpdates<BBDomTree>(BBDomTree &DT,
+extern template LLVM_TEMPLATE_ABI void Calculate<BBDomTree>(BBDomTree &DT);
+extern template LLVM_TEMPLATE_ABI void CalculateWithUpdates<BBDomTree>(BBDomTree &DT,
                                                      BBUpdates U);
 
-extern template void Calculate<BBPostDomTree>(BBPostDomTree &DT);
+extern template LLVM_TEMPLATE_ABI void Calculate<BBPostDomTree>(BBPostDomTree &DT);
 
-extern template void InsertEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
+extern template LLVM_TEMPLATE_ABI void InsertEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
                                            BasicBlock *To);
-extern template void InsertEdge<BBPostDomTree>(BBPostDomTree &DT,
+extern template LLVM_TEMPLATE_ABI void InsertEdge<BBPostDomTree>(BBPostDomTree &DT,
                                                BasicBlock *From,
                                                BasicBlock *To);
 
-extern template void DeleteEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
+extern template LLVM_TEMPLATE_ABI void DeleteEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
                                            BasicBlock *To);
-extern template void DeleteEdge<BBPostDomTree>(BBPostDomTree &DT,
+extern template LLVM_TEMPLATE_ABI void DeleteEdge<BBPostDomTree>(BBPostDomTree &DT,
                                                BasicBlock *From,
                                                BasicBlock *To);
 
-extern template void ApplyUpdates<BBDomTree>(BBDomTree &DT,
+extern template LLVM_TEMPLATE_ABI void ApplyUpdates<BBDomTree>(BBDomTree &DT,
                                              BBDomTreeGraphDiff &,
                                              BBDomTreeGraphDiff *);
-extern template void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT,
+extern template LLVM_TEMPLATE_ABI void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT,
                                                  BBPostDomTreeGraphDiff &,
                                                  BBPostDomTreeGraphDiff *);
 
-extern template bool Verify<BBDomTree>(const BBDomTree &DT,
+extern template LLVM_TEMPLATE_ABI bool Verify<BBDomTree>(const BBDomTree &DT,
                                        BBDomTree::VerificationLevel VL);
-extern template bool Verify<BBPostDomTree>(const BBPostDomTree &DT,
+extern template LLVM_TEMPLATE_ABI bool Verify<BBPostDomTree>(const BBPostDomTree &DT,
                                            BBPostDomTree::VerificationLevel VL);
 }  // namespace DomTreeBuilder
 
@@ -279,7 +279,7 @@ template <> struct GraphTraits<DominatorTree*>
 /// Analysis pass which computes a \c DominatorTree.
 class DominatorTreeAnalysis : public AnalysisInfoMixin<DominatorTreeAnalysis> {
   friend AnalysisInfoMixin<DominatorTreeAnalysis>;
-  static AnalysisKey Key;
+  LLVM_ABI static AnalysisKey Key;
 
 public:
   /// Provide the result typedef for this analysis pass.

llvm/include/llvm/IR/Function.h

@@ -792,8 +792,8 @@ class LLVM_ABI Function : public GlobalObject, public ilist_node<Function> {
 
 private:
   // These need access to the underlying BB list.
-  friend void BasicBlock::removeFromParent();
-  friend iplist<BasicBlock>::iterator BasicBlock::eraseFromParent();
+  LLVM_ABI_FRIEND friend void BasicBlock::removeFromParent();
+  LLVM_ABI_FRIEND friend iplist<BasicBlock>::iterator BasicBlock::eraseFromParent();
   template <class BB_t, class BB_i_t, class BI_t, class II_t>
   friend class InstIterator;
   friend class llvm::SymbolTableListTraits<llvm::BasicBlock>;

llvm/include/llvm/IR/GenericFloatingPointPredicateUtils.h

@@ -15,6 +15,7 @@
 #ifndef LLVM_ADT_GENERICFLOATINGPOINTPREDICATEUTILS_H
 #define LLVM_ADT_GENERICFLOATINGPOINTPREDICATEUTILS_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/IR/Instructions.h"
@@ -29,12 +30,12 @@ template <typename ContextT> class GenericFloatingPointPredicateUtils {
   constexpr static ValueRefT Invalid = {};
 
 private:
-  static DenormalMode queryDenormalMode(const FunctionT &F, ValueRefT Val);
+  LLVM_ABI static DenormalMode queryDenormalMode(const FunctionT &F, ValueRefT Val);
 
-  static bool lookThroughFAbs(const FunctionT &F, ValueRefT LHS,
+  LLVM_ABI static bool lookThroughFAbs(const FunctionT &F, ValueRefT LHS,
                               ValueRefT &Src);
 
-  static std::optional<APFloat> matchConstantFloat(const FunctionT &F,
+  LLVM_ABI static std::optional<APFloat> matchConstantFloat(const FunctionT &F,
                                                    ValueRefT Val);
 
   /// Return the return value for fcmpImpliesClass for a compare that produces

llvm/include/llvm/IR/Metadata.h

@@ -1336,9 +1336,9 @@ class MDNode : public Metadata {
   /// @}
 
 private:
-  MDNode *replaceWithPermanentImpl();
-  MDNode *replaceWithUniquedImpl();
-  MDNode *replaceWithDistinctImpl();
+  LLVM_ABI MDNode *replaceWithPermanentImpl();
+  LLVM_ABI MDNode *replaceWithUniquedImpl();
+  LLVM_ABI MDNode *replaceWithDistinctImpl();
 
 protected:
   /// Set an operand.

llvm/include/llvm/IR/PassInstrumentation.h

@@ -351,7 +351,7 @@ LLVM_ABI bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Spec
 class PassInstrumentationAnalysis
     : public AnalysisInfoMixin<PassInstrumentationAnalysis> {
   friend AnalysisInfoMixin<PassInstrumentationAnalysis>;
-  static AnalysisKey Key;
+  LLVM_ABI static AnalysisKey Key;
 
   PassInstrumentationCallbacks *Callbacks;
 

llvm/include/llvm/IR/PassManager.h

@@ -232,7 +232,7 @@ void printIRUnitNameForStackTrace(raw_ostream &OS, const IRUnitT &IR);
 template <>
 LLVM_ABI void printIRUnitNameForStackTrace<Module>(raw_ostream &OS, const Module &IR);
 
-extern template class PassManager<Module>;
+extern template class LLVM_TEMPLATE_ABI PassManager<Module>;
 
 /// Convenience typedef for a pass manager over modules.
 using ModulePassManager = PassManager<Module>;
@@ -241,7 +241,7 @@ template <>
 LLVM_ABI void printIRUnitNameForStackTrace<Function>(raw_ostream &OS,
                                             const Function &IR);
 
-extern template class PassManager<Function>;
+extern template class LLVM_TEMPLATE_ABI PassManager<Function>;
 
 /// Convenience typedef for a pass manager over functions.
 using FunctionPassManager = PassManager<Function>;
@@ -536,12 +536,12 @@ template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager {
   AnalysisResultMapT AnalysisResults;
 };
 
-extern template class AnalysisManager<Module>;
+extern template class LLVM_TEMPLATE_ABI AnalysisManager<Module>;
 
 /// Convenience typedef for the Module analysis manager.
 using ModuleAnalysisManager = AnalysisManager<Module>;
 
-extern template class AnalysisManager<Function>;
+extern template class LLVM_TEMPLATE_ABI AnalysisManager<Function>;
 
 /// Convenience typedef for the Function analysis manager.
 using FunctionAnalysisManager = AnalysisManager<Function>;
@@ -563,7 +563,7 @@ using FunctionAnalysisManager = AnalysisManager<Function>;
 /// Note that the proxy's result is a move-only RAII object.  The validity of
 /// the analyses in the inner analysis manager is tied to its lifetime.
 template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
-class InnerAnalysisManagerProxy
+class LLVM_TEMPLATE_ABI InnerAnalysisManagerProxy
     : public AnalysisInfoMixin<
           InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
 public:
@@ -796,7 +796,7 @@ template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
 AnalysisKey
     OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
 
-extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
+extern template class LLVM_TEMPLATE_ABI OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                                 Function>;
 /// Provide the \c ModuleAnalysisManager to \c Function proxy.
 using ModuleAnalysisManagerFunctionProxy =

llvm/include/llvm/IR/ReplaceConstant.h

@@ -14,6 +14,8 @@
 #ifndef LLVM_IR_REPLACECONSTANT_H
 #define LLVM_IR_REPLACECONSTANT_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 template <typename T> class ArrayRef;