static bool GetMangledName(clang::MangleContext* ctx,
const clang::NamedDecl* decl,
MangledName* result) {
- if (!isa<clang::CXXConstructorDecl>(decl) &&
- !isa<clang::CXXDestructorDecl>(decl)) {
+ if (!llvm::isa<clang::CXXConstructorDecl>(decl) &&
+ !llvm::isa<clang::CXXDestructorDecl>(decl)) {
llvm::SmallVector<char, 512> output;
llvm::raw_svector_ostream out(output);
ctx->mangleName(decl, out);
static bool IsExternalVMState(const clang::ValueDecl* var) {
const clang::EnumConstantDecl* enum_constant =
- dyn_cast<clang::EnumConstantDecl>(var);
+ llvm::dyn_cast<clang::EnumConstantDecl>(var);
if (enum_constant != NULL && enum_constant->getNameAsString() == EXTERNAL) {
clang::QualType type = enum_constant->getType();
return (type.getAsString() == STATE_TAG);
clang::DeclContext::lookup_result result =
decl_ctx_->lookup(ResolveName(n));
- clang::DeclContext::lookup_iterator end = result.second;
- for (clang::DeclContext::lookup_iterator i = result.first;
- i != end;
+ clang::DeclContext::lookup_iterator end = result.end();
+ for (clang::DeclContext::lookup_iterator i = result.begin(); i != end;
i++) {
- if (isa<T>(*i)) return cast<T>(*i);
+ if (llvm::isa<T>(*i)) return llvm::cast<T>(*i);
}
return NULL;
: public clang::ASTConsumer,
public clang::RecursiveASTVisitor<FunctionDeclarationFinder> {
public:
- explicit FunctionDeclarationFinder(clang::Diagnostic& d,
+ explicit FunctionDeclarationFinder(clang::DiagnosticsEngine& d,
clang::SourceManager& sm,
const std::vector<std::string>& args)
- : d_(d), sm_(sm) { }
+ : d_(d), sm_(sm) {}
virtual void HandleTranslationUnit(clang::ASTContext &ctx) {
- mangle_context_ = clang::createItaniumMangleContext(ctx, d_);
+ mangle_context_ = clang::ItaniumMangleContext::create(ctx, d_);
callees_printer_ = new CalleesPrinter(mangle_context_);
TraverseDecl(ctx.getTranslationUnitDecl());
}
private:
- clang::Diagnostic& d_;
+ clang::DiagnosticsEngine& d_;
clang::SourceManager& sm_;
clang::MangleContext* mangle_context_;
FunctionAnalyzer(clang::MangleContext* ctx,
clang::DeclarationName handle_decl_name,
clang::CXXRecordDecl* object_decl,
- clang::CXXRecordDecl* smi_decl,
- clang::Diagnostic& d,
- clang::SourceManager& sm,
- bool dead_vars_analysis)
+ clang::CXXRecordDecl* smi_decl, clang::DiagnosticsEngine& d,
+ clang::SourceManager& sm, bool dead_vars_analysis)
: ctx_(ctx),
handle_decl_name_(handle_decl_name),
object_decl_(object_decl),
d_(d),
sm_(sm),
block_(NULL),
- dead_vars_analysis_(dead_vars_analysis) {
- }
+ dead_vars_analysis_(dead_vars_analysis) {}
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
ExprEffect VisitExpr(clang::Expr* expr, const Environment& env) {
-#define VISIT(type) do { \
- clang::type* concrete_expr = dyn_cast_or_null<clang::type>(expr); \
- if (concrete_expr != NULL) { \
- return Visit##type (concrete_expr, env); \
- } \
- } while(0);
+#define VISIT(type) \
+ do { \
+ clang::type* concrete_expr = llvm::dyn_cast_or_null<clang::type>(expr); \
+ if (concrete_expr != NULL) { \
+ return Visit##type(concrete_expr, env); \
+ } \
+ } while (0);
VISIT(AbstractConditionalOperator);
VISIT(AddrLabelExpr);
VISIT(ArraySubscriptExpr);
VISIT(BinaryOperator);
- VISIT(BinaryTypeTraitExpr);
- VISIT(BlockDeclRefExpr);
VISIT(BlockExpr);
VISIT(CallExpr);
VISIT(CastExpr);
VISIT(StmtExpr);
VISIT(StringLiteral);
VISIT(SubstNonTypeTemplateParmPackExpr);
+ VISIT(TypeTraitExpr);
VISIT(UnaryOperator);
- VISIT(UnaryTypeTraitExpr);
VISIT(VAArgExpr);
#undef VISIT
}
IGNORE_EXPR(AddrLabelExpr);
- IGNORE_EXPR(BinaryTypeTraitExpr);
IGNORE_EXPR(BlockExpr);
IGNORE_EXPR(CharacterLiteral);
IGNORE_EXPR(ChooseExpr);
IGNORE_EXPR(StmtExpr);
IGNORE_EXPR(StringLiteral);
IGNORE_EXPR(SubstNonTypeTemplateParmPackExpr);
- IGNORE_EXPR(UnaryTypeTraitExpr);
+ IGNORE_EXPR(TypeTraitExpr);
IGNORE_EXPR(VAArgExpr);
IGNORE_EXPR(GNUNullExpr);
IGNORE_EXPR(OverloadExpr);
}
bool IsRawPointerVar(clang::Expr* expr, std::string* var_name) {
- if (isa<clang::BlockDeclRefExpr>(expr)) {
- *var_name = cast<clang::BlockDeclRefExpr>(expr)->getDecl()->
- getNameAsString();
- return true;
- } else if (isa<clang::DeclRefExpr>(expr)) {
- *var_name = cast<clang::DeclRefExpr>(expr)->getDecl()->getNameAsString();
+ if (llvm::isa<clang::DeclRefExpr>(expr)) {
+ *var_name =
+ llvm::cast<clang::DeclRefExpr>(expr)->getDecl()->getNameAsString();
return true;
}
return false;
return VisitExpr(expr->getArgument(), env);
}
- DECL_VISIT_EXPR(CXXNewExpr) {
- return Par(expr,
- expr->getNumConstructorArgs(),
- expr->getConstructorArgs(),
- env);
- }
+ DECL_VISIT_EXPR(CXXNewExpr) { return VisitExpr(expr->getInitializer(), env); }
DECL_VISIT_EXPR(ExprWithCleanups) {
return VisitExpr(expr->getSubExpr(), env);
return Use(expr, expr->getDecl(), env);
}
- DECL_VISIT_EXPR(BlockDeclRefExpr) {
- return Use(expr, expr->getDecl(), env);
- }
-
ExprEffect Par(clang::Expr* parent,
int n,
clang::Expr** exprs,
CallProps props;
clang::CXXMemberCallExpr* memcall =
- dyn_cast_or_null<clang::CXXMemberCallExpr>(call);
+ llvm::dyn_cast_or_null<clang::CXXMemberCallExpr>(call);
if (memcall != NULL) {
clang::Expr* receiver = memcall->getImplicitObjectArgument();
props.SetEffect(0, VisitExpr(receiver, env));
// --------------------------------------------------------------------------
Environment VisitStmt(clang::Stmt* stmt, const Environment& env) {
-#define VISIT(type) do { \
- clang::type* concrete_stmt = dyn_cast_or_null<clang::type>(stmt); \
- if (concrete_stmt != NULL) { \
- return Visit##type (concrete_stmt, env); \
- } \
- } while(0);
-
- if (clang::Expr* expr = dyn_cast_or_null<clang::Expr>(stmt)) {
+#define VISIT(type) \
+ do { \
+ clang::type* concrete_stmt = llvm::dyn_cast_or_null<clang::type>(stmt); \
+ if (concrete_stmt != NULL) { \
+ return Visit##type(concrete_stmt, env); \
+ } \
+ } while (0);
+
+ if (clang::Expr* expr = llvm::dyn_cast_or_null<clang::Expr>(stmt)) {
return env.ApplyEffect(VisitExpr(expr, env));
}
const clang::TagType* ToTagType(const clang::Type* t) {
if (t == NULL) {
return NULL;
- } else if (isa<clang::TagType>(t)) {
- return cast<clang::TagType>(t);
- } else if (isa<clang::SubstTemplateTypeParmType>(t)) {
- return ToTagType(cast<clang::SubstTemplateTypeParmType>(t)->
- getReplacementType().getTypePtr());
+ } else if (llvm::isa<clang::TagType>(t)) {
+ return llvm::cast<clang::TagType>(t);
+ } else if (llvm::isa<clang::SubstTemplateTypeParmType>(t)) {
+ return ToTagType(llvm::cast<clang::SubstTemplateTypeParmType>(t)
+ ->getReplacementType()
+ .getTypePtr());
} else {
return NULL;
}
bool IsRawPointerType(clang::QualType qtype) {
const clang::PointerType* type =
- dyn_cast_or_null<clang::PointerType>(qtype.getTypePtrOrNull());
+ llvm::dyn_cast_or_null<clang::PointerType>(qtype.getTypePtrOrNull());
if (type == NULL) return false;
const clang::TagType* pointee =
if (pointee == NULL) return false;
clang::CXXRecordDecl* record =
- dyn_cast_or_null<clang::CXXRecordDecl>(pointee->getDecl());
+ llvm::dyn_cast_or_null<clang::CXXRecordDecl>(pointee->getDecl());
if (record == NULL) return false;
if (!InV8Namespace(record)) return false;
}
Environment VisitDecl(clang::Decl* decl, const Environment& env) {
- if (clang::VarDecl* var = dyn_cast<clang::VarDecl>(decl)) {
+ if (clang::VarDecl* var = llvm::dyn_cast<clang::VarDecl>(decl)) {
Environment out = var->hasInit() ? VisitStmt(var->getInit(), env) : env;
if (IsRawPointerType(var->getType())) {
private:
void ReportUnsafe(const clang::Expr* expr, const std::string& msg) {
d_.Report(clang::FullSourceLoc(expr->getExprLoc(), sm_),
- d_.getCustomDiagID(clang::Diagnostic::Warning, msg));
+ d_.getCustomDiagID(clang::DiagnosticsEngine::Warning, "%0"))
+ << msg;
}
clang::CXXRecordDecl* object_decl_;
clang::CXXRecordDecl* smi_decl_;
- clang::Diagnostic& d_;
+ clang::DiagnosticsEngine& d_;
clang::SourceManager& sm_;
Block* block_;
class ProblemsFinder : public clang::ASTConsumer,
public clang::RecursiveASTVisitor<ProblemsFinder> {
public:
- ProblemsFinder(clang::Diagnostic& d,
- clang::SourceManager& sm,
+ ProblemsFinder(clang::DiagnosticsEngine& d, clang::SourceManager& sm,
const std::vector<std::string>& args)
: d_(d), sm_(sm), dead_vars_analysis_(false) {
for (unsigned i = 0; i < args.size(); ++i) {
if (smi_decl != NULL) smi_decl = smi_decl->getDefinition();
if (object_decl != NULL && smi_decl != NULL) {
- function_analyzer_ =
- new FunctionAnalyzer(clang::createItaniumMangleContext(ctx, d_),
- r.ResolveName("Handle"),
- object_decl,
- smi_decl,
- d_,
- sm_,
- dead_vars_analysis_);
+ function_analyzer_ = new FunctionAnalyzer(
+ clang::ItaniumMangleContext::create(ctx, d_), r.ResolveName("Handle"),
+ object_decl, smi_decl, d_, sm_, dead_vars_analysis_);
TraverseDecl(ctx.getTranslationUnitDecl());
} else {
if (object_decl == NULL) {
}
private:
- clang::Diagnostic& d_;
+ clang::DiagnosticsEngine& d_;
clang::SourceManager& sm_;
bool dead_vars_analysis_;