From 26a93bc733f38efdf4e12a07fd86035182fe96f1 Mon Sep 17 00:00:00 2001
From: Anton Mitrokhin <anton.mitrokhin@phystech.edu>
Date: Thu, 9 Jul 2015 12:38:58 +0300
Subject: [PATCH 1/3] Id's fo Expr-inherited classes

---
 Makefile          |   6 +-
 ast.cpp           | 118 ++++++++++++++++++------------------
 ast.h             |  23 +++++--
 ctx.cpp           |   2 +-
 decl.cpp          |   4 +-
 expr.cpp          | 148 +++++++++++++++++++++++-----------------------
 expr.h            |   6 +-
 func.cpp          |   2 +-
 module.cpp        |  10 ++--
 parse.yy          |   4 +-
 stmt.cpp          |  50 ++++++++--------
 test_class_of.cpp |   8 +++
 type.cpp          |   6 +-
 13 files changed, 205 insertions(+), 182 deletions(-)
 create mode 100644 test_class_of.cpp

diff --git a/Makefile b/Makefile
index b551a49a..5698fd42 100644
--- a/Makefile
+++ b/Makefile
@@ -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.
diff --git a/ast.cpp b/ast.cpp
index fa5b8083..ca465571 100644
--- a/ast.cpp
+++ b/ast.cpp
@@ -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;
diff --git a/ast.h b/ast.h
index e0f864ba..e4a5d73f 100644
--- a/ast.h
+++ b/ast.h
@@ -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
diff --git a/ctx.cpp b/ctx.cpp
index e4a20f64..50b03653 100644
--- a/ctx.cpp
+++ b/ctx.cpp
@@ -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;
 
