class TargetData;
class Function;
class Type;
- struct LLVMContext;
+ class LLVMContext;
/// ConstantFoldInstruction - Attempt to constant fold the specified
/// instruction. If successful, the constant result is returned, if not, null
class DebugLoc;
struct DebugLocTracker;
class Instruction;
- struct LLVMContext;
+ class LLVMContext;
class DIDescriptor {
protected:
class Type;
class ScalarEvolution;
class TargetData;
- struct LLVMContext;
+ class LLVMContext;
class Loop;
class LoopInfo;
class Operator;
class BasicBlock;
class Function;
class SparseSolver;
- struct LLVMContext;
+ class LLVMContext;
template<typename T> class SmallVectorImpl;
class Instruction;
class APInt;
class TargetData;
- struct LLVMContext;
+ class LLVMContext;
/// ComputeMaskedBits - Determine which of the bits specified in Mask are
/// known to be either zero or one and return them in the KnownZero/KnownOne
class Module;
class SMDiagnostic;
class raw_ostream;
-struct LLVMContext;
+class LLVMContext;
/// This function is the main interface to the LLVM Assembly Parser. It parses
/// an ASCII file that (presumably) contains LLVM Assembly code. It returns a
namespace llvm {
class TerminatorInst;
-struct LLVMContext;
+class LLVMContext;
template<> struct ilist_traits<Instruction>
: public SymbolTableListTraits<Instruction, BasicBlock> {
class Module; // From VMCore
class Archive; // Declared below
class ArchiveMemberHeader; // Internal implementation class
-struct LLVMContext; // Global data
+class LLVMContext; // Global data
/// This class is the main class manipulated by users of the Archive class. It
/// holds information about one member of the Archive. It is also the element
class MemoryBuffer;
class ModulePass;
class BitstreamWriter;
- struct LLVMContext;
+ class LLVMContext;
class raw_ostream;
/// getBitcodeModuleProvider - Read the header of the specified bitcode buffer
namespace llvm {
class Type;
- struct LLVMContext;
+ class LLVMContext;
struct EVT { // EVT = Machine Value Type
public:
class APInt;
template<typename T> class SmallVectorImpl;
- struct LLVMContext;
+ class LLVMContext;
/// This is an important base class in LLVM. It provides the common facilities
/// of all constant values in an LLVM program. A constant is a value that is
APFloat Val;
void *operator new(size_t, unsigned);// DO NOT IMPLEMENT
ConstantFP(const ConstantFP &); // DO NOT IMPLEMENT
- friend struct LLVMContextImpl;
+ friend class LLVMContextImpl;
protected:
ConstantFP(const Type *Ty, const APFloat& V);
protected:
namespace llvm {
class Module;
class InferiorProcess;
- struct LLVMContext;
+ class LLVMContext;
/// Debugger class - This class implements the LLVM source-level debugger.
/// This allows clients to handle the user IO processing without having to
class VectorValType;
class IntegerValType;
class APInt;
-struct LLVMContext;
+class LLVMContext;
class DerivedType : public Type {
friend class Type;
namespace llvm {
class FunctionType;
-struct LLVMContext;
+class LLVMContext;
// Traits for intrusive list of basic blocks...
template<> struct ilist_traits<BasicBlock>
class Module;
class Constant;
-struct LLVMContext;
+class LLVMContext;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
namespace llvm {
-struct LLVMContext;
+class LLVMContext;
//===----------------------------------------------------------------------===//
// TerminatorInst Class
namespace llvm {
-struct LLVMContext;
+class LLVMContext;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
class ConstantInt;
class ConstantRange;
class APInt;
-struct LLVMContext;
+class LLVMContext;
//===----------------------------------------------------------------------===//
// AllocationInst Class
class Type;
class FunctionType;
class Function;
-struct LLVMContext;
+class LLVMContext;
class Module;
class AttrListPtr;
namespace llvm {
-struct LLVMContextImpl;
+class LLVMContextImpl;
/// This is an important class for using LLVM in a threaded context. It
/// (opaquely) owns and manages the core "global" data of LLVM's core
/// infrastructure, including the type and constant uniquing tables.
/// LLVMContext itself provides no locking guarantees, so you should be careful
/// to have one context per thread.
-struct LLVMContext {
+class LLVMContext {
+public:
LLVMContextImpl* pImpl;
bool RemoveDeadMetadata();
LLVMContext();
namespace llvm {
class Module;
-struct LLVMContext;
+class LLVMContext;
/// This class provides the core functionality of linking in LLVM. It retains a
/// Module object which is the composite of the modules and libraries linked
namespace llvm {
class Constant;
-struct LLVMContext;
+class LLVMContext;
template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator;
class NamedMDNode : public MetadataBase, public ilist_node<NamedMDNode> {
friend class SymbolTableListTraits<NamedMDNode, Module>;
- friend struct LLVMContextImpl;
+ friend class LLVMContextImpl;
NamedMDNode(const NamedMDNode &); // DO NOT IMPLEMENT
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
class GlobalValueRefMap; // Used by ConstantVals.cpp
class FunctionType;
-struct LLVMContext;
+class LLVMContext;
template<> struct ilist_traits<Function>
: public SymbolTableListTraits<Function, Module> {
namespace llvm {
-struct LLVMContext;
+class LLVMContext;
/// ConstantFolder - Create constants with minimum, target independent, folding.
class ConstantFolder {
namespace llvm {
-struct LLVMContext;
+class LLVMContext;
/// NoFolder - Create "constants" (actually, values) with no folding.
class NoFolder {
namespace llvm {
class TargetData;
-struct LLVMContext;
+class LLVMContext;
/// TargetFolder - Create constants with target dependent folding.
class TargetFolder {
class TargetData;
class Loop;
class LoopInfo;
-struct LLVMContext;
+class LLVMContext;
/// CloneModule - Return an exact copy of the specified module
///
class AllocaInst;
class ConstantExpr;
class TargetData;
-struct LLVMContext;
+class LLVMContext;
struct DbgInfoIntrinsic;
template<typename T> class SmallVectorImpl;
class DominatorTree;
class DominanceFrontier;
class AliasSetTracker;
-struct LLVMContext;
+class LLVMContext;
/// isAllocaPromotable - Return true if this alloca is legal for promotion.
/// This is true if there are only loads and stores to the alloca...
namespace llvm {
class Value;
class Instruction;
- struct LLVMContext;
+ class LLVMContext;
typedef DenseMap<const Value *, Value *> ValueMapTy;
Value *MapValue(const Value *V, ValueMapTy &VM, LLVMContext &Context);
class raw_ostream;
class AssemblyAnnotationWriter;
class ValueHandleBase;
-struct LLVMContext;
+class LLVMContext;
//===----------------------------------------------------------------------===//
// Value Class
namespace llvm {
- struct LLVMContext;
+ class LLVMContext;
/// The ArchiveMemberHeader structure is used internally for bitcode
/// archives.
class MemoryBuffer;
class Type;
class SMDiagnostic;
- struct LLVMContext;
+ class LLVMContext;
class LLLexer {
const char *CurPtr;
namespace llvm {
class MemoryBuffer;
- struct LLVMContext;
+ class LLVMContext;
//===----------------------------------------------------------------------===//
// BitcodeReaderValueList Class
class Value;
class Constant;
class Type;
- struct LLVMContext;
+ class LLVMContext;
// Constant fold various types of instruction...
Constant *ConstantFoldCastInstruction(
//===----------------------------------------------------------------------===//
//
// This file implements LLVMContext, as a wrapper around the opaque
-// struct LLVMContextImpl.
+// class LLVMContextImpl.
//
//===----------------------------------------------------------------------===//
class ConstantFP;
class MDString;
class MDNode;
-struct LLVMContext;
+class LLVMContext;
class Type;
class Value;
static bool isPod() { return false; }
};
-struct LLVMContextImpl {
+class LLVMContextImpl {
+public:
sys::SmartRWMutex<true> ConstantsLock;
typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
class BasicBlock;
class AbstractInterpreter;
class Instruction;
-struct LLVMContext;
+class LLVMContext;
class DebugCrashes;
struct SourceLanguage;
class ProgramInfo;
class RuntimeInfo;
- struct LLVMContext;
+ class LLVMContext;
/// CLIDebugger - This class implements the command line interface for the
/// LLVM debugger.
projects / oota-llvm.git / commitdiff