In gcmole assume that methods exiting VM can cause GC.

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 51 matching lines @@
 
   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);
+  if (enum_constant != NULL && enum_constant->getNameAsString() == EXTERNAL) {
+    clang::QualType type = enum_constant->getType();
+    return (type.getAsString() == STATE_TAG);
+  }
+
+  return false;
+}
+
+
 struct Resolver {
   explicit Resolver(clang::ASTContext& ctx)
       : ctx_(ctx), decl_ctx_(ctx.getTranslationUnitDecl()) {
   }
 
   Resolver(clang::ASTContext& ctx, clang::DeclContext* decl_ctx)
       : ctx_(ctx), decl_ctx_(decl_ctx) {
   }
 
   clang::DeclarationName ResolveName(const char* n) {
@@ skipping 32 matching lines @@
  public:
   explicit CalleesPrinter(clang::MangleContext* ctx) : ctx_(ctx) {
   }
 
   virtual bool VisitCallExpr(clang::CallExpr* expr) {
     const clang::FunctionDecl* callee = expr->getDirectCallee();
     if (callee != NULL) AnalyzeFunction(callee);
     return true;
   }
 
+  virtual bool VisitDeclRefExpr(clang::DeclRefExpr* expr) {
+    // If function mentions EXTERNAL VMState add artificial garbage collection
+    // mark.
+    if (IsExternalVMState(expr->getDecl())) AddCallee("CollectGarbage");
+    return true;
+  }
+
   void AnalyzeFunction(const clang::FunctionDecl* f) {
     MangledName name;
     if (InV8Namespace(f) && GetMangledName(ctx_, f, &name)) {
       AddCallee(name);
 
       const clang::FunctionDecl* body = NULL;
       if (f->hasBody(body) && !Analyzed(name)) {
         EnterScope(name);
         TraverseStmt(body->getBody());
         LeaveScope();
@@ skipping 137 matching lines @@
   static ExprEffect RawUse() { return ExprEffect(kRawUse, NULL); }
 
   static ExprEffect Merge(ExprEffect a, ExprEffect b);
   static ExprEffect MergeSeq(ExprEffect a, ExprEffect b);
   ExprEffect Define(const std::string& name);
 
   Environment* env() {
     return reinterpret_cast<Environment*>(effect_ & ~kAllEffects);
   }
 
+  static ExprEffect GC() {
+    return ExprEffect(kCausesGC, NULL);
+  }
+
  private:
   ExprEffect(int effect, Environment* env)
       : effect_((effect & kAllEffects) |
                 reinterpret_cast<intptr_t>(env)) { }
 
   intptr_t effect_;
 };
 
 
 const std::string BAD_EXPR_MSG("Possible problem with evaluation order.");
@@ skipping 492 matching lines @@
         ReportUnsafe(parent, DEAD_VAR_MSG);
       }
       return ExprEffect::RawUse();
     }
     return ExprEffect::None();
   }
 
   ExprEffect Use(const clang::Expr* parent,
                  const clang::ValueDecl* var,
                  const Environment& env) {
+    if (IsExternalVMState(var)) {
+      return ExprEffect::GC();
+    }
     return Use(parent, var->getType(), var->getNameAsString(), env);
   }
 
 
   template<typename ExprType>
   ExprEffect VisitArguments(ExprType* call, const Environment& env) {
     CallProps props;
     VisitArguments<>(call, &props, env);
     if (!props.IsSafe()) ReportUnsafe(call, BAD_EXPR_MSG);
     return props.ComputeCumulativeEffect(IsRawPointerType(call->getType()));
@@ skipping 449 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.");