Use LLVM_LIBRARY_VISIBILITY to prevent LLVM dynamic libraries from export symbols for SROA internals.

[resistor]

Summary

Because the new pass manager exposes the pass types, member functions on those passes become exported symbols by default. We can use LLVM_LIBRARY_VISIBILITY to restrict their linkage to be accessible within the LLVM dynamic library itself, but not exported from it.

include/llvm/Transforms/Scalar/SROA.h

public:
   PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
 
 private:
   friend class sroa::AllocaSliceRewriter;
   friend class sroa::SROALegacyPass;
 
   /// Helper used by both the public run method and by the legacy pass.
   PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
-                            AssumptionCache &RunAC);
+                            AssumptionCache &RunAC) LLVM_LIBRARY_VISIBILITY;
 
-  bool presplitLoadsAndStores(AllocaInst &AI, sroa::AllocaSlices &AS);
+  bool presplitLoadsAndStores(AllocaInst &AI, sroa::AllocaSlices &AS)
+         LLVM_LIBRARY_VISIBILITY;
   AllocaInst *rewritePartition(AllocaInst &AI, sroa::AllocaSlices &AS,
-                               sroa::Partition &P);
-  bool splitAlloca(AllocaInst &AI, sroa::AllocaSlices &AS);
-  bool runOnAlloca(AllocaInst &AI);
-  void clobberUse(Use &U);
-  void deleteDeadInstructions(SmallPtrSetImpl<AllocaInst *> &DeletedAllocas);
-  bool promoteAllocas(Function &F);
+                               sroa::Partition &P) LLVM_LIBRARY_VISIBILITY;
+  bool splitAlloca(AllocaInst &AI, sroa::AllocaSlices &AS)
+         LLVM_LIBRARY_VISIBILITY;
+  bool runOnAlloca(AllocaInst &AI) LLVM_LIBRARY_VISIBILITY;
+  void clobberUse(Use &U) LLVM_LIBRARY_VISIBILITY;
+  void deleteDeadInstructions(SmallPtrSetImpl<AllocaInst *> &DeletedAllocas)
+         LLVM_LIBRARY_VISIBILITY;
+  bool promoteAllocas(Function &F) LLVM_LIBRARY_VISIBILITY;
 };
 
 }
 
 #endif

lib/Transforms/Scalar/SROA.cpp

 
 /// \brief Representation of the alloca slices.
 ///
 /// This class represents the slices of an alloca which are formed by its
 /// various uses. If a pointer escapes, we can't fully build a representation
 /// for the slices used and we reflect that in this structure. The uses are
 /// stored, sorted by increasing beginning offset and with unsplittable slices
 /// starting at a particular offset before splittable slices.
-class llvm::sroa::AllocaSlices {
+class LLVM_LIBRARY_VISIBILITY llvm::sroa::AllocaSlices  {
 public:
   /// \brief Construct the slices of a particular alloca.
   AllocaSlices(const DataLayout &DL, AllocaInst &AI);
 
   /// \brief Test whether a pointer to the allocation escapes our analysis.
   ///
   /// If this is true, the slices are never fully built and should be
   /// ignored.
void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addPreserved<GlobalsAAWrapperPass>();
     AU.setPreservesCFG();
   }
 
   const char *getPassName() const override { return "SROA"; }
   static char ID;
 };
 
-char SROALegacyPass::ID = 0;
+char LLVM_LIBRARY_VISIBILITY SROALegacyPass::ID = 0;
 
 FunctionPass *llvm::createSROAPass() { return new SROALegacyPass(); }
 
 INITIALIZE_PASS_BEGIN(SROALegacyPass, "sroa",
                       "Scalar Replacement Of Aggregates", false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_END(SROALegacyPass, "sroa", "Scalar Replacement Of Aggregates",
                     false, false)