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

Id's fo Expr-inherited classes

Browse Source
This commit is contained in:
Anton Mitrokhin
2015-07-09 12:38:58 +03:00
parent 3ec674a820
commit 26a93bc733
13 changed files with 205 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@@ -169,7 +169,7 @@ CXXFLAGS=$(OPT) $(LLVM_CXXFLAGS) -I. -Iobjs/ -I$(CLANG_INCLUDE) \
# if( !($(LLVM_VERSION) == LLVM_3_2 || $(LLVM_VERSION) == LLVM_3_3 || $(LLVM_VERSION) == LLVM_3_4))
ifeq (,$(filter $(LLVM_VERSION), LLVM_3_2 LLVM_3_3 LLVM_3_4))
CXXFLAGS+=-std=c++11 -Wno-c99-extensions -Wno-deprecated-register
CXXFLAGS+=-std=c++11 -Wno-c99-extensions -Wno-deprecated-register -fno-rtti
endif
ifneq ($(ARM_ENABLED), 0)
CXXFLAGS+=-DISPC_ARM_ENABLED
@@ -194,7 +194,7 @@ YACC=bison -d -v -t
###########################################################################
CXX_SRC=ast.cpp builtins.cpp cbackend.cpp ctx.cpp decl.cpp expr.cpp func.cpp \
CXX_SRC=ast.cpp builtins.cpp cbackend.cpp ctx.cpp decl.cpp expr.cpp func.cpp test_class_of.cpp \
ispc.cpp llvmutil.cpp main.cpp module.cpp opt.cpp stmt.cpp sym.cpp \
type.cpp util.cpp
HEADERS=ast.h builtins.h ctx.h decl.h expr.h func.h ispc.h llvmutil.h module.h \
@@ -262,6 +262,8 @@ doxygen:
ispc: print_llvm_src dirs $(OBJS)
@echo Creating ispc executable
@$(CXX) $(OPT) $(LDFLAGS) -o $@ $(OBJS) $(ISPC_LIBS)
@echo Creating test_class_of executable
@$(CXX) $(OPT) $(LDFLAGS) -o tcexe $(OBJS) $(ISPC_LIBS)
# Use clang as a default compiler, instead of gcc
# This is default now.

118
ast.cpp
View File

