aaron/ispc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove LLVM_TYPE_CONST #define / usage.

Browse Source 
Now with LLVM 3.0 and beyond, types aren't const.
This commit is contained in:
Matt Pharr
2012-04-15 20:11:27 -07:00
parent 098c4910de
commit fefa86e0cf
14 changed files with 303 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
builtins.cpp
View File

@@ -291,7 +291,7 @@ lCheckModuleIntrinsics(llvm::Module *module) {
if (!strncmp(funcName.c_str(), "llvm.x86.", 9)) { if (!strncmp(funcName.c_str(), "llvm.x86.", 9)) {
llvm::Intrinsic::ID id = (llvm::Intrinsic::ID)func->getIntrinsicID(); llvm::Intrinsic::ID id = (llvm::Intrinsic::ID)func->getIntrinsicID();
Assert(id != 0); Assert(id != 0);
LLVM_TYPE_CONST llvm::Type *intrinsicType = llvm::Type *intrinsicType =
llvm::Intrinsic::getType(*g->ctx, id); llvm::Intrinsic::getType(*g->ctx, id);
intrinsicType = llvm::PointerType::get(intrinsicType, 0); intrinsicType = llvm::PointerType::get(intrinsicType, 0);
Assert(func->getType() == intrinsicType); Assert(func->getType() == intrinsicType);
@@ -641,7 +641,7 @@ lDefineConstantInt(const char *name, int val, llvm::Module *module,
new Symbol(name, SourcePos(), AtomicType::UniformInt32->GetAsConstType(), new Symbol(name, SourcePos(), AtomicType::UniformInt32->GetAsConstType(),
SC_STATIC); SC_STATIC);
pw->constValue = new ConstExpr(pw->type, val, SourcePos()); pw->constValue = new ConstExpr(pw->type, val, SourcePos());
LLVM_TYPE_CONST llvm::Type *ltype = LLVMTypes::Int32Type; llvm::Type *ltype = LLVMTypes::Int32Type;
llvm::Constant *linit = LLVMInt32(val); llvm::Constant *linit = LLVMInt32(val);
pw->storagePtr = new llvm::GlobalVariable(*module, ltype, true, pw->storagePtr = new llvm::GlobalVariable(*module, ltype, true,
llvm::GlobalValue::InternalLinkage, llvm::GlobalValue::InternalLinkage,
@@ -681,7 +681,7 @@ lDefineProgramIndex(llvm::Module *module, SymbolTable *symbolTable) {
pi[i] = i; pi[i] = i;
pidx->constValue = new ConstExpr(pidx->type, pi, SourcePos()); pidx->constValue = new ConstExpr(pidx->type, pi, SourcePos());
LLVM_TYPE_CONST llvm::Type *ltype = LLVMTypes::Int32VectorType; llvm::Type *ltype = LLVMTypes::Int32VectorType;
llvm::Constant *linit = LLVMInt32Vector(pi); llvm::Constant *linit = LLVMInt32Vector(pi);
pidx->storagePtr = new llvm::GlobalVariable(*module, ltype, true, pidx->storagePtr = new llvm::GlobalVariable(*module, ltype, true,
llvm::GlobalValue::InternalLinkage, linit, llvm::GlobalValue::InternalLinkage, linit,

172
ctx.cpp
View File

@@ -251,7 +251,7 @@ FunctionEmitContext::FunctionEmitContext(Function *func, Symbol *funSym,
if (!returnType || Type::Equal(returnType, AtomicType::Void)) if (!returnType || Type::Equal(returnType, AtomicType::Void))
returnValuePtr = NULL; returnValuePtr = NULL;
else { else {
LLVM_TYPE_CONST llvm::Type *ftype = returnType->LLVMType(g->ctx); llvm::Type *ftype = returnType->LLVMType(g->ctx);
returnValuePtr = AllocaInst(ftype, "return_value_memory"); returnValuePtr = AllocaInst(ftype, "return_value_memory");
} }
@@ -1050,7 +1050,7 @@ FunctionEmitContext::SwitchInst(llvm::Value *expr, llvm::BasicBlock *bbDefault,
caseBlocks = new std::vector<std::pair<int, llvm::BasicBlock *> >(bbCases); caseBlocks = new std::vector<std::pair<int, llvm::BasicBlock *> >(bbCases);
nextBlocks = new std::map<llvm::BasicBlock *, llvm::BasicBlock *>(bbNext); nextBlocks = new std::map<llvm::BasicBlock *, llvm::BasicBlock *>(bbNext);
switchConditionWasUniform = switchConditionWasUniform =
(llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(expr->getType()) == false); (llvm::isa<llvm::VectorType>(expr->getType()) == false);
if (switchConditionWasUniform == true) { if (switchConditionWasUniform == true) {
// For a uniform switch condition, just wire things up to the LLVM // For a uniform switch condition, just wire things up to the LLVM
@@ -1325,12 +1325,12 @@ FunctionEmitContext::I1VecToBoolVec(llvm::Value *b) {
if (g->target.maskBitCount == 1) if (g->target.maskBitCount == 1)
return b; return b;
LLVM_TYPE_CONST llvm::ArrayType *at = llvm::ArrayType *at =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(b->getType()); llvm::dyn_cast<llvm::ArrayType>(b->getType());
if (at) { if (at) {
// If we're given an array of vectors of i1s, then do the // If we're given an array of vectors of i1s, then do the
// conversion for each of the elements // conversion for each of the elements
LLVM_TYPE_CONST llvm::Type *boolArrayType = llvm::Type *boolArrayType =
llvm::ArrayType::get(LLVMTypes::BoolVectorType, at->getNumElements()); llvm::ArrayType::get(LLVMTypes::BoolVectorType, at->getNumElements());
llvm::Value *ret = llvm::UndefValue::get(boolArrayType); llvm::Value *ret = llvm::UndefValue::get(boolArrayType);
@@ -1493,16 +1493,16 @@ FunctionEmitContext::EmitFunctionParameterDebugInfo(Symbol *sym) {
Otherwise return zero. Otherwise return zero.
*/ */
static int static int
lArrayVectorWidth(LLVM_TYPE_CONST llvm::Type *t) { lArrayVectorWidth(llvm::Type *t) {
LLVM_TYPE_CONST llvm::ArrayType *arrayType = llvm::ArrayType *arrayType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(t); llvm::dyn_cast<llvm::ArrayType>(t);
if (arrayType == NULL) if (arrayType == NULL)
return 0; return 0;
// We shouldn't be seeing arrays of anything but vectors being passed // We shouldn't be seeing arrays of anything but vectors being passed
// to things like FunctionEmitContext::BinaryOperator() as operands. // to things like FunctionEmitContext::BinaryOperator() as operands.
LLVM_TYPE_CONST llvm::VectorType *vectorElementType = llvm::VectorType *vectorElementType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(arrayType->getElementType()); llvm::dyn_cast<llvm::VectorType>(arrayType->getElementType());
Assert((vectorElementType != NULL && Assert((vectorElementType != NULL &&
(int)vectorElementType->getNumElements() == g->target.vectorWidth)); (int)vectorElementType->getNumElements() == g->target.vectorWidth));
@@ -1520,7 +1520,7 @@ FunctionEmitContext::BinaryOperator(llvm::Instruction::BinaryOps inst,
} }
Assert(v0->getType() == v1->getType()); Assert(v0->getType() == v1->getType());
LLVM_TYPE_CONST llvm::Type *type = v0->getType(); llvm::Type *type = v0->getType();
int arraySize = lArrayVectorWidth(type); int arraySize = lArrayVectorWidth(type);
if (arraySize == 0) { if (arraySize == 0) {
llvm::Instruction *bop = llvm::Instruction *bop =
@@ -1554,7 +1554,7 @@ FunctionEmitContext::NotOperator(llvm::Value *v, const char *name) {
// Similarly to BinaryOperator, do the operation on all the elements of // Similarly to BinaryOperator, do the operation on all the elements of
// the array if we're given an array type; otherwise just do the // the array if we're given an array type; otherwise just do the
// regular llvm operation. // regular llvm operation.
LLVM_TYPE_CONST llvm::Type *type = v->getType(); llvm::Type *type = v->getType();
int arraySize = lArrayVectorWidth(type); int arraySize = lArrayVectorWidth(type);
if (arraySize == 0) { if (arraySize == 0) {
llvm::Instruction *binst = llvm::Instruction *binst =
@@ -1579,18 +1579,18 @@ FunctionEmitContext::NotOperator(llvm::Value *v, const char *name) {
// Given the llvm Type that represents an ispc VectorType, return an // Given the llvm Type that represents an ispc VectorType, return an
// equally-shaped type with boolean elements. (This is the type that will // equally-shaped type with boolean elements. (This is the type that will
// be returned from CmpInst with ispc VectorTypes). // be returned from CmpInst with ispc VectorTypes).
static LLVM_TYPE_CONST llvm::Type * static llvm::Type *
lGetMatchingBoolVectorType(LLVM_TYPE_CONST llvm::Type *type) { lGetMatchingBoolVectorType(llvm::Type *type) {
LLVM_TYPE_CONST llvm::ArrayType *arrayType = llvm::ArrayType *arrayType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(type); llvm::dyn_cast<llvm::ArrayType>(type);
Assert(arrayType != NULL); Assert(arrayType != NULL);
LLVM_TYPE_CONST llvm::VectorType *vectorElementType = llvm::VectorType *vectorElementType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(arrayType->getElementType()); llvm::dyn_cast<llvm::VectorType>(arrayType->getElementType());
Assert(vectorElementType != NULL); Assert(vectorElementType != NULL);
Assert((int)vectorElementType->getNumElements() == g->target.vectorWidth); Assert((int)vectorElementType->getNumElements() == g->target.vectorWidth);
LLVM_TYPE_CONST llvm::Type *base = llvm::Type *base =
llvm::VectorType::get(LLVMTypes::BoolType, g->target.vectorWidth); llvm::VectorType::get(LLVMTypes::BoolType, g->target.vectorWidth);
return llvm::ArrayType::get(base, arrayType->getNumElements()); return llvm::ArrayType::get(base, arrayType->getNumElements());
} }
@@ -1607,7 +1607,7 @@ FunctionEmitContext::CmpInst(llvm::Instruction::OtherOps inst,
} }
Assert(v0->getType() == v1->getType()); Assert(v0->getType() == v1->getType());
LLVM_TYPE_CONST llvm::Type *type = v0->getType(); llvm::Type *type = v0->getType();
int arraySize = lArrayVectorWidth(type); int arraySize = lArrayVectorWidth(type);
if (arraySize == 0) { if (arraySize == 0) {
llvm::Instruction *ci = llvm::Instruction *ci =
@@ -1617,7 +1617,7 @@ FunctionEmitContext::CmpInst(llvm::Instruction::OtherOps inst,
return ci; return ci;
} }
else { else {
LLVM_TYPE_CONST llvm::Type *boolType = lGetMatchingBoolVectorType(type); llvm::Type *boolType = lGetMatchingBoolVectorType(type);
llvm::Value *ret = llvm::UndefValue::get(boolType); llvm::Value *ret = llvm::UndefValue::get(boolType);
for (int i = 0; i < arraySize; ++i) { for (int i = 0; i < arraySize; ++i) {
llvm::Value *a = ExtractInst(v0, i); llvm::Value *a = ExtractInst(v0, i);
@@ -1638,10 +1638,10 @@ FunctionEmitContext::SmearUniform(llvm::Value *value, const char *name) {
} }
llvm::Value *ret = NULL; llvm::Value *ret = NULL;
LLVM_TYPE_CONST llvm::Type *eltType = value->getType(); llvm::Type *eltType = value->getType();
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(eltType); llvm::dyn_cast<llvm::PointerType>(eltType);
if (pt != NULL) { if (pt != NULL) {
// Varying pointers are represented as vectors of i32/i64s // Varying pointers are represented as vectors of i32/i64s
ret = llvm::UndefValue::get(LLVMTypes::VoidPointerVectorType); ret = llvm::UndefValue::get(LLVMTypes::VoidPointerVectorType);
@@ -1665,7 +1665,7 @@ FunctionEmitContext::SmearUniform(llvm::Value *value, const char *name) {
llvm::Value * llvm::Value *
FunctionEmitContext::BitCastInst(llvm::Value *value, FunctionEmitContext::BitCastInst(llvm::Value *value,
LLVM_TYPE_CONST llvm::Type *type, llvm::Type *type,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1686,11 +1686,11 @@ FunctionEmitContext::PtrToIntInst(llvm::Value *value, const char *name) {
return NULL; return NULL;
} }
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(value->getType())) if (llvm::isa<llvm::VectorType>(value->getType()))
// no-op for varying pointers; they're already vectors of ints // no-op for varying pointers; they're already vectors of ints
return value; return value;
LLVM_TYPE_CONST llvm::Type *type = LLVMTypes::PointerIntType; llvm::Type *type = LLVMTypes::PointerIntType;
llvm::Instruction *inst = llvm::Instruction *inst =
new llvm::PtrToIntInst(value, type, name ? name : "ptr2int", bblock); new llvm::PtrToIntInst(value, type, name ? name : "ptr2int", bblock);
AddDebugPos(inst); AddDebugPos(inst);
@@ -1700,15 +1700,15 @@ FunctionEmitContext::PtrToIntInst(llvm::Value *value, const char *name) {
llvm::Value * llvm::Value *
FunctionEmitContext::PtrToIntInst(llvm::Value *value, FunctionEmitContext::PtrToIntInst(llvm::Value *value,
LLVM_TYPE_CONST llvm::Type *toType, llvm::Type *toType,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *fromType = value->getType(); llvm::Type *fromType = value->getType();
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(fromType)) { if (llvm::isa<llvm::VectorType>(fromType)) {
// varying pointer // varying pointer
if (fromType == toType) if (fromType == toType)
// already the right type--done // already the right type--done
@@ -1731,15 +1731,15 @@ FunctionEmitContext::PtrToIntInst(llvm::Value *value,
llvm::Value * llvm::Value *
FunctionEmitContext::IntToPtrInst(llvm::Value *value, FunctionEmitContext::IntToPtrInst(llvm::Value *value,
LLVM_TYPE_CONST llvm::Type *toType, llvm::Type *toType,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *fromType = value->getType(); llvm::Type *fromType = value->getType();
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(fromType)) { if (llvm::isa<llvm::VectorType>(fromType)) {
// varying pointer // varying pointer
if (fromType == toType) if (fromType == toType)
// done // done
@@ -1761,7 +1761,7 @@ FunctionEmitContext::IntToPtrInst(llvm::Value *value,
llvm::Instruction * llvm::Instruction *
FunctionEmitContext::TruncInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, FunctionEmitContext::TruncInst(llvm::Value *value, llvm::Type *type,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1779,7 +1779,7 @@ FunctionEmitContext::TruncInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *t
llvm::Instruction * llvm::Instruction *
FunctionEmitContext::CastInst(llvm::Instruction::CastOps op, llvm::Value *value, FunctionEmitContext::CastInst(llvm::Instruction::CastOps op, llvm::Value *value,
LLVM_TYPE_CONST llvm::Type *type, const char *name) { llvm::Type *type, const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -1795,7 +1795,7 @@ FunctionEmitContext::CastInst(llvm::Instruction::CastOps op, llvm::Value *value,
llvm::Instruction * llvm::Instruction *
FunctionEmitContext::FPCastInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, FunctionEmitContext::FPCastInst(llvm::Value *value, llvm::Type *type,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1812,7 +1812,7 @@ FunctionEmitContext::FPCastInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *
llvm::Instruction * llvm::Instruction *
FunctionEmitContext::SExtInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, FunctionEmitContext::SExtInst(llvm::Value *value, llvm::Type *type,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1829,7 +1829,7 @@ FunctionEmitContext::SExtInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *ty
llvm::Instruction * llvm::Instruction *
FunctionEmitContext::ZExtInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, FunctionEmitContext::ZExtInst(llvm::Value *value, llvm::Type *type,
const char *name) { const char *name) {
if (value == NULL) { if (value == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1860,7 +1860,7 @@ FunctionEmitContext::applyVaryingGEP(llvm::Value *basePtr, llvm::Value *index,
llvm::Value *scale = g->target.SizeOf(scaleType->LLVMType(g->ctx), bblock); llvm::Value *scale = g->target.SizeOf(scaleType->LLVMType(g->ctx), bblock);
bool indexIsVarying = bool indexIsVarying =
llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(index->getType()); llvm::isa<llvm::VectorType>(index->getType());
llvm::Value *offset = NULL; llvm::Value *offset = NULL;
if (indexIsVarying == false) { if (indexIsVarying == false) {
// Truncate or sign extend the index as appropriate to a 32 or // Truncate or sign extend the index as appropriate to a 32 or
@@ -1904,7 +1904,7 @@ FunctionEmitContext::applyVaryingGEP(llvm::Value *basePtr, llvm::Value *index,
// Smear out the pointer to be varying; either the base pointer or the // Smear out the pointer to be varying; either the base pointer or the
// index must be varying for this method to be called. // index must be varying for this method to be called.
bool baseIsUniform = bool baseIsUniform =
(llvm::isa<LLVM_TYPE_CONST llvm::PointerType>(basePtr->getType())); (llvm::isa<llvm::PointerType>(basePtr->getType()));
Assert(baseIsUniform == false || indexIsVarying == true); Assert(baseIsUniform == false || indexIsVarying == true);
llvm::Value *varyingPtr = baseIsUniform ? llvm::Value *varyingPtr = baseIsUniform ?
SmearUniform(basePtr, "ptr_smear") : basePtr; SmearUniform(basePtr, "ptr_smear") : basePtr;
@@ -1916,18 +1916,18 @@ FunctionEmitContext::applyVaryingGEP(llvm::Value *basePtr, llvm::Value *index,
void void
FunctionEmitContext::MatchIntegerTypes(llvm::Value **v0, llvm::Value **v1) { FunctionEmitContext::MatchIntegerTypes(llvm::Value **v0, llvm::Value **v1) {
LLVM_TYPE_CONST llvm::Type *type0 = (*v0)->getType(); llvm::Type *type0 = (*v0)->getType();
LLVM_TYPE_CONST llvm::Type *type1 = (*v1)->getType(); llvm::Type *type1 = (*v1)->getType();
// First, promote to a vector type if one of the two values is a vector // First, promote to a vector type if one of the two values is a vector
// type // type
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(type0) && if (llvm::isa<llvm::VectorType>(type0) &&
!llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(type1)) { !llvm::isa<llvm::VectorType>(type1)) {
*v1 = SmearUniform(*v1, "smear_v1"); *v1 = SmearUniform(*v1, "smear_v1");
type1 = (*v1)->getType(); type1 = (*v1)->getType();
} }
if (!llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(type0) && if (!llvm::isa<llvm::VectorType>(type0) &&
llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(type1)) { llvm::isa<llvm::VectorType>(type1)) {
*v0 = SmearUniform(*v0, "smear_v0"); *v0 = SmearUniform(*v0, "smear_v0");
type0 = (*v0)->getType(); type0 = (*v0)->getType();
} }
@@ -1964,7 +1964,7 @@ lComputeSliceIndex(FunctionEmitContext *ctx, int soaWidth,
ctx->MatchIntegerTypes(&indexValue, &ptrSliceOffset); ctx->MatchIntegerTypes(&indexValue, &ptrSliceOffset);
LLVM_TYPE_CONST llvm::Type *indexType = indexValue->getType(); llvm::Type *indexType = indexValue->getType();
llvm::Value *shift = LLVMIntAsType(logWidth, indexType); llvm::Value *shift = LLVMIntAsType(logWidth, indexType);
llvm::Value *mask = LLVMIntAsType(soaWidth-1, indexType); llvm::Value *mask = LLVMIntAsType(soaWidth-1, indexType);
@@ -1992,10 +1992,10 @@ FunctionEmitContext::MakeSlicePointer(llvm::Value *ptr, llvm::Value *offset) {
// Create a small struct where the first element is the type of the // Create a small struct where the first element is the type of the
// given pointer and the second element is the type of the offset // given pointer and the second element is the type of the offset
// value. // value.
std::vector<LLVM_TYPE_CONST llvm::Type *> eltTypes; std::vector<llvm::Type *> eltTypes;
eltTypes.push_back(ptr->getType()); eltTypes.push_back(ptr->getType());
eltTypes.push_back(offset->getType()); eltTypes.push_back(offset->getType());
LLVM_TYPE_CONST llvm::StructType *st = llvm::StructType *st =
llvm::StructType::get(*g->ctx, eltTypes); llvm::StructType::get(*g->ctx, eltTypes);
llvm::Value *ret = llvm::UndefValue::get(st); llvm::Value *ret = llvm::UndefValue::get(st);
@@ -2023,7 +2023,7 @@ FunctionEmitContext::GetElementPtrInst(llvm::Value *basePtr, llvm::Value *index,
} }
if (ptrType->IsSlice()) { if (ptrType->IsSlice()) {
Assert(llvm::isa<LLVM_TYPE_CONST llvm::StructType>(basePtr->getType())); Assert(llvm::isa<llvm::StructType>(basePtr->getType()));
llvm::Value *ptrSliceOffset = ExtractInst(basePtr, 1); llvm::Value *ptrSliceOffset = ExtractInst(basePtr, 1);
if (ptrType->IsFrozenSlice() == false) { if (ptrType->IsFrozenSlice() == false) {
@@ -2051,12 +2051,12 @@ FunctionEmitContext::GetElementPtrInst(llvm::Value *basePtr, llvm::Value *index,
// Double-check consistency between the given pointer type and its LLVM // Double-check consistency between the given pointer type and its LLVM
// type. // type.
if (ptrType->IsUniformType()) if (ptrType->IsUniformType())
Assert(llvm::isa<LLVM_TYPE_CONST llvm::PointerType>(basePtr->getType())); Assert(llvm::isa<llvm::PointerType>(basePtr->getType()));
else if (ptrType->IsVaryingType()) else if (ptrType->IsVaryingType())
Assert(llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(basePtr->getType())); Assert(llvm::isa<llvm::VectorType>(basePtr->getType()));
bool indexIsVaryingType = bool indexIsVaryingType =
llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(index->getType()); llvm::isa<llvm::VectorType>(index->getType());
if (indexIsVaryingType == false && ptrType->IsUniformType() == true) { if (indexIsVaryingType == false && ptrType->IsUniformType() == true) {
// The easy case: both the base pointer and the indices are // The easy case: both the base pointer and the indices are
@@ -2096,7 +2096,7 @@ FunctionEmitContext::GetElementPtrInst(llvm::Value *basePtr, llvm::Value *index0
// Similar to the 1D GEP implementation above, for non-frozen slice // Similar to the 1D GEP implementation above, for non-frozen slice
// pointers we do the two-step indexing calculation and then pass // pointers we do the two-step indexing calculation and then pass
// the new major index on to a recursive GEP call. // the new major index on to a recursive GEP call.
Assert(llvm::isa<LLVM_TYPE_CONST llvm::StructType>(basePtr->getType())); Assert(llvm::isa<llvm::StructType>(basePtr->getType()));
llvm::Value *ptrSliceOffset = ExtractInst(basePtr, 1); llvm::Value *ptrSliceOffset = ExtractInst(basePtr, 1);
if (ptrType->IsFrozenSlice() == false) { if (ptrType->IsFrozenSlice() == false) {
llvm::Value *newSliceOffset; llvm::Value *newSliceOffset;
@@ -2113,9 +2113,9 @@ FunctionEmitContext::GetElementPtrInst(llvm::Value *basePtr, llvm::Value *index0
} }
bool index0IsVaryingType = bool index0IsVaryingType =
llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(index0->getType()); llvm::isa<llvm::VectorType>(index0->getType());
bool index1IsVaryingType = bool index1IsVaryingType =
llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(index1->getType()); llvm::isa<llvm::VectorType>(index1->getType());
if (index0IsVaryingType == false && index1IsVaryingType == false && if (index0IsVaryingType == false && index1IsVaryingType == false &&
ptrType->IsUniformType() == true) { ptrType->IsUniformType() == true) {
@@ -2140,7 +2140,7 @@ FunctionEmitContext::GetElementPtrInst(llvm::Value *basePtr, llvm::Value *index0
Assert(st != NULL); Assert(st != NULL);
bool ptr0IsUniform = bool ptr0IsUniform =
llvm::isa<LLVM_TYPE_CONST llvm::PointerType>(ptr0->getType()); llvm::isa<llvm::PointerType>(ptr0->getType());
const Type *ptr0BaseType = st->GetElementType(); const Type *ptr0BaseType = st->GetElementType();
const Type *ptr0Type = ptr0IsUniform ? const Type *ptr0Type = ptr0IsUniform ?
PointerType::GetUniform(ptr0BaseType) : PointerType::GetUniform(ptr0BaseType) :
@@ -2175,7 +2175,7 @@ FunctionEmitContext::AddElementOffset(llvm::Value *fullBasePtr, int elementNum,
// unfortunate... // unfortunate...
llvm::Value *basePtr = fullBasePtr; llvm::Value *basePtr = fullBasePtr;
bool baseIsSlicePtr = bool baseIsSlicePtr =
llvm::isa<LLVM_TYPE_CONST llvm::StructType>(fullBasePtr->getType()); llvm::isa<llvm::StructType>(fullBasePtr->getType());
const PointerType *rpt; const PointerType *rpt;
if (baseIsSlicePtr) { if (baseIsSlicePtr) {
Assert(ptrType != NULL); Assert(ptrType != NULL);
@@ -2263,8 +2263,8 @@ FunctionEmitContext::LoadInst(llvm::Value *ptr, const char *name) {
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(ptr->getType()); llvm::dyn_cast<llvm::PointerType>(ptr->getType());
Assert(pt != NULL); Assert(pt != NULL);
// FIXME: it's not clear to me that we generate unaligned vector loads // FIXME: it's not clear to me that we generate unaligned vector loads
@@ -2272,7 +2272,7 @@ FunctionEmitContext::LoadInst(llvm::Value *ptr, const char *name) {
// optimization passes that lower gathers to vector loads, I think..) // optimization passes that lower gathers to vector loads, I think..)
// So remove this?? // So remove this??
int align = 0; int align = 0;
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(pt->getElementType())) if (llvm::isa<llvm::VectorType>(pt->getElementType()))
align = 1; align = 1;
llvm::Instruction *inst = new llvm::LoadInst(ptr, name ? name : "load", llvm::Instruction *inst = new llvm::LoadInst(ptr, name ? name : "load",
false /* not volatile */, false /* not volatile */,
@@ -2332,7 +2332,7 @@ FunctionEmitContext::loadUniformFromSOA(llvm::Value *ptr, llvm::Value *mask,
// If we have a struct/array, we need to decompose it into // If we have a struct/array, we need to decompose it into
// individual element loads to fill in the result structure since // individual element loads to fill in the result structure since
// the SOA slice of values we need isn't contiguous in memory... // the SOA slice of values we need isn't contiguous in memory...
LLVM_TYPE_CONST llvm::Type *llvmReturnType = unifType->LLVMType(g->ctx); llvm::Type *llvmReturnType = unifType->LLVMType(g->ctx);
llvm::Value *retValue = llvm::UndefValue::get(llvmReturnType); llvm::Value *retValue = llvm::UndefValue::get(llvmReturnType);
for (int i = 0; i < ct->GetElementCount(); ++i) { for (int i = 0; i < ct->GetElementCount(); ++i) {
@@ -2416,7 +2416,7 @@ FunctionEmitContext::gather(llvm::Value *ptr, const PointerType *ptrType,
Assert(ptrType->IsVaryingType()); Assert(ptrType->IsVaryingType());
const Type *returnType = ptrType->GetBaseType()->GetAsVaryingType(); const Type *returnType = ptrType->GetBaseType()->GetAsVaryingType();
LLVM_TYPE_CONST llvm::Type *llvmReturnType = returnType->LLVMType(g->ctx); llvm::Type *llvmReturnType = returnType->LLVMType(g->ctx);
const CollectionType *collectionType = const CollectionType *collectionType =
dynamic_cast<const CollectionType *>(ptrType->GetBaseType()); dynamic_cast<const CollectionType *>(ptrType->GetBaseType());
@@ -2524,7 +2524,7 @@ FunctionEmitContext::addGSMetadata(llvm::Value *v, SourcePos pos) {
llvm::Value * llvm::Value *
FunctionEmitContext::AllocaInst(LLVM_TYPE_CONST llvm::Type *llvmType, FunctionEmitContext::AllocaInst(llvm::Type *llvmType,
const char *name, int align, const char *name, int align,
bool atEntryBlock) { bool atEntryBlock) {
if (llvmType == NULL) { if (llvmType == NULL) {
@@ -2550,10 +2550,10 @@ FunctionEmitContext::AllocaInst(LLVM_TYPE_CONST llvm::Type *llvmType,
// unlikely that this array will be loaded into varying variables with // unlikely that this array will be loaded into varying variables with
// what will be aligned accesses if the uniform -> varying load is done // what will be aligned accesses if the uniform -> varying load is done
// in regular chunks. // in regular chunks.
LLVM_TYPE_CONST llvm::ArrayType *arrayType = llvm::ArrayType *arrayType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(llvmType); llvm::dyn_cast<llvm::ArrayType>(llvmType);
if (align == 0 && arrayType != NULL && if (align == 0 && arrayType != NULL &&
!llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(arrayType->getElementType())) !llvm::isa<llvm::VectorType>(arrayType->getElementType()))
align = 4 * g->target.nativeVectorWidth; align = 4 * g->target.nativeVectorWidth;
if (align != 0) if (align != 0)
@@ -2760,7 +2760,7 @@ FunctionEmitContext::scatter(llvm::Value *value, llvm::Value *ptr,
Assert(pt != NULL || Assert(pt != NULL ||
dynamic_cast<const AtomicType *>(valueType) != NULL); dynamic_cast<const AtomicType *>(valueType) != NULL);
LLVM_TYPE_CONST llvm::Type *type = value->getType(); llvm::Type *type = value->getType();
const char *funcName = NULL; const char *funcName = NULL;
if (pt != NULL) if (pt != NULL)
funcName = g->target.is32Bit ? "__pseudo_scatter32_32" : funcName = g->target.is32Bit ? "__pseudo_scatter32_32" :
@@ -2957,7 +2957,7 @@ FunctionEmitContext::ExtractInst(llvm::Value *v, int elt, const char *name) {
} }
llvm::Instruction *ei = NULL; llvm::Instruction *ei = NULL;
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(v->getType())) if (llvm::isa<llvm::VectorType>(v->getType()))
ei = llvm::ExtractElementInst::Create(v, LLVMInt32(elt), ei = llvm::ExtractElementInst::Create(v, LLVMInt32(elt),
name ? name : "extract", bblock); name ? name : "extract", bblock);
else else
@@ -2977,7 +2977,7 @@ FunctionEmitContext::InsertInst(llvm::Value *v, llvm::Value *eltVal, int elt,
} }
llvm::Instruction *ii = NULL; llvm::Instruction *ii = NULL;
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(v->getType())) if (llvm::isa<llvm::VectorType>(v->getType()))
ii = llvm::InsertElementInst::Create(v, eltVal, LLVMInt32(elt), ii = llvm::InsertElementInst::Create(v, eltVal, LLVMInt32(elt),
name ? name : "insert", bblock); name ? name : "insert", bblock);
else else
@@ -2989,7 +2989,7 @@ FunctionEmitContext::InsertInst(llvm::Value *v, llvm::Value *eltVal, int elt,
llvm::PHINode * llvm::PHINode *
FunctionEmitContext::PhiNode(LLVM_TYPE_CONST llvm::Type *type, int count, FunctionEmitContext::PhiNode(llvm::Type *type, int count,
const char *name) { const char *name) {
llvm::PHINode *pn = llvm::PHINode::Create(type, count, llvm::PHINode *pn = llvm::PHINode::Create(type, count,
name ? name : "phi", bblock); name ? name : "phi", bblock);
@@ -3019,18 +3019,18 @@ FunctionEmitContext::SelectInst(llvm::Value *test, llvm::Value *val0,
function has. */ function has. */
static unsigned int static unsigned int
lCalleeArgCount(llvm::Value *callee, const FunctionType *funcType) { lCalleeArgCount(llvm::Value *callee, const FunctionType *funcType) {
LLVM_TYPE_CONST llvm::FunctionType *ft = llvm::FunctionType *ft =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::FunctionType>(callee->getType()); llvm::dyn_cast<llvm::FunctionType>(callee->getType());
if (ft == NULL) { if (ft == NULL) {
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(callee->getType()); llvm::dyn_cast<llvm::PointerType>(callee->getType());
if (pt == NULL) { if (pt == NULL) {
// varying--in this case, it must be the version of the // varying--in this case, it must be the version of the
// function that takes a mask // function that takes a mask
return funcType->GetNumParameters() + 1; return funcType->GetNumParameters() + 1;
} }
ft = llvm::dyn_cast<LLVM_TYPE_CONST llvm::FunctionType>(pt->getElementType()); ft = llvm::dyn_cast<llvm::FunctionType>(pt->getElementType());
} }
Assert(ft != NULL); Assert(ft != NULL);
@@ -3057,7 +3057,7 @@ FunctionEmitContext::CallInst(llvm::Value *func, const FunctionType *funcType,
if (argVals.size() + 1 == calleeArgCount) if (argVals.size() + 1 == calleeArgCount)
argVals.push_back(GetFullMask()); argVals.push_back(GetFullMask());
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(func->getType()) == false) { if (llvm::isa<llvm::VectorType>(func->getType()) == false) {
// Regular 'uniform' function call--just one function or function // Regular 'uniform' function call--just one function or function
// pointer, so just emit the IR directly. // pointer, so just emit the IR directly.
llvm::Instruction *ci = llvm::Instruction *ci =
@@ -3085,7 +3085,7 @@ FunctionEmitContext::CallInst(llvm::Value *func, const FunctionType *funcType,
// First allocate memory to accumulate the various program // First allocate memory to accumulate the various program
// instances' return values... // instances' return values...
const Type *returnType = funcType->GetReturnType(); const Type *returnType = funcType->GetReturnType();
LLVM_TYPE_CONST llvm::Type *llvmReturnType = returnType->LLVMType(g->ctx); llvm::Type *llvmReturnType = returnType->LLVMType(g->ctx);
llvm::Value *resultPtr = NULL; llvm::Value *resultPtr = NULL;
if (llvmReturnType->isVoidTy() == false) if (llvmReturnType->isVoidTy() == false)
resultPtr = AllocaInst(llvmReturnType); resultPtr = AllocaInst(llvmReturnType);
@@ -3152,9 +3152,9 @@ FunctionEmitContext::CallInst(llvm::Value *func, const FunctionType *funcType,
// bitcast the i32/64 function pointer to the actual function // bitcast the i32/64 function pointer to the actual function
// pointer type (the variant that includes a mask). // pointer type (the variant that includes a mask).
LLVM_TYPE_CONST llvm::Type *llvmFuncType = llvm::Type *llvmFuncType =
funcType->LLVMFunctionType(g->ctx, true); funcType->LLVMFunctionType(g->ctx, true);
LLVM_TYPE_CONST llvm::Type *llvmFPtrType = llvm::Type *llvmFPtrType =
llvm::PointerType::get(llvmFuncType, 0); llvm::PointerType::get(llvmFuncType, 0);
llvm::Value *fptrCast = IntToPtrInst(fptr, llvmFPtrType); llvm::Value *fptrCast = IntToPtrInst(fptr, llvmFPtrType);
@@ -3251,14 +3251,14 @@ FunctionEmitContext::LaunchInst(llvm::Value *callee,
launchedTasks = true; launchedTasks = true;
Assert(llvm::isa<llvm::Function>(callee)); Assert(llvm::isa<llvm::Function>(callee));
LLVM_TYPE_CONST llvm::Type *argType = llvm::Type *argType =
(llvm::dyn_cast<llvm::Function>(callee))->arg_begin()->getType(); (llvm::dyn_cast<llvm::Function>(callee))->arg_begin()->getType();
Assert(llvm::PointerType::classof(argType)); Assert(llvm::PointerType::classof(argType));
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(argType); llvm::dyn_cast<llvm::PointerType>(argType);
Assert(llvm::StructType::classof(pt->getElementType())); Assert(llvm::StructType::classof(pt->getElementType()));
LLVM_TYPE_CONST llvm::StructType *argStructType = llvm::StructType *argStructType =
static_cast<LLVM_TYPE_CONST llvm::StructType *>(pt->getElementType()); static_cast<llvm::StructType *>(pt->getElementType());
Assert(argStructType->getNumElements() == argVals.size() + 1); Assert(argStructType->getNumElements() == argVals.size() + 1);
llvm::Function *falloc = m->module->getFunction("ISPCAlloc"); llvm::Function *falloc = m->module->getFunction("ISPCAlloc");
@@ -3356,7 +3356,7 @@ FunctionEmitContext::addVaryingOffsetsIfNeeded(llvm::Value *ptr,
return ptr; return ptr;
// Find the size of a uniform element of the varying type // Find the size of a uniform element of the varying type
LLVM_TYPE_CONST llvm::Type *llvmBaseUniformType = llvm::Type *llvmBaseUniformType =
baseType->GetAsUniformType()->LLVMType(g->ctx); baseType->GetAsUniformType()->LLVMType(g->ctx);
llvm::Value *unifSize = g->target.SizeOf(llvmBaseUniformType, bblock); llvm::Value *unifSize = g->target.SizeOf(llvmBaseUniformType, bblock);
unifSize = SmearUniform(unifSize); unifSize = SmearUniform(unifSize);

20
ctx.h
View File

@@ -380,23 +380,23 @@ public:
array, for pointer types). */ array, for pointer types). */
llvm::Value *SmearUniform(llvm::Value *value, const char *name = NULL); llvm::Value *SmearUniform(llvm::Value *value, const char *name = NULL);
llvm::Value *BitCastInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Value *BitCastInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Value *PtrToIntInst(llvm::Value *value, const char *name = NULL); llvm::Value *PtrToIntInst(llvm::Value *value, const char *name = NULL);
llvm::Value *PtrToIntInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Value *PtrToIntInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Value *IntToPtrInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Value *IntToPtrInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Instruction *TruncInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Instruction *TruncInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Instruction *CastInst(llvm::Instruction::CastOps op, llvm::Value *value, llvm::Instruction *CastInst(llvm::Instruction::CastOps op, llvm::Value *value,
LLVM_TYPE_CONST llvm::Type *type, const char *name = NULL); llvm::Type *type, const char *name = NULL);
llvm::Instruction *FPCastInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Instruction *FPCastInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Instruction *SExtInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Instruction *SExtInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
llvm::Instruction *ZExtInst(llvm::Value *value, LLVM_TYPE_CONST llvm::Type *type, llvm::Instruction *ZExtInst(llvm::Value *value, llvm::Type *type,
const char *name = NULL); const char *name = NULL);
/** Given two integer-typed values (but possibly one vector and the /** Given two integer-typed values (but possibly one vector and the
@@ -448,7 +448,7 @@ public:
instruction is added at the start of the function in the entry instruction is added at the start of the function in the entry
basic block; if it should be added to the current basic block, then basic block; if it should be added to the current basic block, then
the atEntryBlock parameter should be false. */ the atEntryBlock parameter should be false. */
llvm::Value *AllocaInst(LLVM_TYPE_CONST llvm::Type *llvmType, llvm::Value *AllocaInst(llvm::Type *llvmType,
const char *name = NULL, int align = 0, const char *name = NULL, int align = 0,
bool atEntryBlock = true); bool atEntryBlock = true);
@@ -485,7 +485,7 @@ public:
llvm::Value *InsertInst(llvm::Value *v, llvm::Value *eltVal, int elt, llvm::Value *InsertInst(llvm::Value *v, llvm::Value *eltVal, int elt,
const char *name = NULL); const char *name = NULL);
llvm::PHINode *PhiNode(LLVM_TYPE_CONST llvm::Type *type, int count, llvm::PHINode *PhiNode(llvm::Type *type, int count,
const char *name = NULL); const char *name = NULL);
llvm::Instruction *SelectInst(llvm::Value *test, llvm::Value *val0, llvm::Instruction *SelectInst(llvm::Value *test, llvm::Value *val0,
llvm::Value *val1, const char *name = NULL); llvm::Value *val1, const char *name = NULL);

92
expr.cpp
View File

@@ -637,7 +637,7 @@ InitSymbol(llvm::Value *ptr, const Type *symType, Expr *initExpr,
// instead we'll make a constant static global that holds the // instead we'll make a constant static global that holds the
// constant value and emit a memcpy to put its value into the // constant value and emit a memcpy to put its value into the
// pointer we have. // pointer we have.
LLVM_TYPE_CONST llvm::Type *llvmType = symType->LLVMType(g->ctx); llvm::Type *llvmType = symType->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return; return;
@@ -771,7 +771,7 @@ InitSymbol(llvm::Value *ptr, const Type *symType, Expr *initExpr,
else { else {
// If we don't have enough initializer values, initialize the // If we don't have enough initializer values, initialize the
// rest as zero. // rest as zero.
LLVM_TYPE_CONST llvm::Type *llvmType = elementType->LLVMType(g->ctx); llvm::Type *llvmType = elementType->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return; return;
@@ -905,7 +905,7 @@ lLLVMConstantValue(const Type *type, llvm::LLVMContext *ctx, double value) {
// a recursive call to lLLVMConstantValue(). // a recursive call to lLLVMConstantValue().
const Type *baseType = vectorType->GetBaseType(); const Type *baseType = vectorType->GetBaseType();
llvm::Constant *constElement = lLLVMConstantValue(baseType, ctx, value); llvm::Constant *constElement = lLLVMConstantValue(baseType, ctx, value);
LLVM_TYPE_CONST llvm::Type *llvmVectorType = vectorType->LLVMType(ctx); llvm::Type *llvmVectorType = vectorType->LLVMType(ctx);
// Now create a constant version of the corresponding LLVM type that we // Now create a constant version of the corresponding LLVM type that we
// use to represent the VectorType. // use to represent the VectorType.
@@ -914,8 +914,8 @@ lLLVMConstantValue(const Type *type, llvm::LLVMContext *ctx, double value) {
// LLVM ArrayTypes leaks into the code here; it feels like this detail // LLVM ArrayTypes leaks into the code here; it feels like this detail
// should be better encapsulated? // should be better encapsulated?
if (baseType->IsUniformType()) { if (baseType->IsUniformType()) {
LLVM_TYPE_CONST llvm::VectorType *lvt = llvm::VectorType *lvt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(llvmVectorType); llvm::dyn_cast<llvm::VectorType>(llvmVectorType);
Assert(lvt != NULL); Assert(lvt != NULL);
std::vector<llvm::Constant *> vals; std::vector<llvm::Constant *> vals;
for (unsigned int i = 0; i < lvt->getNumElements(); ++i) for (unsigned int i = 0; i < lvt->getNumElements(); ++i)
@@ -923,8 +923,8 @@ lLLVMConstantValue(const Type *type, llvm::LLVMContext *ctx, double value) {
return llvm::ConstantVector::get(vals); return llvm::ConstantVector::get(vals);
} }
else { else {
LLVM_TYPE_CONST llvm::ArrayType *lat = llvm::ArrayType *lat =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(llvmVectorType); llvm::dyn_cast<llvm::ArrayType>(llvmVectorType);
Assert(lat != NULL); Assert(lat != NULL);
std::vector<llvm::Constant *> vals; std::vector<llvm::Constant *> vals;
for (unsigned int i = 0; i < lat->getNumElements(); ++i) for (unsigned int i = 0; i < lat->getNumElements(); ++i)
@@ -1439,7 +1439,7 @@ lEmitBinaryPointerArith(BinaryExpr::Op op, llvm::Value *value0,
// Now divide by the size of the type that the pointer // Now divide by the size of the type that the pointer
// points to in order to return the difference in elements. // points to in order to return the difference in elements.
LLVM_TYPE_CONST llvm::Type *llvmElementType = llvm::Type *llvmElementType =
ptrType->GetBaseType()->LLVMType(g->ctx); ptrType->GetBaseType()->LLVMType(g->ctx);
llvm::Value *size = g->target.SizeOf(llvmElementType, llvm::Value *size = g->target.SizeOf(llvmElementType,
ctx->GetCurrentBasicBlock()); ctx->GetCurrentBasicBlock());
@@ -1648,7 +1648,7 @@ lEmitLogicalOp(BinaryExpr::Op op, Expr *arg0, Expr *arg1,
// Allocate temporary storage for the return value // Allocate temporary storage for the return value
const Type *retType = Type::MoreGeneralType(type0, type1, pos, lOpString(op)); const Type *retType = Type::MoreGeneralType(type0, type1, pos, lOpString(op));
LLVM_TYPE_CONST llvm::Type *llvmRetType = retType->LLVMType(g->ctx); llvm::Type *llvmRetType = retType->LLVMType(g->ctx);
llvm::Value *retPtr = ctx->AllocaInst(llvmRetType, "logical_op_mem"); llvm::Value *retPtr = ctx->AllocaInst(llvmRetType, "logical_op_mem");
llvm::BasicBlock *bbSkipEvalValue1 = ctx->CreateBasicBlock("skip_eval_1"); llvm::BasicBlock *bbSkipEvalValue1 = ctx->CreateBasicBlock("skip_eval_1");
@@ -3010,7 +3010,7 @@ SelectExpr::GetValue(FunctionEmitContext *ctx) const {
// Temporary storage to store the values computed for each // Temporary storage to store the values computed for each
// expression, if any. (These stay as uninitialized memory if we // expression, if any. (These stay as uninitialized memory if we
// short circuit around the corresponding expression.) // short circuit around the corresponding expression.)
LLVM_TYPE_CONST llvm::Type *exprType = llvm::Type *exprType =
expr1->GetType()->LLVMType(g->ctx); expr1->GetType()->LLVMType(g->ctx);
llvm::Value *expr1Ptr = ctx->AllocaInst(exprType); llvm::Value *expr1Ptr = ctx->AllocaInst(exprType);
llvm::Value *expr2Ptr = ctx->AllocaInst(exprType); llvm::Value *expr2Ptr = ctx->AllocaInst(exprType);
@@ -3690,7 +3690,7 @@ ExprList::GetConstant(const Type *type) const {
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *llvmType = elementType->LLVMType(g->ctx); llvm::Type *llvmType = elementType->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -3701,23 +3701,23 @@ ExprList::GetConstant(const Type *type) const {
} }
if (dynamic_cast<const StructType *>(type) != NULL) { if (dynamic_cast<const StructType *>(type) != NULL) {
LLVM_TYPE_CONST llvm::StructType *llvmStructType = llvm::StructType *llvmStructType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::StructType>(collectionType->LLVMType(g->ctx)); llvm::dyn_cast<llvm::StructType>(collectionType->LLVMType(g->ctx));
Assert(llvmStructType != NULL); Assert(llvmStructType != NULL);
return llvm::ConstantStruct::get(llvmStructType, cv); return llvm::ConstantStruct::get(llvmStructType, cv);
} }
else { else {
LLVM_TYPE_CONST llvm::Type *lt = type->LLVMType(g->ctx); llvm::Type *lt = type->LLVMType(g->ctx);
LLVM_TYPE_CONST llvm::ArrayType *lat = llvm::ArrayType *lat =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(lt); llvm::dyn_cast<llvm::ArrayType>(lt);
if (lat != NULL) if (lat != NULL)
return llvm::ConstantArray::get(lat, cv); return llvm::ConstantArray::get(lat, cv);
else { else {
// uniform short vector type // uniform short vector type
Assert(type->IsUniformType() && Assert(type->IsUniformType() &&
dynamic_cast<const VectorType *>(type) != NULL); dynamic_cast<const VectorType *>(type) != NULL);
LLVM_TYPE_CONST llvm::VectorType *lvt = llvm::VectorType *lvt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(lt); llvm::dyn_cast<llvm::VectorType>(lt);
Assert(lvt != NULL); Assert(lvt != NULL);
// Uniform short vectors are stored as vectors of length // Uniform short vectors are stored as vectors of length
@@ -3994,10 +3994,10 @@ IndexExpr::GetBaseSymbol() const {
static llvm::Value * static llvm::Value *
lConvertToSlicePointer(FunctionEmitContext *ctx, llvm::Value *ptr, lConvertToSlicePointer(FunctionEmitContext *ctx, llvm::Value *ptr,
const PointerType *slicePtrType) { const PointerType *slicePtrType) {
LLVM_TYPE_CONST llvm::Type *llvmSlicePtrType = llvm::Type *llvmSlicePtrType =
slicePtrType->LLVMType(g->ctx); slicePtrType->LLVMType(g->ctx);
LLVM_TYPE_CONST llvm::StructType *sliceStructType = llvm::StructType *sliceStructType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::StructType>(llvmSlicePtrType); llvm::dyn_cast<llvm::StructType>(llvmSlicePtrType);
Assert(sliceStructType != NULL && Assert(sliceStructType != NULL &&
sliceStructType->getElementType(0) == ptr->getType()); sliceStructType->getElementType(0) == ptr->getType());
@@ -5675,7 +5675,7 @@ ConstExpr::GetConstant(const Type *type) const {
// The only time we should get here is if we have an integer '0' // The only time we should get here is if we have an integer '0'
// constant that should be turned into a NULL pointer of the // constant that should be turned into a NULL pointer of the
// appropriate type. // appropriate type.
LLVM_TYPE_CONST llvm::Type *llvmType = type->LLVMType(g->ctx); llvm::Type *llvmType = type->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -5788,7 +5788,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
switch (toType->basicType) { switch (toType->basicType) {
case AtomicType::TYPE_FLOAT: { case AtomicType::TYPE_FLOAT: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::FloatType : fromType->IsUniformType() ? LLVMTypes::FloatType :
LLVMTypes::FloatVectorType; LLVMTypes::FloatVectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -5832,7 +5832,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_DOUBLE: { case AtomicType::TYPE_DOUBLE: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::DoubleType : fromType->IsUniformType() ? LLVMTypes::DoubleType :
LLVMTypes::DoubleVectorType; LLVMTypes::DoubleVectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -5870,7 +5870,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_INT8: { case AtomicType::TYPE_INT8: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int8Type : fromType->IsUniformType() ? LLVMTypes::Int8Type :
LLVMTypes::Int8VectorType; LLVMTypes::Int8VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -5906,7 +5906,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_UINT8: { case AtomicType::TYPE_UINT8: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int8Type : fromType->IsUniformType() ? LLVMTypes::Int8Type :
LLVMTypes::Int8VectorType; LLVMTypes::Int8VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -5948,7 +5948,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_INT16: { case AtomicType::TYPE_INT16: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int16Type : fromType->IsUniformType() ? LLVMTypes::Int16Type :
LLVMTypes::Int16VectorType; LLVMTypes::Int16VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -5988,7 +5988,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_UINT16: { case AtomicType::TYPE_UINT16: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int16Type : fromType->IsUniformType() ? LLVMTypes::Int16Type :
LLVMTypes::Int16VectorType; LLVMTypes::Int16VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -6034,7 +6034,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_INT32: { case AtomicType::TYPE_INT32: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int32Type : fromType->IsUniformType() ? LLVMTypes::Int32Type :
LLVMTypes::Int32VectorType; LLVMTypes::Int32VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -6074,7 +6074,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_UINT32: { case AtomicType::TYPE_UINT32: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int32Type : fromType->IsUniformType() ? LLVMTypes::Int32Type :
LLVMTypes::Int32VectorType; LLVMTypes::Int32VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -6120,7 +6120,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_INT64: { case AtomicType::TYPE_INT64: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int64Type : fromType->IsUniformType() ? LLVMTypes::Int64Type :
LLVMTypes::Int64VectorType; LLVMTypes::Int64VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -6158,7 +6158,7 @@ lTypeConvAtomic(FunctionEmitContext *ctx, llvm::Value *exprVal,
break; break;
} }
case AtomicType::TYPE_UINT64: { case AtomicType::TYPE_UINT64: {
LLVM_TYPE_CONST llvm::Type *targetType = llvm::Type *targetType =
fromType->IsUniformType() ? LLVMTypes::Int64Type : fromType->IsUniformType() ? LLVMTypes::Int64Type :
LLVMTypes::Int64VectorType; LLVMTypes::Int64VectorType;
switch (fromType->basicType) { switch (fromType->basicType) {
@@ -6302,7 +6302,7 @@ lUniformValueToVarying(FunctionEmitContext *ctx, llvm::Value *value,
const CollectionType *collectionType = const CollectionType *collectionType =
dynamic_cast<const CollectionType *>(type); dynamic_cast<const CollectionType *>(type);
if (collectionType != NULL) { if (collectionType != NULL) {
LLVM_TYPE_CONST llvm::Type *llvmType = llvm::Type *llvmType =
type->GetAsVaryingType()->LLVMType(g->ctx); type->GetAsVaryingType()->LLVMType(g->ctx);
llvm::Value *retValue = llvm::UndefValue::get(llvmType); llvm::Value *retValue = llvm::UndefValue::get(llvmType);
@@ -6404,10 +6404,10 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
Assert(dynamic_cast<const AtomicType *>(toType) != NULL); Assert(dynamic_cast<const AtomicType *>(toType) != NULL);
if (toType->IsBoolType()) { if (toType->IsBoolType()) {
// convert pointer to bool // convert pointer to bool
LLVM_TYPE_CONST llvm::Type *lfu = llvm::Type *lfu =
fromType->GetAsUniformType()->LLVMType(g->ctx); fromType->GetAsUniformType()->LLVMType(g->ctx);
LLVM_TYPE_CONST llvm::PointerType *llvmFromUnifType = llvm::PointerType *llvmFromUnifType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(lfu); llvm::dyn_cast<llvm::PointerType>(lfu);
llvm::Value *nullPtrValue = llvm::Value *nullPtrValue =
llvm::ConstantPointerNull::get(llvmFromUnifType); llvm::ConstantPointerNull::get(llvmFromUnifType);
@@ -6436,7 +6436,7 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
if (toType->IsVaryingType() && fromType->IsUniformType()) if (toType->IsVaryingType() && fromType->IsUniformType())
value = ctx->SmearUniform(value); value = ctx->SmearUniform(value);
LLVM_TYPE_CONST llvm::Type *llvmToType = toType->LLVMType(g->ctx); llvm::Type *llvmToType = toType->LLVMType(g->ctx);
if (llvmToType == NULL) if (llvmToType == NULL)
return NULL; return NULL;
return ctx->PtrToIntInst(value, llvmToType, "ptr_typecast"); return ctx->PtrToIntInst(value, llvmToType, "ptr_typecast");
@@ -6479,7 +6479,7 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
Assert(Type::EqualIgnoringConst(toArrayType->GetBaseType(), Assert(Type::EqualIgnoringConst(toArrayType->GetBaseType(),
fromArrayType->GetBaseType())); fromArrayType->GetBaseType()));
llvm::Value *v = expr->GetValue(ctx); llvm::Value *v = expr->GetValue(ctx);
LLVM_TYPE_CONST llvm::Type *ptype = toType->LLVMType(g->ctx); llvm::Type *ptype = toType->LLVMType(g->ctx);
return ctx->BitCastInst(v, ptype); //, "array_cast_0size"); return ctx->BitCastInst(v, ptype); //, "array_cast_0size");
} }
@@ -6501,7 +6501,7 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
Assert(Type::EqualIgnoringConst(toArray->GetBaseType(), Assert(Type::EqualIgnoringConst(toArray->GetBaseType(),
fromArray->GetBaseType())); fromArray->GetBaseType()));
llvm::Value *v = expr->GetValue(ctx); llvm::Value *v = expr->GetValue(ctx);
LLVM_TYPE_CONST llvm::Type *ptype = toType->LLVMType(g->ctx); llvm::Type *ptype = toType->LLVMType(g->ctx);
return ctx->BitCastInst(v, ptype); //, "array_cast_0size"); return ctx->BitCastInst(v, ptype); //, "array_cast_0size");
} }
@@ -6589,7 +6589,7 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
if (toType->IsVaryingType() && fromType->IsUniformType()) if (toType->IsVaryingType() && fromType->IsUniformType())
exprVal = ctx->SmearUniform(exprVal); exprVal = ctx->SmearUniform(exprVal);
LLVM_TYPE_CONST llvm::Type *llvmToType = toType->LLVMType(g->ctx); llvm::Type *llvmToType = toType->LLVMType(g->ctx);
if (llvmToType == NULL) if (llvmToType == NULL)
return NULL; return NULL;
@@ -6828,7 +6828,7 @@ lConvertPointerConstant(llvm::Constant *c, const Type *constType) {
if (constType->IsVaryingType()) if (constType->IsVaryingType())
return llvm::ConstantVector::get(smear); return llvm::ConstantVector::get(smear);
else { else {
LLVM_TYPE_CONST llvm::ArrayType *at = llvm::ArrayType *at =
llvm::ArrayType::get(LLVMTypes::PointerIntType, count); llvm::ArrayType::get(LLVMTypes::PointerIntType, count);
return llvm::ConstantArray::get(at, smear); return llvm::ConstantArray::get(at, smear);
} }
@@ -6881,7 +6881,7 @@ ReferenceExpr::GetValue(FunctionEmitContext *ctx) const {
// value is NULL if the expression is a temporary; in this case, we'll // value is NULL if the expression is a temporary; in this case, we'll
// allocate storage for it so that we can return the pointer to that... // allocate storage for it so that we can return the pointer to that...
const Type *type; const Type *type;
LLVM_TYPE_CONST llvm::Type *llvmType; llvm::Type *llvmType;
if ((type = expr->GetType()) == NULL || if ((type = expr->GetType()) == NULL ||
(llvmType = type->LLVMType(g->ctx)) == NULL) { (llvmType = type->LLVMType(g->ctx)) == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -7299,7 +7299,7 @@ SizeOfExpr::GetValue(FunctionEmitContext *ctx) const {
if (t == NULL) if (t == NULL)
return NULL; return NULL;
LLVM_TYPE_CONST llvm::Type *llvmType = t->LLVMType(g->ctx); llvm::Type *llvmType = t->LLVMType(g->ctx);
if (llvmType == NULL) if (llvmType == NULL)
return NULL; return NULL;
@@ -7913,7 +7913,7 @@ NullPointerExpr::GetConstant(const Type *type) const {
if (pt == NULL) if (pt == NULL)
return NULL; return NULL;
LLVM_TYPE_CONST llvm::Type *llvmType = type->LLVMType(g->ctx); llvm::Type *llvmType = type->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -8059,7 +8059,7 @@ NewExpr::GetValue(FunctionEmitContext *ctx) const {
// Initialize the memory pointed to by the pointer for the // Initialize the memory pointed to by the pointer for the
// current lane. // current lane.
ctx->SetCurrentBasicBlock(bbInit); ctx->SetCurrentBasicBlock(bbInit);
LLVM_TYPE_CONST llvm::Type *ptrType = llvm::Type *ptrType =
retType->GetAsUniformType()->LLVMType(g->ctx); retType->GetAsUniformType()->LLVMType(g->ctx);
llvm::Value *ptr = ctx->IntToPtrInst(p, ptrType); llvm::Value *ptr = ctx->IntToPtrInst(p, ptrType);
InitSymbol(ptr, allocType, initExpr, ctx, pos); InitSymbol(ptr, allocType, initExpr, ctx, pos);
@@ -8075,7 +8075,7 @@ NewExpr::GetValue(FunctionEmitContext *ctx) const {
// For uniform news, we just need to cast the void * to be a // For uniform news, we just need to cast the void * to be a
// pointer of the return type and to run the code for initializers, // pointer of the return type and to run the code for initializers,
// if present. // if present.
LLVM_TYPE_CONST llvm::Type *ptrType = retType->LLVMType(g->ctx); llvm::Type *ptrType = retType->LLVMType(g->ctx);
ptrValue = ctx->BitCastInst(ptrValue, ptrType, "cast_new_ptr"); ptrValue = ctx->BitCastInst(ptrValue, ptrType, "cast_new_ptr");
if (initExpr != NULL) if (initExpr != NULL)

4
func.cpp
View File

@@ -165,7 +165,7 @@ lCopyInTaskParameter(int i, llvm::Value *structArgPtr, const
llvm::dyn_cast<const llvm::StructType>(pt->getElementType()); llvm::dyn_cast<const llvm::StructType>(pt->getElementType());
// Get the type of the argument we're copying in and its Symbol pointer // Get the type of the argument we're copying in and its Symbol pointer
LLVM_TYPE_CONST llvm::Type *argType = argStructType->getElementType(i); llvm::Type *argType = argStructType->getElementType(i);
Symbol *sym = args[i]; Symbol *sym = args[i];
if (sym == NULL) if (sym == NULL)
@@ -435,7 +435,7 @@ Function::GenerateIR() {
Assert(type != NULL); Assert(type != NULL);
if (type->isExported) { if (type->isExported) {
if (!type->isTask) { if (!type->isTask) {
LLVM_TYPE_CONST llvm::FunctionType *ftype = llvm::FunctionType *ftype =
type->LLVMFunctionType(g->ctx); type->LLVMFunctionType(g->ctx);
llvm::GlobalValue::LinkageTypes linkage = llvm::GlobalValue::ExternalLinkage; llvm::GlobalValue::LinkageTypes linkage = llvm::GlobalValue::ExternalLinkage;
std::string functionName = sym->name; std::string functionName = sym->name;

28
ispc.cpp
View File

@@ -457,7 +457,7 @@ Target::GetISAString() const {
static bool static bool
lGenericTypeLayoutIndeterminate(LLVM_TYPE_CONST llvm::Type *type) { lGenericTypeLayoutIndeterminate(llvm::Type *type) {
if (type->isPrimitiveType() || type->isIntegerTy()) if (type->isPrimitiveType() || type->isIntegerTy())
return false; return false;
@@ -466,18 +466,18 @@ lGenericTypeLayoutIndeterminate(LLVM_TYPE_CONST llvm::Type *type) {
type == LLVMTypes::Int1VectorType) type == LLVMTypes::Int1VectorType)
return true; return true;
LLVM_TYPE_CONST llvm::ArrayType *at = llvm::ArrayType *at =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(type); llvm::dyn_cast<llvm::ArrayType>(type);
if (at != NULL) if (at != NULL)
return lGenericTypeLayoutIndeterminate(at->getElementType()); return lGenericTypeLayoutIndeterminate(at->getElementType());
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(type); llvm::dyn_cast<llvm::PointerType>(type);
if (pt != NULL) if (pt != NULL)
return false; return false;
LLVM_TYPE_CONST llvm::StructType *st = llvm::StructType *st =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::StructType>(type); llvm::dyn_cast<llvm::StructType>(type);
if (st != NULL) { if (st != NULL) {
for (int i = 0; i < (int)st->getNumElements(); ++i) for (int i = 0; i < (int)st->getNumElements(); ++i)
if (lGenericTypeLayoutIndeterminate(st->getElementType(i))) if (lGenericTypeLayoutIndeterminate(st->getElementType(i)))
@@ -485,18 +485,18 @@ lGenericTypeLayoutIndeterminate(LLVM_TYPE_CONST llvm::Type *type) {
return false; return false;
} }
Assert(llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(type)); Assert(llvm::isa<llvm::VectorType>(type));
return true; return true;
} }
llvm::Value * llvm::Value *
Target::SizeOf(LLVM_TYPE_CONST llvm::Type *type, Target::SizeOf(llvm::Type *type,
llvm::BasicBlock *insertAtEnd) { llvm::BasicBlock *insertAtEnd) {
if (isa == Target::GENERIC && if (isa == Target::GENERIC &&
lGenericTypeLayoutIndeterminate(type)) { lGenericTypeLayoutIndeterminate(type)) {
llvm::Value *index[1] = { LLVMInt32(1) }; llvm::Value *index[1] = { LLVMInt32(1) };
LLVM_TYPE_CONST llvm::PointerType *ptrType = llvm::PointerType::get(type, 0); llvm::PointerType *ptrType = llvm::PointerType::get(type, 0);
llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType); llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType);
#if defined(LLVM_3_0) || defined(LLVM_3_0svn) || defined(LLVM_3_1svn) #if defined(LLVM_3_0) || defined(LLVM_3_0svn) || defined(LLVM_3_1svn)
llvm::ArrayRef<llvm::Value *> arrayRef(&index[0], &index[1]); llvm::ArrayRef<llvm::Value *> arrayRef(&index[0], &index[1]);
@@ -529,12 +529,12 @@ Target::SizeOf(LLVM_TYPE_CONST llvm::Type *type,
llvm::Value * llvm::Value *
Target::StructOffset(LLVM_TYPE_CONST llvm::Type *type, int element, Target::StructOffset(llvm::Type *type, int element,
llvm::BasicBlock *insertAtEnd) { llvm::BasicBlock *insertAtEnd) {
if (isa == Target::GENERIC && if (isa == Target::GENERIC &&
lGenericTypeLayoutIndeterminate(type) == true) { lGenericTypeLayoutIndeterminate(type) == true) {
llvm::Value *indices[2] = { LLVMInt32(0), LLVMInt32(element) }; llvm::Value *indices[2] = { LLVMInt32(0), LLVMInt32(element) };
LLVM_TYPE_CONST llvm::PointerType *ptrType = llvm::PointerType::get(type, 0); llvm::PointerType *ptrType = llvm::PointerType::get(type, 0);
llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType); llvm::Value *voidPtr = llvm::ConstantPointerNull::get(ptrType);
#if defined(LLVM_3_0) || defined(LLVM_3_0svn) || defined(LLVM_3_1svn) #if defined(LLVM_3_0) || defined(LLVM_3_0svn) || defined(LLVM_3_1svn)
llvm::ArrayRef<llvm::Value *> arrayRef(&indices[0], &indices[2]); llvm::ArrayRef<llvm::Value *> arrayRef(&indices[0], &indices[2]);
@@ -556,8 +556,8 @@ Target::StructOffset(LLVM_TYPE_CONST llvm::Type *type, int element,
const llvm::TargetData *td = GetTargetMachine()->getTargetData(); const llvm::TargetData *td = GetTargetMachine()->getTargetData();
Assert(td != NULL); Assert(td != NULL);
LLVM_TYPE_CONST llvm::StructType *structType = llvm::StructType *structType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::StructType>(type); llvm::dyn_cast<llvm::StructType>(type);
Assert(structType != NULL); Assert(structType != NULL);
const llvm::StructLayout *sl = td->getStructLayout(structType); const llvm::StructLayout *sl = td->getStructLayout(structType);
Assert(sl != NULL); Assert(sl != NULL);

10
ispc.h
View File

@@ -92,12 +92,6 @@ namespace llvm {
class Value; class Value;
} }
// llvm::Type *s are no longer const in llvm 3.0
#if defined(LLVM_3_0) || defined(LLVM_3_0svn) || defined(LLVM_3_1svn)
#define LLVM_TYPE_CONST
#else
#define LLVM_TYPE_CONST const
#endif
class ArrayType; class ArrayType;
class AST; class AST;
@@ -191,13 +185,13 @@ struct Target {
const char *GetISAString() const; const char *GetISAString() const;
/** Returns the size of the given type */ /** Returns the size of the given type */
llvm::Value *SizeOf(LLVM_TYPE_CONST llvm::Type *type, llvm::Value *SizeOf(llvm::Type *type,
llvm::BasicBlock *insertAtEnd); llvm::BasicBlock *insertAtEnd);
/** Given a structure type and an element number in the structure, /** Given a structure type and an element number in the structure,
returns a value corresponding to the number of bytes from the start returns a value corresponding to the number of bytes from the start
of the structure where the element is located. */ of the structure where the element is located. */
llvm::Value *StructOffset(LLVM_TYPE_CONST llvm::Type *type, llvm::Value *StructOffset(llvm::Type *type,
int element, llvm::BasicBlock *insertAtEnd); int element, llvm::BasicBlock *insertAtEnd);
/** llvm Target object representing this target. */ /** llvm Target object representing this target. */

102
llvmutil.cpp
View File

@@ -43,44 +43,44 @@
#include <set> #include <set>
#include <map> #include <map>
LLVM_TYPE_CONST llvm::Type *LLVMTypes::VoidType = NULL; llvm::Type *LLVMTypes::VoidType = NULL;
LLVM_TYPE_CONST llvm::PointerType *LLVMTypes::VoidPointerType = NULL; llvm::PointerType *LLVMTypes::VoidPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::PointerIntType = NULL; llvm::Type *LLVMTypes::PointerIntType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::BoolType = NULL; llvm::Type *LLVMTypes::BoolType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int8Type = NULL; llvm::Type *LLVMTypes::Int8Type = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int16Type = NULL; llvm::Type *LLVMTypes::Int16Type = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int32Type = NULL; llvm::Type *LLVMTypes::Int32Type = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int64Type = NULL; llvm::Type *LLVMTypes::Int64Type = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::FloatType = NULL; llvm::Type *LLVMTypes::FloatType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::DoubleType = NULL; llvm::Type *LLVMTypes::DoubleType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int8PointerType = NULL; llvm::Type *LLVMTypes::Int8PointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int16PointerType = NULL; llvm::Type *LLVMTypes::Int16PointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int32PointerType = NULL; llvm::Type *LLVMTypes::Int32PointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int64PointerType = NULL; llvm::Type *LLVMTypes::Int64PointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::FloatPointerType = NULL; llvm::Type *LLVMTypes::FloatPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::DoublePointerType = NULL; llvm::Type *LLVMTypes::DoublePointerType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::MaskType = NULL; llvm::VectorType *LLVMTypes::MaskType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::BoolVectorType = NULL; llvm::VectorType *LLVMTypes::BoolVectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::Int1VectorType = NULL; llvm::VectorType *LLVMTypes::Int1VectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::Int8VectorType = NULL; llvm::VectorType *LLVMTypes::Int8VectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::Int16VectorType = NULL; llvm::VectorType *LLVMTypes::Int16VectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::Int32VectorType = NULL; llvm::VectorType *LLVMTypes::Int32VectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::Int64VectorType = NULL; llvm::VectorType *LLVMTypes::Int64VectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::FloatVectorType = NULL; llvm::VectorType *LLVMTypes::FloatVectorType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::DoubleVectorType = NULL; llvm::VectorType *LLVMTypes::DoubleVectorType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int8VectorPointerType = NULL; llvm::Type *LLVMTypes::Int8VectorPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int16VectorPointerType = NULL; llvm::Type *LLVMTypes::Int16VectorPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int32VectorPointerType = NULL; llvm::Type *LLVMTypes::Int32VectorPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::Int64VectorPointerType = NULL; llvm::Type *LLVMTypes::Int64VectorPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::FloatVectorPointerType = NULL; llvm::Type *LLVMTypes::FloatVectorPointerType = NULL;
LLVM_TYPE_CONST llvm::Type *LLVMTypes::DoubleVectorPointerType = NULL; llvm::Type *LLVMTypes::DoubleVectorPointerType = NULL;
LLVM_TYPE_CONST llvm::VectorType *LLVMTypes::VoidPointerVectorType = NULL; llvm::VectorType *LLVMTypes::VoidPointerVectorType = NULL;
llvm::Constant *LLVMTrue = NULL; llvm::Constant *LLVMTrue = NULL;
llvm::Constant *LLVMFalse = NULL; llvm::Constant *LLVMFalse = NULL;
@@ -473,9 +473,9 @@ LLVMBoolVector(const bool *bvec) {
llvm::Constant * llvm::Constant *
LLVMIntAsType(int64_t val, LLVM_TYPE_CONST llvm::Type *type) { LLVMIntAsType(int64_t val, llvm::Type *type) {
LLVM_TYPE_CONST llvm::VectorType *vecType = llvm::VectorType *vecType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(type); llvm::dyn_cast<llvm::VectorType>(type);
if (vecType != NULL) { if (vecType != NULL) {
llvm::Constant *v = llvm::ConstantInt::get(vecType->getElementType(), llvm::Constant *v = llvm::ConstantInt::get(vecType->getElementType(),
@@ -491,9 +491,9 @@ LLVMIntAsType(int64_t val, LLVM_TYPE_CONST llvm::Type *type) {
llvm::Constant * llvm::Constant *
LLVMUIntAsType(uint64_t val, LLVM_TYPE_CONST llvm::Type *type) { LLVMUIntAsType(uint64_t val, llvm::Type *type) {
LLVM_TYPE_CONST llvm::VectorType *vecType = llvm::VectorType *vecType =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(type); llvm::dyn_cast<llvm::VectorType>(type);
if (vecType != NULL) { if (vecType != NULL) {
llvm::Constant *v = llvm::ConstantInt::get(vecType->getElementType(), llvm::Constant *v = llvm::ConstantInt::get(vecType->getElementType(),
@@ -642,8 +642,8 @@ LLVMFlattenInsertChain(llvm::InsertElementInst *ie, int vectorWidth,
bool bool
LLVMExtractVectorInts(llvm::Value *v, int64_t ret[], int *nElts) { LLVMExtractVectorInts(llvm::Value *v, int64_t ret[], int *nElts) {
// Make sure we do in fact have a vector of integer values here // Make sure we do in fact have a vector of integer values here
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(v->getType()); llvm::dyn_cast<llvm::VectorType>(v->getType());
Assert(vt != NULL); Assert(vt != NULL);
Assert(llvm::isa<llvm::IntegerType>(vt->getElementType())); Assert(llvm::isa<llvm::IntegerType>(vt->getElementType()));
@@ -696,7 +696,7 @@ lVectorValuesAllEqual(llvm::Value *v, int vectorLength,
static bool static bool
lIsExactMultiple(llvm::Value *val, int baseValue, int vectorLength, lIsExactMultiple(llvm::Value *val, int baseValue, int vectorLength,
std::vector<llvm::PHINode *> &seenPhis) { std::vector<llvm::PHINode *> &seenPhis) {
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(val->getType()) == false) { if (llvm::isa<llvm::VectorType>(val->getType()) == false) {
// If we've worked down to a constant int, then the moment of truth // If we've worked down to a constant int, then the moment of truth
// has arrived... // has arrived...
llvm::ConstantInt *ci = llvm::dyn_cast<llvm::ConstantInt>(val); llvm::ConstantInt *ci = llvm::dyn_cast<llvm::ConstantInt>(val);
@@ -780,7 +780,7 @@ static bool
lAllDivBaseEqual(llvm::Value *val, int64_t baseValue, int vectorLength, lAllDivBaseEqual(llvm::Value *val, int64_t baseValue, int vectorLength,
std::vector<llvm::PHINode *> &seenPhis, std::vector<llvm::PHINode *> &seenPhis,
bool &canAdd) { bool &canAdd) {
Assert(llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(val->getType())); Assert(llvm::isa<llvm::VectorType>(val->getType()));
// Make sure the base value is a positive power of 2 // Make sure the base value is a positive power of 2
Assert(baseValue > 0 && (baseValue & (baseValue-1)) == 0); Assert(baseValue > 0 && (baseValue & (baseValue-1)) == 0);
@@ -790,7 +790,7 @@ lAllDivBaseEqual(llvm::Value *val, int64_t baseValue, int vectorLength,
int64_t vecVals[ISPC_MAX_NVEC]; int64_t vecVals[ISPC_MAX_NVEC];
int nElts; int nElts;
if (llvm::isa<LLVM_TYPE_CONST llvm::VectorType>(val->getType()) && if (llvm::isa<llvm::VectorType>(val->getType()) &&
LLVMExtractVectorInts(val, vecVals, &nElts)) { LLVMExtractVectorInts(val, vecVals, &nElts)) {
// If we have a vector of compile-time constant integer values, // If we have a vector of compile-time constant integer values,
// then go ahead and check them directly.. // then go ahead and check them directly..
@@ -1074,8 +1074,8 @@ lVectorValuesAllEqual(llvm::Value *v, int vectorLength,
*/ */
bool bool
LLVMVectorValuesAllEqual(llvm::Value *v) { LLVMVectorValuesAllEqual(llvm::Value *v) {
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(v->getType()); llvm::dyn_cast<llvm::VectorType>(v->getType());
Assert(vt != NULL); Assert(vt != NULL);
int vectorLength = vt->getNumElements(); int vectorLength = vt->getNumElements();
@@ -1344,8 +1344,8 @@ lVectorIsLinear(llvm::Value *v, int vectorLength, int stride,
*/ */
bool bool
LLVMVectorIsLinear(llvm::Value *v, int stride) { LLVMVectorIsLinear(llvm::Value *v, int stride) {
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(v->getType()); llvm::dyn_cast<llvm::VectorType>(v->getType());
Assert(vt != NULL); Assert(vt != NULL);
int vectorLength = vt->getNumElements(); int vectorLength = vt->getNumElements();
@@ -1399,8 +1399,8 @@ lExtractFirstVectorElement(llvm::Value *v, llvm::Instruction *insertBefore,
return llvm::ExtractElementInst::Create(v, LLVMInt32(0), "first_elt", return llvm::ExtractElementInst::Create(v, LLVMInt32(0), "first_elt",
insertBefore); insertBefore);
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(v->getType()); llvm::dyn_cast<llvm::VectorType>(v->getType());
Assert(vt != NULL); Assert(vt != NULL);
std::string newName = v->getName().str() + std::string(".elt0"); std::string newName = v->getName().str() + std::string(".elt0");
@@ -1489,8 +1489,8 @@ LLVMConcatVectors(llvm::Value *v1, llvm::Value *v2,
llvm::Instruction *insertBefore) { llvm::Instruction *insertBefore) {
Assert(v1->getType() == v2->getType()); Assert(v1->getType() == v2->getType());
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(v1->getType()); llvm::dyn_cast<llvm::VectorType>(v1->getType());
Assert(vt != NULL); Assert(vt != NULL);
int32_t identity[ISPC_MAX_NVEC]; int32_t identity[ISPC_MAX_NVEC];

71
llvmutil.h
View File

@@ -48,53 +48,50 @@ namespace llvm {
class InsertElementInst; class InsertElementInst;
} }
// llvm::Type *s are no longer const in llvm 3.0
#define LLVM_TYPE_CONST
/** This structure holds pointers to a variety of LLVM types; code /** This structure holds pointers to a variety of LLVM types; code
elsewhere can use them from here, ratherthan needing to make more elsewhere can use them from here, ratherthan needing to make more
verbose LLVM API calls. verbose LLVM API calls.
*/ */
struct LLVMTypes { struct LLVMTypes {
static LLVM_TYPE_CONST llvm::Type *VoidType; static llvm::Type *VoidType;
static LLVM_TYPE_CONST llvm::PointerType *VoidPointerType; static llvm::PointerType *VoidPointerType;
static LLVM_TYPE_CONST llvm::Type *PointerIntType; static llvm::Type *PointerIntType;
static LLVM_TYPE_CONST llvm::Type *BoolType; static llvm::Type *BoolType;
static LLVM_TYPE_CONST llvm::Type *Int8Type; static llvm::Type *Int8Type;
static LLVM_TYPE_CONST llvm::Type *Int16Type; static llvm::Type *Int16Type;
static LLVM_TYPE_CONST llvm::Type *Int32Type; static llvm::Type *Int32Type;
static LLVM_TYPE_CONST llvm::Type *Int64Type; static llvm::Type *Int64Type;
static LLVM_TYPE_CONST llvm::Type *FloatType; static llvm::Type *FloatType;
static LLVM_TYPE_CONST llvm::Type *DoubleType; static llvm::Type *DoubleType;
static LLVM_TYPE_CONST llvm::Type *Int8PointerType; static llvm::Type *Int8PointerType;
static LLVM_TYPE_CONST llvm::Type *Int16PointerType; static llvm::Type *Int16PointerType;
static LLVM_TYPE_CONST llvm::Type *Int32PointerType; static llvm::Type *Int32PointerType;
static LLVM_TYPE_CONST llvm::Type *Int64PointerType; static llvm::Type *Int64PointerType;
static LLVM_TYPE_CONST llvm::Type *FloatPointerType; static llvm::Type *FloatPointerType;
static LLVM_TYPE_CONST llvm::Type *DoublePointerType; static llvm::Type *DoublePointerType;
static LLVM_TYPE_CONST llvm::VectorType *MaskType; static llvm::VectorType *MaskType;
static LLVM_TYPE_CONST llvm::VectorType *BoolVectorType; static llvm::VectorType *BoolVectorType;
static LLVM_TYPE_CONST llvm::VectorType *Int1VectorType; static llvm::VectorType *Int1VectorType;
static LLVM_TYPE_CONST llvm::VectorType *Int8VectorType; static llvm::VectorType *Int8VectorType;
static LLVM_TYPE_CONST llvm::VectorType *Int16VectorType; static llvm::VectorType *Int16VectorType;
static LLVM_TYPE_CONST llvm::VectorType *Int32VectorType; static llvm::VectorType *Int32VectorType;
static LLVM_TYPE_CONST llvm::VectorType *Int64VectorType; static llvm::VectorType *Int64VectorType;
static LLVM_TYPE_CONST llvm::VectorType *FloatVectorType; static llvm::VectorType *FloatVectorType;
static LLVM_TYPE_CONST llvm::VectorType *DoubleVectorType; static llvm::VectorType *DoubleVectorType;
static LLVM_TYPE_CONST llvm::Type *Int8VectorPointerType; static llvm::Type *Int8VectorPointerType;
static LLVM_TYPE_CONST llvm::Type *Int16VectorPointerType; static llvm::Type *Int16VectorPointerType;
static LLVM_TYPE_CONST llvm::Type *Int32VectorPointerType; static llvm::Type *Int32VectorPointerType;
static LLVM_TYPE_CONST llvm::Type *Int64VectorPointerType; static llvm::Type *Int64VectorPointerType;
static LLVM_TYPE_CONST llvm::Type *FloatVectorPointerType; static llvm::Type *FloatVectorPointerType;
static LLVM_TYPE_CONST llvm::Type *DoubleVectorPointerType; static llvm::Type *DoubleVectorPointerType;
static LLVM_TYPE_CONST llvm::VectorType *VoidPointerVectorType; static llvm::VectorType *VoidPointerVectorType;
}; };
/** These variables hold the corresponding LLVM constant values as a /** These variables hold the corresponding LLVM constant values as a
@@ -171,11 +168,11 @@ extern llvm::Constant *LLVMDoubleVector(double f);
/** Returns a constant integer or vector (according to the given type) of /** Returns a constant integer or vector (according to the given type) of
the given signed integer value. */ the given signed integer value. */
extern llvm::Constant *LLVMIntAsType(int64_t, LLVM_TYPE_CONST llvm::Type *t); extern llvm::Constant *LLVMIntAsType(int64_t, llvm::Type *t);
/** Returns a constant integer or vector (according to the given type) of /** Returns a constant integer or vector (according to the given type) of
the given unsigned integer value. */ the given unsigned integer value. */
extern llvm::Constant *LLVMUIntAsType(uint64_t, LLVM_TYPE_CONST llvm::Type *t); extern llvm::Constant *LLVMUIntAsType(uint64_t, llvm::Type *t);
/** Returns an LLVM boolean vector based on the given array of values. /** Returns an LLVM boolean vector based on the given array of values.
The array should have g->target.vectorWidth elements. */ The array should have g->target.vectorWidth elements. */

8
module.cpp
View File

@@ -278,7 +278,7 @@ Module::AddGlobalVariable(const std::string &name, const Type *type, Expr *initE
return; return;
} }
LLVM_TYPE_CONST llvm::Type *llvmType = type->LLVMType(g->ctx); llvm::Type *llvmType = type->LLVMType(g->ctx);
if (llvmType == NULL) if (llvmType == NULL)
return; return;
@@ -573,7 +573,7 @@ Module::AddFunctionDeclaration(const std::string &name,
// Get the LLVM FunctionType // Get the LLVM FunctionType
bool includeMask = (storageClass != SC_EXTERN_C); bool includeMask = (storageClass != SC_EXTERN_C);
LLVM_TYPE_CONST llvm::FunctionType *llvmFunctionType = llvm::FunctionType *llvmFunctionType =
functionType->LLVMFunctionType(g->ctx, includeMask); functionType->LLVMFunctionType(g->ctx, includeMask);
if (llvmFunctionType == NULL) if (llvmFunctionType == NULL)
return; return;
@@ -1405,7 +1405,7 @@ lAddExtractedGlobals(llvm::Module *module,
for (unsigned int i = 0; i < globals[firstActive].size(); ++i) { for (unsigned int i = 0; i < globals[firstActive].size(); ++i) {
RewriteGlobalInfo &rgi = globals[firstActive][i]; RewriteGlobalInfo &rgi = globals[firstActive][i];
llvm::GlobalVariable *gv = rgi.gv; llvm::GlobalVariable *gv = rgi.gv;
LLVM_TYPE_CONST llvm::Type *type = gv->getType()->getElementType(); llvm::Type *type = gv->getType()->getElementType();
llvm::Constant *initializer = rgi.init; llvm::Constant *initializer = rgi.init;
// Create a new global in the given model that matches the original // Create a new global in the given model that matches the original
@@ -1469,7 +1469,7 @@ lCreateDispatchFunction(llvm::Module *module, llvm::Function *setISAFunc,
// we'll start by generating an 'extern' declaration of each one that // we'll start by generating an 'extern' declaration of each one that
// we have in the current module so that we can then call out to that. // we have in the current module so that we can then call out to that.
llvm::Function *targetFuncs[Target::NUM_ISAS]; llvm::Function *targetFuncs[Target::NUM_ISAS];
LLVM_TYPE_CONST llvm::FunctionType *ftype = NULL; llvm::FunctionType *ftype = NULL;
for (int i = 0; i < Target::NUM_ISAS; ++i) { for (int i = 0; i < Target::NUM_ISAS; ++i) {
if (funcs.func[i] == NULL) { if (funcs.func[i] == NULL) {

40
opt.cpp
View File

@@ -984,7 +984,7 @@ static llvm::Value *
lCheckForActualPointer(llvm::Value *v) { lCheckForActualPointer(llvm::Value *v) {
if (v == NULL) if (v == NULL)
return NULL; return NULL;
else if (llvm::isa<LLVM_TYPE_CONST llvm::PointerType>(v->getType())) else if (llvm::isa<llvm::PointerType>(v->getType()))
return v; return v;
else if (llvm::isa<llvm::PtrToIntInst>(v)) else if (llvm::isa<llvm::PtrToIntInst>(v))
return v; return v;
@@ -1908,8 +1908,8 @@ MaskedStoreOptPass::runOnBasicBlock(llvm::BasicBlock &bb) {
} }
else if (maskAsInt == allOnMask) { else if (maskAsInt == allOnMask) {
// The mask is all on, so turn this into a regular store // The mask is all on, so turn this into a regular store
LLVM_TYPE_CONST llvm::Type *rvalueType = rvalue->getType(); llvm::Type *rvalueType = rvalue->getType();
LLVM_TYPE_CONST llvm::Type *ptrType = llvm::Type *ptrType =
llvm::PointerType::get(rvalueType, 0); llvm::PointerType::get(rvalueType, 0);
lvalue = new llvm::BitCastInst(lvalue, ptrType, "lvalue_to_ptr_type", callInst); lvalue = new llvm::BitCastInst(lvalue, ptrType, "lvalue_to_ptr_type", callInst);
@@ -2011,7 +2011,7 @@ MaskedLoadOptPass::runOnBasicBlock(llvm::BasicBlock &bb) {
} }
else if (maskAsInt == allOnMask) { else if (maskAsInt == allOnMask) {
// The mask is all on, so turn this into a regular load // The mask is all on, so turn this into a regular load
LLVM_TYPE_CONST llvm::Type *ptrType = llvm::Type *ptrType =
llvm::PointerType::get(callInst->getType(), 0); llvm::PointerType::get(callInst->getType(), 0);
ptr = new llvm::BitCastInst(ptr, ptrType, "ptr_cast_for_load", ptr = new llvm::BitCastInst(ptr, ptrType, "ptr_cast_for_load",
callInst); callInst);
@@ -2069,17 +2069,17 @@ lIsSafeToBlend(llvm::Value *lvalue) {
else { else {
llvm::AllocaInst *ai = llvm::dyn_cast<llvm::AllocaInst>(lvalue); llvm::AllocaInst *ai = llvm::dyn_cast<llvm::AllocaInst>(lvalue);
if (ai) { if (ai) {
LLVM_TYPE_CONST llvm::Type *type = ai->getType(); llvm::Type *type = ai->getType();
LLVM_TYPE_CONST llvm::PointerType *pt = llvm::PointerType *pt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::PointerType>(type); llvm::dyn_cast<llvm::PointerType>(type);
assert(pt != NULL); assert(pt != NULL);
type = pt->getElementType(); type = pt->getElementType();
LLVM_TYPE_CONST llvm::ArrayType *at; llvm::ArrayType *at;
while ((at = llvm::dyn_cast<LLVM_TYPE_CONST llvm::ArrayType>(type))) { while ((at = llvm::dyn_cast<llvm::ArrayType>(type))) {
type = at->getElementType(); type = at->getElementType();
} }
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::dyn_cast<LLVM_TYPE_CONST llvm::VectorType>(type); llvm::dyn_cast<llvm::VectorType>(type);
return (vt != NULL && return (vt != NULL &&
(int)vt->getNumElements() == g->target.vectorWidth); (int)vt->getNumElements() == g->target.vectorWidth);
} }
@@ -2232,7 +2232,7 @@ lComputeCommonPointer(llvm::Value *base, llvm::Value *offsets,
struct ScatterImpInfo { struct ScatterImpInfo {
ScatterImpInfo(const char *pName, const char *msName, ScatterImpInfo(const char *pName, const char *msName,
LLVM_TYPE_CONST llvm::Type *vpt, int a) llvm::Type *vpt, int a)
: align(a) { : align(a) {
pseudoFunc = m->module->getFunction(pName); pseudoFunc = m->module->getFunction(pName);
maskedStoreFunc = m->module->getFunction(msName); maskedStoreFunc = m->module->getFunction(msName);
@@ -2241,7 +2241,7 @@ struct ScatterImpInfo {
} }
llvm::Function *pseudoFunc; llvm::Function *pseudoFunc;
llvm::Function *maskedStoreFunc; llvm::Function *maskedStoreFunc;
LLVM_TYPE_CONST llvm::Type *vecPtrType; llvm::Type *vecPtrType;
const int align; const int align;
}; };
@@ -2742,7 +2742,7 @@ lCoalescePerfInfo(const std::vector<llvm::CallInst *> &coalesceGroup,
*/ */
llvm::Value * llvm::Value *
lGEPAndLoad(llvm::Value *basePtr, int64_t offset, int align, lGEPAndLoad(llvm::Value *basePtr, int64_t offset, int align,
llvm::Instruction *insertBefore, LLVM_TYPE_CONST llvm::Type *type) { llvm::Instruction *insertBefore, llvm::Type *type) {
llvm::Value *ptr = lGEPInst(basePtr, LLVMInt64(offset), "new_base", llvm::Value *ptr = lGEPInst(basePtr, LLVMInt64(offset), "new_base",
insertBefore); insertBefore);
ptr = new llvm::BitCastInst(ptr, llvm::PointerType::get(type, 0), ptr = new llvm::BitCastInst(ptr, llvm::PointerType::get(type, 0),
@@ -2796,7 +2796,7 @@ lEmitLoads(llvm::Value *basePtr, std::vector<CoalescedLoadOp> &loadOps,
} }
case 4: { case 4: {
// 4-wide vector load // 4-wide vector load
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::VectorType::get(LLVMTypes::Int32Type, 4); llvm::VectorType::get(LLVMTypes::Int32Type, 4);
loadOps[i].load = lGEPAndLoad(basePtr, start, align, loadOps[i].load = lGEPAndLoad(basePtr, start, align,
insertBefore, vt); insertBefore, vt);
@@ -2804,7 +2804,7 @@ lEmitLoads(llvm::Value *basePtr, std::vector<CoalescedLoadOp> &loadOps,
} }
case 8: { case 8: {
// 8-wide vector load // 8-wide vector load
LLVM_TYPE_CONST llvm::VectorType *vt = llvm::VectorType *vt =
llvm::VectorType::get(LLVMTypes::Int32Type, 8); llvm::VectorType::get(LLVMTypes::Int32Type, 8);
loadOps[i].load = lGEPAndLoad(basePtr, start, align, loadOps[i].load = lGEPAndLoad(basePtr, start, align,
insertBefore, vt); insertBefore, vt);
@@ -2896,7 +2896,7 @@ lApplyLoad2(llvm::Value *result, const CoalescedLoadOp &load,
Assert(set[elt] == false && set[elt+1] == false); Assert(set[elt] == false && set[elt+1] == false);
// In this case, we bitcast from a 4xi32 to a 2xi64 vector // In this case, we bitcast from a 4xi32 to a 2xi64 vector
LLVM_TYPE_CONST llvm::Type *vec2x64Type = llvm::Type *vec2x64Type =
llvm::VectorType::get(LLVMTypes::Int64Type, 2); llvm::VectorType::get(LLVMTypes::Int64Type, 2);
result = new llvm::BitCastInst(result, vec2x64Type, "to2x64", result = new llvm::BitCastInst(result, vec2x64Type, "to2x64",
insertBefore); insertBefore);
@@ -2908,7 +2908,7 @@ lApplyLoad2(llvm::Value *result, const CoalescedLoadOp &load,
"insert64", insertBefore); "insert64", insertBefore);
// And back to 4xi32. // And back to 4xi32.
LLVM_TYPE_CONST llvm::Type *vec4x32Type = llvm::Type *vec4x32Type =
llvm::VectorType::get(LLVMTypes::Int32Type, 4); llvm::VectorType::get(LLVMTypes::Int32Type, 4);
result = new llvm::BitCastInst(result, vec4x32Type, "to4x32", result = new llvm::BitCastInst(result, vec4x32Type, "to4x32",
insertBefore); insertBefore);
@@ -2988,7 +2988,7 @@ lApplyLoad4(llvm::Value *result, const CoalescedLoadOp &load,
static llvm::Value * static llvm::Value *
lAssemble4Vector(const std::vector<CoalescedLoadOp> &loadOps, lAssemble4Vector(const std::vector<CoalescedLoadOp> &loadOps,
const int64_t offsets[4], llvm::Instruction *insertBefore) { const int64_t offsets[4], llvm::Instruction *insertBefore) {
LLVM_TYPE_CONST llvm::Type *returnType = llvm::Type *returnType =
llvm::VectorType::get(LLVMTypes::Int32Type, 4); llvm::VectorType::get(LLVMTypes::Int32Type, 4);
llvm::Value *result = llvm::UndefValue::get(returnType); llvm::Value *result = llvm::UndefValue::get(returnType);
@@ -3128,7 +3128,7 @@ lApplyLoad12s(llvm::Value *result, const std::vector<CoalescedLoadOp> &loadOps,
static llvm::Value * static llvm::Value *
lAssemble4Vector(const std::vector<CoalescedLoadOp> &loadOps, lAssemble4Vector(const std::vector<CoalescedLoadOp> &loadOps,
const int64_t offsets[4], llvm::Instruction *insertBefore) { const int64_t offsets[4], llvm::Instruction *insertBefore) {
LLVM_TYPE_CONST llvm::Type *returnType = llvm::Type *returnType =
llvm::VectorType::get(LLVMTypes::Int32Type, 4); llvm::VectorType::get(LLVMTypes::Int32Type, 4);
llvm::Value *result = llvm::UndefValue::get(returnType); llvm::Value *result = llvm::UndefValue::get(returnType);

8
stmt.cpp
View File

@@ -189,7 +189,7 @@ DeclStmt::EmitCode(FunctionEmitContext *ctx) const {
} }
} }
LLVM_TYPE_CONST llvm::Type *llvmType = sym->type->LLVMType(g->ctx); llvm::Type *llvmType = sym->type->LLVMType(g->ctx);
if (llvmType == NULL) { if (llvmType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return; return;
@@ -2497,7 +2497,7 @@ lProcessPrintArg(Expr *expr, FunctionEmitContext *ctx, std::string &argTypes) {
else { else {
argTypes.push_back(t); argTypes.push_back(t);
LLVM_TYPE_CONST llvm::Type *llvmExprType = type->LLVMType(g->ctx); llvm::Type *llvmExprType = type->LLVMType(g->ctx);
llvm::Value *ptr = ctx->AllocaInst(llvmExprType, "print_arg"); llvm::Value *ptr = ctx->AllocaInst(llvmExprType, "print_arg");
llvm::Value *val = expr->GetValue(ctx); llvm::Value *val = expr->GetValue(ctx);
if (!val) if (!val)
@@ -2537,7 +2537,7 @@ PrintStmt::EmitCode(FunctionEmitContext *ctx) const {
std::string argTypes; std::string argTypes;
if (values == NULL) { if (values == NULL) {
LLVM_TYPE_CONST llvm::Type *ptrPtrType = llvm::Type *ptrPtrType =
llvm::PointerType::get(LLVMTypes::VoidPointerType, 0); llvm::PointerType::get(LLVMTypes::VoidPointerType, 0);
args[4] = llvm::Constant::getNullValue(ptrPtrType); args[4] = llvm::Constant::getNullValue(ptrPtrType);
} }
@@ -2549,7 +2549,7 @@ PrintStmt::EmitCode(FunctionEmitContext *ctx) const {
int nArgs = elist ? elist->exprs.size() : 1; int nArgs = elist ? elist->exprs.size() : 1;
// Allocate space for the array of pointers to values to be printed // Allocate space for the array of pointers to values to be printed
LLVM_TYPE_CONST llvm::Type *argPtrArrayType = llvm::Type *argPtrArrayType =
llvm::ArrayType::get(LLVMTypes::VoidPointerType, nArgs); llvm::ArrayType::get(LLVMTypes::VoidPointerType, nArgs);
llvm::Value *argPtrArray = ctx->AllocaInst(argPtrArrayType, llvm::Value *argPtrArray = ctx->AllocaInst(argPtrArrayType,
"print_arg_ptrs"); "print_arg_ptrs");

34
type.cpp
View File

@@ -414,7 +414,7 @@ AtomicType::GetCDeclaration(const std::string &name) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
AtomicType::LLVMType(llvm::LLVMContext *ctx) const { AtomicType::LLVMType(llvm::LLVMContext *ctx) const {
Assert(variability.type != Variability::Unbound); Assert(variability.type != Variability::Unbound);
bool isUniform = (variability == Variability::Uniform); bool isUniform = (variability == Variability::Uniform);
@@ -725,7 +725,7 @@ EnumType::GetCDeclaration(const std::string &varName) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
EnumType::LLVMType(llvm::LLVMContext *ctx) const { EnumType::LLVMType(llvm::LLVMContext *ctx) const {
Assert(variability != Variability::Unbound); Assert(variability != Variability::Unbound);
@@ -1083,7 +1083,7 @@ PointerType::GetCDeclaration(const std::string &name) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
PointerType::LLVMType(llvm::LLVMContext *ctx) const { PointerType::LLVMType(llvm::LLVMContext *ctx) const {
if (baseType == NULL) { if (baseType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -1098,7 +1098,7 @@ PointerType::LLVMType(llvm::LLVMContext *ctx) const {
switch (variability.type) { switch (variability.type) {
case Variability::Uniform: { case Variability::Uniform: {
LLVM_TYPE_CONST llvm::Type *ptype = NULL; llvm::Type *ptype = NULL;
const FunctionType *ftype = dynamic_cast<const FunctionType *>(baseType); const FunctionType *ftype = dynamic_cast<const FunctionType *>(baseType);
if (ftype != NULL) if (ftype != NULL)
// Get the type of the function variant that takes the mask as the // Get the type of the function variant that takes the mask as the
@@ -1178,14 +1178,14 @@ ArrayType::ArrayType(const Type *c, int a)
} }
LLVM_TYPE_CONST llvm::ArrayType * llvm::ArrayType *
ArrayType::LLVMType(llvm::LLVMContext *ctx) const { ArrayType::LLVMType(llvm::LLVMContext *ctx) const {
if (child == NULL) { if (child == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *ct = child->LLVMType(ctx); llvm::Type *ct = child->LLVMType(ctx);
if (ct == NULL) { if (ct == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -1630,14 +1630,14 @@ VectorType::GetElementType() const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
VectorType::LLVMType(llvm::LLVMContext *ctx) const { VectorType::LLVMType(llvm::LLVMContext *ctx) const {
if (base == NULL) { if (base == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *bt = base->LLVMType(ctx); llvm::Type *bt = base->LLVMType(ctx);
if (!bt) if (!bt)
return NULL; return NULL;
@@ -1912,9 +1912,9 @@ StructType::GetCDeclaration(const std::string &n) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
StructType::LLVMType(llvm::LLVMContext *ctx) const { StructType::LLVMType(llvm::LLVMContext *ctx) const {
std::vector<LLVM_TYPE_CONST llvm::Type *> llvmTypes; std::vector<llvm::Type *> llvmTypes;
for (int i = 0; i < GetElementCount(); ++i) { for (int i = 0; i < GetElementCount(); ++i) {
const Type *type = GetElementType(i); const Type *type = GetElementType(i);
if (type == NULL) if (type == NULL)
@@ -2257,14 +2257,14 @@ ReferenceType::GetCDeclaration(const std::string &name) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
ReferenceType::LLVMType(llvm::LLVMContext *ctx) const { ReferenceType::LLVMType(llvm::LLVMContext *ctx) const {
if (targetType == NULL) { if (targetType == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
} }
LLVM_TYPE_CONST llvm::Type *t = targetType->LLVMType(ctx); llvm::Type *t = targetType->LLVMType(ctx);
if (t == NULL) { if (t == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -2489,7 +2489,7 @@ FunctionType::GetCDeclaration(const std::string &fname) const {
} }
LLVM_TYPE_CONST llvm::Type * llvm::Type *
FunctionType::LLVMType(llvm::LLVMContext *ctx) const { FunctionType::LLVMType(llvm::LLVMContext *ctx) const {
FATAL("FunctionType::LLVMType() shouldn't be called"); FATAL("FunctionType::LLVMType() shouldn't be called");
return NULL; return NULL;
@@ -2540,13 +2540,13 @@ FunctionType::GetReturnTypeString() const {
} }
LLVM_TYPE_CONST llvm::FunctionType * llvm::FunctionType *
FunctionType::LLVMFunctionType(llvm::LLVMContext *ctx, bool includeMask) const { FunctionType::LLVMFunctionType(llvm::LLVMContext *ctx, bool includeMask) const {
if (isTask == true) if (isTask == true)
Assert(includeMask == true); Assert(includeMask == true);
// Get the LLVM Type *s for the function arguments // Get the LLVM Type *s for the function arguments
std::vector<LLVM_TYPE_CONST llvm::Type *> llvmArgTypes; std::vector<llvm::Type *> llvmArgTypes;
for (unsigned int i = 0; i < paramTypes.size(); ++i) { for (unsigned int i = 0; i < paramTypes.size(); ++i) {
if (paramTypes[i] == NULL) { if (paramTypes[i] == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
@@ -2554,7 +2554,7 @@ FunctionType::LLVMFunctionType(llvm::LLVMContext *ctx, bool includeMask) const {
} }
Assert(Type::Equal(paramTypes[i], AtomicType::Void) == false); Assert(Type::Equal(paramTypes[i], AtomicType::Void) == false);
LLVM_TYPE_CONST llvm::Type *t = paramTypes[i]->LLVMType(ctx); llvm::Type *t = paramTypes[i]->LLVMType(ctx);
if (t == NULL) { if (t == NULL) {
Assert(m->errorCount > 0); Assert(m->errorCount > 0);
return NULL; return NULL;
@@ -2566,7 +2566,7 @@ FunctionType::LLVMFunctionType(llvm::LLVMContext *ctx, bool includeMask) const {
if (includeMask) if (includeMask)
llvmArgTypes.push_back(LLVMTypes::MaskType); llvmArgTypes.push_back(LLVMTypes::MaskType);
std::vector<LLVM_TYPE_CONST llvm::Type *> callTypes; std::vector<llvm::Type *> callTypes;
if (isTask) { if (isTask) {
// Tasks take three arguments: a pointer to a struct that holds the // Tasks take three arguments: a pointer to a struct that holds the
// actual task arguments, the thread index, and the total number of // actual task arguments, the thread index, and the total number of

20
type.h
View File

@@ -187,7 +187,7 @@ public:
virtual std::string GetCDeclaration(const std::string &name) const = 0; virtual std::string GetCDeclaration(const std::string &name) const = 0;
/** Returns the LLVM type corresponding to this ispc type */ /** Returns the LLVM type corresponding to this ispc type */
virtual LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const = 0; virtual llvm::Type *LLVMType(llvm::LLVMContext *ctx) const = 0;
/** Returns the DIType (LLVM's debugging information structure), /** Returns the DIType (LLVM's debugging information structure),
corresponding to this type. */ corresponding to this type. */
@@ -269,7 +269,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
/** This enumerator records the basic types that AtomicTypes can be /** This enumerator records the basic types that AtomicTypes can be
@@ -343,7 +343,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
/** Provides the enumerators defined in the enum definition. */ /** Provides the enumerators defined in the enum definition. */
@@ -425,7 +425,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
static PointerType *Void; static PointerType *Void;
@@ -523,7 +523,7 @@ public:
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
LLVM_TYPE_CONST llvm::ArrayType *LLVMType(llvm::LLVMContext *ctx) const; llvm::ArrayType *LLVMType(llvm::LLVMContext *ctx) const;
/** This method returns the total number of elements in the array, /** This method returns the total number of elements in the array,
including all dimensions if this is a multidimensional array. */ including all dimensions if this is a multidimensional array. */
@@ -589,7 +589,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
int GetElementCount() const; int GetElementCount() const;
@@ -639,7 +639,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
/** Returns the type of the structure element with the given name (if any). /** Returns the type of the structure element with the given name (if any).
@@ -719,7 +719,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &name) const; std::string GetCDeclaration(const std::string &name) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
private: private:
@@ -771,7 +771,7 @@ public:
std::string Mangle() const; std::string Mangle() const;
std::string GetCDeclaration(const std::string &fname) const; std::string GetCDeclaration(const std::string &fname) const;
LLVM_TYPE_CONST llvm::Type *LLVMType(llvm::LLVMContext *ctx) const; llvm::Type *LLVMType(llvm::LLVMContext *ctx) const;
llvm::DIType GetDIType(llvm::DIDescriptor scope) const; llvm::DIType GetDIType(llvm::DIDescriptor scope) const;
const Type *GetReturnType() const { return returnType; } const Type *GetReturnType() const { return returnType; }
@@ -782,7 +782,7 @@ public:
function type. The \c includeMask parameter indicates whether the function type. The \c includeMask parameter indicates whether the
llvm::FunctionType should have a mask as the last argument in its llvm::FunctionType should have a mask as the last argument in its
function signature. */ function signature. */
LLVM_TYPE_CONST llvm::FunctionType *LLVMFunctionType(llvm::LLVMContext *ctx, llvm::FunctionType *LLVMFunctionType(llvm::LLVMContext *ctx,
bool includeMask = false) const; bool includeMask = false) const;
int GetNumParameters() const { return (int)paramTypes.size(); } int GetNumParameters() const { return (int)paramTypes.size(); }