Update gcmole to a more recent clang/llvm.

tools/gcmole/gcmole.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 33 matching lines @@
 #include <stack>
 
 namespace {
 
 typedef std::string MangledName;
 typedef std::set<MangledName> CalleesSet;
 
 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);
     *result = out.str().str();
     return true;
   }
 
   return false;
 }
 
 
 static bool InV8Namespace(const clang::NamedDecl* decl) {
   return decl->getQualifiedNameAsString().compare(0, 4, "v8::") == 0;
 }
 
 
 static std::string EXTERNAL("EXTERNAL");
 static std::string STATE_TAG("enum v8::internal::StateTag");
 
 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);
   }
 
   return false;
 }
 
 
 struct Resolver {
@@ skipping 14 matching lines @@
     return Resolver(ctx_, Resolve<clang::NamespaceDecl>(n));
   }
 
   template<typename T>
   T* Resolve(const char* n) {
     if (decl_ctx_ == NULL) return NULL;
 
     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;
   }
 
  private:
   clang::ASTContext& ctx_;
   clang::DeclContext* decl_ctx_;
 };
 
@@ skipping 74 matching lines @@
 
   std::stack<CalleesSet* > scopes_;
   Callgraph callgraph_;
 };
 
 
 class FunctionDeclarationFinder
     : 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());
 
     callees_printer_->PrintCallGraph();
   }
 
   virtual bool VisitFunctionDecl(clang::FunctionDecl* decl) {
     callees_printer_->AnalyzeFunction(decl);
     return true;
   }
 
  private:
-  clang::Diagnostic& d_;
+  clang::DiagnosticsEngine& d_;
   clang::SourceManager& sm_;
   clang::MangleContext* mangle_context_;
 
   CalleesPrinter* callees_printer_;
 };
 
 
 static bool loaded = false;
 static CalleesSet gc_suspects;
 
@@ skipping 259 matching lines @@
 
 
 static std::string THIS ("this");
 
 
 class FunctionAnalyzer {
  public:
   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),
         smi_decl_(smi_decl),
         d_(d),
         sm_(sm),
         block_(NULL),
-        dead_vars_analysis_(dead_vars_analysis) {
-  }
+        dead_vars_analysis_(dead_vars_analysis) {}
 
 
   // --------------------------------------------------------------------------
   // Expressions
   // --------------------------------------------------------------------------
 
   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(CharacterLiteral);
     VISIT(ChooseExpr);
     VISIT(CompoundLiteralExpr);
     VISIT(CXXBindTemporaryExpr);
     VISIT(CXXBoolLiteralExpr);
     VISIT(CXXConstructExpr);
     VISIT(CXXDefaultArgExpr);
@@ skipping 26 matching lines @@
     VISIT(OverloadExpr);
     VISIT(PackExpansionExpr);
     VISIT(ParenExpr);
     VISIT(ParenListExpr);
     VISIT(PredefinedExpr);
     VISIT(ShuffleVectorExpr);
     VISIT(SizeOfPackExpr);
     VISIT(StmtExpr);
     VISIT(StringLiteral);
     VISIT(SubstNonTypeTemplateParmPackExpr);
+    VISIT(TypeTraitExpr);
     VISIT(UnaryOperator);
-    VISIT(UnaryTypeTraitExpr);
     VISIT(VAArgExpr);
 #undef VISIT
 
     return ExprEffect::None();
   }
 
 #define DECL_VISIT_EXPR(type)                                           \
   ExprEffect Visit##type (clang::type* expr, const Environment& env)
 
 #define IGNORE_EXPR(type)                                               \
   ExprEffect Visit##type (clang::type* expr, const Environment& env) {  \
     return ExprEffect::None();                                          \
   }
 
   IGNORE_EXPR(AddrLabelExpr);