@@ -85,7 +85,7 @@ WalkAST(ASTNode *node, ASTPreCallBackFunc preFunc, ASTPostCallBackFunc postFunc,
////////////////////////////////////////////////////////////////////////////
// Handle Statements
if (dynamic_cast<Stmt *>(node) != NULL) {
if (llvm::dyn_cast<Stmt>(node) != NULL) {
ExprStmt *es;
DeclStmt *ds;
IfStmt *is;
@@ -105,33 +105,33 @@ WalkAST(ASTNode *node, ASTPreCallBackFunc preFunc, ASTPostCallBackFunc postFunc,
DeleteStmt *dels;
UnmaskedStmt *ums;
if ((es = dynamic_cast<ExprStmt *>(node)) != NULL)
if ((es = llvm::dyn_cast<ExprStmt>(node)) != NULL)
es->expr = (Expr *)WalkAST(es->expr, preFunc, postFunc, data);
else if ((ds = dynamic_cast<DeclStmt *>(node)) != NULL) {
else if ((ds = llvm::dyn_cast<DeclStmt>(node)) != NULL) {
for (unsigned int i = 0; i < ds->vars.size(); ++i)
ds->vars[i].init = (Expr *)WalkAST(ds->vars[i].init, preFunc,
postFunc, data);
}
else if ((is = dynamic_cast<IfStmt *>(node)) != NULL) {
else if ((is = llvm::dyn_cast<IfStmt>(node)) != NULL) {
is->test = (Expr *)WalkAST(is->test, preFunc, postFunc, data);
is->trueStmts = (Stmt *)WalkAST(is->trueStmts, preFunc,
postFunc, data);
is->falseStmts = (Stmt *)WalkAST(is->falseStmts, preFunc,
postFunc, data);
}
else if ((dos = dynamic_cast<DoStmt *>(node)) != NULL) {
else if ((dos = llvm::dyn_cast<DoStmt>(node)) != NULL) {
dos->testExpr = (Expr *)WalkAST(dos->testExpr, preFunc,
postFunc, data);
dos->bodyStmts = (Stmt *)WalkAST(dos->bodyStmts, preFunc,
postFunc, data);
}
else if ((fs = dynamic_cast<ForStmt *>(node)) != NULL) {
else if ((fs = llvm::dyn_cast<ForStmt>(node)) != NULL) {
fs->init = (Stmt *)WalkAST(fs->init, preFunc, postFunc, data);
fs->test = (Expr *)WalkAST(fs->test, preFunc, postFunc, data);
fs->step = (Stmt *)WalkAST(fs->step, preFunc, postFunc, data);
fs->stmts = (Stmt *)WalkAST(fs->stmts, preFunc, postFunc, data);
}
else if ((fes = dynamic_cast<ForeachStmt *>(node)) != NULL) {
else if ((fes = llvm::dyn_cast<ForeachStmt>(node)) != NULL) {
for (unsigned int i = 0; i < fes->startExprs.size(); ++i)
fes->startExprs[i] = (Expr *)WalkAST(fes->startExprs[i], preFunc,
postFunc, data);
@@ -140,42 +140,42 @@ WalkAST(ASTNode *node, ASTPreCallBackFunc preFunc, ASTPostCallBackFunc postFunc,
postFunc, data);
fes->stmts = (Stmt *)WalkAST(fes->stmts, preFunc, postFunc, data);
}
else if ((fas = dynamic_cast<ForeachActiveStmt *>(node)) != NULL) {
else if ((fas = llvm::dyn_cast<ForeachActiveStmt>(node)) != NULL) {
fas->stmts = (Stmt *)WalkAST(fas->stmts, preFunc, postFunc, data);
}
else if ((fus = dynamic_cast<ForeachUniqueStmt *>(node)) != NULL) {
else if ((fus = llvm::dyn_cast<ForeachUniqueStmt>(node)) != NULL) {
fus->expr = (Expr *)WalkAST(fus->expr, preFunc, postFunc, data);
fus->stmts = (Stmt *)WalkAST(fus->stmts, preFunc, postFunc, data);
}
else if ((cs = dynamic_cast<CaseStmt *>(node)) != NULL)
else if ((cs = llvm::dyn_cast<CaseStmt>(node)) != NULL)
cs->stmts = (Stmt *)WalkAST(cs->stmts, preFunc, postFunc, data);
else if ((defs = dynamic_cast<DefaultStmt *>(node)) != NULL)
else if ((defs = llvm::dyn_cast<DefaultStmt>(node)) != NULL)
defs->stmts = (Stmt *)WalkAST(defs->stmts, preFunc, postFunc, data);
else if ((ss = dynamic_cast<SwitchStmt *>(node)) != NULL) {
else if ((ss = llvm::dyn_cast<SwitchStmt>(node)) != NULL) {
ss->expr = (Expr *)WalkAST(ss->expr, preFunc, postFunc, data);
ss->stmts = (Stmt *)WalkAST(ss->stmts, preFunc, postFunc, data);
}
else if (dynamic_cast<BreakStmt *>(node) != NULL ||
dynamic_cast<ContinueStmt *>(node) != NULL ||
dynamic_cast<GotoStmt *>(node) != NULL) {
else if (llvm::dyn_cast<BreakStmt>(node) != NULL ||
llvm::dyn_cast<ContinueStmt>(node) != NULL ||
llvm::dyn_cast<GotoStmt>(node) != NULL) {
// nothing
}
else if ((ls = dynamic_cast<LabeledStmt *>(node)) != NULL)
else if ((ls = llvm::dyn_cast<LabeledStmt>(node)) != NULL)
ls->stmt = (Stmt *)WalkAST(ls->stmt, preFunc, postFunc, data);
else if ((rs = dynamic_cast<ReturnStmt *>(node)) != NULL)
else if ((rs = llvm::dyn_cast<ReturnStmt>(node)) != NULL)
rs->expr = (Expr *)WalkAST(rs->expr, preFunc, postFunc, data);
else if ((sl = dynamic_cast<StmtList *>(node)) != NULL) {
else if ((sl = llvm::dyn_cast<StmtList>(node)) != NULL) {
std::vector<Stmt *> &sls = sl->stmts;
for (unsigned int i = 0; i < sls.size(); ++i)
sls[i] = (Stmt *)WalkAST(sls[i], preFunc, postFunc, data);
}
else if ((ps = dynamic_cast<PrintStmt *>(node)) != NULL)
else if ((ps = llvm::dyn_cast<PrintStmt>(node)) != NULL)
ps->values = (Expr *)WalkAST(ps->values, preFunc, postFunc, data);
else if ((as = dynamic_cast<AssertStmt *>(node)) != NULL)
else if ((as = llvm::dyn_cast<AssertStmt>(node)) != NULL)
as->expr = (Expr *)WalkAST(as->expr, preFunc, postFunc, data);
else if ((dels = dynamic_cast<DeleteStmt *>(node)) != NULL)
else if ((dels = llvm::dyn_cast<DeleteStmt>(node)) != NULL)
dels->expr = (Expr *)WalkAST(dels->expr, preFunc, postFunc, data);
else if ((ums = dynamic_cast<UnmaskedStmt *>(node)) != NULL)
else if ((ums = llvm::dyn_cast<UnmaskedStmt>(node)) != NULL)
ums->stmts = (Stmt *)WalkAST(ums->stmts, preFunc, postFunc, data);
else
FATAL("Unhandled statement type in WalkAST()");
@@ -183,7 +183,7 @@ WalkAST(ASTNode *node, ASTPreCallBackFunc preFunc, ASTPostCallBackFunc postFunc,
else {
///////////////////////////////////////////////////////////////////////////
// Handle expressions
Assert(dynamic_cast<Expr *>(node) != NULL);
Assert(llvm::dyn_cast<Expr>(node) != NULL);
UnaryExpr *ue;
BinaryExpr *be;
AssignExpr *ae;
@@ -200,64 +200,64 @@ WalkAST(ASTNode *node, ASTPreCallBackFunc preFunc, ASTPostCallBackFunc postFunc,
AddressOfExpr *aoe;
NewExpr *newe;
if ((ue = dynamic_cast<UnaryExpr *>(node)) != NULL)
if ((ue = llvm::dyn_cast<UnaryExpr>(node)) != NULL)
ue->expr = (Expr *)WalkAST(ue->expr, preFunc, postFunc, data);
else if ((be = dynamic_cast<BinaryExpr *>(node)) != NULL) {
else if ((be = llvm::dyn_cast<BinaryExpr>(node)) != NULL) {
be->arg0 = (Expr *)WalkAST(be->arg0, preFunc, postFunc, data);
be->arg1 = (Expr *)WalkAST(be->arg1, preFunc, postFunc, data);
}
else if ((ae = dynamic_cast<AssignExpr *>(node)) != NULL) {
else if ((ae = llvm::dyn_cast<AssignExpr>(node)) != NULL) {
ae->lvalue = (Expr *)WalkAST(ae->lvalue, preFunc, postFunc, data);
ae->rvalue = (Expr *)WalkAST(ae->rvalue, preFunc, postFunc, data);
}
else if ((se = dynamic_cast<SelectExpr *>(node)) != NULL) {
else if ((se = llvm::dyn_cast<SelectExpr>(node)) != NULL) {
se->test = (Expr *)WalkAST(se->test, preFunc, postFunc, data);
se->expr1 = (Expr *)WalkAST(se->expr1, preFunc, postFunc, data);
se->expr2 = (Expr *)WalkAST(se->expr2, preFunc, postFunc, data);
}
else if ((el = dynamic_cast<ExprList *>(node)) != NULL) {
else if ((el = llvm::dyn_cast<ExprList>(node)) != NULL) {
for (unsigned int i = 0; i < el->exprs.size(); ++i)
el->exprs[i] = (Expr *)WalkAST(el->exprs[i], preFunc,
postFunc, data);
}
else if ((fce = dynamic_cast<FunctionCallExpr *>(node)) != NULL) {
else if ((fce = llvm::dyn_cast<FunctionCallExpr>(node)) != NULL) {
fce->func = (Expr *)WalkAST(fce->func, preFunc, postFunc, data);
fce->args = (ExprList *)WalkAST(fce->args, preFunc, postFunc, data);
for (int k = 0; k < 3; k++)
fce->launchCountExpr[0] = (Expr *)WalkAST(fce->launchCountExpr[0], preFunc,
postFunc, data);
}
else if ((ie = dynamic_cast<IndexExpr *>(node)) != NULL) {
else if ((ie = llvm::dyn_cast<IndexExpr>(node)) != NULL) {
ie->baseExpr = (Expr *)WalkAST(ie->baseExpr, preFunc, postFunc, data);
ie->index = (Expr *)WalkAST(ie->index, preFunc, postFunc, data);
}
else if ((me = dynamic_cast<MemberExpr *>(node)) != NULL)
else if ((me = llvm::dyn_cast<MemberExpr>(node)) != NULL)
me->expr = (Expr *)WalkAST(me->expr, preFunc, postFunc, data);
else if ((tce = dynamic_cast<TypeCastExpr *>(node)) != NULL)
else if ((tce = llvm::dyn_cast<TypeCastExpr>(node)) != NULL)
tce->expr = (Expr *)WalkAST(tce->expr, preFunc, postFunc, data);
else if ((re = dynamic_cast<ReferenceExpr *>(node)) != NULL)
else if ((re = llvm::dyn_cast<ReferenceExpr>(node)) != NULL)
re->expr = (Expr *)WalkAST(re->expr, preFunc, postFunc, data);
else if ((ptrderef = dynamic_cast<PtrDerefExpr *>(node)) != NULL)
else if ((ptrderef = llvm::dyn_cast<PtrDerefExpr>(node)) != NULL)
ptrderef->expr = (Expr *)WalkAST(ptrderef->expr, preFunc, postFunc,
data);
else if ((refderef = dynamic_cast<RefDerefExpr *>(node)) != NULL)
else if ((refderef = llvm::dyn_cast<RefDerefExpr>(node)) != NULL)
refderef->expr = (Expr *)WalkAST(refderef->expr, preFunc, postFunc,
data);
else if ((soe = dynamic_cast<SizeOfExpr *>(node)) != NULL)
else if ((soe = llvm::dyn_cast<SizeOfExpr>(node)) != NULL)
soe->expr = (Expr *)WalkAST(soe->expr, preFunc, postFunc, data);
else if ((aoe = dynamic_cast<AddressOfExpr *>(node)) != NULL)
else if ((aoe = llvm::dyn_cast<AddressOfExpr>(node)) != NULL)
aoe->expr = (Expr *)WalkAST(aoe->expr, preFunc, postFunc, data);
else if ((newe = dynamic_cast<NewExpr *>(node)) != NULL) {
else if ((newe = llvm::dyn_cast<NewExpr>(node)) != NULL) {
newe->countExpr = (Expr *)WalkAST(newe->countExpr, preFunc,
postFunc, data);
newe->initExpr = (Expr *)WalkAST(newe->initExpr, preFunc,
postFunc, data);
}
else if (dynamic_cast<SymbolExpr *>(node) != NULL ||
dynamic_cast<ConstExpr *>(node) != NULL ||
dynamic_cast<FunctionSymbolExpr *>(node) != NULL ||
dynamic_cast<SyncExpr *>(node) != NULL ||
dynamic_cast<NullPointerExpr *>(node) != NULL) {
else if (llvm::dyn_cast<SymbolExpr>(node) != NULL ||
llvm::dyn_cast<ConstExpr>(node) != NULL ||
llvm::dyn_cast<FunctionSymbolExpr>(node) != NULL ||
llvm::dyn_cast<SyncExpr>(node) != NULL ||
llvm::dyn_cast<NullPointerExpr>(node) != NULL) {
// nothing to do
}
else
@@ -331,7 +331,7 @@ struct CostData {
static bool
lCostCallbackPre(ASTNode *node, void *d) {
CostData *data = (CostData *)d;
if (dynamic_cast<ForeachStmt *>(node) != NULL)
if (llvm::dyn_cast<ForeachStmt>(node) != NULL)
++data->foreachDepth;
if (data->foreachDepth == 0)
data->cost += node->EstimateCost();
@@ -342,7 +342,7 @@ lCostCallbackPre(ASTNode *node, void *d) {
static ASTNode *
lCostCallbackPost(ASTNode *node, void *d) {
CostData *data = (CostData *)d;
if (dynamic_cast<ForeachStmt *>(node) != NULL)
if (llvm::dyn_cast<ForeachStmt>(node) != NULL)
--data->foreachDepth;
return node;
}
@@ -364,7 +364,7 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
bool *okPtr = (bool *)data;
FunctionCallExpr *fce;
if ((fce = dynamic_cast<FunctionCallExpr *>(node)) != NULL) {
if ((fce = llvm::dyn_cast<FunctionCallExpr>(node)) != NULL) {
if (fce->func == NULL)
return false;
@@ -381,7 +381,7 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
}
}
if (dynamic_cast<AssertStmt *>(node) != NULL) {
if (llvm::dyn_cast<AssertStmt>(node) != NULL) {
// While it's fine to run the assert for varying tests, it's not
// desirable to check an assert on a uniform variable if all of the
// lanes are off.
@@ -389,13 +389,13 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
return false;
}
if (dynamic_cast<PrintStmt *>(node) != NULL) {
if (llvm::dyn_cast<PrintStmt>(node) != NULL) {
*okPtr = false;
return false;
}
if (dynamic_cast<NewExpr *>(node) != NULL ||
dynamic_cast<DeleteStmt *>(node) != NULL) {
if (llvm::dyn_cast<NewExpr>(node) != NULL ||
llvm::dyn_cast<DeleteStmt>(node) != NULL) {
// We definitely don't want to run the uniform variants of these if
// the mask is all off. It's also worth skipping the overhead of
// executing the varying versions of them in the all-off mask case.
@@ -403,10 +403,10 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
return false;
}
if (dynamic_cast<ForeachStmt *>(node) != NULL ||
dynamic_cast<ForeachActiveStmt *>(node) != NULL ||
dynamic_cast<ForeachUniqueStmt *>(node) != NULL ||
dynamic_cast<UnmaskedStmt *>(node) != NULL) {
if (llvm::dyn_cast<ForeachStmt>(node) != NULL ||
llvm::dyn_cast<ForeachActiveStmt>(node) != NULL ||
llvm::dyn_cast<ForeachUniqueStmt>(node) != NULL ||
llvm::dyn_cast<UnmaskedStmt>(node) != NULL) {
// The various foreach statements also shouldn't be run with an
// all-off mask. Since they can re-establish an 'all on' mask,
// this would be pretty unintuitive. (More generally, it's
@@ -421,14 +421,14 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
}
IndexExpr *ie;
if ((ie = dynamic_cast<IndexExpr *>(node)) != NULL && ie->baseExpr != NULL) {
if ((ie = llvm::dyn_cast<IndexExpr>(node)) != NULL && ie->baseExpr != NULL) {
const Type *type = ie->baseExpr->GetType();
if (type == NULL)
return true;
if (CastType<ReferenceType>(type) != NULL)
type = type->GetReferenceTarget();
ConstExpr *ce = dynamic_cast<ConstExpr *>(ie->index);
ConstExpr *ce = llvm::dyn_cast<ConstExpr>(ie->index);
if (ce == NULL) {
// indexing with a variable... -> not safe
*okPtr = false;
@@ -466,13 +466,13 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
}
MemberExpr *me;
if ((me = dynamic_cast<MemberExpr *>(node)) != NULL &&
if ((me = llvm::dyn_cast<MemberExpr>(node)) != NULL &&
me->dereferenceExpr) {
*okPtr = false;
return false;
}
if (dynamic_cast<PtrDerefExpr *>(node) != NULL) {
if (llvm::dyn_cast<PtrDerefExpr>(node) != NULL) {
*okPtr = false;
return false;
}
@@ -482,7 +482,7 @@ lCheckAllOffSafety(ASTNode *node, void *data) {
assign to a uniform.
*/
AssignExpr *ae;
if ((ae = dynamic_cast<AssignExpr *>(node)) != NULL) {
if ((ae = llvm::dyn_cast<AssignExpr>(node)) != NULL) {
if (ae->GetType()) {
if (ae->GetType()->IsUniformType()) {
*okPtr = false;

23
ast.h
View File

@@ -48,8 +48,9 @@
(Expr) and statements (Stmt) inherit from this class.
*/
class ASTNode {
const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast)
public:
ASTNode(SourcePos p) : pos(p) { }
ASTNode(SourcePos p, unsigned scid) : SubclassID(scid), pos(p) { }
virtual ~ASTNode();
/** The Optimize() method should perform any appropriate early-stage
@@ -74,12 +75,24 @@ public:
/** All AST nodes must track the file position where they are
defined. */
SourcePos pos;
/** An enumeration for keeping track of the concrete subclass of Value
that is actually instantiated.*/
enum ASTNodeTy {
ExprID,
StmtID
};
/** Return an ID for the concrete type of this object. This is used to
implement the classof checks. This should not be used for any
other purpose, as the values may change as ISPC evolves */
unsigned getValueID() const {
return SubclassID;
}
static inline bool classof(ASTNode const*) { return true; }
};
/** Simple representation of the abstract syntax trees for all of the
functions declared in a compilation unit.
*/
class AST {
public:
/** Add the AST for a function described by the given declaration

2
ctx.cpp
View File

@@ -1241,7 +1241,7 @@ FunctionEmitContext::EnableGatherScatterWarnings() {
bool
FunctionEmitContext::initLabelBBlocks(ASTNode *node, void *data) {
LabeledStmt *ls = dynamic_cast<LabeledStmt *>(node);
LabeledStmt *ls = llvm::dyn_cast<LabeledStmt>(node);
if (ls == NULL)
return true;

4
decl.cpp
View File

@@ -519,9 +519,9 @@ Declarator::InitFromType(const Type *baseType, DeclSpecs *ds) {
decl->initExpr = TypeCheck(decl->initExpr);
decl->initExpr = Optimize(decl->initExpr);
if (decl->initExpr != NULL) {
init = dynamic_cast<ConstExpr *>(decl->initExpr);
init = llvm::dyn_cast<ConstExpr>(decl->initExpr);
if (init == NULL)
init = dynamic_cast<NullPointerExpr *>(decl->initExpr);
init = llvm::dyn_cast<NullPointerExpr>(decl->initExpr);
if (init == NULL)
Error(decl->initExpr->pos, "Default value for parameter "
"\"%s\" must be a compile-time constant.",

148
expr.cpp
View File

@@ -178,7 +178,7 @@ lIsAllIntZeros(Expr *expr) {
if (type == NULL || type->IsIntType() == false)
return false;
ConstExpr *ce = dynamic_cast<ConstExpr *>(expr);
ConstExpr *ce = llvm::dyn_cast<ConstExpr>(expr);
if (ce == NULL)
return false;
@@ -355,7 +355,7 @@ lDoTypeConv(const Type *fromType, const Type *toType, Expr **expr,
}
else if (PointerType::IsVoidPointer(fromPointerType) &&
expr != NULL &&
dynamic_cast<NullPointerExpr *>(*expr) != NULL) {
llvm::dyn_cast<NullPointerExpr>(*expr) != NULL) {
// and a NULL convert to any other pointer type
goto typecast_ok;
}
@@ -617,7 +617,7 @@ PossiblyResolveFunctionOverloads(Expr *expr, const Type *type) {
const FunctionType *funcType = NULL;
if (CastType<PointerType>(type) != NULL &&
(funcType = CastType<FunctionType>(type->GetBaseType())) &&
(fse = dynamic_cast<FunctionSymbolExpr *>(expr)) != NULL) {
(fse = llvm::dyn_cast<FunctionSymbolExpr>(expr)) != NULL) {
// We're initializing a function pointer with a function symbol,
// which in turn may represent an overloaded function. So we need
// to try to resolve the overload based on the type of the symbol
@@ -684,7 +684,7 @@ InitSymbol(llvm::Value *ptr, const Type *symType, Expr *initExpr,
// If the initializer is a straight up expression that isn't an
// ExprList, then we'll see if we can type convert it to the type of
// the variable.
if (dynamic_cast<ExprList *>(initExpr) == NULL) {
if (llvm::dyn_cast<ExprList>(initExpr) == NULL) {
if (PossiblyResolveFunctionOverloads(initExpr, symType) == false)
return;
initExpr = TypeConvertExpr(initExpr, symType, "initializer");
@@ -703,7 +703,7 @@ InitSymbol(llvm::Value *ptr, const Type *symType, Expr *initExpr,
// expressions if they have a single element (except for SOA types,
// which are handled below).
if (symType->IsSOAType() == false && Type::IsBasicType(symType)) {
ExprList *elist = dynamic_cast<ExprList *>(initExpr);
ExprList *elist = llvm::dyn_cast<ExprList>(initExpr);
if (elist != NULL) {
if (elist->exprs.size() == 1)
InitSymbol(ptr, symType, elist->exprs[0], ctx, pos);
@@ -755,7 +755,7 @@ InitSymbol(llvm::Value *ptr, const Type *symType, Expr *initExpr,
// an initializer list may be provided (float foo[3] = { 1,2,3 }),
// in which case the elements are initialized with the
// corresponding values.
ExprList *exprList = dynamic_cast<ExprList *>(initExpr);
ExprList *exprList = llvm::dyn_cast<ExprList>(initExpr);
if (exprList != NULL) {
// The { ... } case; make sure we have the no more expressions
// in the ExprList as we have struct members
@@ -1108,7 +1108,7 @@ lEmitNegate(Expr *arg, SourcePos pos, FunctionEmitContext *ctx) {
UnaryExpr::UnaryExpr(Op o, Expr *e, SourcePos p)
: Expr(p), op(o) {
: Expr(p, UnaryExprID), op(o) {
expr = e;
}
@@ -1184,7 +1184,7 @@ lOptimizeBitNot(ConstExpr *constExpr, const Type *type, SourcePos pos) {
Expr *
UnaryExpr::Optimize() {
ConstExpr *constExpr = dynamic_cast<ConstExpr *>(expr);
ConstExpr *constExpr = llvm::dyn_cast<ConstExpr>(expr);
// If the operand isn't a constant, then we can't do any optimization
// here...
if (constExpr == NULL)
@@ -1359,7 +1359,7 @@ UnaryExpr::TypeCheck() {
int
UnaryExpr::EstimateCost() const {
if (dynamic_cast<ConstExpr *>(expr) != NULL)
if (llvm::dyn_cast<ConstExpr>(expr) != NULL)
return 0;
return COST_SIMPLE_ARITH_LOGIC_OP;
@@ -1666,7 +1666,7 @@ lEmitBinaryCmp(BinaryExpr::Op op, llvm::Value *e0Val, llvm::Value *e1Val,
BinaryExpr::BinaryExpr(Op o, Expr *a, Expr *b, SourcePos p)
: Expr(p), op(o) {
: Expr(p, BinaryExprID), op(o) {
arg0 = a;
arg1 = b;
}
@@ -1990,7 +1990,7 @@ lIsDifficultShiftAmount(Expr *expr) {
if (expr->GetType()->IsVaryingType() == false)
return false;
ConstExpr *ce = dynamic_cast<ConstExpr *>(expr);
ConstExpr *ce = llvm::dyn_cast<ConstExpr>(expr);
if (ce) {
// If the shift is by a constant amount, *and* it's the same amount
// in all vector lanes, we're in good shape.
@@ -2002,7 +2002,7 @@ lIsDifficultShiftAmount(Expr *expr) {
return false;
}
TypeCastExpr *tce = dynamic_cast<TypeCastExpr *>(expr);
TypeCastExpr *tce = llvm::dyn_cast<TypeCastExpr>(expr);
if (tce && tce->expr) {
// Finally, if the shift amount is given by a uniform value that's
// been smeared out into a varying, we have the same shift for all
@@ -2330,7 +2330,7 @@ lCanImproveVectorDivide(Expr *arg0, Expr *arg1, int *divisor) {
// The divisor must be the same compile-time constant value for all of
// the vector lanes.
ConstExpr *ce = dynamic_cast<ConstExpr *>(arg1);
ConstExpr *ce = llvm::dyn_cast<ConstExpr>(arg1);
if (!ce)
return false;
int64_t div[ISPC_MAX_NVEC];
@@ -2357,8 +2357,8 @@ BinaryExpr::Optimize() {
if (arg0 == NULL || arg1 == NULL)
return NULL;
ConstExpr *constArg0 = dynamic_cast<ConstExpr *>(arg0);
ConstExpr *constArg1 = dynamic_cast<ConstExpr *>(arg1);
ConstExpr *constArg0 = llvm::dyn_cast<ConstExpr>(arg0);
ConstExpr *constArg1 = llvm::dyn_cast<ConstExpr>(arg1);
if (g->opt.fastMath) {
// optimizations related to division by floats..
@@ -2823,8 +2823,8 @@ BinaryExpr::GetLValueType() const {
int
BinaryExpr::EstimateCost() const {
if (dynamic_cast<ConstExpr *>(arg0) != NULL &&
dynamic_cast<ConstExpr *>(arg1) != NULL)
if (llvm::dyn_cast<ConstExpr>(arg0) != NULL &&
llvm::dyn_cast<ConstExpr>(arg1) != NULL)
return 0;
return (op == Div || op == Mod) ? COST_COMPLEX_ARITH_OP :
@@ -2945,7 +2945,7 @@ lEmitOpAssign(AssignExpr::Op op, Expr *arg0, Expr *arg1, const Type *type,
AssignExpr::AssignExpr(AssignExpr::Op o, Expr *a, Expr *b, SourcePos p)
: Expr(p), op(o) {
: Expr(p, AssignExprID), op(o) {
lvalue = a;
rvalue = b;
}
@@ -3170,7 +3170,7 @@ AssignExpr::Print() const {
// SelectExpr
SelectExpr::SelectExpr(Expr *t, Expr *e1, Expr *e2, SourcePos p)
: Expr(p) {
: Expr(p, SelectExprID) {
test = t;
expr1 = e1;
expr2 = e2;
@@ -3404,7 +3404,7 @@ SelectExpr::Optimize() {
if (test == NULL || expr1 == NULL || expr2 == NULL)
return NULL;
ConstExpr *constTest = dynamic_cast<ConstExpr *>(test);
ConstExpr *constTest = llvm::dyn_cast<ConstExpr>(test);
if (constTest == NULL)
return this;
@@ -3431,8 +3431,8 @@ SelectExpr::Optimize() {
// Last chance: see if the two expressions are constants; if so,
// then we can do an element-wise selection based on the constant
// condition..
ConstExpr *constExpr1 = dynamic_cast<ConstExpr *>(expr1);
ConstExpr *constExpr2 = dynamic_cast<ConstExpr *>(expr2);
ConstExpr *constExpr1 = llvm::dyn_cast<ConstExpr>(expr1);
ConstExpr *constExpr2 = llvm::dyn_cast<ConstExpr>(expr2);
if (constExpr1 == NULL || constExpr2 == NULL)
return this;
@@ -3555,7 +3555,7 @@ SelectExpr::Print() const {
FunctionCallExpr::FunctionCallExpr(Expr *f, ExprList *a, SourcePos p,
bool il, Expr *lce[3])
: Expr(p), isLaunch(il) {
: Expr(p, FunctionCallExprID), isLaunch(il) {
func = f;
args = a;
if (lce != NULL)
@@ -3728,8 +3728,8 @@ bool FullResolveOverloads(Expr * func, ExprList * args,
if (t == NULL)
return false;
argTypes->push_back(t);
argCouldBeNULL->push_back(lIsAllIntZeros(expr) || dynamic_cast<NullPointerExpr *>(expr));
argIsConstant->push_back(dynamic_cast<ConstExpr *>(expr) || dynamic_cast<NullPointerExpr *>(expr));
argCouldBeNULL->push_back(lIsAllIntZeros(expr) || llvm::dyn_cast<NullPointerExpr>(expr));
argIsConstant->push_back(llvm::dyn_cast<ConstExpr>(expr) || llvm::dyn_cast<NullPointerExpr>(expr));
}
return true;
}
@@ -3740,7 +3740,7 @@ FunctionCallExpr::GetType() const {
std::vector<const Type *> argTypes;
std::vector<bool> argCouldBeNULL, argIsConstant;
if (FullResolveOverloads(func, args, &argTypes, &argCouldBeNULL, &argIsConstant) == true) {
FunctionSymbolExpr *fse = dynamic_cast<FunctionSymbolExpr *>(func);
FunctionSymbolExpr *fse = llvm::dyn_cast<FunctionSymbolExpr>(func);
if (fse != NULL) {
fse->ResolveOverloads(args->pos, argTypes, &argCouldBeNULL, &argIsConstant);
}
@@ -3785,7 +3785,7 @@ FunctionCallExpr::TypeCheck() {
return NULL;
}
FunctionSymbolExpr *fse = dynamic_cast<FunctionSymbolExpr *>(func);
FunctionSymbolExpr *fse = llvm::dyn_cast<FunctionSymbolExpr>(func);
if (fse != NULL) {
// Regular function call
if (fse->ResolveOverloads(args->pos, argTypes, &argCouldBeNULL,
@@ -4012,7 +4012,7 @@ ExprList::GetConstant(const Type *type) const {
const Type *elementType = collectionType->GetElementType(i);
Expr *expr = exprs[i];
if (dynamic_cast<ExprList *>(expr) == NULL) {
if (llvm::dyn_cast<ExprList>(expr) == NULL) {
// If there's a simple type conversion from the type of this
// expression to the type we need, then let the regular type
// conversion machinery handle it.
@@ -4121,7 +4121,7 @@ ExprList::Print() const {
// IndexExpr
IndexExpr::IndexExpr(Expr *a, Expr *i, SourcePos p)
: Expr(p) {
: Expr(p, IndexExprID) {
baseExpr = a;
index = i;
type = lvalueType = NULL;
@@ -4294,8 +4294,8 @@ IndexExpr::GetValue(FunctionEmitContext *ctx) const {
}
else {
Symbol *baseSym = GetBaseSymbol();
if (dynamic_cast<FunctionCallExpr *>(baseExpr) == NULL &&
dynamic_cast<BinaryExpr *>(baseExpr) == NULL) {
if (llvm::dyn_cast<FunctionCallExpr>(baseExpr) == NULL &&
llvm::dyn_cast<BinaryExpr>(baseExpr) == NULL) {
// Don't check if we're doing a function call or pointer arith
AssertPos(pos, baseSym != NULL);
}
@@ -4404,7 +4404,7 @@ lCheckIndicesVersusBounds(const Type *baseExprType, Expr *index) {
if (soaWidth > 0)
nElements *= soaWidth;
ConstExpr *ce = dynamic_cast<ConstExpr *>(index);
ConstExpr *ce = llvm::dyn_cast<ConstExpr>(index);
if (ce == NULL)
return;
@@ -4737,7 +4737,7 @@ private:
StructMemberExpr::StructMemberExpr(Expr *e, const char *id, SourcePos p,
SourcePos idpos, bool derefLValue)
: MemberExpr(e, id, p, idpos, derefLValue) {
: MemberExpr(e, id, p, idpos, derefLValue, StructMemberExprID) {
}
@@ -4908,7 +4908,7 @@ private:
VectorMemberExpr::VectorMemberExpr(Expr *e, const char *id, SourcePos p,
SourcePos idpos, bool derefLValue)
: MemberExpr(e, id, p, idpos, derefLValue) {
: MemberExpr(e, id, p, idpos, derefLValue, VectorMemberExprID) {
const Type *exprType = e->GetType();
exprVectorType = CastType<VectorType>(exprType);
if (exprVectorType == NULL) {
@@ -5166,8 +5166,8 @@ MemberExpr::create(Expr *e, const char *id, SourcePos p, SourcePos idpos,
MemberExpr::MemberExpr(Expr *e, const char *id, SourcePos p, SourcePos idpos,
bool derefLValue)
: Expr(p), identifierPos(idpos) {
bool derefLValue, unsigned scid)
: Expr(p, scid), identifierPos(idpos) {
expr = e;
identifier = id;
dereferenceExpr = derefLValue;
@@ -5340,7 +5340,7 @@ MemberExpr::getCandidateNearMatches() const {
// ConstExpr
ConstExpr::ConstExpr(const Type *t, int8_t i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt8->GetAsConstType()));
@@ -5349,7 +5349,7 @@ ConstExpr::ConstExpr(const Type *t, int8_t i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int8_t *i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt8->GetAsConstType()) ||
@@ -5360,7 +5360,7 @@ ConstExpr::ConstExpr(const Type *t, int8_t *i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint8_t u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt8->GetAsConstType()));
@@ -5369,7 +5369,7 @@ ConstExpr::ConstExpr(const Type *t, uint8_t u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint8_t *u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt8->GetAsConstType()) ||
@@ -5380,7 +5380,7 @@ ConstExpr::ConstExpr(const Type *t, uint8_t *u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int16_t i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt16->GetAsConstType()));
@@ -5389,7 +5389,7 @@ ConstExpr::ConstExpr(const Type *t, int16_t i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int16_t *i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt16->GetAsConstType()) ||
@@ -5400,7 +5400,7 @@ ConstExpr::ConstExpr(const Type *t, int16_t *i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint16_t u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt16->GetAsConstType()));
@@ -5409,7 +5409,7 @@ ConstExpr::ConstExpr(const Type *t, uint16_t u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint16_t *u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt16->GetAsConstType()) ||
@@ -5420,7 +5420,7 @@ ConstExpr::ConstExpr(const Type *t, uint16_t *u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int32_t i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt32->GetAsConstType()));
@@ -5429,7 +5429,7 @@ ConstExpr::ConstExpr(const Type *t, int32_t i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int32_t *i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt32->GetAsConstType()) ||
@@ -5440,7 +5440,7 @@ ConstExpr::ConstExpr(const Type *t, int32_t *i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint32_t u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt32->GetAsConstType()) ||
@@ -5451,7 +5451,7 @@ ConstExpr::ConstExpr(const Type *t, uint32_t u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint32_t *u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt32->GetAsConstType()) ||
@@ -5463,7 +5463,7 @@ ConstExpr::ConstExpr(const Type *t, uint32_t *u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, float f, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformFloat->GetAsConstType()));
@@ -5472,7 +5472,7 @@ ConstExpr::ConstExpr(const Type *t, float f, SourcePos p)
ConstExpr::ConstExpr(const Type *t, float *f, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformFloat->GetAsConstType()) ||
@@ -5483,7 +5483,7 @@ ConstExpr::ConstExpr(const Type *t, float *f, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int64_t i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt64->GetAsConstType()));
@@ -5492,7 +5492,7 @@ ConstExpr::ConstExpr(const Type *t, int64_t i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, int64_t *i, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformInt64->GetAsConstType()) ||
@@ -5503,7 +5503,7 @@ ConstExpr::ConstExpr(const Type *t, int64_t *i, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint64_t u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt64->GetAsConstType()));
@@ -5512,7 +5512,7 @@ ConstExpr::ConstExpr(const Type *t, uint64_t u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, uint64_t *u, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformUInt64->GetAsConstType()) ||
@@ -5523,7 +5523,7 @@ ConstExpr::ConstExpr(const Type *t, uint64_t *u, SourcePos p)
ConstExpr::ConstExpr(const Type *t, double f, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformDouble->GetAsConstType()));
@@ -5532,7 +5532,7 @@ ConstExpr::ConstExpr(const Type *t, double f, SourcePos p)
ConstExpr::ConstExpr(const Type *t, double *f, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformDouble->GetAsConstType()) ||
@@ -5543,7 +5543,7 @@ ConstExpr::ConstExpr(const Type *t, double *f, SourcePos p)
ConstExpr::ConstExpr(const Type *t, bool b, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformBool->GetAsConstType()));
@@ -5552,7 +5552,7 @@ ConstExpr::ConstExpr(const Type *t, bool b, SourcePos p)
ConstExpr::ConstExpr(const Type *t, bool *b, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = t;
type = type->GetAsConstType();
AssertPos(pos, Type::Equal(type, AtomicType::UniformBool->GetAsConstType()) ||
@@ -5563,7 +5563,7 @@ ConstExpr::ConstExpr(const Type *t, bool *b, SourcePos p)
ConstExpr::ConstExpr(ConstExpr *old, double *v)
: Expr(old->pos) {
: Expr(old->pos, ConstExprID) {
type = old->type;
AtomicType::BasicType basicType = getBasicType();
@@ -5617,7 +5617,7 @@ ConstExpr::ConstExpr(ConstExpr *old, double *v)
ConstExpr::ConstExpr(ConstExpr *old, SourcePos p)
: Expr(p) {
: Expr(p, ConstExprID) {
type = old->type;
AtomicType::BasicType basicType = getBasicType();
@@ -6223,7 +6223,7 @@ ConstExpr::Print() const {
// TypeCastExpr
TypeCastExpr::TypeCastExpr(const Type *t, Expr *e, SourcePos p)
: Expr(p) {
: Expr(p, TypeCastExprID) {
type = t;
expr = e;
}
@@ -7229,7 +7229,7 @@ TypeCastExpr::TypeCheck() {
Expr *
TypeCastExpr::Optimize() {
ConstExpr *constExpr = dynamic_cast<ConstExpr *>(expr);
ConstExpr *constExpr = llvm::dyn_cast<ConstExpr>(expr);
if (constExpr == NULL)
// We can't do anything if this isn't a const expr
return this;
@@ -7315,7 +7315,7 @@ TypeCastExpr::Optimize() {
int
TypeCastExpr::EstimateCost() const {
if (dynamic_cast<ConstExpr *>(expr) != NULL)
if (llvm::dyn_cast<ConstExpr>(expr) != NULL)
return 0;
// FIXME: return COST_TYPECAST_COMPLEX when appropriate
@@ -7392,7 +7392,7 @@ TypeCastExpr::GetConstant(const Type *constType) const {
// ReferenceExpr
ReferenceExpr::ReferenceExpr(Expr *e, SourcePos p)
: Expr(p) {
: Expr(p, ReferenceExprID) {
expr = e;
}
@@ -7500,8 +7500,8 @@ ReferenceExpr::Print() const {
///////////////////////////////////////////////////////////////////////////
// DerefExpr
DerefExpr::DerefExpr(Expr *e, SourcePos p)
: Expr(p) {
DerefExpr::DerefExpr(Expr *e, SourcePos p, unsigned scid)
: Expr(p, scid) {
expr = e;
}
@@ -7563,7 +7563,7 @@ DerefExpr::Optimize() {
// PtrDerefExpr
PtrDerefExpr::PtrDerefExpr(Expr *e, SourcePos p)
: DerefExpr(e, p) {
: DerefExpr(e, p, PtrDerefExprID) {
}
@@ -7641,7 +7641,7 @@ PtrDerefExpr::Print() const {
// RefDerefExpr
RefDerefExpr::RefDerefExpr(Expr *e, SourcePos p)
: DerefExpr(e, p) {
: DerefExpr(e, p, RefDerefExprID) {
}
@@ -7700,7 +7700,7 @@ RefDerefExpr::Print() const {
// AddressOfExpr
AddressOfExpr::AddressOfExpr(Expr *e, SourcePos p)
: Expr(p), expr(e) {
: Expr(p, AddressOfExprID), expr(e) {
}
@@ -7832,12 +7832,12 @@ AddressOfExpr::GetConstant(const Type *type) const {
// SizeOfExpr
SizeOfExpr::SizeOfExpr(Expr *e, SourcePos p)
: Expr(p), expr(e), type(NULL) {
: Expr(p, SizeOfExprID), expr(e), type(NULL) {
}
SizeOfExpr::SizeOfExpr(const Type *t, SourcePos p)
: Expr(p), expr(NULL), type(t) {
: Expr(p, SizeOfExprID), expr(NULL), type(t) {
type = type->ResolveUnboundVariability(Variability::Varying);
}
@@ -7914,7 +7914,7 @@ SizeOfExpr::EstimateCost() const {
// SymbolExpr
SymbolExpr::SymbolExpr(Symbol *s, SourcePos p)
: Expr(p) {
: Expr(p, SymbolExprID) {
symbol = s;
}
@@ -8008,7 +8008,7 @@ SymbolExpr::Print() const {
FunctionSymbolExpr::FunctionSymbolExpr(const char *n,
const std::vector<Symbol *> &candidates,
SourcePos p)
: Expr(p) {
: Expr(p, FunctionSymbolExprID) {
name = n;
candidateFunctions = candidates;
matchingFunc = (candidates.size() == 1) ? candidates[0] : NULL;
@@ -8555,7 +8555,7 @@ NullPointerExpr::EstimateCost() const {
NewExpr::NewExpr(int typeQual, const Type *t, Expr *init, Expr *count,
SourcePos tqPos, SourcePos p)
: Expr(p) {
: Expr(p, NewExprID) {
allocType = t;
initExpr = init;

6
expr.h
View File

@@ -47,7 +47,7 @@
*/
class Expr : public ASTNode {
public:
Expr(SourcePos p) : ASTNode(p) { }
Expr(SourcePos p, unsigned scid) : ASTNode(p, scid) { }
/** This is the main method for Expr implementations to implement. It
should call methods in the FunctionEmitContext to emit LLVM IR
@@ -322,7 +322,7 @@ public:
const SourcePos identifierPos;
MemberExpr(Expr *expr, const char *identifier, SourcePos pos,
SourcePos identifierPos, bool derefLValue);
SourcePos identifierPos, bool derefLValue, unsigned scid);
/** Indicates whether the expression should be dereferenced before the
member is found. (i.e. this is true if the MemberExpr was a '->'
@@ -498,7 +498,7 @@ public:
PtrDerefExpr and RefDerefExpr. */
class DerefExpr : public Expr {
public:
DerefExpr(Expr *e, SourcePos p);
DerefExpr(Expr *e, SourcePos p, unsigned scid = DerefExprID);
llvm::Value *GetValue(FunctionEmitContext *ctx) const;
llvm::Value *GetLValue(FunctionEmitContext *ctx) const;

2
func.cpp
View File

@@ -499,7 +499,7 @@ Function::GenerateIR() {
// non-StmtList statment...
SourcePos firstStmtPos = sym->pos;
if (code) {
StmtList *sl = dynamic_cast<StmtList *>(code);
StmtList *sl = llvm::dyn_cast<StmtList>(code);
if (sl && sl->stmts.size() > 0 && sl->stmts[0] != NULL)
firstStmtPos = sl->stmts[0]->pos;
else

10
module.cpp
View File

@@ -608,7 +608,7 @@ Module::AddGlobalVariable(const std::string &name, const Type *type, Expr *initE
// the same type as the global. (But not if it's an
// ExprList; they don't have types per se / can't type
// convert themselves anyway.)
if (dynamic_cast<ExprList *>(initExpr) == NULL)
if (llvm::dyn_cast<ExprList>(initExpr) == NULL)
initExpr = TypeConvertExpr(initExpr, type, "initializer");
if (initExpr != NULL) {
@@ -620,11 +620,11 @@ Module::AddGlobalVariable(const std::string &name, const Type *type, Expr *initE
if (llvmInitializer != NULL) {
if (type->IsConstType())
// Try to get a ConstExpr associated with
// the symbol. This dynamic_cast can
// the symbol. This llvm::dyn_cast can
// validly fail, for example for types like
// StructTypes where a ConstExpr can't
// represent their values.
constValue = dynamic_cast<ConstExpr *>(initExpr);
constValue = llvm::dyn_cast<ConstExpr>(initExpr);
}
else
Error(initExpr->pos, "Initializer for global variable \"%s\" "
@@ -1906,7 +1906,7 @@ std::string emitOffloadParamStruct(const std::string &paramStructName,
Error(sym->pos,"When emitting offload-stubs, \"export\"ed functions cannot have non-const reference-type parameters.\n");
}
const ReferenceType *refType
= dynamic_cast<const ReferenceType*>(orgParamType);
= llvm::dyn_cast<const ReferenceType>(orgParamType);
paramType = refType->GetReferenceTarget()->GetAsNonConstType();
} else {
paramType = orgParamType->GetAsNonConstType();
@@ -2025,7 +2025,7 @@ Module::writeDevStub(const char *fn)
Error(sym->pos,"When emitting offload-stubs, \"export\"ed functions cannot have non-const reference-type parameters.\n");
}
const ReferenceType *refType
= dynamic_cast<const ReferenceType*>(orgParamType);
= llvm::dyn_cast<const ReferenceType>(orgParamType);
paramType = refType->GetReferenceTarget()->GetAsNonConstType();
} else {
paramType = orgParamType->GetAsNonConstType();

4
parse.yy
View File

@@ -480,7 +480,7 @@ argument_expression_list
: assignment_expression { $$ = new ExprList($1, @1); }
| argument_expression_list ',' assignment_expression
{
ExprList *argList = dynamic_cast<ExprList *>($1);
ExprList *argList = llvm::dyn_cast<ExprList>($1);
if (argList == NULL) {
AssertPos(@1, m->errorCount > 0);
argList = new ExprList(@3);
@@ -2422,7 +2422,7 @@ lFinalizeEnumeratorSymbols(std::vector<Symbol *> &enums,
Expr *castExpr = new TypeCastExpr(enumType, enums[i]->constValue,
enums[i]->pos);
castExpr = Optimize(castExpr);
enums[i]->constValue = dynamic_cast<ConstExpr *>(castExpr);
enums[i]->constValue = llvm::dyn_cast<ConstExpr>(castExpr);
AssertPos(enums[i]->pos, enums[i]->constValue != NULL);
}
else {

50
stmt.cpp
View File

@@ -295,7 +295,7 @@ DeclStmt::EmitCode(FunctionEmitContext *ctx) const {
// FIXME: we only need this for function pointers; it was
// already done for atomic types and enums in
// DeclStmt::TypeCheck()...
if (dynamic_cast<ExprList *>(initExpr) == NULL) {
if (llvm::dyn_cast<ExprList>(initExpr) == NULL) {
initExpr = TypeConvertExpr(initExpr, sym->type,
"initializer");
// FIXME: and this is only needed to re-establish
@@ -436,7 +436,7 @@ Stmt *
DeclStmt::Optimize() {
for (unsigned int i = 0; i < vars.size(); ++i) {
Expr *init = vars[i].init;
if (init != NULL && dynamic_cast<ExprList *>(init) == NULL) {
if (init != NULL && llvm::dyn_cast<ExprList>(init) == NULL) {
// If the variable is const-qualified, after we've optimized
// the initializer expression, see if we have a ConstExpr. If
// so, save it in Symbol::constValue where it can be used in
@@ -455,7 +455,7 @@ DeclStmt::Optimize() {
Symbol *sym = vars[i].sym;
if (sym->type && sym->type->IsConstType() &&
Type::Equal(init->GetType(), sym->type))
sym->constValue = dynamic_cast<ConstExpr *>(init);
sym->constValue = llvm::dyn_cast<ConstExpr>(init);
}
}
return this;
@@ -483,7 +483,7 @@ DeclStmt::TypeCheck() {
// If it's an expr list with an atomic type, we'll later issue
// an error. Need to leave vars[i].init as is in that case so
// it is in fact caught later, though.
if (dynamic_cast<ExprList *>(vars[i].init) == NULL) {
if (llvm::dyn_cast<ExprList>(vars[i].init) == NULL) {
vars[i].init = TypeConvertExpr(vars[i].init, type,
"initializer");
if (vars[i].init == NULL)
@@ -534,11 +534,11 @@ lEmitIfStatements(FunctionEmitContext *ctx, Stmt *stmts, const char *trueOrFalse
if (!stmts)
return;
if (dynamic_cast<StmtList *>(stmts) == NULL)
if (llvm::dyn_cast<StmtList>(stmts) == NULL)
ctx->StartScope();
ctx->AddInstrumentationPoint(trueOrFalse);
stmts->EmitCode(ctx);
if (dynamic_cast<const StmtList *>(stmts) == NULL)
if (llvm::dyn_cast<const StmtList>(stmts) == NULL)
ctx->EndScope();
}
@@ -549,18 +549,18 @@ lEmitIfStatements(FunctionEmitContext *ctx, Stmt *stmts, const char *trueOrFalse
static bool
lCanApplyBreakOptimization(Stmt *trueStmts, Stmt *falseStmts) {
if (falseStmts != NULL) {
if (StmtList *sl = dynamic_cast<StmtList *>(falseStmts)) {
if (StmtList *sl = llvm::dyn_cast<StmtList>(falseStmts)) {
return (sl->stmts.size() == 0);
}
else
return false;
}
if (dynamic_cast<BreakStmt *>(trueStmts))
if (llvm::dyn_cast<BreakStmt>(trueStmts))
return true;
else if (StmtList *sl = dynamic_cast<StmtList *>(trueStmts))
else if (StmtList *sl = llvm::dyn_cast<StmtList>(trueStmts))
return (sl->stmts.size() == 1 &&
dynamic_cast<BreakStmt *>(sl->stmts[0]) != NULL);
llvm::dyn_cast<BreakStmt>(sl->stmts[0]) != NULL);
else
return false;
}
@@ -949,7 +949,7 @@ struct VaryingBCCheckInfo {
static bool
lIsVaryingFor(ASTNode *node) {
IfStmt *ifStmt;
if ((ifStmt = dynamic_cast<IfStmt *>(node)) != NULL &&
if ((ifStmt = llvm::dyn_cast<IfStmt>(node)) != NULL &&
ifStmt->test != NULL) {
const Type *type = ifStmt->test->GetType();
return (type != NULL && type->IsVaryingType());
@@ -967,8 +967,8 @@ lVaryingBCPreFunc(ASTNode *node, void *d) {
// We found a break or continue statement; if we're under varying
// control flow, then bingo.
if ((dynamic_cast<BreakStmt *>(node) != NULL ||
dynamic_cast<ContinueStmt *>(node) != NULL) &&
if ((llvm::dyn_cast<BreakStmt>(node) != NULL ||
llvm::dyn_cast<ContinueStmt>(node) != NULL) &&
info->varyingControlFlowDepth > 0) {
info->foundVaryingBreakOrContinue = true;
return false;
@@ -979,9 +979,9 @@ lVaryingBCPreFunc(ASTNode *node, void *d) {
if (lIsVaryingFor(node))
++info->varyingControlFlowDepth;
if (dynamic_cast<ForStmt *>(node) != NULL ||
dynamic_cast<DoStmt *>(node) != NULL ||
dynamic_cast<ForeachStmt *>(node) != NULL)
if (llvm::dyn_cast<ForStmt>(node) != NULL ||
llvm::dyn_cast<DoStmt>(node) != NULL ||
llvm::dyn_cast<ForeachStmt>(node) != NULL)
// Don't recurse into these guys, since we don't care about varying
// breaks or continues within them...
return false;
@@ -1052,7 +1052,7 @@ void DoStmt::EmitCode(FunctionEmitContext *ctx) const {
// scope around the statements in the list. So if the body is just a
// single statement (and thus not a statement list), we need a new
// scope, but we don't want two scopes in the StmtList case.
if (!dynamic_cast<StmtList *>(bodyStmts))
if (!llvm::dyn_cast<StmtList>(bodyStmts))
ctx->StartScope();
ctx->AddInstrumentationPoint("do loop body");
@@ -1094,7 +1094,7 @@ void DoStmt::EmitCode(FunctionEmitContext *ctx) const {
ctx->BranchInst(btest);
}
// End the scope we started above, if needed.
if (!dynamic_cast<StmtList *>(bodyStmts))
if (!llvm::dyn_cast<StmtList>(bodyStmts))
ctx->EndScope();
// Now emit code for the loop test.
@@ -1219,7 +1219,7 @@ ForStmt::EmitCode(FunctionEmitContext *ctx) const {
// it and then jump into the loop test code. (Also start a new scope
// since the initiailizer may be a declaration statement).
if (init) {
AssertPos(pos, dynamic_cast<StmtList *>(init) == NULL);
AssertPos(pos, llvm::dyn_cast<StmtList>(init) == NULL);
ctx->StartScope();
init->EmitCode(ctx);
}
@@ -1261,7 +1261,7 @@ ForStmt::EmitCode(FunctionEmitContext *ctx) const {
ctx->SetCurrentBasicBlock(bloop);
ctx->SetBlockEntryMask(ctx->GetFullMask());
ctx->AddInstrumentationPoint("for loop body");
if (!dynamic_cast<StmtList *>(stmts))
if (!llvm::dyn_cast<StmtList>(stmts))
ctx->StartScope();
if (doCoherentCheck && !uniformTest) {
@@ -1306,7 +1306,7 @@ ForStmt::EmitCode(FunctionEmitContext *ctx) const {
if (ctx->GetCurrentBasicBlock())
ctx->BranchInst(bstep);
}
if (!dynamic_cast<StmtList *>(stmts))
if (!llvm::dyn_cast<StmtList>(stmts))
ctx->EndScope();
// Emit code for the loop step. First, restore the lane mask of any
@@ -2794,13 +2794,13 @@ struct SwitchVisitInfo {
static bool
lSwitchASTPreVisit(ASTNode *node, void *d) {
if (dynamic_cast<SwitchStmt *>(node) != NULL)
if (llvm::dyn_cast<SwitchStmt>(node) != NULL)
// don't continue recursively into a nested switch--we only want
// our own case and default statements!
return false;
CaseStmt *cs = dynamic_cast<CaseStmt *>(node);
DefaultStmt *ds = dynamic_cast<DefaultStmt *>(node);
CaseStmt *cs = llvm::dyn_cast<CaseStmt>(node);
DefaultStmt *ds = llvm::dyn_cast<DefaultStmt>(node);
SwitchVisitInfo *svi = (SwitchVisitInfo *)d;
llvm::BasicBlock *bb = NULL;
@@ -3383,7 +3383,7 @@ PrintStmt::EmitCode(FunctionEmitContext *ctx) const {
// Get the values passed to the print() statement evaluated and
// stored in memory so that we set up the array of pointers to them
// for the 5th __do_print() argument
ExprList *elist = dynamic_cast<ExprList *>(values);
ExprList *elist = llvm::dyn_cast<ExprList>(values);
int nArgs = elist ? elist->exprs.size() : 1;
// Allocate space for the array of pointers to values to be printed

8
test_class_of.cpp Normal file
View File

@@ -0,0 +1,8 @@
#include "ispc.h"
int main() {
return 0;
};

6
type.cpp
View File

@@ -1603,7 +1603,7 @@ ArrayType::SizeUnsizedArrays(const Type *type, Expr *initExpr) {
if (at == NULL)
return type;
ExprList *exprList = dynamic_cast<ExprList *>(initExpr);
ExprList *exprList = llvm::dyn_cast<ExprList>(initExpr);
if (exprList == NULL || exprList->exprs.size() == 0)
return type;
@@ -1618,7 +1618,7 @@ ArrayType::SizeUnsizedArrays(const Type *type, Expr *initExpr) {
// now. Otherwise we'll use the first one to size the next dimension
// (after checking below that it has the same length as all of the
// other ones.
ExprList *nextList = dynamic_cast<ExprList *>(exprList->exprs[0]);
ExprList *nextList = llvm::dyn_cast<ExprList>(exprList->exprs[0]);
if (nextList == NULL)
return type;
@@ -1638,7 +1638,7 @@ ArrayType::SizeUnsizedArrays(const Type *type, Expr *initExpr) {
continue;
}
ExprList *el = dynamic_cast<ExprList *>(exprList->exprs[i]);
ExprList *el = llvm::dyn_cast<ExprList>(exprList->exprs[i]);
if (el == NULL || el->exprs.size() != nextSize) {
Error(Union(exprList->exprs[0]->pos, exprList->exprs[i]->pos),
"Inconsistent initializer expression list lengths "