diff --git a/decl.cpp b/decl.cpp
index c915d6b8..476407bd 100644
--- a/decl.cpp
+++ b/decl.cpp
@@ -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.",
diff --git a/expr.cpp b/expr.cpp
index cf20f202..24e86a69 100644
--- a/expr.cpp
+++ b/expr.cpp
@@ -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;
diff --git a/expr.h b/expr.h
index c1570412..89b987f5 100644
--- a/expr.h
+++ b/expr.h
@@ -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;
diff --git a/func.cpp b/func.cpp
index 6529cddb..122f5601 100644
--- a/func.cpp
+++ b/func.cpp
@@ -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
diff --git a/module.cpp b/module.cpp
index 84a0d140..d54ff6c8 100644
--- a/module.cpp
+++ b/module.cpp
@@ -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();
diff --git a/parse.yy b/parse.yy
index 5484ceed..a5a95851 100644
--- a/parse.yy
+++ b/parse.yy
@@ -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 {
diff --git a/stmt.cpp b/stmt.cpp
index 67553a8d..224646e4 100644
--- a/stmt.cpp
+++ b/stmt.cpp
@@ -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
diff --git a/test_class_of.cpp b/test_class_of.cpp
new file mode 100644
index 00000000..58812229
--- /dev/null
+++ b/test_class_of.cpp
@@ -0,0 +1,8 @@
+#include "ispc.h"
+
+int main() {
+
+
+
+    return 0;
+};
diff --git a/type.cpp b/type.cpp
index 9785d532..e70dd312 100644
--- a/type.cpp
+++ b/type.cpp
@@ -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 "

From 8217448ee523b4bf32644ad4313588511687b2da Mon Sep 17 00:00:00 2001
From: Anton Mitrokhin <anton.mitrokhin@phystech.edu>
Date: Thu, 9 Jul 2015 14:45:33 +0300
Subject: [PATCH 2/3] Id's for Stmt-inherited classes

---
 Makefile   | 10 ++++++----
 ast.h      | 50 ++++++++++++++++++++++++++++++++++++++++++++++++--
 expr.h     |  8 ++++----
 module.cpp |  6 ++----
 stmt.cpp   | 40 ++++++++++++++++++++--------------------
 stmt.h     |  4 ++--
 6 files changed, 82 insertions(+), 36 deletions(-)

diff --git a/Makefile b/Makefile
index 5698fd42..dd13d7b4 100644
--- a/Makefile
+++ b/Makefile
@@ -194,9 +194,9 @@ YACC=bison -d -v -t
 
 ###########################################################################
 
-CXX_SRC=ast.cpp builtins.cpp cbackend.cpp ctx.cpp decl.cpp expr.cpp func.cpp test_class_of.cpp \
+CXX_SRC=ast.cpp builtins.cpp cbackend.cpp ctx.cpp decl.cpp expr.cpp func.cpp \
 	ispc.cpp llvmutil.cpp main.cpp module.cpp opt.cpp stmt.cpp sym.cpp \
-	type.cpp util.cpp
+	type.cpp util.cpp test_class_of.cpp
 HEADERS=ast.h builtins.h ctx.h decl.h expr.h func.h ispc.h llvmutil.h module.h \
 	opt.h stmt.h sym.h type.h util.h
 TARGETS=avx2-i64x4 avx11-i64x4 avx1-i64x4 avx1 avx1-x2 avx11 avx11-x2 avx2 avx2-x2 \
@@ -261,9 +261,11 @@ doxygen:
 
 ispc: print_llvm_src dirs $(OBJS)
 	@echo Creating ispc executable
-	@$(CXX) $(OPT) $(LDFLAGS) -o $@ $(OBJS) $(ISPC_LIBS)
+	@$(CXX) $(OPT) $(LDFLAGS) -o $@ $(filter-out objs/test_class_of.o, $(OBJS)) $(ISPC_LIBS)
+
+tcof: print_llvm_src dirs $(OBJS)
 	@echo Creating test_class_of executable
-	@$(CXX) $(OPT) $(LDFLAGS) -o tcexe $(OBJS) $(ISPC_LIBS)
+	@$(CXX) $(OPT) $(LDFLAGS) -o tcof $(filter-out objs/main.o, $(OBJS)) $(ISPC_LIBS)
 
 # Use clang as a default compiler, instead of gcc
 # This is default now.
diff --git a/ast.h b/ast.h
index e4a5d73f..20442b8d 100644
--- a/ast.h
+++ b/ast.h
@@ -79,8 +79,51 @@ public:
     /** An enumeration for keeping track of the concrete subclass of Value 
         that is actually instantiated.*/
     enum ASTNodeTy {
-        ExprID,
-        StmtID
+        /* For classes inherited from Expr */
+        AddressOfExprID,
+        AssignExprID,
+        BinaryExprID,
+        ConstExprID,
+        DerefExprID,
+        PtrDerefExprID,
+        RefDerefExprID,
+        ExprListID,
+        FunctionCallExprID,
+        FunctionSymbolExprID,
+        IndexExprID,
+        StructMemberExprID,
+        VectorMemberExprID,
+        NewExprID,
+        NullPointerExprID,
+        ReferenceExprID,
+        SelectExprID,
+        SizeOfExprID,
+        SymbolExprID,
+        SyncExprID,
+        TypeCastExprID,
+        UnaryExprID,
+        /* For classes inherited from Stmt */
+        AssertStmtID,
+        BreakStmtID,
+        CaseStmtID,
+        ContinueStmtID,
+        DeclStmtID,
+        DefaultStmtID,
+        DeleteStmtID,
+        DoStmtID,
+        ExprStmtID,
+        ForeachActiveStmtID,
+        ForeachStmtID,
+        ForeachUniqueStmtID,
+        ForStmtID,
+        GotoStmtID,
+        IfStmtID,
+        LabeledStmtID,
+        PrintStmtID,
+        ReturnStmtID,
+        StmtListID,
+        SwitchStmtID,
+        UnmaskedStmtID
     };
    
     /** Return an ID for the concrete type of this object. This is used to
@@ -93,6 +136,9 @@ public:
     static inline bool classof(ASTNode const*) { return true; }
 };
 
+
+
+
 class AST {
 public:
     /** Add the AST for a function described by the given declaration
diff --git a/expr.h b/expr.h
index 89b987f5..5c053f0d 100644
--- a/expr.h
+++ b/expr.h
@@ -227,8 +227,8 @@ public:
  */
 class ExprList : public Expr {
 public:
-    ExprList(SourcePos p) : Expr(p) { }
-    ExprList(Expr *e, SourcePos p) : Expr(p) { exprs.push_back(e); }
+    ExprList(SourcePos p) : Expr(p, ExprListID) { }
+    ExprList(Expr *e, SourcePos p) : Expr(p, ExprListID) { exprs.push_back(e); }
 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -658,7 +658,7 @@ private:
     proceeding). */
 class SyncExpr : public Expr {
 public:
-    SyncExpr(SourcePos p) : Expr(p) { }
+    SyncExpr(SourcePos p) : Expr(p, SyncExprID) { }
 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -672,7 +672,7 @@ public:
 /** @brief An expression that represents a NULL pointer. */
 class NullPointerExpr : public Expr {
 public:
-    NullPointerExpr(SourcePos p) : Expr(p) { }
+    NullPointerExpr(SourcePos p) : Expr(p, NullPointerExprID) { }
 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
diff --git a/module.cpp b/module.cpp
index d54ff6c8..4c64392f 100644
--- a/module.cpp
+++ b/module.cpp
@@ -1905,8 +1905,7 @@ std::string emitOffloadParamStruct(const std::string &paramStructName,
       if (!orgParamType->IsConstType()) {
         Error(sym->pos,"When emitting offload-stubs, \"export\"ed functions cannot have non-const reference-type parameters.\n");
       }
-      const ReferenceType *refType
-        = llvm::dyn_cast<const ReferenceType>(orgParamType);
+      const ReferenceType *refType = static_cast<const ReferenceType *>(orgParamType);
       paramType = refType->GetReferenceTarget()->GetAsNonConstType();
     } else {
       paramType = orgParamType->GetAsNonConstType();
@@ -2024,8 +2023,7 @@ Module::writeDevStub(const char *fn)
         if (!orgParamType->IsConstType()) {
           Error(sym->pos,"When emitting offload-stubs, \"export\"ed functions cannot have non-const reference-type parameters.\n");
         }
-        const ReferenceType *refType
-          = llvm::dyn_cast<const ReferenceType>(orgParamType);
+        const ReferenceType *refType = static_cast<const ReferenceType *>(orgParamType);
         paramType = refType->GetReferenceTarget()->GetAsNonConstType();
       } else {
         paramType = orgParamType->GetAsNonConstType();
diff --git a/stmt.cpp b/stmt.cpp
index 224646e4..b96dd55c 100644
--- a/stmt.cpp
+++ b/stmt.cpp
@@ -82,7 +82,7 @@ Stmt::Optimize() {
 // ExprStmt
 
 ExprStmt::ExprStmt(Expr *e, SourcePos p)
-  : Stmt(p) {
+  : Stmt(p, ExprStmtID) {
     expr = e;
 }
 
@@ -126,7 +126,7 @@ ExprStmt::EstimateCost() const {
 // DeclStmt
 
 DeclStmt::DeclStmt(const std::vector<VariableDeclaration> &v, SourcePos p)
-    : Stmt(p), vars(v) {
+    : Stmt(p, DeclStmtID), vars(v) {
 }
 
 
@@ -523,7 +523,7 @@ DeclStmt::EstimateCost() const {
 // IfStmt
 
 IfStmt::IfStmt(Expr *t, Stmt *ts, Stmt *fs, bool checkCoherence, SourcePos p)
-    : Stmt(p), test(t), trueStmts(ts), falseStmts(fs),
+    : Stmt(p, IfStmtID), test(t), trueStmts(ts), falseStmts(fs),
       doAllCheck(checkCoherence &&
                  !g->opt.disableCoherentControlFlow) {
 }
@@ -1017,7 +1017,7 @@ lHasVaryingBreakOrContinue(Stmt *stmt) {
 
 
 DoStmt::DoStmt(Expr *t, Stmt *s, bool cc, SourcePos p)
-    : Stmt(p), testExpr(t), bodyStmts(s),
+    : Stmt(p, DoStmtID), testExpr(t), bodyStmts(s),
       doCoherentCheck(cc && !g->opt.disableCoherentControlFlow) {
 }
 
@@ -1193,7 +1193,7 @@ DoStmt::Print(int indent) const {
 // ForStmt
 
 ForStmt::ForStmt(Stmt *i, Expr *t, Stmt *s, Stmt *st, bool cc, SourcePos p)
-    : Stmt(p), init(i), test(t), step(s), stmts(st),
+    : Stmt(p, ForStmtID), init(i), test(t), step(s), stmts(st),
       doCoherentCheck(cc && !g->opt.disableCoherentControlFlow) {
 }
 
@@ -1387,7 +1387,7 @@ ForStmt::Print(int indent) const {
 // BreakStmt
 
 BreakStmt::BreakStmt(SourcePos p)
-    : Stmt(p) {
+    : Stmt(p, BreakStmtID) {
 }
 
 
@@ -1425,7 +1425,7 @@ BreakStmt::Print(int indent) const {
 // ContinueStmt
 
 ContinueStmt::ContinueStmt(SourcePos p)
-    : Stmt(p) {
+    : Stmt(p, ContinueStmtID) {
 }
 
 
@@ -1466,7 +1466,7 @@ ForeachStmt::ForeachStmt(const std::vector<Symbol *> &lvs,
                          const std::vector<Expr *> &se,
                          const std::vector<Expr *> &ee,
                          Stmt *s, bool t, SourcePos pos)
-    : Stmt(pos), dimVariables(lvs), startExprs(se), endExprs(ee), isTiled(t),
+    : Stmt(pos, ForeachStmtID), dimVariables(lvs), startExprs(se), endExprs(ee), isTiled(t),
       stmts(s) {
 }
 
@@ -2223,7 +2223,7 @@ ForeachStmt::Print(int indent) const {
 // ForeachActiveStmt
 
 ForeachActiveStmt::ForeachActiveStmt(Symbol *s, Stmt *st, SourcePos pos)
-    : Stmt(pos) {
+    : Stmt(pos, ForeachActiveStmtID) {
     sym = s;
     stmts = st;
 }
@@ -2410,7 +2410,7 @@ ForeachActiveStmt::EstimateCost() const {
 
 ForeachUniqueStmt::ForeachUniqueStmt(const char *iterName, Expr *e,
                                      Stmt *s, SourcePos pos)
-    : Stmt(pos) {
+    : Stmt(pos, ForeachUniqueStmtID) {
     sym = m->symbolTable->LookupVariable(iterName);
     expr = e;
     stmts = s;
@@ -2678,7 +2678,7 @@ lCheckMask(Stmt *stmts) {
 
 
 CaseStmt::CaseStmt(int v, Stmt *s, SourcePos pos)
-    : Stmt(pos), value(v) {
+    : Stmt(pos, CaseStmtID), value(v) {
     stmts = s;
 }
 
@@ -2716,7 +2716,7 @@ CaseStmt::EstimateCost() const {
 // DefaultStmt
 
 DefaultStmt::DefaultStmt(Stmt *s, SourcePos pos)
-    : Stmt(pos) {
+    : Stmt(pos, DefaultStmtID) {
     stmts = s;
 }
 
@@ -2754,7 +2754,7 @@ DefaultStmt::EstimateCost() const {
 // SwitchStmt
 
 SwitchStmt::SwitchStmt(Expr *e, Stmt *s, SourcePos pos)
-    : Stmt(pos) {
+    : Stmt(pos, SwitchStmtID) {
     expr = e;
     stmts = s;
 }
@@ -2954,7 +2954,7 @@ SwitchStmt::EstimateCost() const {
 // UnmaskedStmt
 
 UnmaskedStmt::UnmaskedStmt(Stmt *s, SourcePos pos)
-    : Stmt(pos) {
+    : Stmt(pos, UnmaskedStmtID) {
     stmts = s;
 }
 
@@ -3008,7 +3008,7 @@ UnmaskedStmt::EstimateCost() const {
 // ReturnStmt
 
 ReturnStmt::ReturnStmt(Expr *e, SourcePos p)
-    : Stmt(p), expr(e) {
+    : Stmt(p, ReturnStmtID), expr(e) {
 }
 
 
@@ -3075,7 +3075,7 @@ ReturnStmt::Print(int indent) const {
 // GotoStmt
 
 GotoStmt::GotoStmt(const char *l, SourcePos gotoPos, SourcePos ip)
-    : Stmt(gotoPos) {
+    : Stmt(gotoPos, GotoStmtID) {
     label = l;
     identifierPos = ip;
 }
@@ -3151,7 +3151,7 @@ GotoStmt::EstimateCost() const {
 // LabeledStmt
 
 LabeledStmt::LabeledStmt(const char *n, Stmt *s, SourcePos p)
-    : Stmt(p) {
+    : Stmt(p, LabeledStmtID) {
     name = n;
     stmt = s;
 }
@@ -3253,7 +3253,7 @@ StmtList::Print(int indent) const {
 // PrintStmt
 
 PrintStmt::PrintStmt(const std::string &f, Expr *v, SourcePos p)
-    : Stmt(p), format(f), values(v) {
+    : Stmt(p, PrintStmtID), format(f), values(v) {
 }
 
 /* Because the pointers to values that are passed to __do_print() are all
@@ -3463,7 +3463,7 @@ PrintStmt::EstimateCost() const {
 // AssertStmt
 
 AssertStmt::AssertStmt(const std::string &msg, Expr *e, SourcePos p)
-    : Stmt(p), message(msg), expr(e) {
+    : Stmt(p, AssertStmtID), message(msg), expr(e) {
 }
 
 
@@ -3542,7 +3542,7 @@ AssertStmt::EstimateCost() const {
 // DeleteStmt
 
 DeleteStmt::DeleteStmt(Expr *e, SourcePos p)
-    : Stmt(p) {
+    : Stmt(p, DeleteStmtID) {
     expr = e;
 }
 
diff --git a/stmt.h b/stmt.h
index fb34c801..ba5a29b6 100644
--- a/stmt.h
+++ b/stmt.h
@@ -48,7 +48,7 @@
  */
 class Stmt : public ASTNode {
 public:
-    Stmt(SourcePos p) : ASTNode(p) { }
+    Stmt(SourcePos p, unsigned scid) : ASTNode(p, scid) { }
 
     /** Emit LLVM IR for the statement, using the FunctionEmitContext to create the
         necessary instructions.
@@ -411,7 +411,7 @@ public:
  */
 class StmtList : public Stmt {
 public:
-    StmtList(SourcePos p) : Stmt(p) { }
+    StmtList(SourcePos p) : Stmt(p, StmtListID) { }
 
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;

From 9f083f99ac8e2446acbd8b13d78a257758bc7742 Mon Sep 17 00:00:00 2001
From: Anton Mitrokhin <anton.mitrokhin@phystech.edu>
Date: Fri, 10 Jul 2015 12:27:16 +0300
Subject: [PATCH 3/3] classof implementations for all classes

---
 Makefile          |   8 +---
 ast.h             |   2 +
 expr.cpp          |  11 ++++-
 expr.h            | 117 +++++++++++++++++++++++++++++++++++++++++++++-
 stmt.h            | 110 +++++++++++++++++++++++++++++++++++++++++++
 test_class_of.cpp |   8 ----
 type.cpp          |   6 +--
 7 files changed, 242 insertions(+), 20 deletions(-)
 delete mode 100644 test_class_of.cpp

diff --git a/Makefile b/Makefile
index dd13d7b4..5301fab5 100644
--- a/Makefile
+++ b/Makefile
@@ -196,7 +196,7 @@ YACC=bison -d -v -t
 
 CXX_SRC=ast.cpp builtins.cpp cbackend.cpp ctx.cpp decl.cpp expr.cpp func.cpp \
 	ispc.cpp llvmutil.cpp main.cpp module.cpp opt.cpp stmt.cpp sym.cpp \
-	type.cpp util.cpp test_class_of.cpp
+	type.cpp util.cpp
 HEADERS=ast.h builtins.h ctx.h decl.h expr.h func.h ispc.h llvmutil.h module.h \
 	opt.h stmt.h sym.h type.h util.h
 TARGETS=avx2-i64x4 avx11-i64x4 avx1-i64x4 avx1 avx1-x2 avx11 avx11-x2 avx2 avx2-x2 \
@@ -261,11 +261,7 @@ doxygen:
 
 ispc: print_llvm_src dirs $(OBJS)
 	@echo Creating ispc executable
-	@$(CXX) $(OPT) $(LDFLAGS) -o $@ $(filter-out objs/test_class_of.o, $(OBJS)) $(ISPC_LIBS)
-
-tcof: print_llvm_src dirs $(OBJS)
-	@echo Creating test_class_of executable
-	@$(CXX) $(OPT) $(LDFLAGS) -o tcof $(filter-out objs/main.o, $(OBJS)) $(ISPC_LIBS)
+	@$(CXX) $(OPT) $(LDFLAGS) -o $@ $(OBJS) $(ISPC_LIBS)
 
 # Use clang as a default compiler, instead of gcc
 # This is default now.
diff --git a/ast.h b/ast.h
index 20442b8d..0a2a2edf 100644
--- a/ast.h
+++ b/ast.h
@@ -102,6 +102,8 @@ public:
         SyncExprID,
         TypeCastExprID,
         UnaryExprID,
+        /* This is a convenience separator to shorten classof implementations */
+        MaxExprID,
         /* For classes inherited from Stmt */
         AssertStmtID,
         BreakStmtID,
diff --git a/expr.cpp b/expr.cpp
index 24e86a69..8c795e3b 100644
--- a/expr.cpp
+++ b/expr.cpp
@@ -1112,7 +1112,6 @@ UnaryExpr::UnaryExpr(Op o, Expr *e, SourcePos p)
     expr = e;
 }
 
-
 llvm::Value *
 UnaryExpr::GetValue(FunctionEmitContext *ctx) const {
     if (expr == NULL)
@@ -4725,6 +4724,11 @@ public:
     StructMemberExpr(Expr *e, const char *id, SourcePos p,
                      SourcePos idpos, bool derefLValue);
 
+    static inline bool classof(StructMemberExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == StructMemberExprID;
+    }
+
     const Type *GetType() const;
     const Type *GetLValueType() const;
     int getElementNumber() const;
@@ -4892,6 +4896,11 @@ public:
     VectorMemberExpr(Expr *e, const char *id, SourcePos p,
                      SourcePos idpos, bool derefLValue);
 
+    static inline bool classof(VectorMemberExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == VectorMemberExprID;
+    }
+
     llvm::Value *GetValue(FunctionEmitContext* ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext* ctx) const;
     const Type *GetType() const;
diff --git a/expr.h b/expr.h
index 5c053f0d..90bf3db8 100644
--- a/expr.h
+++ b/expr.h
@@ -49,6 +49,11 @@ class Expr : public ASTNode {
 public:
     Expr(SourcePos p, unsigned scid) : ASTNode(p, scid) { }
 
+    static inline bool classof(Expr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() < MaxExprID;
+    }
+
     /** This is the main method for Expr implementations to implement.  It
         should call methods in the FunctionEmitContext to emit LLVM IR
         instructions to the current basic block in order to generate an
@@ -111,6 +116,11 @@ public:
 
     UnaryExpr(Op op, Expr *expr, SourcePos pos);
 
+    static inline bool classof(UnaryExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == UnaryExprID;
+    }
+
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -152,7 +162,12 @@ public:
     };
 
     BinaryExpr(Op o, Expr *a, Expr *b, SourcePos p);
-
+    
+    static inline bool classof(BinaryExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == BinaryExprID;
+    }
+    
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     const Type *GetLValueType() const;
@@ -186,6 +201,11 @@ public:
 
     AssignExpr(Op o, Expr *a, Expr *b, SourcePos p);
 
+    static inline bool classof(AssignExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == AssignExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -207,6 +227,11 @@ class SelectExpr : public Expr {
 public:
     SelectExpr(Expr *test, Expr *a, Expr *b, SourcePos p);
 
+    static inline bool classof(SelectExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == SelectExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -218,7 +243,6 @@ public:
     Expr *test, *expr1, *expr2;
 };
 
-
 /** @brief A list of expressions.
 
     These are mostly used for representing curly-brace delimited
@@ -230,6 +254,11 @@ public:
     ExprList(SourcePos p) : Expr(p, ExprListID) { }
     ExprList(Expr *e, SourcePos p) : Expr(p, ExprListID) { exprs.push_back(e); }
 
+    static inline bool classof(ExprList const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ExprListID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -250,6 +279,11 @@ public:
                      bool isLaunch = false, 
                      Expr *launchCountExpr[3] = NULL);
 
+    static inline bool classof(FunctionCallExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == FunctionCallExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -276,6 +310,11 @@ class IndexExpr : public Expr {
 public:
     IndexExpr(Expr *baseExpr, Expr *index, SourcePos p);
 
+    static inline bool classof(IndexExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == IndexExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -304,6 +343,13 @@ public:
     static MemberExpr *create(Expr *expr, const char *identifier,
                               SourcePos pos, SourcePos identifierPos,
                               bool derefLvalue);
+
+    static inline bool classof(MemberExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return ((N->getValueID() == StructMemberExprID) ||
+                (N->getValueID() == VectorMemberExprID));
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -402,6 +448,11 @@ public:
         but at the given position. */
     ConstExpr(ConstExpr *old, SourcePos pos);
 
+    static inline bool classof(ConstExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ConstExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -459,6 +510,11 @@ class TypeCastExpr : public Expr {
 public:
     TypeCastExpr(const Type *t, Expr *e, SourcePos p);
 
+    static inline bool classof(TypeCastExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == TypeCastExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -481,6 +537,11 @@ class ReferenceExpr : public Expr {
 public:
     ReferenceExpr(Expr *e, SourcePos p);
 
+    static inline bool classof(ReferenceExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ReferenceExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     const Type *GetLValueType() const;
@@ -500,6 +561,13 @@ class DerefExpr : public Expr {
 public:
     DerefExpr(Expr *e, SourcePos p, unsigned scid = DerefExprID);
 
+    static inline bool classof(DerefExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return ((N->getValueID() == DerefExprID) ||
+                (N->getValueID() == PtrDerefExprID) ||
+                (N->getValueID() == RefDerefExprID));
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetLValueType() const;
@@ -516,6 +584,11 @@ class PtrDerefExpr : public DerefExpr {
 public:
     PtrDerefExpr(Expr *e, SourcePos p);
 
+    static inline bool classof(PtrDerefExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == PtrDerefExprID;
+    }
+ 
     const Type *GetType() const;
     void Print() const;
     Expr *TypeCheck();
@@ -529,6 +602,11 @@ class RefDerefExpr : public DerefExpr {
 public:
     RefDerefExpr(Expr *e, SourcePos p);
 
+    static inline bool classof(RefDerefExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == RefDerefExprID;
+    }
+ 
     const Type *GetType() const;
     void Print() const;
     Expr *TypeCheck();
@@ -541,6 +619,11 @@ class AddressOfExpr : public Expr {
 public:
     AddressOfExpr(Expr *e, SourcePos p);
 
+    static inline bool classof(AddressOfExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == AddressOfExprID;
+    }
+
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     const Type *GetLValueType() const;
@@ -562,6 +645,11 @@ public:
     SizeOfExpr(Expr *e, SourcePos p);
     SizeOfExpr(const Type *t, SourcePos p);
 
+    static inline bool classof(SizeOfExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == SizeOfExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     void Print() const;
@@ -581,6 +669,11 @@ class SymbolExpr : public Expr {
 public:
     SymbolExpr(Symbol *s, SourcePos p);
 
+    static inline bool classof(SymbolExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == SymbolExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     llvm::Value *GetLValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
@@ -604,6 +697,11 @@ public:
     FunctionSymbolExpr(const char *name, const std::vector<Symbol *> &candFuncs,
                        SourcePos pos);
 
+    static inline bool classof(FunctionSymbolExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == FunctionSymbolExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     Symbol *GetBaseSymbol() const;
@@ -660,6 +758,11 @@ class SyncExpr : public Expr {
 public:
     SyncExpr(SourcePos p) : Expr(p, SyncExprID) { }
 
+    static inline bool classof(SyncExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == SyncExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     Expr *TypeCheck();
@@ -674,6 +777,11 @@ class NullPointerExpr : public Expr {
 public:
     NullPointerExpr(SourcePos p) : Expr(p, NullPointerExprID) { }
 
+    static inline bool classof(NullPointerExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == NullPointerExprID;
+    }
+ 
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     Expr *TypeCheck();
@@ -692,6 +800,11 @@ public:
     NewExpr(int typeQual, const Type *type, Expr *initializer, Expr *count,
             SourcePos tqPos, SourcePos p);
 
+    static inline bool classof(NewExpr const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == NewExprID;
+    }
+
     llvm::Value *GetValue(FunctionEmitContext *ctx) const;
     const Type *GetType() const;
     Expr *TypeCheck();
diff --git a/stmt.h b/stmt.h
index ba5a29b6..ab0f666b 100644
--- a/stmt.h
+++ b/stmt.h
@@ -50,6 +50,11 @@ class Stmt : public ASTNode {
 public:
     Stmt(SourcePos p, unsigned scid) : ASTNode(p, scid) { }
 
+    static inline bool classof(Stmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() > MaxExprID;
+    }
+
     /** Emit LLVM IR for the statement, using the FunctionEmitContext to create the
         necessary instructions.
      */
@@ -73,6 +78,11 @@ class ExprStmt : public Stmt {
 public:
     ExprStmt(Expr *expr, SourcePos pos);
 
+    static inline bool classof(ExprStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ExprStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -97,6 +107,11 @@ class DeclStmt : public Stmt {
 public:
     DeclStmt(const std::vector<VariableDeclaration> &v, SourcePos pos);
 
+    static inline bool classof(DeclStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == DeclStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -115,6 +130,11 @@ public:
     IfStmt(Expr *testExpr, Stmt *trueStmts, Stmt *falseStmts,
            bool doAllCheck, SourcePos pos);
 
+    static inline bool classof(IfStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == IfStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -155,6 +175,11 @@ public:
     DoStmt(Expr *testExpr, Stmt *bodyStmts, bool doCoherentCheck,
            SourcePos pos);
 
+    static inline bool classof(DoStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == DoStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -175,6 +200,11 @@ public:
     ForStmt(Stmt *initializer, Expr *testExpr, Stmt *stepStatements,
             Stmt *bodyStatements, bool doCoherentCheck, SourcePos pos);
 
+    static inline bool classof(ForStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ForStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -201,6 +231,11 @@ class BreakStmt : public Stmt {
 public:
     BreakStmt(SourcePos pos);
 
+    static inline bool classof(BreakStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == BreakStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -215,6 +250,11 @@ class ContinueStmt : public Stmt {
 public:
     ContinueStmt(SourcePos pos);
 
+    static inline bool classof(ContinueStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ContinueStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -232,6 +272,11 @@ public:
                 const std::vector<Expr *> &endExprs,
                 Stmt *bodyStatements, bool tiled, SourcePos pos);
 
+    static inline bool classof(ForeachStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ForeachStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -252,6 +297,11 @@ class ForeachActiveStmt : public Stmt {
 public:
     ForeachActiveStmt(Symbol *iterSym, Stmt *stmts, SourcePos pos);
 
+    static inline bool classof(ForeachActiveStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ForeachActiveStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -271,6 +321,11 @@ public:
     ForeachUniqueStmt(const char *iterName, Expr *expr, Stmt *stmts,
                       SourcePos pos);
 
+    static inline bool classof(ForeachUniqueStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ForeachUniqueStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -289,6 +344,11 @@ class UnmaskedStmt : public Stmt {
 public:
     UnmaskedStmt(Stmt *stmt, SourcePos pos);
 
+    static inline bool classof(UnmaskedStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == UnmaskedStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -306,6 +366,11 @@ class ReturnStmt : public Stmt {
 public:
     ReturnStmt(Expr *e, SourcePos p);
 
+    static inline bool classof(ReturnStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == ReturnStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -323,6 +388,11 @@ class CaseStmt : public Stmt {
 public:
     CaseStmt(int value, Stmt *stmt, SourcePos pos);
 
+    static inline bool classof(CaseStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == CaseStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -341,6 +411,11 @@ class DefaultStmt : public Stmt {
 public:
     DefaultStmt(Stmt *stmt, SourcePos pos);
 
+    static inline bool classof(DefaultStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == DefaultStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -356,6 +431,11 @@ class SwitchStmt : public Stmt {
 public:
     SwitchStmt(Expr *expr, Stmt *stmts, SourcePos pos);
 
+    static inline bool classof(SwitchStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == SwitchStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -374,6 +454,11 @@ class GotoStmt : public Stmt {
 public:
     GotoStmt(const char *label, SourcePos gotoPos, SourcePos idPos);
 
+    static inline bool classof(GotoStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == GotoStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -393,6 +478,11 @@ class LabeledStmt : public Stmt {
 public:
     LabeledStmt(const char *label, Stmt *stmt, SourcePos p);
 
+    static inline bool classof(LabeledStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == LabeledStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -413,6 +503,11 @@ class StmtList : public Stmt {
 public:
     StmtList(SourcePos p) : Stmt(p, StmtListID) { }
 
+    static inline bool classof(StmtList const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == StmtListID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -438,6 +533,11 @@ class PrintStmt : public Stmt {
 public:
     PrintStmt(const std::string &f, Expr *v, SourcePos p);
 
+    static inline bool classof(PrintStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == PrintStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -464,6 +564,11 @@ class AssertStmt : public Stmt {
 public:
     AssertStmt(const std::string &msg, Expr *e, SourcePos p);
 
+    static inline bool classof(AssertStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == AssertStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
@@ -483,6 +588,11 @@ class DeleteStmt : public Stmt {
 public:
     DeleteStmt(Expr *e, SourcePos p);
 
+    static inline bool classof(DeleteStmt const*) { return true; }
+    static inline bool classof(ASTNode const* N) {
+        return N->getValueID() == DeleteStmtID;
+    }
+
     void EmitCode(FunctionEmitContext *ctx) const;
     void Print(int indent) const;
 
diff --git a/test_class_of.cpp b/test_class_of.cpp
deleted file mode 100644
index 58812229..00000000
--- a/test_class_of.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "ispc.h"
-
-int main() {
-
-
-
-    return 0;
-};
diff --git a/type.cpp b/type.cpp
index e70dd312..b4b739a7 100644
--- a/type.cpp
+++ b/type.cpp
@@ -1603,7 +1603,7 @@ ArrayType::SizeUnsizedArrays(const Type *type, Expr *initExpr) {
     if (at == NULL)
         return type;
 
-    ExprList *exprList = llvm::dyn_cast<ExprList>(initExpr);
+    ExprList *exprList = llvm::dyn_cast_or_null<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 = llvm::dyn_cast<ExprList>(exprList->exprs[0]);
+    ExprList *nextList = llvm::dyn_cast_or_null<ExprList>(exprList->exprs[0]);
     if (nextList == NULL)
         return type;
 
@@ -1638,7 +1638,7 @@ ArrayType::SizeUnsizedArrays(const Type *type, Expr *initExpr) {
                 continue;
             }
 
-            ExprList *el = llvm::dyn_cast<ExprList>(exprList->exprs[i]);
+            ExprList *el = llvm::dyn_cast_or_null<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 "