-  IGNORE_EXPR(BinaryTypeTraitExpr);
   IGNORE_EXPR(BlockExpr);
   IGNORE_EXPR(CharacterLiteral);
   IGNORE_EXPR(ChooseExpr);
   IGNORE_EXPR(CompoundLiteralExpr);
   IGNORE_EXPR(CXXBoolLiteralExpr);
   IGNORE_EXPR(CXXDependentScopeMemberExpr);
   IGNORE_EXPR(CXXNullPtrLiteralExpr);
   IGNORE_EXPR(CXXPseudoDestructorExpr);
   IGNORE_EXPR(CXXScalarValueInitExpr);
   IGNORE_EXPR(CXXNoexceptExpr);
   IGNORE_EXPR(CXXTypeidExpr);
   IGNORE_EXPR(CXXUnresolvedConstructExpr);
   IGNORE_EXPR(CXXUuidofExpr);
   IGNORE_EXPR(DependentScopeDeclRefExpr);
   IGNORE_EXPR(DesignatedInitExpr);
   IGNORE_EXPR(ExtVectorElementExpr);
   IGNORE_EXPR(FloatingLiteral);
   IGNORE_EXPR(ImaginaryLiteral);
   IGNORE_EXPR(IntegerLiteral);
   IGNORE_EXPR(OffsetOfExpr);
   IGNORE_EXPR(ImplicitValueInitExpr);
   IGNORE_EXPR(PackExpansionExpr);
   IGNORE_EXPR(PredefinedExpr);
   IGNORE_EXPR(ShuffleVectorExpr);
   IGNORE_EXPR(SizeOfPackExpr);
   IGNORE_EXPR(StmtExpr);
   IGNORE_EXPR(StringLiteral);
   IGNORE_EXPR(SubstNonTypeTemplateParmPackExpr);
-  IGNORE_EXPR(UnaryTypeTraitExpr);
+  IGNORE_EXPR(TypeTraitExpr);
   IGNORE_EXPR(VAArgExpr);
   IGNORE_EXPR(GNUNullExpr);
   IGNORE_EXPR(OverloadExpr);
 
   DECL_VISIT_EXPR(CXXThisExpr) {
     return Use(expr, expr->getType(), THIS, env);
   }
 
   DECL_VISIT_EXPR(AbstractConditionalOperator) {
     Environment after_cond = env.ApplyEffect(VisitExpr(expr->getCond(), env));
     return ExprEffect::Merge(VisitExpr(expr->getTrueExpr(), after_cond),
                              VisitExpr(expr->getFalseExpr(), after_cond));
   }
 
   DECL_VISIT_EXPR(ArraySubscriptExpr) {
     clang::Expr* exprs[2] = {expr->getBase(), expr->getIdx()};
     return Par(expr, 2, exprs, env);
   }
 
   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;
   }
 
   DECL_VISIT_EXPR(BinaryOperator) {
     clang::Expr* lhs = expr->getLHS();
     clang::Expr* rhs = expr->getRHS();
     clang::Expr* exprs[2] = {lhs, rhs};
 
@@ skipping 27 matching lines @@
   }
 
   DECL_VISIT_EXPR(CXXDefaultArgExpr) {
     return VisitExpr(expr->getExpr(), env);
   }
 
   DECL_VISIT_EXPR(CXXDeleteExpr) {
     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);
   }
 
   DECL_VISIT_EXPR(CXXThrowExpr) {
     return VisitExpr(expr->getSubExpr(), env);
   }
 
   DECL_VISIT_EXPR(InitListExpr) {
@@ skipping 33 matching lines @@
   }
 
   DECL_VISIT_EXPR(CastExpr) {
     return VisitExpr(expr->getSubExpr(), env);
   }
 
   DECL_VISIT_EXPR(DeclRefExpr) {
     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,
                  const Environment& env) {
     CallProps props;
 
     for (int i = 0; i < n; ++i) {
       props.SetEffect(i, VisitExpr(exprs[i], env));
     }
 
@@ skipping 54 matching lines @@
       props->SetEffect(arg + 1, VisitExpr(call->getArg(arg), env));
     }
   }
 
 
   ExprEffect VisitCallExpr(clang::CallExpr* call,
                            const Environment& env) {
     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));
     }
 
     VisitArguments<>(call, &props, env);
 
     if (!props.IsSafe()) ReportUnsafe(call, BAD_EXPR_MSG);
 
     ExprEffect out =
         props.ComputeCumulativeEffect(IsRawPointerType(call->getType()));
 
     clang::FunctionDecl* callee = call->getDirectCallee();
     if ((callee != NULL) && KnownToCauseGC(ctx_, callee)) {
       out.setGC();
     }
 
     return out;
   }
 
   // --------------------------------------------------------------------------
   // Statements
   // --------------------------------------------------------------------------
 
   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);
