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

adding const to Atomic::Void type

Browse Source
This commit is contained in:
Ilia Filippov
2014-03-17 14:42:55 +04:00
parent 11f17ce0cd
commit 02d55f24f6
7 changed files with 36 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ctx.cpp
View File

@@ -276,7 +276,7 @@ FunctionEmitContext::FunctionEmitContext(Function *func, Symbol *funSym,
disableGSWarningCount = 0;
const Type *returnType = function->GetReturnType();
if (!returnType || Type::Equal(returnType, AtomicType::Void))
if (!returnType || returnType->IsVoidType())
returnValuePtr = NULL;
else {
llvm::Type *ftype = returnType->LLVMType(g->ctx);
@@ -1244,7 +1244,7 @@ FunctionEmitContext::GetLabels() {
void
FunctionEmitContext::CurrentLanesReturned(Expr *expr, bool doCoherenceCheck) {
const Type *returnType = function->GetReturnType();
if (Type::Equal(returnType, AtomicType::Void)) {
if (returnType->IsVoidType()) {
if (expr != NULL)
Error(expr->pos, "Can't return non-void type \"%s\" from void function.",
expr->GetType()->GetString().c_str());
@@ -3516,7 +3516,7 @@ FunctionEmitContext::ReturnInst() {
rinst = llvm::ReturnInst::Create(*g->ctx, retVal, bblock);
}
else {
AssertPos(currentPos, Type::Equal(function->GetReturnType(), AtomicType::Void));
AssertPos(currentPos, function->GetReturnType()->IsVoidType());
rinst = llvm::ReturnInst::Create(*g->ctx, bblock);
}

16
decl.cpp
View File

@@ -80,19 +80,19 @@ lApplyTypeQualifiers(int typeQualifiers, const Type *type, SourcePos pos) {
}
if ((typeQualifiers & TYPEQUAL_UNIFORM) != 0) {
if (Type::Equal(type, AtomicType::Void))
if (type->IsVoidType())
Error(pos, "\"uniform\" qualifier is illegal with \"void\" type.");
else
type = type->GetAsUniformType();
}
else if ((typeQualifiers & TYPEQUAL_VARYING) != 0) {
if (Type::Equal(type, AtomicType::Void))
if (type->IsVoidType())
Error(pos, "\"varying\" qualifier is illegal with \"void\" type.");
else
type = type->GetAsVaryingType();
}
else {
if (Type::Equal(type, AtomicType::Void) == false)
if (type->IsVoidType() == false)
type = type->GetAsUnboundVariabilityType();
}
@@ -392,7 +392,7 @@ Declarator::InitFromType(const Type *baseType, DeclSpecs *ds) {
type = refType;
}
else if (kind == DK_ARRAY) {
if (Type::Equal(baseType, AtomicType::Void)) {
if (baseType->IsVoidType()) {
Error(pos, "Arrays of \"void\" type are illegal.");
return;
}
@@ -454,7 +454,7 @@ Declarator::InitFromType(const Type *baseType, DeclSpecs *ds) {
"function parameter declaration for parameter \"%s\".",
lGetStorageClassName(d->declSpecs->storageClass),
decl->name.c_str());
if (Type::Equal(decl->type, AtomicType::Void)) {
if (decl->type->IsVoidType()) {
Error(decl->pos, "Parameter with type \"void\" illegal in function "
"parameter list.");
decl->type = NULL;
@@ -625,7 +625,7 @@ Declaration::GetVariableDeclarations() const {
continue;
}
if (Type::Equal(decl->type, AtomicType::Void))
if (decl->type->IsVoidType())
Error(decl->pos, "\"void\" type variable illegal in declaration.");
else if (CastType<FunctionType>(decl->type) == NULL) {
decl->type = decl->type->ResolveUnboundVariability(Variability::Varying);
@@ -689,7 +689,7 @@ GetStructTypesNamesPositions(const std::vector<StructDeclaration *> &sd,
// FIXME: making this fake little DeclSpecs here is really
// disgusting
DeclSpecs ds(type);
if (Type::Equal(type, AtomicType::Void) == false) {
if (type->IsVoidType() == false) {
if (type->IsUniformType())
ds.typeQualifiers |= TYPEQUAL_UNIFORM;
else if (type->IsVaryingType())
@@ -703,7 +703,7 @@ GetStructTypesNamesPositions(const std::vector<StructDeclaration *> &sd,
Declarator *d = (*sd[i]->declarators)[j];
d->InitFromDeclSpecs(&ds);
if (Type::Equal(d->type, AtomicType::Void))
if (d->type->IsVoidType())
Error(d->pos, "\"void\" type illegal for struct member.");
elementTypes->push_back(d->type);

21
expr.cpp
View File

@@ -209,14 +209,14 @@ lDoTypeConv(const Type *fromType, const Type *toType, Expr **expr,
if (Type::Equal(toType, fromType))
return true;
if (Type::Equal(fromType, AtomicType::Void)) {
if (fromType->IsVoidType()) {
if (!failureOk)
Error(pos, "Can't convert from \"void\" to \"%s\" for %s.",
toType->GetString().c_str(), errorMsgBase);
return false;
}
if (Type::Equal(toType, AtomicType::Void)) {
if (toType->IsVoidType()) {
if (!failureOk)
Error(pos, "Can't convert type \"%s\" to \"void\" for %s.",
fromType->GetString().c_str(), errorMsgBase);
@@ -342,7 +342,8 @@ lDoTypeConv(const Type *fromType, const Type *toType, Expr **expr,
return false;
}
else if (PointerType::IsVoidPointer(toPointerType)) {
if (fromPointerType->GetBaseType()->IsConstType()) {
if (fromPointerType->GetBaseType()->IsConstType() &&
!(toPointerType->GetBaseType()->IsConstType())) {
if (!failureOk)
Error(pos, "Can't convert pointer to const \"%s\" to void pointer.",
fromPointerType->GetString().c_str());
@@ -3611,7 +3612,7 @@ FunctionCallExpr::GetValue(FunctionEmitContext *ctx) const {
const FunctionType *ft = lGetFunctionType(func);
AssertPos(pos, ft != NULL);
bool isVoidFunc = Type::Equal(ft->GetReturnType(), AtomicType::Void);
bool isVoidFunc = ft->GetReturnType()->IsVoidType();
// Automatically convert function call args to references if needed.
// FIXME: this should move to the TypeCheck() method... (but the
@@ -3898,7 +3899,7 @@ FunctionCallExpr::TypeCheck() {
if (fptrType->IsVaryingType()) {
const Type *retType = funcType->GetReturnType();
if (Type::Equal(retType, AtomicType::Void) == false &&
if (retType->IsVoidType() == false &&
retType->IsUniformType()) {
Error(pos, "Illegal to call a varying function pointer that "
"points to a function with a uniform return type \"%s\".",
@@ -4606,7 +4607,7 @@ IndexExpr::TypeCheck() {
if (!CastType<SequentialType>(baseExprType->GetReferenceTarget())) {
if (const PointerType *pt = CastType<PointerType>(baseExprType)) {
if (Type::Equal(AtomicType::Void, pt->GetBaseType())) {
if (pt->GetBaseType()->IsVoidType()) {
Error(pos, "Illegal to dereference void pointer type \"%s\".",
baseExprType->GetString().c_str());
return NULL;
@@ -6800,7 +6801,7 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
return NULL;
}
if (Type::Equal(toType, AtomicType::Void)) {
if (toType->IsVoidType()) {
// emit the code for the expression in case it has side-effects but
// then we're done.
(void)expr->GetValue(ctx);
@@ -7163,10 +7164,10 @@ TypeCastExpr::TypeCheck() {
toType = lDeconstifyType(toType);
// Anything can be cast to void...
if (Type::Equal(toType, AtomicType::Void))
if (toType->IsVoidType())
return this;
if (Type::Equal(fromType, AtomicType::Void) ||
if (fromType->IsVoidType() ||
(fromType->IsVaryingType() && toType->IsUniformType())) {
Error(pos, "Can't type cast from type \"%s\" to type \"%s\"",
fromType->GetString().c_str(), toType->GetString().c_str());
@@ -7589,7 +7590,7 @@ PtrDerefExpr::TypeCheck() {
}
if (const PointerType *pt = CastType<PointerType>(type)) {
if (Type::Equal(AtomicType::Void, pt->GetBaseType())) {
if (pt->GetBaseType()->IsVoidType()) {
Error(pos, "Illegal to dereference void pointer type \"%s\".",
type->GetString().c_str());
return NULL;

2
func.cpp
View File

@@ -427,7 +427,7 @@ Function::emitCode(FunctionEmitContext *ctx, llvm::Function *function,
// issue a warning. Also need to warn if it's the entry block for
// the function (in which case it will not have predeccesors but is
// still reachable.)
if (Type::Equal(type->GetReturnType(), AtomicType::Void) == false &&
if (type->GetReturnType()->IsVoidType() == false &&
(pred_begin(ec.bblock) != pred_end(ec.bblock) || (ec.bblock == entryBBlock)))
Warning(sym->pos, "Missing return statement in function returning \"%s\".",
type->rType->GetString().c_str());

4
module.cpp
View File

@@ -426,7 +426,7 @@ Module::AddGlobalVariable(const std::string &name, const Type *type, Expr *initE
return;
}
if (Type::Equal(type, AtomicType::Void)) {
if (type->IsVoidType()) {
Error(pos, "\"void\" type global variable is illegal.");
return;
}
@@ -818,7 +818,7 @@ Module::AddFunctionDeclaration(const std::string &name,
"exported function \"%s\"", name.c_str());
if (functionType->isTask &&
Type::Equal(functionType->GetReturnType(), AtomicType::Void) == false)
functionType->GetReturnType()->IsVoidType() == false)
Error(pos, "Task-qualified functions must have void return type.");
if (functionType->isExported || functionType->isExternC)

8
parse.yy
View File

@@ -617,7 +617,7 @@ rate_qualified_type_specifier
{
if ($2 == NULL)
$$ = NULL;
else if (Type::Equal($2, AtomicType::Void)) {
else if ($2->IsVoidType()) {
Error(@1, "\"uniform\" qualifier is illegal with \"void\" type.");
$$ = NULL;
}
@@ -628,7 +628,7 @@ rate_qualified_type_specifier
{
if ($2 == NULL)
$$ = NULL;
else if (Type::Equal($2, AtomicType::Void)) {
else if ($2->IsVoidType()) {
Error(@1, "\"varying\" qualifier is illegal with \"void\" type.");
$$ = NULL;
}
@@ -1081,7 +1081,7 @@ specifier_qualifier_list
{
if ($2 != NULL) {
if ($1 == TYPEQUAL_UNIFORM) {
if (Type::Equal($2, AtomicType::Void)) {
if ($2->IsVoidType()) {
Error(@1, "\"uniform\" qualifier is illegal with \"void\" type.");
$$ = NULL;
}
@@ -1089,7 +1089,7 @@ specifier_qualifier_list
$$ = $2->GetAsUniformType();
}
else if ($1 == TYPEQUAL_VARYING) {
if (Type::Equal($2, AtomicType::Void)) {
if ($2->IsVoidType()) {
Error(@1, "\"varying\" qualifier is illegal with \"void\" type.");
$$ = NULL;
}

14
type.cpp
View File

@@ -228,7 +228,7 @@ Type::IsReferenceType() const {
bool
Type::IsVoidType() const {
return this == AtomicType::Void;
return EqualIgnoringConst(this, AtomicType::Void);
}
bool
@@ -290,7 +290,7 @@ AtomicType::GetAsUnsignedType() const {
const AtomicType *
AtomicType::GetAsConstType() const {
if (basicType == TYPE_VOID || isConst == true)
if (isConst == true)
return this;
if (asOtherConstType == NULL) {
@@ -303,7 +303,7 @@ AtomicType::GetAsConstType() const {
const AtomicType *
AtomicType::GetAsNonConstType() const {
if (basicType == TYPE_VOID || isConst == false)
if (isConst == false)
return this;
if (asOtherConstType == NULL) {
@@ -380,8 +380,8 @@ AtomicType::ResolveUnboundVariability(Variability v) const {
std::string
AtomicType::GetString() const {
std::string ret;
if (isConst) ret += "const ";
if (basicType != TYPE_VOID) {
if (isConst) ret += "const ";
ret += variability.GetString();
ret += " ";
}
@@ -1167,7 +1167,7 @@ PointerType::LLVMType(llvm::LLVMContext *ctx) const {
if (ftype != NULL)
ptype = llvm::PointerType::get(ftype->LLVMFunctionType(ctx), 0);
else {
if (baseType == AtomicType::Void)
if (baseType->IsVoidType())
ptype = LLVMTypes::VoidPointerType;
else
ptype = llvm::PointerType::get(baseType->LLVMType(ctx), 0);
@@ -1235,7 +1235,7 @@ ArrayType::ArrayType(const Type *c, int a)
: SequentialType(ARRAY_TYPE), child(c), numElements(a) {
// 0 -> unsized array.
Assert(numElements >= 0);
Assert(Type::Equal(c, AtomicType::Void) == false);
Assert(c->IsVoidType() == false);
}
@@ -3015,7 +3015,7 @@ FunctionType::LLVMFunctionType(llvm::LLVMContext *ctx, bool removeMask) const {
Assert(m->errorCount > 0);
return NULL;
}
Assert(Type::Equal(paramTypes[i], AtomicType::Void) == false);
Assert(paramTypes[i]->IsVoidType() == false);
llvm::Type *t = paramTypes[i]->LLVMType(ctx);
if (t == NULL) {