class SMDiagnostic;
class LLVMContext;
- class LLVM_LIBRARY_VISIBILITY LLLexer {
+ class LLLexer {
const char *CurPtr;
MemoryBuffer *CurBuf;
SMDiagnostic &ErrorInfo;
/// 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 LLVM_LIBRARY_VISIBILITY ValID {
+ struct ValID {
enum {
t_LocalID, t_GlobalID, // ID in UIntVal.
t_LocalName, t_GlobalName, // Name in StrVal.
}
};
- class LLVM_LIBRARY_VISIBILITY LLParser {
+ class LLParser {
public:
typedef LLLexer::LocTy LocTy;
private:
// BitcodeReaderValueList Class
//===----------------------------------------------------------------------===//
-class LLVM_LIBRARY_VISIBILITY BitcodeReaderValueList {
+class BitcodeReaderValueList {
std::vector<WeakVH> ValuePtrs;
/// ResolveConstants - As we resolve forward-referenced constants, we add
// BitcodeReaderMDValueList Class
//===----------------------------------------------------------------------===//
-class LLVM_LIBRARY_VISIBILITY BitcodeReaderMDValueList {
+class BitcodeReaderMDValueList {
std::vector<WeakVH> MDValuePtrs;
LLVMContext &Context;
void AssignValue(Value *V, unsigned Idx);
};
-class LLVM_LIBRARY_VISIBILITY BitcodeReader : public GVMaterializer {
+class BitcodeReader : public GVMaterializer {
LLVMContext &Context;
Module *TheModule;
MemoryBuffer *Buffer;
class MDSymbolTable;
class raw_ostream;
-class LLVM_LIBRARY_VISIBILITY ValueEnumerator {
+class ValueEnumerator {
public:
typedef std::vector<Type*> TypeList;
/// Class AggressiveAntiDepState
/// Contains all the state necessary for anti-dep breaking.
- class LLVM_LIBRARY_VISIBILITY AggressiveAntiDepState {
+ class AggressiveAntiDepState {
public:
/// RegisterReference - Information about a register reference
/// within a liverange
/// Class AggressiveAntiDepBreaker
- class LLVM_LIBRARY_VISIBILITY AggressiveAntiDepBreaker
- : public AntiDepBreaker {
+ class AggressiveAntiDepBreaker : public AntiDepBreaker {
MachineFunction& MF;
MachineRegisterInfo &MRI;
const TargetInstrInfo *TII;
class RegisterClassInfo;
class VirtRegMap;
-class LLVM_LIBRARY_VISIBILITY AllocationOrder {
+class AllocationOrder {
SmallVector<MCPhysReg, 16> Hints;
ArrayRef<MCPhysReg> Order;
int Pos;
/// AntiDepBreaker - This class works into conjunction with the
/// post-RA scheduler to rename registers to break register
/// anti-dependencies.
-class LLVM_LIBRARY_VISIBILITY AntiDepBreaker {
+class AntiDepBreaker {
public:
typedef std::vector<std::pair<MachineInstr *, MachineInstr *> >
DbgValueVector;
//===--------------------------------------------------------------------===//
/// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
/// Dwarf abbreviation.
- class LLVM_LIBRARY_VISIBILITY DIEAbbrevData {
+ class DIEAbbrevData {
/// Attribute - Dwarf attribute code.
///
uint16_t Attribute;
//===--------------------------------------------------------------------===//
/// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
/// information object.
- class LLVM_LIBRARY_VISIBILITY DIEAbbrev : public FoldingSetNode {
+ class DIEAbbrev : public FoldingSetNode {
/// Tag - Dwarf tag code.
///
uint16_t Tag;
/// describes its organization.
class DIEValue;
- class LLVM_LIBRARY_VISIBILITY DIE {
+ class DIE {
protected:
/// Offset - Offset in debug info section.
///
//===--------------------------------------------------------------------===//
/// DIEValue - A debug information entry value.
///
- class LLVM_LIBRARY_VISIBILITY DIEValue {
+ class DIEValue {
virtual void anchor();
public:
enum {
//===--------------------------------------------------------------------===//
/// DIEInteger - An integer value DIE.
///
- class LLVM_LIBRARY_VISIBILITY DIEInteger : public DIEValue {
+ class DIEInteger : public DIEValue {
uint64_t Integer;
public:
explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
//===--------------------------------------------------------------------===//
/// DIEExpr - An expression DIE.
//
- class LLVM_LIBRARY_VISIBILITY DIEExpr : public DIEValue {
+ class DIEExpr : public DIEValue {
const MCExpr *Expr;
public:
explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {}
//===--------------------------------------------------------------------===//
/// DIELabel - A label DIE.
//
- class LLVM_LIBRARY_VISIBILITY DIELabel : public DIEValue {
+ class DIELabel : public DIEValue {
const MCSymbol *Label;
public:
explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {}
//===--------------------------------------------------------------------===//
/// DIEDelta - A simple label difference DIE.
///
- class LLVM_LIBRARY_VISIBILITY DIEDelta : public DIEValue {
+ class DIEDelta : public DIEValue {
const MCSymbol *LabelHi;
const MCSymbol *LabelLo;
public:
//===--------------------------------------------------------------------===//
/// DIEString - A container for string values.
///
- class LLVM_LIBRARY_VISIBILITY DIEString : public DIEValue {
+ class DIEString : public DIEValue {
const DIEValue *Access;
const StringRef Str;
/// 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 LLVM_LIBRARY_VISIBILITY DIEEntry : public DIEValue {
+ class DIEEntry : public DIEValue {
DIE *const Entry;
public:
explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) {
//===--------------------------------------------------------------------===//
/// DIEBlock - A block of values. Primarily used for location expressions.
//
- class LLVM_LIBRARY_VISIBILITY DIEBlock : public DIEValue, public DIE {
+ class DIEBlock : public DIEValue, public DIE {
unsigned Size; // Size in bytes excluding size header.
public:
DIEBlock()
/// \brief An object containing the capability of hashing and adding hash
/// attributes onto a DIE.
-class LLVM_LIBRARY_VISIBILITY DIEHash {
+class DIEHash {
// The entry for a particular attribute.
struct AttrEntry {
const DIEValue *Val;
class DIE;
class DwarfUnits;
-class LLVM_LIBRARY_VISIBILITY DwarfAccelTable {
+class DwarfAccelTable {
static uint32_t HashDJB(StringRef Str) {
uint32_t h = 5381;
//===----------------------------------------------------------------------===//
/// CompileUnit - This dwarf writer support class manages information associated
/// with a source file.
-class LLVM_LIBRARY_VISIBILITY CompileUnit {
+class CompileUnit {
/// UniqueID - a numeric ID unique among all CUs in the module
///
unsigned UniqueID;
//===----------------------------------------------------------------------===//
/// \brief This class is used to record source line correspondence.
-class LLVM_LIBRARY_VISIBILITY SrcLineInfo {
+class SrcLineInfo {
unsigned Line; // Source line number.
unsigned Column; // Source column.
unsigned SourceID; // Source ID number.
/// \brief This struct describes location entries emitted in the .debug_loc
/// section.
-class LLVM_LIBRARY_VISIBILITY DotDebugLocEntry {
+class DotDebugLocEntry {
// Begin and end symbols for the address range that this location is valid.
const MCSymbol *Begin;
const MCSymbol *End;
//===----------------------------------------------------------------------===//
/// \brief This class is used to track local variable information.
-class LLVM_LIBRARY_VISIBILITY DbgVariable {
+class DbgVariable {
DIVariable Var; // Variable Descriptor.
DIE *TheDIE; // Variable DIE.
unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
/// \brief Collects and handles information specific to a particular
/// collection of units.
-class LLVM_LIBRARY_VISIBILITY DwarfUnits {
+class DwarfUnits {
// Target of Dwarf emission, used for sizing of abbreviations.
AsmPrinter *Asm;
};
/// \brief Collects and handles dwarf debug information.
-class LLVM_LIBRARY_VISIBILITY DwarfDebug {
+class DwarfDebug {
// Target of Dwarf emission.
AsmPrinter *Asm;
//===----------------------------------------------------------------------===//
/// DwarfException - Emits Dwarf exception handling directives.
///
-class LLVM_LIBRARY_VISIBILITY DwarfException {
+class DwarfException {
protected:
/// Asm - Target of Dwarf emission.
AsmPrinter *Asm;
virtual void EndFunction();
};
-class LLVM_LIBRARY_VISIBILITY DwarfCFIException : public DwarfException {
+class DwarfCFIException : public DwarfException {
/// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
/// should be emitted.
bool shouldEmitPersonality;
virtual void EndFunction();
};
-class LLVM_LIBRARY_VISIBILITY ARMException : public DwarfException {
+class ARMException : public DwarfException {
void EmitTypeInfos(unsigned TTypeEncoding);
public:
//===--------------------------------------------------------------------===//
virtual void EndFunction();
};
-class LLVM_LIBRARY_VISIBILITY Win64Exception : public DwarfException {
+class Win64Exception : public DwarfException {
/// shouldEmitPersonality - Per-function flag to indicate if personality
/// info should be emitted.
bool shouldEmitPersonality;
class TargetInstrInfo;
class TargetRegisterInfo;
- class LLVM_LIBRARY_VISIBILITY BranchFolder {
+ class BranchFolder {
public:
explicit BranchFolder(bool defaultEnableTailMerge, bool CommonHoist);
class TargetInstrInfo;
class TargetRegisterInfo;
- class LLVM_LIBRARY_VISIBILITY CriticalAntiDepBreaker : public AntiDepBreaker {
+ class CriticalAntiDepBreaker : public AntiDepBreaker {
MachineFunction& MF;
MachineRegisterInfo &MRI;
const TargetInstrInfo *TII;
class LiveIntervals;
-class LLVM_LIBRARY_VISIBILITY InterferenceCache {
+class InterferenceCache {
const TargetRegisterInfo *TRI;
LiveIntervalUnion *LIUArray;
MachineFunction *MF;
class LiveIntervals;
class VirtRegMap;
-class LLVM_LIBRARY_VISIBILITY LiveDebugVariables : public MachineFunctionPass {
+class LiveDebugVariables : public MachineFunctionPass {
void *pImpl;
public:
static char ID; // Pass identification, replacement for typeid
template <class NodeT> class DomTreeNodeBase;
typedef DomTreeNodeBase<MachineBasicBlock> MachineDomTreeNode;
-class LLVM_LIBRARY_VISIBILITY LiveRangeCalc {
+class LiveRangeCalc {
const MachineFunction *MF;
const MachineRegisterInfo *MRI;
SlotIndexes *Indexes;
class RegScavenger;
class MachineBasicBlock;
- class LLVM_LIBRARY_VISIBILITY PEI : public MachineFunctionPass {
+ class PEI : public MachineFunctionPass {
public:
static char ID;
PEI() : MachineFunctionPass(ID) {
/// Register allocators must override the selectOrSplit() method to implement
/// live range splitting. They must also override enqueue/dequeue to provide an
/// assignment order.
-class LLVM_LIBRARY_VISIBILITY RegAllocBase {
+class RegAllocBase {
protected:
const TargetRegisterInfo *TRI;
MachineRegisterInfo *MRI;
class MCInstrDesc;
class SDDbgValue;
-class LLVM_LIBRARY_VISIBILITY InstrEmitter {
+class InstrEmitter {
MachineFunction *MF;
MachineRegisterInfo *MRI;
const TargetMachine *TM;
/// SDDbgValue - Holds the information from a dbg_value node through SDISel.
/// We do not use SDValue here to avoid including its header.
-class LLVM_LIBRARY_VISIBILITY SDDbgValue {
+class SDDbgValue {
public:
enum DbgValueKind {
SDNODE = 0, // value is the result of an expression
/// edges. Physical register dependence information is not carried in
/// the DAG and must be handled explicitly by schedulers.
///
- class LLVM_LIBRARY_VISIBILITY ScheduleDAGSDNodes : public ScheduleDAG {
+ class ScheduleDAGSDNodes : public ScheduleDAG {
public:
MachineBasicBlock *BB;
SelectionDAG *DAG; // DAG of the current basic block
/// SelectionDAGBuilder - This is the common target-independent lowering
/// implementation that is parameterized by a TargetLowering object.
///
-class LLVM_LIBRARY_VISIBILITY SelectionDAGBuilder {
+class SelectionDAGBuilder {
/// CurInst - The current instruction being visited
const Instruction *CurInst;
class MachineBasicBlock;
class MachineLoopInfo;
-class LLVM_LIBRARY_VISIBILITY SpillPlacement : public MachineFunctionPass {
+class SpillPlacement : public MachineFunctionPass {
struct Node;
const MachineFunction *MF;
const EdgeBundles *bundles;
/// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
/// opportunities.
-class LLVM_LIBRARY_VISIBILITY SplitAnalysis {
+class SplitAnalysis {
public:
const MachineFunction &MF;
const VirtRegMap &VRM;
/// - Finish the current interval with closeIntv and repeat from 2.
/// - Rewrite instructions with finish().
///
-class LLVM_LIBRARY_VISIBILITY SplitEditor {
+class SplitEditor {
SplitAnalysis &SA;
LiveIntervals &LIS;
VirtRegMap &VRM;
// TypePrinting Class: Type printing machinery
//===----------------------------------------------------------------------===//
-class LLVM_LIBRARY_VISIBILITY TypePrinting {
+class TypePrinting {
TypePrinting(const TypePrinting &) LLVM_DELETED_FUNCTION;
void operator=(const TypePrinting&) LLVM_DELETED_FUNCTION;
public:
void printStructBody(StructType *Ty, raw_ostream &OS);
};
-class LLVM_LIBRARY_VISIBILITY AssemblyWriter {
+class AssemblyWriter {
protected:
formatted_raw_ostream &Out;
const Module *TheModule;
/// \class
/// \brief This class represents a single, uniqued attribute. That attribute
/// could be a single enum, a tuple, or a string.
-class LLVM_LIBRARY_VISIBILITY AttributeImpl : public FoldingSetNode {
+class AttributeImpl : public FoldingSetNode {
unsigned char KindID; ///< Holds the AttrEntryKind of the attribute
// AttributesImpl is uniqued, these should not be publicly available.
/// represented by Attribute::AttrKind; alignment attribute entries; and string
/// attribute enties, which are for target-dependent attributes.
-class LLVM_LIBRARY_VISIBILITY EnumAttributeImpl : public AttributeImpl {
+class EnumAttributeImpl : public AttributeImpl {
Attribute::AttrKind Kind;
protected:
Attribute::AttrKind getEnumKind() const { return Kind; }
};
-class LLVM_LIBRARY_VISIBILITY AlignAttributeImpl : public EnumAttributeImpl {
+class AlignAttributeImpl : public EnumAttributeImpl {
unsigned Align;
public:
unsigned getAlignment() const { return Align; }
};
-class LLVM_LIBRARY_VISIBILITY StringAttributeImpl : public AttributeImpl {
+class StringAttributeImpl : public AttributeImpl {
std::string Kind;
std::string Val;
/// \class
/// \brief This class represents a group of attributes that apply to one
/// element: function, return type, or parameter.
-class LLVM_LIBRARY_VISIBILITY AttributeSetNode : public FoldingSetNode {
+class AttributeSetNode : public FoldingSetNode {
unsigned NumAttrs; ///< Number of attributes in this node.
AttributeSetNode(ArrayRef<Attribute> Attrs) : NumAttrs(Attrs.size()) {
/// \class
/// \brief This class represents a set of attributes that apply to the function,
/// return type, and parameters.
-class LLVM_LIBRARY_VISIBILITY AttributeSetImpl : public FoldingSetNode {
+class AttributeSetImpl : public FoldingSetNode {
friend class AttributeSet;
LLVMContext &Context;
/// UnaryConstantExpr - This class is private to Constants.cpp, and is used
/// behind the scenes to implement unary constant exprs.
-class LLVM_LIBRARY_VISIBILITY UnaryConstantExpr : public ConstantExpr {
+class UnaryConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// BinaryConstantExpr - This class is private to Constants.cpp, and is used
/// behind the scenes to implement binary constant exprs.
-class LLVM_LIBRARY_VISIBILITY BinaryConstantExpr : public ConstantExpr {
+class BinaryConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// SelectConstantExpr - This class is private to Constants.cpp, and is used
/// behind the scenes to implement select constant exprs.
-class LLVM_LIBRARY_VISIBILITY SelectConstantExpr : public ConstantExpr {
+class SelectConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// ExtractElementConstantExpr - This class is private to
/// Constants.cpp, and is used behind the scenes to implement
/// extractelement constant exprs.
-class LLVM_LIBRARY_VISIBILITY ExtractElementConstantExpr : public ConstantExpr {
+class ExtractElementConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// InsertElementConstantExpr - This class is private to
/// Constants.cpp, and is used behind the scenes to implement
/// insertelement constant exprs.
-class LLVM_LIBRARY_VISIBILITY InsertElementConstantExpr : public ConstantExpr {
+class InsertElementConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// ShuffleVectorConstantExpr - This class is private to
/// Constants.cpp, and is used behind the scenes to implement
/// shufflevector constant exprs.
-class LLVM_LIBRARY_VISIBILITY ShuffleVectorConstantExpr : public ConstantExpr {
+class ShuffleVectorConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// ExtractValueConstantExpr - This class is private to
/// Constants.cpp, and is used behind the scenes to implement
/// extractvalue constant exprs.
-class LLVM_LIBRARY_VISIBILITY ExtractValueConstantExpr : public ConstantExpr {
+class ExtractValueConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// InsertValueConstantExpr - This class is private to
/// Constants.cpp, and is used behind the scenes to implement
/// insertvalue constant exprs.
-class LLVM_LIBRARY_VISIBILITY InsertValueConstantExpr : public ConstantExpr {
+class InsertValueConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
/// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is
/// used behind the scenes to implement getelementpr constant exprs.
-class LLVM_LIBRARY_VISIBILITY GetElementPtrConstantExpr : public ConstantExpr {
+class GetElementPtrConstantExpr : public ConstantExpr {
virtual void anchor();
GetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList,
Type *DestTy);
// 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 LLVM_LIBRARY_VISIBILITY CompareConstantExpr : public ConstantExpr {
+class CompareConstantExpr : public ConstantExpr {
virtual void anchor();
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
public:
};
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value)
-struct LLVM_LIBRARY_VISIBILITY ExprMapKeyType {
+struct ExprMapKeyType {
ExprMapKeyType(unsigned opc,
ArrayRef<Constant*> ops,
unsigned short flags = 0,
}
};
-struct LLVM_LIBRARY_VISIBILITY InlineAsmKeyType {
+struct InlineAsmKeyType {
InlineAsmKeyType(StringRef AsmString,
StringRef Constraints, bool hasSideEffects,
bool isAlignStack, InlineAsm::AsmDialect asmDialect)
template<class ValType, class ValRefType, class TypeClass, class ConstantClass,
bool HasLargeKey = false /*true for arrays and structs*/ >
-class LLVM_LIBRARY_VISIBILITY ConstantUniqueMap {
+class ConstantUniqueMap {
public:
typedef std::pair<TypeClass*, ValType> MapKey;
typedef std::map<MapKey, ConstantClass *> MapTy;
// Unique map for aggregate constants
template<class TypeClass, class ConstantClass>
-class LLVM_LIBRARY_VISIBILITY ConstantAggrUniqueMap {
+class ConstantAggrUniqueMap {
public:
typedef ArrayRef<Constant*> Operands;
typedef std::pair<TypeClass*, Operands> LookupKey;
class Type;
class Value;
-struct LLVM_LIBRARY_VISIBILITY DenseMapAPIntKeyInfo {
+struct DenseMapAPIntKeyInfo {
struct KeyTy {
APInt val;
Type* type;
}
};
-struct LLVM_LIBRARY_VISIBILITY DenseMapAPFloatKeyInfo {
+struct DenseMapAPFloatKeyInfo {
struct KeyTy {
APFloat val;
KeyTy(const APFloat& V) : val(V){}
}
};
-struct LLVM_LIBRARY_VISIBILITY AnonStructTypeKeyInfo {
+struct AnonStructTypeKeyInfo {
struct KeyTy {
ArrayRef<Type*> ETypes;
bool isPacked;
}
};
-struct LLVM_LIBRARY_VISIBILITY FunctionTypeKeyInfo {
+struct FunctionTypeKeyInfo {
struct KeyTy {
const Type *ReturnType;
ArrayRef<Type*> Params;
/// 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 LLVM_LIBRARY_VISIBILITY DebugRecVH : public CallbackVH {
+class DebugRecVH : public CallbackVH {
/// Ctx - This is the LLVM Context being referenced.
LLVMContextImpl *Ctx;
virtual void allUsesReplacedWith(Value *VNew);
};
-class LLVM_LIBRARY_VISIBILITY LLVMContextImpl {
+class LLVMContextImpl {
public:
/// OwnedModules - The set of modules instantiated in this context, and which
/// will be automatically deleted if this context is deleted.
};
template <typename T>
-struct LLVM_LIBRARY_VISIBILITY LeakDetectorImpl {
+struct LeakDetectorImpl {
explicit LeakDetectorImpl(const char* const name = "") :
Cache(0), Name(name) { }
namespace llvm {
-class LLVM_LIBRARY_VISIBILITY DebugIR : public llvm::ModulePass {
+class DebugIR : public llvm::ModulePass {
/// If true, write a source file to disk.
bool WriteSourceToDisk;
/// Declarations for ObjC runtime functions and constants. These are initialized
/// lazily to avoid cluttering up the Module with unused declarations.
-class LLVM_LIBRARY_VISIBILITY ARCRuntimeEntryPoints {
+class ARCRuntimeEntryPoints {
public:
enum EntryPointType {
EPT_AutoreleaseRV,
/// 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 LLVM_LIBRARY_VISIBILITY ObjCARCAliasAnalysis : public ImmutablePass,
- public AliasAnalysis {
+ class ObjCARCAliasAnalysis : public ImmutablePass,
+ public AliasAnalysis {
public:
static char ID; // Class identification, replacement for typeinfo
ObjCARCAliasAnalysis() : ImmutablePass(ID) {
/// 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 LLVM_LIBRARY_VISIBILITY ProvenanceAnalysis {
+class ProvenanceAnalysis {
AliasAnalysis *AA;
typedef std::pair<const Value *, const Value *> ValuePairTy;
projects / oota-llvm.git / commitdiff