[llvm] DLLExport Analysis library public interface

Author: andrurogerz

llvm/include/llvm/Analysis/AliasAnalysis.h

@@ -43,6 +43,7 @@
 #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>
@@ -142,11 +143,11 @@ static_assert(sizeof(AliasResult) == 4,
               "AliasResult size is intended to be 4 bytes!");
 
 /// << operator for AliasResult.
-raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
 
 /// Virtual base class for providers of capture analysis.
 struct CaptureAnalysis {
-  virtual ~CaptureAnalysis() = 0;
+  LLVM_ABI virtual ~CaptureAnalysis() = 0;
 
   /// Check whether Object is not captured before instruction I. If OrAt is
   /// true, captures by instruction I itself are also considered.
@@ -159,10 +160,12 @@ struct CaptureAnalysis {
 /// Context-free CaptureAnalysis provider, which computes and caches whether an
 /// object is captured in the function at all, but does not distinguish whether
 /// it was captured before or after the context instruction.
-class SimpleCaptureAnalysis final : public CaptureAnalysis {
+class LLVM_ABI SimpleCaptureAnalysis final : public CaptureAnalysis {
   SmallDenseMap<const Value *, bool, 8> IsCapturedCache;
 
 public:
+  ~SimpleCaptureAnalysis() = default;
+
   bool isNotCapturedBefore(const Value *Object, const Instruction *I,
                            bool OrAt) override;
 };
@@ -188,10 +191,12 @@ class EarliestEscapeAnalysis final : public CaptureAnalysis {
   EarliestEscapeAnalysis(DominatorTree &DT, const LoopInfo *LI = nullptr)
       : DT(DT), LI(LI) {}
 
-  bool isNotCapturedBefore(const Value *Object, const Instruction *I,
+  LLVM_ABI ~EarliestEscapeAnalysis() = default;
+
+  LLVM_ABI bool isNotCapturedBefore(const Value *Object, const Instruction *I,
                            bool OrAt) override;
 
-  void removeInstruction(Instruction *I);
+  LLVM_ABI void removeInstruction(Instruction *I);
 };
 
 /// Cache key for BasicAA results. It only includes the pointer and size from
@@ -315,9 +320,9 @@ class AAResults {
 public:
   // Make these results default constructable and movable. We have to spell
   // these out because MSVC won't synthesize them.
-  AAResults(const TargetLibraryInfo &TLI);
-  AAResults(AAResults &&Arg);
-  ~AAResults();
+  LLVM_ABI AAResults(const TargetLibraryInfo &TLI);
+  LLVM_ABI AAResults(AAResults &&Arg);
+  LLVM_ABI ~AAResults();
 
   /// Register a specific AA result.
   template <typename AAResultT> void addAAResult(AAResultT &AAResult) {
@@ -338,7 +343,7 @@ class AAResults {
   ///
   /// The aggregation is invalidated if any of the underlying analyses is
   /// invalidated.
-  bool invalidate(Function &F, const PreservedAnalyses &PA,
+  LLVM_ABI bool invalidate(Function &F, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &Inv);
 
   //===--------------------------------------------------------------------===//
@@ -349,7 +354,7 @@ 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.
-  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,
@@ -417,7 +422,7 @@ class AAResults {
   ///
   /// If IgnoreLocals is true, then this method returns NoModRef for memory
   /// that points to a local alloca.
-  ModRefInfo getModRefInfoMask(const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc,
                                bool IgnoreLocals = false);
 
   /// A convenience wrapper around the primary \c getModRefInfoMask
@@ -431,13 +436,13 @@ class AAResults {
   /// that these bits do not necessarily account for the overall behavior of
   /// the function, but rather only provide additional per-argument
   /// information.
-  ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx);
+  LLVM_ABI ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx);
 
   /// Return the behavior of the given call site.
-  MemoryEffects getMemoryEffects(const CallBase *Call);
+  LLVM_ABI MemoryEffects getMemoryEffects(const CallBase *Call);
 
   /// Return the behavior when calling the given function.
-  MemoryEffects getMemoryEffects(const Function *F);
+  LLVM_ABI MemoryEffects getMemoryEffects(const Function *F);
 
   /// Checks if the specified call is known to never read or write memory.
   ///
@@ -519,7 +524,7 @@ class AAResults {
 
   /// Return information about whether a call and an instruction may refer to
   /// the same memory locations.
-  ModRefInfo getModRefInfo(const Instruction *I, const CallBase *Call);
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I, const CallBase *Call);
 
   /// Return information about whether two instructions may refer to the same
   /// memory locations.
@@ -548,7 +553,7 @@ class AAResults {
 
   /// Check if it is possible for execution of the specified basic block to
   /// modify the location Loc.
-  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,
@@ -561,7 +566,7 @@ 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.
-  bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
+  LLVM_ABI bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
                                  const MemoryLocation &Loc,
                                  const ModRefInfo Mode);
 
@@ -574,42 +579,42 @@ class AAResults {
 
   // CtxI can be nullptr, in which case the query is whether or not the aliasing
   // relationship holds through the entire function.
-  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
+  LLVM_ABI AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI, const Instruction *CtxI = nullptr);
 
-  ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI,
+  LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                                bool IgnoreLocals = false);
-  ModRefInfo getModRefInfo(const Instruction *I, const CallBase *Call2,
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I, const CallBase *Call2,
                            AAQueryInfo &AAQIP);
-  ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
+  LLVM_ABI ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const VAArgInst *V, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const VAArgInst *V, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const LoadInst *L, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const LoadInst *L, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const StoreInst *S, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const StoreInst *S, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const FenceInst *S, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const FenceInst *S, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX,
+  LLVM_ABI ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX,
                            const MemoryLocation &Loc, AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const CatchPadInst *I, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const CatchPadInst *I, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc,
+  LLVM_ABI ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
-  ModRefInfo getModRefInfo(const Instruction *I,
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I,
                            const std::optional<MemoryLocation> &OptLoc,
                            AAQueryInfo &AAQIP);
-  ModRefInfo getModRefInfo(const Instruction *I1, const Instruction *I2,
+  LLVM_ABI ModRefInfo getModRefInfo(const Instruction *I1, const Instruction *I2,
                            AAQueryInfo &AAQI);
-  ModRefInfo callCapturesBefore(const Instruction *I,
+  LLVM_ABI ModRefInfo callCapturesBefore(const Instruction *I,
                                 const MemoryLocation &MemLoc, DominatorTree *DT,
                                 AAQueryInfo &AAQIP);
-  MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI);
+  LLVM_ABI MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI);
 
 private:
   class Concept;
@@ -708,7 +713,7 @@ using AliasAnalysis = AAResults;
 /// All of these methods model methods by the same name in the \c
 /// AAResults class. Only differences and specifics to how the
 /// implementations are called are documented here.
-class AAResults::Concept {
+class LLVM_ABI AAResults::Concept {
 public:
   virtual ~Concept() = 0;
 
@@ -869,7 +874,7 @@ class AAResultBase {
 };
 
 /// Return true if this pointer is returned by a noalias function.
-bool isNoAliasCall(const Value *V);
+LLVM_ABI bool isNoAliasCall(const Value *V);
 
 /// Return true if this pointer refers to a distinct and identifiable object.
 /// This returns true for:
@@ -878,32 +883,32 @@ bool isNoAliasCall(const Value *V);
 ///    ByVal and NoAlias Arguments
 ///    NoAlias returns (e.g. calls to malloc)
 ///
-bool isIdentifiedObject(const Value *V);
+LLVM_ABI bool isIdentifiedObject(const Value *V);
 
 /// Return true if V is umabigously identified at the function-level.
 /// Different IdentifiedFunctionLocals can't alias.
 /// Further, an IdentifiedFunctionLocal can not alias with any function
 /// arguments other than itself, which is not necessarily true for
 /// IdentifiedObjects.
-bool isIdentifiedFunctionLocal(const Value *V);
+LLVM_ABI bool isIdentifiedFunctionLocal(const Value *V);
 
 /// Return true if we know V to the base address of the corresponding memory
 /// object.  This implies that any address less than V must be out of bounds
 /// for the underlying object.  Note that just being isIdentifiedObject() is
 /// not enough - For example, a negative offset from a noalias argument or call
 /// can be inbounds w.r.t the actual underlying object.
-bool isBaseOfObject(const Value *V);
+LLVM_ABI bool isBaseOfObject(const Value *V);
 
 /// Returns true if the pointer is one which would have been considered an
 /// escape by isNonEscapingLocalObject.
-bool isEscapeSource(const Value *V);
+LLVM_ABI bool isEscapeSource(const Value *V);
 
 /// Return true if Object memory is not visible after an unwind, in the sense
 /// that program semantics cannot depend on Object containing any particular
 /// value on unwind. If the RequiresNoCaptureBeforeUnwind out parameter is set
 /// 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.
-bool isNotVisibleOnUnwind(const Value *Object,
+LLVM_ABI bool isNotVisibleOnUnwind(const Value *Object,
                           bool &RequiresNoCaptureBeforeUnwind);
 
 /// Return true if the Object is writable, in the sense that any location based
@@ -917,7 +922,7 @@ 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.
-bool isWritableObject(const Value *Object, bool &ExplicitlyDereferenceableOnly);
+LLVM_ABI bool isWritableObject(const Value *Object, bool &ExplicitlyDereferenceableOnly);
 
 /// A manager for alias analyses.
 ///
@@ -950,12 +955,12 @@ class AAManager : public AnalysisInfoMixin<AAManager> {
     ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
   }
 
-  Result run(Function &F, FunctionAnalysisManager &AM);
+  LLVM_ABI Result run(Function &F, FunctionAnalysisManager &AM);
 
 private:
   friend AnalysisInfoMixin<AAManager>;
 
-  static AnalysisKey Key;
+  LLVM_ABI static AnalysisKey Key;
 
   SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,
                        AAResults &AAResults),
@@ -988,16 +993,16 @@ class AAResultsWrapperPass : public FunctionPass {
   std::unique_ptr<AAResults> AAR;
 
 public:
-  static char ID;
+  LLVM_ABI static char ID;
 
-  AAResultsWrapperPass();
+  LLVM_ABI AAResultsWrapperPass();
 
   AAResults &getAAResults() { return *AAR; }
   const AAResults &getAAResults() const { return *AAR; }
 
-  bool runOnFunction(Function &F) override;
+  LLVM_ABI bool runOnFunction(Function &F) override;
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  LLVM_ABI void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
 /// A wrapper pass for external alias analyses. This just squirrels away the
@@ -1007,11 +1012,11 @@ struct ExternalAAWrapperPass : ImmutablePass {
 
   CallbackT CB;
 
-  static char ID;
+  LLVM_ABI static char ID;
 
-  ExternalAAWrapperPass();
+  LLVM_ABI ExternalAAWrapperPass();
 
-  explicit ExternalAAWrapperPass(CallbackT CB);
+  LLVM_ABI explicit ExternalAAWrapperPass(CallbackT CB);
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
@@ -1025,7 +1030,7 @@ struct ExternalAAWrapperPass : ImmutablePass {
 /// object, and will receive a reference to the function wrapper pass, the
 /// function, and the AAResults object to populate. This should be used when
 /// setting up a custom pass pipeline to inject a hook into the AA results.
-ImmutablePass *createExternalAAWrapperPass(
+LLVM_ABI ImmutablePass *createExternalAAWrapperPass(
     std::function<void(Pass &, Function &, AAResults &)> Callback);
 
 } // end namespace llvm

llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h

@@ -25,6 +25,7 @@
 #define LLVM_ANALYSIS_ALIASANALYSISEVALUATOR_H
 
 #include "llvm/IR/PassManager.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 class AAResults;
@@ -47,10 +48,10 @@ class AAEvaluator : public PassInfoMixin<AAEvaluator> {
         ModRefCount(Arg.ModRefCount) {
     Arg.FunctionCount = 0;
   }
-  ~AAEvaluator();
+  LLVM_ABI ~AAEvaluator();
 
   /// Run the pass over the function.
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
 private:
   void runInternal(Function &F, AAResults &AA);