#ifndef LLVM_LLVMCONTEXT_H
#define LLVM_LLVMCONTEXT_H
-#include "llvm/Support/DataTypes.h"
-#include <vector>
-#include <string>
-
namespace llvm {
-class APFloat;
-class APInt;
-class ArrayType;
-class Constant;
-class ConstantAggregateZero;
-class ConstantArray;
-class ConstantFP;
-class ConstantInt;
-class ConstantPointerNull;
-class ConstantStruct;
-class ConstantVector;
-class FunctionType;
-class IntegerType;
class LLVMContextImpl;
-class MDNode;
-class MDString;
-class OpaqueType;
-class PointerType;
class StringRef;
-class StructType;
-class Type;
-class UndefValue;
-class Use;
-class Value;
-class VectorType;
+class Instruction;
+class Module;
+class SMDiagnostic;
+template <typename T> class SmallVectorImpl;
/// 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
/// LLVMContext itself provides no locking guarantees, so you should be careful
/// to have one context per thread.
class LLVMContext {
- LLVMContextImpl* pImpl;
-
- friend class ConstantInt;
public:
+ LLVMContextImpl *const pImpl;
LLVMContext();
~LLVMContext();
- // Constant accessors
- Constant* getNullValue(const Type* Ty);
-
- /// @returns the value for an integer constant of the given type that has all
- /// its bits set to true.
- /// @brief Get the all ones value
- Constant* getAllOnesValue(const Type* Ty);
+ // Pinned metadata names, which always have the same value. This is a
+ // compile-time performance optimization, not a correctness optimization.
+ enum {
+ MD_dbg = 0, // "dbg"
+ MD_tbaa = 1 // "tbaa"
+ };
- // UndefValue accessors
- UndefValue* getUndef(const Type* Ty);
+ /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
+ /// This ID is uniqued across modules in the current LLVMContext.
+ unsigned getMDKindID(StringRef Name) const;
- // ConstantInt accessors
- ConstantInt* getTrue();
- ConstantInt* getFalse();
+ /// getMDKindNames - Populate client supplied SmallVector with the name for
+ /// custom metadata IDs registered in this LLVMContext.
+ void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
- // ConstantPointerNull accessors
- ConstantPointerNull* getConstantPointerNull(const PointerType* T);
- // ConstantStruct accessors
- Constant* getConstantStruct(const StructType* T,
- const std::vector<Constant*>& V);
- Constant* getConstantStruct(const std::vector<Constant*>& V,
- bool Packed = false);
- Constant* getConstantStruct(Constant* const *Vals, unsigned NumVals,
- bool Packed = false);
-
- // ConstantAggregateZero accessors
- ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
+ typedef void (*InlineAsmDiagHandlerTy)(const SMDiagnostic&, void *Context,
+ unsigned LocCookie);
- // ConstantArray accessors
- Constant* getConstantArray(const ArrayType* T,
- const std::vector<Constant*>& V);
- Constant* getConstantArray(const ArrayType* T, Constant* const* Vals,
- unsigned NumVals);
-
- /// This method constructs a ConstantArray and initializes it with a text
- /// string. The default behavior (AddNull==true) causes a null terminator to
- /// be placed at the end of the array. This effectively increases the length
- /// of the array by one (you've been warned). However, in some situations
- /// this is not desired so if AddNull==false then the string is copied without
- /// null termination.
- Constant* getConstantArray(const StringRef &Initializer,
- bool AddNull = true);
-
- // ConstantExpr accessors
- Constant* getConstantExpr(unsigned Opcode, Constant* C1, Constant* C2);
- Constant* getConstantExprTrunc(Constant* C, const Type* Ty);
- Constant* getConstantExprSExt(Constant* C, const Type* Ty);
- Constant* getConstantExprZExt(Constant* C, const Type* Ty);
- Constant* getConstantExprFPTrunc(Constant* C, const Type* Ty);
- Constant* getConstantExprFPExtend(Constant* C, const Type* Ty);
- Constant* getConstantExprUIToFP(Constant* C, const Type* Ty);
- Constant* getConstantExprSIToFP(Constant* C, const Type* Ty);
- Constant* getConstantExprFPToUI(Constant* C, const Type* Ty);
- Constant* getConstantExprFPToSI(Constant* C, const Type* Ty);
- Constant* getConstantExprPtrToInt(Constant* C, const Type* Ty);
- Constant* getConstantExprIntToPtr(Constant* C, const Type* Ty);
- Constant* getConstantExprBitCast(Constant* C, const Type* Ty);
- Constant* getConstantExprCast(unsigned ops, Constant* C, const Type* Ty);
- Constant* getConstantExprZExtOrBitCast(Constant* C, const Type* Ty);
- Constant* getConstantExprSExtOrBitCast(Constant* C, const Type* Ty);
- Constant* getConstantExprTruncOrBitCast(Constant* C, const Type* Ty);
- Constant* getConstantExprPointerCast(Constant* C, const Type* Ty);
- Constant* getConstantExprIntegerCast(Constant* C, const Type* Ty,
- bool isSigned);
- Constant* getConstantExprFPCast(Constant* C, const Type* Ty);
- Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2);
-
- /// getAlignOf constant expr - computes the alignment of a type in a target
- /// independent way (Note: the return type is an i32; Note: assumes that i8
- /// is byte aligned).
+ /// setInlineAsmDiagnosticHandler - This method sets a handler that is invoked
+ /// when problems with inline asm are detected by the backend. The first
+ /// argument is a function pointer and the second is a context pointer that
+ /// gets passed into the DiagHandler.
///
- Constant* getConstantExprAlignOf(const Type* Ty);
- Constant* getConstantExprCompare(unsigned short pred,
- Constant* C1, Constant* C2);
- Constant* getConstantExprNeg(Constant* C);
- Constant* getConstantExprFNeg(Constant* C);
- Constant* getConstantExprNot(Constant* C);
- Constant* getConstantExprAdd(Constant* C1, Constant* C2);
- Constant* getConstantExprFAdd(Constant* C1, Constant* C2);
- Constant* getConstantExprSub(Constant* C1, Constant* C2);
- Constant* getConstantExprFSub(Constant* C1, Constant* C2);
- Constant* getConstantExprMul(Constant* C1, Constant* C2);
- Constant* getConstantExprFMul(Constant* C1, Constant* C2);
- Constant* getConstantExprUDiv(Constant* C1, Constant* C2);
- Constant* getConstantExprSDiv(Constant* C1, Constant* C2);
- Constant* getConstantExprFDiv(Constant* C1, Constant* C2);
- Constant* getConstantExprURem(Constant* C1, Constant* C2);
- Constant* getConstantExprSRem(Constant* C1, Constant* C2);
- Constant* getConstantExprFRem(Constant* C1, Constant* C2);
- Constant* getConstantExprAnd(Constant* C1, Constant* C2);
- Constant* getConstantExprOr(Constant* C1, Constant* C2);
- Constant* getConstantExprXor(Constant* C1, Constant* C2);
- Constant* getConstantExprICmp(unsigned short pred, Constant* LHS,
- Constant* RHS);
- Constant* getConstantExprFCmp(unsigned short pred, Constant* LHS,
- Constant* RHS);
- Constant* getConstantExprShl(Constant* C1, Constant* C2);
- Constant* getConstantExprLShr(Constant* C1, Constant* C2);
- Constant* getConstantExprAShr(Constant* C1, Constant* C2);
- Constant* getConstantExprGetElementPtr(Constant* C, Constant* const* IdxList,
- unsigned NumIdx);
- Constant* getConstantExprGetElementPtr(Constant* C, Value* const* IdxList,
- unsigned NumIdx);
- Constant* getConstantExprExtractElement(Constant* Vec, Constant* Idx);
- Constant* getConstantExprInsertElement(Constant* Vec, Constant* Elt,
- Constant* Idx);
- Constant* getConstantExprShuffleVector(Constant* V1, Constant* V2,
- Constant* Mask);
- Constant* getConstantExprExtractValue(Constant* Agg, const unsigned* IdxList,
- unsigned NumIdx);
- Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val,
- const unsigned* IdxList,
- unsigned NumIdx);
+ /// LLVMContext doesn't take ownership or interpret either of these
+ /// pointers.
+ void setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler,
+ void *DiagContext = 0);
- /// getSizeOf constant expr - computes the size of a type in a target
- /// independent way (Note: the return type is an i64).
- ///
- Constant* getConstantExprSizeOf(const Type* Ty);
-
- /// Floating point negation must be implemented with f(x) = -0.0 - x. This
- /// method returns the negative zero constant for floating point or vector
- /// floating point types; for all other types, it returns the null value.
- Constant* getZeroValueForNegation(const Type* Ty);
-
- // ConstantFP accessors
- ConstantFP* getConstantFP(const APFloat& V);
-
- /// get() - This returns a ConstantFP, or a vector containing a splat of a
- /// ConstantFP, for the specified value in the specified type. This should
- /// only be used for simple constant values like 2.0/1.0 etc, that are
- /// known-valid both as host double and as the target format.
- Constant* getConstantFP(const Type* Ty, double V);
- ConstantFP* getConstantFPNegativeZero(const Type* Ty);
-
- // ConstantVector accessors
- Constant* getConstantVector(const VectorType* T,
- const std::vector<Constant*>& V);
- Constant* getConstantVector(const std::vector<Constant*>& V);
- Constant* getConstantVector(Constant* const* Vals, unsigned NumVals);
-
- // MDNode accessors
- MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
-
- // MDString accessors
- MDString* getMDString(const StringRef &Str);
-
- // FunctionType accessors
- FunctionType* getFunctionType(const Type* Result, bool isVarArg);
- FunctionType* getFunctionType(const Type* Result,
- const std::vector<const Type*>& Params,
- bool isVarArg);
-
- // IntegerType accessors
- const IntegerType* getIntegerType(unsigned NumBits);
-
- // OpaqueType accessors
- OpaqueType* getOpaqueType();
-
- // StructType accessors
- StructType* getStructType(bool isPacked=false);
- StructType* getStructType(const std::vector<const Type*>& Params,
- bool isPacked = false);
- StructType* getStructType(const Type* type, ...);
-
- // ArrayType accessors
- ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements);
-
- // PointerType accessors
- PointerType* getPointerType(const Type* ElementType, unsigned AddressSpace);
- PointerType* getPointerTypeUnqual(const Type* ElementType);
-
- // VectorType accessors
- VectorType* getVectorType(const Type* ElementType, unsigned NumElements);
- VectorType* getVectorTypeInteger(const VectorType* VTy);
- VectorType* getVectorTypeExtendedElement(const VectorType* VTy);
- VectorType* getVectorTypeTruncatedElement(const VectorType* VTy);
-
- // Other helpers
- /// @brief Create a result type for fcmp/icmp
- const Type* makeCmpResultType(const Type* opnd_type);
+ /// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by
+ /// setInlineAsmDiagnosticHandler.
+ InlineAsmDiagHandlerTy getInlineAsmDiagnosticHandler() const;
+
+ /// getInlineAsmDiagnosticContext - Return the diagnostic context set by
+ /// setInlineAsmDiagnosticHandler.
+ void *getInlineAsmDiagnosticContext() const;
+
+
+ /// emitError - Emit an error message to the currently installed error handler
+ /// with optional location information. This function returns, so code should
+ /// be prepared to drop the erroneous construct on the floor and "not crash".
+ /// The generated code need not be correct. The error message will be
+ /// implicitly prefixed with "error: " and should not end with a ".".
+ void emitError(unsigned LocCookie, StringRef ErrorStr);
+ void emitError(const Instruction *I, StringRef ErrorStr);
+ void emitError(StringRef ErrorStr);
+
+private:
+ // DO NOT IMPLEMENT
+ LLVMContext(LLVMContext&);
+ void operator=(LLVMContext&);
+
+ /// addModule - Register a module as being instantiated in this context. If
+ /// the context is deleted, the module will be deleted as well.
+ void addModule(Module*);
- // Methods for erasing constants
- void erase(MDString *M);
- void erase(MDNode *M);
- void erase(ConstantAggregateZero *Z);
- void erase(ConstantArray *Z);
- void erase(ConstantStruct *S);
- void erase(ConstantVector *V);
+ /// removeModule - Unregister a module from this context.
+ void removeModule(Module*);
- // RAUW helpers
- Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
- Value *From, Value *To, Use *U);
- Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
- Value *To, Use *U);
+ // Module needs access to the add/removeModule methods.
+ friend class Module;
};
-/// FOR BACKWARDS COMPATIBILITY - Returns a global context.
-extern LLVMContext& getGlobalContext();
+/// getGlobalContext - Returns a global context. This is for LLVM clients that
+/// only care about operating on a single thread.
+extern LLVMContext &getGlobalContext();
}