Give internal classes hidden visibility.

Worth 100k on a linux/x86_64 Release+Asserts clang.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190534 91177308-0d34-0410-b5e6-96231b3b80d8

lib/AsmParser/LLLexer.h

@@ -26,7 +26,7 @@ namespace llvm {
   class SMDiagnostic;
   class LLVMContext;
 
-  class LLLexer {
+  class LLVM_LIBRARY_VISIBILITY LLLexer {
     const char *CurPtr;
     MemoryBuffer *CurBuf;
     SMDiagnostic &ErrorInfo;

lib/AsmParser/LLParser.h

@@ -42,7 +42,7 @@ namespace llvm {
   /// There are several cases where we have to parse the value but where the
   /// type can depend on later context.  This may either be a numeric reference
   /// or a symbolic (%var) reference.  This is just a discriminated union.
-  struct ValID {
+  struct LLVM_LIBRARY_VISIBILITY ValID {
     enum {
       t_LocalID, t_GlobalID,      // ID in UIntVal.
       t_LocalName, t_GlobalName,  // Name in StrVal.
@@ -83,7 +83,7 @@ namespace llvm {
     }
   };
 
-  class LLParser {
+  class LLVM_LIBRARY_VISIBILITY LLParser {
   public:
     typedef LLLexer::LocTy LocTy;
   private:

lib/Bitcode/Reader/BitcodeReader.h

@@ -32,7 +32,7 @@ namespace llvm {
 //                          BitcodeReaderValueList Class
 //===----------------------------------------------------------------------===//
 
-class BitcodeReaderValueList {
+class LLVM_LIBRARY_VISIBILITY BitcodeReaderValueList {
   std::vector<WeakVH> ValuePtrs;
 
   /// ResolveConstants - As we resolve forward-referenced constants, we add
@@ -91,7 +91,7 @@ public:
 //                          BitcodeReaderMDValueList Class
 //===----------------------------------------------------------------------===//
 
-class BitcodeReaderMDValueList {
+class LLVM_LIBRARY_VISIBILITY BitcodeReaderMDValueList {
   std::vector<WeakVH> MDValuePtrs;
 
   LLVMContext &Context;
@@ -121,7 +121,7 @@ public:
   void AssignValue(Value *V, unsigned Idx);
 };
 
-class BitcodeReader : public GVMaterializer {
+class LLVM_LIBRARY_VISIBILITY BitcodeReader : public GVMaterializer {
   LLVMContext &Context;
   Module *TheModule;
   MemoryBuffer *Buffer;

lib/Bitcode/Writer/ValueEnumerator.h

@@ -34,7 +34,7 @@ class ValueSymbolTable;
 class MDSymbolTable;
 class raw_ostream;
 
-class ValueEnumerator {
+class LLVM_LIBRARY_VISIBILITY ValueEnumerator {
 public:
   typedef std::vector<Type*> TypeList;
 

lib/CodeGen/AggressiveAntiDepBreaker.h

@@ -34,7 +34,7 @@ class RegisterClassInfo;
 
   /// Class AggressiveAntiDepState
   /// Contains all the state necessary for anti-dep breaking.
-  class AggressiveAntiDepState {
+  class LLVM_LIBRARY_VISIBILITY AggressiveAntiDepState {
   public:
     /// RegisterReference - Information about a register reference
     /// within a liverange
@@ -114,7 +114,8 @@ class RegisterClassInfo;
 
 
   /// Class AggressiveAntiDepBreaker
-  class AggressiveAntiDepBreaker : public AntiDepBreaker {
+  class LLVM_LIBRARY_VISIBILITY AggressiveAntiDepBreaker
+      : public AntiDepBreaker {
     MachineFunction& MF;
     MachineRegisterInfo &MRI;
     const TargetInstrInfo *TII;

lib/CodeGen/AllocationOrder.h

@@ -25,7 +25,7 @@ namespace llvm {
 class RegisterClassInfo;
 class VirtRegMap;
 
-class AllocationOrder {
+class LLVM_LIBRARY_VISIBILITY AllocationOrder {
   SmallVector<MCPhysReg, 16> Hints;
   ArrayRef<MCPhysReg> Order;
   int Pos;

lib/CodeGen/AntiDepBreaker.h

@@ -28,7 +28,7 @@ namespace llvm {
 /// AntiDepBreaker - This class works into conjunction with the
 /// post-RA scheduler to rename registers to break register
 /// anti-dependencies.
-class AntiDepBreaker {
+class LLVM_LIBRARY_VISIBILITY AntiDepBreaker {
 public:
   typedef std::vector<std::pair<MachineInstr *, MachineInstr *> > 
     DbgValueVector;

lib/CodeGen/AsmPrinter/DIE.h

@@ -30,7 +30,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
   /// Dwarf abbreviation.
-  class DIEAbbrevData {
+  class LLVM_LIBRARY_VISIBILITY DIEAbbrevData {
     /// Attribute - Dwarf attribute code.
     ///
     uint16_t Attribute;
@@ -53,7 +53,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
   /// information object.
-  class DIEAbbrev : public FoldingSetNode {
+  class LLVM_LIBRARY_VISIBILITY DIEAbbrev : public FoldingSetNode {
     /// Tag - Dwarf tag code.
     ///
     uint16_t Tag;
@@ -107,7 +107,7 @@ namespace llvm {
   /// describes its organization.
   class DIEValue;
 
-  class DIE {
+  class LLVM_LIBRARY_VISIBILITY DIE {
   protected:
     /// Offset - Offset in debug info section.
     ///
@@ -188,7 +188,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEValue - A debug information entry value.
   ///
-  class DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEValue {
     virtual void anchor();
   public:
     enum {
@@ -228,7 +228,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEInteger - An integer value DIE.
   ///
-  class DIEInteger : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEInteger : public DIEValue {
     uint64_t Integer;
   public:
     explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
@@ -270,7 +270,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEExpr - An expression DIE.
   //
-  class DIEExpr : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEExpr : public DIEValue {
     const MCExpr *Expr;
   public:
     explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {}
@@ -298,7 +298,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIELabel - A label DIE.
   //
-  class DIELabel : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIELabel : public DIEValue {
     const MCSymbol *Label;
   public:
     explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {}
@@ -326,7 +326,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEDelta - A simple label difference DIE.
   ///
-  class DIEDelta : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEDelta : public DIEValue {
     const MCSymbol *LabelHi;
     const MCSymbol *LabelLo;
   public:
@@ -352,7 +352,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEString - A container for string values.
   ///
-  class DIEString : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEString : public DIEValue {
     const DIEValue *Access;
     const StringRef Str;
 
@@ -383,7 +383,7 @@ namespace llvm {
   /// DIEEntry - A pointer to another debug information entry.  An instance of
   /// this class can also be used as a proxy for a debug information entry not
   /// yet defined (ie. types.)
-  class DIEEntry : public DIEValue {
+  class LLVM_LIBRARY_VISIBILITY DIEEntry : public DIEValue {
     DIE *const Entry;
   public:
     explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) {
@@ -417,7 +417,7 @@ namespace llvm {
   //===--------------------------------------------------------------------===//
   /// DIEBlock - A block of values.  Primarily used for location expressions.
   //
-  class DIEBlock : public DIEValue, public DIE {
+  class LLVM_LIBRARY_VISIBILITY DIEBlock : public DIEValue, public DIE {
     unsigned Size;                // Size in bytes excluding size header.
   public:
     DIEBlock()

lib/CodeGen/AsmPrinter/DIEHash.h

@@ -19,7 +19,7 @@ class CompileUnit;
 
 /// \brief An object containing the capability of hashing and adding hash
 /// attributes onto a DIE.
-class DIEHash {
+class LLVM_LIBRARY_VISIBILITY DIEHash {
   // The entry for a particular attribute.
   struct AttrEntry {
     const DIEValue *Val;

lib/CodeGen/AsmPrinter/DwarfAccelTable.h

@@ -65,7 +65,7 @@ class AsmPrinter;
 class DIE;
 class DwarfUnits;
 
-class DwarfAccelTable {
+class LLVM_LIBRARY_VISIBILITY DwarfAccelTable {
 
   static uint32_t HashDJB(StringRef Str) {
     uint32_t h = 5381;

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

@@ -34,7 +34,7 @@ class DbgVariable;
 //===----------------------------------------------------------------------===//
 /// CompileUnit - This dwarf writer support class manages information associated
 /// with a source file.
-class CompileUnit {
+class LLVM_LIBRARY_VISIBILITY CompileUnit {
   /// UniqueID - a numeric ID unique among all CUs in the module
   ///
   unsigned UniqueID;

lib/CodeGen/AsmPrinter/DwarfDebug.h

@@ -44,7 +44,7 @@ class DIEEntry;
 
 //===----------------------------------------------------------------------===//
 /// \brief This class is used to record source line correspondence.
-class SrcLineInfo {
+class LLVM_LIBRARY_VISIBILITY SrcLineInfo {
   unsigned Line;                     // Source line number.
   unsigned Column;                   // Source column.
   unsigned SourceID;                 // Source ID number.
@@ -62,7 +62,7 @@ public:
 
 /// \brief This struct describes location entries emitted in the .debug_loc
 /// section.
-class DotDebugLocEntry {
+class LLVM_LIBRARY_VISIBILITY DotDebugLocEntry {
   // Begin and end symbols for the address range that this location is valid.
   const MCSymbol *Begin;
   const MCSymbol *End;
@@ -143,7 +143,7 @@ public:
 
 //===----------------------------------------------------------------------===//
 /// \brief This class is used to track local variable information.
-class DbgVariable {
+class LLVM_LIBRARY_VISIBILITY DbgVariable {
   DIVariable Var;                    // Variable Descriptor.
   DIE *TheDIE;                       // Variable DIE.
   unsigned DotDebugLocOffset;        // Offset in DotDebugLocEntries.
@@ -212,7 +212,7 @@ public:
 
 /// \brief Collects and handles information specific to a particular
 /// collection of units.
-class DwarfUnits {
+class LLVM_LIBRARY_VISIBILITY DwarfUnits {
   // Target of Dwarf emission, used for sizing of abbreviations.
   AsmPrinter *Asm;
 
@@ -301,7 +301,7 @@ public:
 };
 
 /// \brief Collects and handles dwarf debug information.
-class DwarfDebug {
+class LLVM_LIBRARY_VISIBILITY DwarfDebug {
   // Target of Dwarf emission.
   AsmPrinter *Asm;
 

lib/CodeGen/AsmPrinter/DwarfException.h

@@ -34,7 +34,7 @@ class AsmPrinter;
 //===----------------------------------------------------------------------===//
 /// DwarfException - Emits Dwarf exception handling directives.
 ///
-class DwarfException {
+class LLVM_LIBRARY_VISIBILITY DwarfException {
 protected:
   /// Asm - Target of Dwarf emission.
   AsmPrinter *Asm;
@@ -141,7 +141,7 @@ public:
   virtual void EndFunction();
 };
 
-class DwarfCFIException : public DwarfException {
+class LLVM_LIBRARY_VISIBILITY DwarfCFIException : public DwarfException {
   /// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
   /// should be emitted.
   bool shouldEmitPersonality;
@@ -175,7 +175,7 @@ public:
   virtual void EndFunction();
 };
 
-class ARMException : public DwarfException {
+class LLVM_LIBRARY_VISIBILITY ARMException : public DwarfException {
   void EmitTypeInfos(unsigned TTypeEncoding);
 public:
   //===--------------------------------------------------------------------===//
@@ -196,7 +196,7 @@ public:
   virtual void EndFunction();
 };
 
-class Win64Exception : public DwarfException {
+class LLVM_LIBRARY_VISIBILITY Win64Exception : public DwarfException {
   /// shouldEmitPersonality - Per-function flag to indicate if personality
   /// info should be emitted.
   bool shouldEmitPersonality;

lib/CodeGen/BranchFolding.h

@@ -21,7 +21,7 @@ namespace llvm {
   class TargetInstrInfo;
   class TargetRegisterInfo;
 
-  class BranchFolder {
+  class LLVM_LIBRARY_VISIBILITY BranchFolder {
   public:
     explicit BranchFolder(bool defaultEnableTailMerge, bool CommonHoist);
 

lib/CodeGen/CriticalAntiDepBreaker.h

@@ -31,7 +31,7 @@ class RegisterClassInfo;
 class TargetInstrInfo;
 class TargetRegisterInfo;
 
-  class CriticalAntiDepBreaker : public AntiDepBreaker {
+  class LLVM_LIBRARY_VISIBILITY CriticalAntiDepBreaker : public AntiDepBreaker {
     MachineFunction& MF;
     MachineRegisterInfo &MRI;
     const TargetInstrInfo *TII;

lib/CodeGen/InterferenceCache.h

@@ -21,7 +21,7 @@ namespace llvm {
 
 class LiveIntervals;
 
-class InterferenceCache {
+class LLVM_LIBRARY_VISIBILITY InterferenceCache {
   const TargetRegisterInfo *TRI;
   LiveIntervalUnion *LIUArray;
   MachineFunction *MF;

lib/CodeGen/LiveDebugVariables.h

@@ -30,7 +30,7 @@ class LiveInterval;
 class LiveIntervals;
 class VirtRegMap;
 
-class LiveDebugVariables : public MachineFunctionPass {
+class LLVM_LIBRARY_VISIBILITY LiveDebugVariables : public MachineFunctionPass {
   void *pImpl;
 public:
   static char ID; // Pass identification, replacement for typeid

lib/CodeGen/LiveRangeCalc.h

@@ -33,7 +33,7 @@ class MachineDominatorTree;
 template <class NodeT> class DomTreeNodeBase;
 typedef DomTreeNodeBase<MachineBasicBlock> MachineDomTreeNode;
 
-class LiveRangeCalc {
+class LLVM_LIBRARY_VISIBILITY LiveRangeCalc {
   const MachineFunction *MF;
   const MachineRegisterInfo *MRI;
   SlotIndexes *Indexes;

lib/CodeGen/PrologEpilogInserter.h

@@ -33,7 +33,7 @@ namespace llvm {
   class RegScavenger;
   class MachineBasicBlock;
 
-  class PEI : public MachineFunctionPass {
+  class LLVM_LIBRARY_VISIBILITY PEI : public MachineFunctionPass {
   public:
     static char ID;
     PEI() : MachineFunctionPass(ID) {

lib/CodeGen/RegAllocBase.h

@@ -56,7 +56,7 @@ class Spiller;
 /// Register allocators must override the selectOrSplit() method to implement
 /// live range splitting. They must also override enqueue/dequeue to provide an
 /// assignment order.
-class RegAllocBase {
+class LLVM_LIBRARY_VISIBILITY RegAllocBase {
 protected:
   const TargetRegisterInfo *TRI;
   MachineRegisterInfo *MRI;

lib/CodeGen/SelectionDAG/InstrEmitter.h

@@ -26,7 +26,7 @@ class MachineInstrBuilder;
 class MCInstrDesc;
 class SDDbgValue;
 
-class InstrEmitter {
+class LLVM_LIBRARY_VISIBILITY InstrEmitter {
   MachineFunction *MF;
   MachineRegisterInfo *MRI;
   const TargetMachine *TM;

lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

@@ -27,7 +27,7 @@ class Value;
 /// SDDbgValue - Holds the information from a dbg_value node through SDISel.
 /// We do not use SDValue here to avoid including its header.
 
-class SDDbgValue {
+class LLVM_LIBRARY_VISIBILITY SDDbgValue {
 public:
   enum DbgValueKind {
     SDNODE = 0,             // value is the result of an expression

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h

@@ -33,7 +33,7 @@ namespace llvm {
   /// edges.  Physical register dependence information is not carried in
   /// the DAG and must be handled explicitly by schedulers.
   ///
-  class ScheduleDAGSDNodes : public ScheduleDAG {
+  class LLVM_LIBRARY_VISIBILITY ScheduleDAGSDNodes : public ScheduleDAG {
   public:
     MachineBasicBlock *BB;
     SelectionDAG *DAG;                    // DAG of the current basic block

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

@@ -79,7 +79,7 @@ class ZExtInst;
 /// SelectionDAGBuilder - This is the common target-independent lowering
 /// implementation that is parameterized by a TargetLowering object.
 ///
-class SelectionDAGBuilder {
+class LLVM_LIBRARY_VISIBILITY SelectionDAGBuilder {
   /// CurInst - The current instruction being visited
   const Instruction *CurInst;
 

lib/CodeGen/SpillPlacement.h

@@ -39,7 +39,7 @@ class EdgeBundles;
 class MachineBasicBlock;
 class MachineLoopInfo;
 
-class SpillPlacement  : public MachineFunctionPass {
+class LLVM_LIBRARY_VISIBILITY SpillPlacement : public MachineFunctionPass {
   struct Node;
   const MachineFunction *MF;
   const EdgeBundles *bundles;

lib/CodeGen/SplitKit.h

@@ -39,7 +39,7 @@ class raw_ostream;
 
 /// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
 /// opportunities.
-class SplitAnalysis {
+class LLVM_LIBRARY_VISIBILITY SplitAnalysis {
 public:
   const MachineFunction &MF;
   const VirtRegMap &VRM;
@@ -208,7 +208,7 @@ public:
 /// - Finish the current interval with closeIntv and repeat from 2.
 /// - Rewrite instructions with finish().
 ///
-class SplitEditor {
+class LLVM_LIBRARY_VISIBILITY SplitEditor {
   SplitAnalysis &SA;
   LiveIntervals &LIS;
   VirtRegMap &VRM;

lib/IR/AsmWriter.h

@@ -39,7 +39,7 @@ SlotTracker *createSlotTracker(const Module *M);
 // TypePrinting Class: Type printing machinery
 //===----------------------------------------------------------------------===//
 
-class TypePrinting {
+class LLVM_LIBRARY_VISIBILITY TypePrinting {
   TypePrinting(const TypePrinting &) LLVM_DELETED_FUNCTION;
   void operator=(const TypePrinting&) LLVM_DELETED_FUNCTION;
 public:
@@ -61,7 +61,7 @@ public:
   void printStructBody(StructType *Ty, raw_ostream &OS);
 };
 
-class AssemblyWriter {
+class LLVM_LIBRARY_VISIBILITY AssemblyWriter {
 protected:
   formatted_raw_ostream &Out;
   const Module *TheModule;

lib/IR/AttributeImpl.h

@@ -29,7 +29,7 @@ class LLVMContext;
 /// \class
 /// \brief This class represents a single, uniqued attribute. That attribute
 /// could be a single enum, a tuple, or a string.
-class AttributeImpl : public FoldingSetNode {
+class LLVM_LIBRARY_VISIBILITY AttributeImpl : public FoldingSetNode {
   unsigned char KindID; ///< Holds the AttrEntryKind of the attribute
 
   // AttributesImpl is uniqued, these should not be publicly available.
@@ -93,7 +93,7 @@ public:
 /// represented by Attribute::AttrKind; alignment attribute entries; and string
 /// attribute enties, which are for target-dependent attributes.
 
-class EnumAttributeImpl : public AttributeImpl {
+class LLVM_LIBRARY_VISIBILITY EnumAttributeImpl : public AttributeImpl {
   Attribute::AttrKind Kind;
 
 protected:
@@ -107,7 +107,7 @@ public:
   Attribute::AttrKind getEnumKind() const { return Kind; }
 };
 
-class AlignAttributeImpl : public EnumAttributeImpl {
+class LLVM_LIBRARY_VISIBILITY AlignAttributeImpl : public EnumAttributeImpl {
   unsigned Align;
 
 public:
@@ -121,7 +121,7 @@ public:
   unsigned getAlignment() const { return Align; }
 };
 
-class StringAttributeImpl : public AttributeImpl {
+class LLVM_LIBRARY_VISIBILITY StringAttributeImpl : public AttributeImpl {
   std::string Kind;
   std::string Val;
 
@@ -137,7 +137,7 @@ public:
 /// \class
 /// \brief This class represents a group of attributes that apply to one
 /// element: function, return type, or parameter.
-class AttributeSetNode : public FoldingSetNode {
+class LLVM_LIBRARY_VISIBILITY AttributeSetNode : public FoldingSetNode {
   unsigned NumAttrs; ///< Number of attributes in this node.
 
   AttributeSetNode(ArrayRef<Attribute> Attrs) : NumAttrs(Attrs.size()) {
@@ -180,7 +180,7 @@ public:
 /// \class
 /// \brief This class represents a set of attributes that apply to the function,
 /// return type, and parameters.
-class AttributeSetImpl : public FoldingSetNode {
+class LLVM_LIBRARY_VISIBILITY AttributeSetImpl : public FoldingSetNode {
   friend class AttributeSet;
 
   LLVMContext &Context;

lib/IR/ConstantsContext.h

@@ -31,7 +31,7 @@ struct ConstantTraits;
 
 /// UnaryConstantExpr - This class is private to Constants.cpp, and is used
 /// behind the scenes to implement unary constant exprs.
-class UnaryConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY UnaryConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -48,7 +48,7 @@ public:
 
 /// BinaryConstantExpr - This class is private to Constants.cpp, and is used
 /// behind the scenes to implement binary constant exprs.
-class BinaryConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY BinaryConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -69,7 +69,7 @@ public:
 
 /// SelectConstantExpr - This class is private to Constants.cpp, and is used
 /// behind the scenes to implement select constant exprs.
-class SelectConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY SelectConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -90,7 +90,7 @@ public:
 /// ExtractElementConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// extractelement constant exprs.
-class ExtractElementConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY ExtractElementConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -111,7 +111,7 @@ public:
 /// InsertElementConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// insertelement constant exprs.
-class InsertElementConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY InsertElementConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -133,7 +133,7 @@ public:
 /// ShuffleVectorConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// shufflevector constant exprs.
-class ShuffleVectorConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY ShuffleVectorConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -158,7 +158,7 @@ public:
 /// ExtractValueConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// extractvalue constant exprs.
-class ExtractValueConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY ExtractValueConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -184,7 +184,7 @@ public:
 /// InsertValueConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// insertvalue constant exprs.
-class InsertValueConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY InsertValueConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -211,7 +211,7 @@ public:
 
 /// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is
 /// used behind the scenes to implement getelementpr constant exprs.
-class GetElementPtrConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY GetElementPtrConstantExpr : public ConstantExpr {
   virtual void anchor();
   GetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList,
                             Type *DestTy);
@@ -232,7 +232,7 @@ public:
 // CompareConstantExpr - This class is private to Constants.cpp, and is used
 // behind the scenes to implement ICmp and FCmp constant expressions. This is
 // needed in order to store the predicate value for these instructions.
-class CompareConstantExpr : public ConstantExpr {
+class LLVM_LIBRARY_VISIBILITY CompareConstantExpr : public ConstantExpr {
   virtual void anchor();
   void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
 public:
@@ -313,7 +313,7 @@ struct OperandTraits<CompareConstantExpr> :
 };
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value)
 
-struct ExprMapKeyType {
+struct LLVM_LIBRARY_VISIBILITY ExprMapKeyType {
   ExprMapKeyType(unsigned opc,
       ArrayRef<Constant*> ops,
       unsigned short flags = 0,
@@ -349,7 +349,7 @@ struct ExprMapKeyType {
   }
 };
 
-struct InlineAsmKeyType {
+struct LLVM_LIBRARY_VISIBILITY InlineAsmKeyType {
   InlineAsmKeyType(StringRef AsmString,
                    StringRef Constraints, bool hasSideEffects,
                    bool isAlignStack, InlineAsm::AsmDialect asmDialect)
@@ -512,7 +512,7 @@ struct ConstantKeyData<InlineAsm> {
 
 template<class ValType, class ValRefType, class TypeClass, class ConstantClass,
          bool HasLargeKey = false /*true for arrays and structs*/ >
-class ConstantUniqueMap {
+class LLVM_LIBRARY_VISIBILITY ConstantUniqueMap {
 public:
   typedef std::pair<TypeClass*, ValType> MapKey;
   typedef std::map<MapKey, ConstantClass *> MapTy;
@@ -648,7 +648,7 @@ public:
 
 // Unique map for aggregate constants
 template<class TypeClass, class ConstantClass>
-class ConstantAggrUniqueMap {
+class LLVM_LIBRARY_VISIBILITY ConstantAggrUniqueMap {
 public:
   typedef ArrayRef<Constant*> Operands;
   typedef std::pair<TypeClass*, Operands> LookupKey;

lib/IR/LLVMContextImpl.h

@@ -41,7 +41,7 @@ class LLVMContext;
 class Type;
 class Value;
 
-struct DenseMapAPIntKeyInfo {
+struct LLVM_LIBRARY_VISIBILITY DenseMapAPIntKeyInfo {
   struct KeyTy {
     APInt val;
     Type* type;
@@ -66,7 +66,7 @@ struct DenseMapAPIntKeyInfo {
   }
 };
 
-struct DenseMapAPFloatKeyInfo {
+struct LLVM_LIBRARY_VISIBILITY DenseMapAPFloatKeyInfo {
   struct KeyTy {
     APFloat val;
     KeyTy(const APFloat& V) : val(V){}
@@ -94,7 +94,7 @@ struct DenseMapAPFloatKeyInfo {
   }
 };
 
-struct AnonStructTypeKeyInfo {
+struct LLVM_LIBRARY_VISIBILITY AnonStructTypeKeyInfo {
   struct KeyTy {
     ArrayRef<Type*> ETypes;
     bool isPacked;
@@ -138,7 +138,7 @@ struct AnonStructTypeKeyInfo {
   }
 };
 
-struct FunctionTypeKeyInfo {
+struct LLVM_LIBRARY_VISIBILITY FunctionTypeKeyInfo {
   struct KeyTy {
     const Type *ReturnType;
     ArrayRef<Type*> Params;
@@ -209,7 +209,7 @@ template<> struct FoldingSetTrait<MDNode> : DefaultFoldingSetTrait<MDNode> {
 
 /// DebugRecVH - This is a CallbackVH used to keep the Scope -> index maps
 /// up to date as MDNodes mutate.  This class is implemented in DebugLoc.cpp.
-class DebugRecVH : public CallbackVH {
+class LLVM_LIBRARY_VISIBILITY DebugRecVH : public CallbackVH {
   /// Ctx - This is the LLVM Context being referenced.
   LLVMContextImpl *Ctx;
   
@@ -230,7 +230,7 @@ public:
   virtual void allUsesReplacedWith(Value *VNew);
 };
   
-class LLVMContextImpl {
+class LLVM_LIBRARY_VISIBILITY LLVMContextImpl {
 public:
   /// OwnedModules - The set of modules instantiated in this context, and which
   /// will be automatically deleted if this context is deleted.

lib/IR/LeaksContext.h

@@ -28,7 +28,7 @@ struct PrinterTrait<Value> {
 };
 
 template <typename T>
-struct LeakDetectorImpl {
+struct LLVM_LIBRARY_VISIBILITY LeakDetectorImpl {
   explicit LeakDetectorImpl(const char* const name = "") : 
     Cache(0), Name(name) { }
 

lib/Transforms/Instrumentation/DebugIR.h

@@ -21,7 +21,7 @@
 
 namespace llvm {
 
-class DebugIR : public llvm::ModulePass {
+class LLVM_LIBRARY_VISIBILITY DebugIR : public llvm::ModulePass {
   /// If true, write a source file to disk.
   bool WriteSourceToDisk;
 

lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h

@@ -29,7 +29,7 @@ namespace objcarc {
 
 /// Declarations for ObjC runtime functions and constants. These are initialized
 /// lazily to avoid cluttering up the Module with unused declarations.
-class ARCRuntimeEntryPoints {
+class LLVM_LIBRARY_VISIBILITY ARCRuntimeEntryPoints {
 public:
   enum EntryPointType {
     EPT_AutoreleaseRV,

lib/Transforms/ObjCARC/ObjCARCAliasAnalysis.h

@@ -35,7 +35,7 @@ namespace objcarc {
   /// TODO: This class could be generalized to know about other ObjC-specific
   /// tricks. Such as knowing that ivars in the non-fragile ABI are non-aliasing
   /// even though their offsets are dynamic.
-  class ObjCARCAliasAnalysis : public ImmutablePass,
+  class LLVM_LIBRARY_VISIBILITY ObjCARCAliasAnalysis : public ImmutablePass,
                                                        public AliasAnalysis {
   public:
     static char ID; // Class identification, replacement for typeinfo

lib/Transforms/ObjCARC/ProvenanceAnalysis.h

@@ -46,7 +46,7 @@ namespace objcarc {
 /// an ``independent provenance source'' of a pointer to determine whether or
 /// not two pointers have the same provenance source and thus could
 /// potentially be related.
-class ProvenanceAnalysis {
+class LLVM_LIBRARY_VISIBILITY ProvenanceAnalysis {
   AliasAnalysis *AA;
 
   typedef std::pair<const Value *, const Value *> ValuePairTy;