Disable generating of code cache if the debugger is loaded

src/compiler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/compiler.h"
 
 #include "src/ast-numbering.h"
 #include "src/ast-this-access-visitor.h"
@@ skipping 1266 matching lines @@
   int source_length = source->length();
   isolate->counters()->total_load_size()->Increment(source_length);
   isolate->counters()->total_compile_size()->Increment(source_length);
 
   CompilationCache* compilation_cache = isolate->compilation_cache();
 
   // Do a lookup in the compilation cache but not for extensions.
   MaybeHandle<SharedFunctionInfo> maybe_result;
   Handle<SharedFunctionInfo> result;
   if (extension == NULL) {
-    if (FLAG_serialize_toplevel &&

[vogelheim, 2014/12/11 11:06:22]

I'd prefer to check the condition once upfront and to pass in kNoCompileOptions
when isolate->debug()->is_loaded().

Good places to do that might be either the top of Compile::CompileScript, where
we're sanity checking the compile options, or maybe at the top of
ScriptCompiler::CompileUnbound in api.cc, where we modify the options in similar
fashion (but for other reasons).

-        compile_options == ScriptCompiler::kConsumeCodeCache &&
-        !isolate->debug()->is_loaded()) {
+    if (IsCodeCachingActive(isolate) &&
+        compile_options == ScriptCompiler::kConsumeCodeCache) {
       HistogramTimerScope timer(isolate->counters()->compile_deserialize());
       Handle<SharedFunctionInfo> result;
       if (CodeSerializer::Deserialize(isolate, *cached_data, source)
               .ToHandle(&result)) {
         return result;
       }
       // Deserializer failed. Fall through to compile.
     } else {
       maybe_result = compilation_cache->LookupScript(
           source, script_name, line_offset, column_offset,
           is_shared_cross_origin, context);
     }
   }
 
   base::ElapsedTimer timer;
-  if (FLAG_profile_deserialization && FLAG_serialize_toplevel &&
+  if (FLAG_profile_deserialization && IsCodeCachingActive(isolate) &&
       compile_options == ScriptCompiler::kProduceCodeCache) {
     timer.Start();
   }
 
   if (!maybe_result.ToHandle(&result)) {
     // No cache entry found. Compile the script.
 
     // Create a script object describing the script to be compiled.
     Handle<Script> script = isolate->factory()->NewScript(source);
     if (natives == NATIVES_CODE) {
       script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
     }
     if (!script_name.is_null()) {
       script->set_name(*script_name);
       script->set_line_offset(Smi::FromInt(line_offset));
       script->set_column_offset(Smi::FromInt(column_offset));
     }
     script->set_is_shared_cross_origin(is_shared_cross_origin);
 
     // Compile the function and add it to the cache.
     CompilationInfoWithZone info(script);
     info.MarkAsGlobal();
     info.SetCachedData(cached_data, compile_options);
     info.SetExtension(extension);
     info.SetContext(context);
-    if (FLAG_serialize_toplevel &&
+    if (IsCodeCachingActive(isolate) &&
         compile_options == ScriptCompiler::kProduceCodeCache) {
       info.PrepareForSerializing();
     }
     if (FLAG_use_strict) info.SetStrictMode(STRICT);
 
     result = CompileToplevel(&info);
     if (extension == NULL && !result.is_null() && !result->dont_cache()) {
       compilation_cache->PutScript(source, context, result);
-      if (FLAG_serialize_toplevel &&
+      if (IsCodeCachingActive(isolate) &&
           compile_options == ScriptCompiler::kProduceCodeCache) {
         HistogramTimerScope histogram_timer(
             isolate->counters()->compile_serialize());
         *cached_data = CodeSerializer::Serialize(isolate, result, source);
         if (FLAG_profile_deserialization) {
           PrintF("[Compiling and serializing took %0.3f ms]\n",
                  timer.Elapsed().InMillisecondsF());
         }
       }
     }
@@ skipping 193 matching lines @@
 
 bool Compiler::DebuggerWantsEagerCompilation(CompilationInfo* info,
                                              bool allow_lazy_without_ctx) {
   if (LiveEditFunctionTracker::IsActive(info->isolate())) return true;
   Debug* debug = info->isolate()->debug();
   bool debugging = debug->is_active() || debug->has_break_points();
   return debugging && !allow_lazy_without_ctx;
 }
 
 
+bool Compiler::IsCodeCachingActive(Isolate* isolate) {
+  return FLAG_serialize_toplevel && !isolate->debug()->is_loaded();
+}
+
+
 CompilationPhase::CompilationPhase(const char* name, CompilationInfo* info)
     : name_(name), info_(info), zone_(info->isolate()) {
   if (FLAG_hydrogen_stats) {
     info_zone_start_allocation_size_ = info->zone()->allocation_size();
     timer_.Start();
   }
 }
 
 
 CompilationPhase::~CompilationPhase() {
@@ skipping 11 matching lines @@
   AllowHandleDereference allow_deref;
   bool tracing_on = info()->IsStub()
       ? FLAG_trace_hydrogen_stubs
       : (FLAG_trace_hydrogen &&
          info()->closure()->PassesFilter(FLAG_trace_hydrogen_filter));
   return (tracing_on &&
       base::OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL);
 }
 
 } }  // namespace v8::internal