+#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 = dyn_cast_or_null<clang::Expr>(stmt)) {
+    if (clang::Expr* expr = llvm::dyn_cast_or_null<clang::Expr>(stmt)) {
       return env.ApplyEffect(VisitExpr(expr, env));
     }
 
     VISIT(AsmStmt);
     VISIT(BreakStmt);
     VISIT(CompoundStmt);
     VISIT(ContinueStmt);
     VISIT(CXXCatchStmt);
     VISIT(CXXTryStmt);
     VISIT(DeclStmt);
@@ skipping 180 matching lines @@
   }
 
   DECL_VISIT_STMT(ReturnStmt) {
     VisitExpr(stmt->getRetValue(), env);
     return Environment::Unreachable();
   }
 
   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 IsDerivedFrom(clang::CXXRecordDecl* record,
                      clang::CXXRecordDecl* base) {
     return (record == base) || record->isDerivedFrom(base);
   }
 
   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 =
         ToTagType(type->getPointeeType().getTypePtr());
     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;
 
     if (!record->hasDefinition()) return false;
 
     record = record->getDefinition();
 
     return IsDerivedFrom(record, object_decl_) &&
         !IsDerivedFrom(record, smi_decl_);
   }
 
   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())) {
         out = out.Define(var->getNameAsString());
       }
 
       return out;
     }
     // TODO: handle other declarations?
     return env;
@@ skipping 39 matching lines @@
     return parent;
   }
 
   void LeaveBlock(Block* block) {
     block_ = block;
   }
 
  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::MangleContext* ctx_;
   clang::DeclarationName handle_decl_name_;
   clang::CXXRecordDecl* object_decl_;
   clang::CXXRecordDecl* smi_decl_;
 
-  clang::Diagnostic& d_;
+  clang::DiagnosticsEngine& d_;
   clang::SourceManager& sm_;
 
   Block* block_;
   bool dead_vars_analysis_;
 };
 
 
 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 (args[i] == "--dead-vars") {
         dead_vars_analysis_ = true;
       }
     }
   }
 
   virtual void HandleTranslationUnit(clang::ASTContext &ctx) {
     Resolver r(ctx);
 
     clang::CXXRecordDecl* object_decl =
         r.ResolveNamespace("v8").ResolveNamespace("internal").
             Resolve<clang::CXXRecordDecl>("Object");
 
     clang::CXXRecordDecl* smi_decl =
         r.ResolveNamespace("v8").ResolveNamespace("internal").
             Resolve<clang::CXXRecordDecl>("Smi");
 
     if (object_decl != NULL) object_decl = object_decl->getDefinition();
 
     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) {
         llvm::errs() << "Failed to resolve v8::internal::Object\n";
       }
       if (smi_decl == NULL) {
         llvm::errs() << "Failed to resolve v8::internal::Smi\n";
       }
     }
   }
 
   virtual bool VisitFunctionDecl(clang::FunctionDecl* decl) {
     function_analyzer_->AnalyzeFunction(decl);
     return true;
   }
 
  private:
-  clang::Diagnostic& d_;
+  clang::DiagnosticsEngine& d_;
   clang::SourceManager& sm_;
   bool dead_vars_analysis_;
 
   FunctionAnalyzer* function_analyzer_;
 };
 
 
 template<typename ConsumerType>
 class Action : public clang::PluginASTAction {
  protected:
@@ skipping 16 matching lines @@
 
 
 }
 
 static clang::FrontendPluginRegistry::Add<Action<ProblemsFinder> >
 FindProblems("find-problems", "Find GC-unsafe places.");
 
 static clang::FrontendPluginRegistry::Add<
   Action<FunctionDeclarationFinder> >
 DumpCallees("dump-callees", "Dump callees for each function.");