[inspector] implemented blackboxing inside v8

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/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 487 matching lines @@
         script->FindSharedFunctionInfo(isolate, literal);
     if (maybe_existing.ToHandle(&shared)) {
       DCHECK(!shared->is_toplevel());
       // If we found an existing shared function info with compiled code,
       // we are done.
       if (shared->is_compiled()) continue;
     } else {
       shared =
           isolate->factory()->NewSharedFunctionInfoForLiteral(literal, script);
       shared->set_is_toplevel(false);
+      isolate->debug()->OnNewSharedFunctionInfo(shared);
     }
 
     Zone zone(isolate->allocator(), ZONE_NAME);
     ParseInfo parse_info(&zone, script);
     parse_info.set_literal(literal);
     parse_info.set_shared_info(shared);
     parse_info.set_function_literal_id(shared->function_literal_id());
     parse_info.set_language_mode(literal->scope()->language_mode());
     parse_info.set_ast_value_factory(
         outer_info->parse_info()->ast_value_factory());
@@ skipping 562 matching lines @@
                                : info->isolate()->counters()->compile();
     HistogramTimerScope timer(rate);
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
                  parse_info->is_eval() ? "V8.CompileEval" : "V8.Compile");
 
     // Allocate a shared function info object.
     FunctionLiteral* lit = parse_info->literal();
     DCHECK_EQ(kNoSourcePosition, lit->function_token_position());
     result = isolate->factory()->NewSharedFunctionInfoForLiteral(lit, script);
     result->set_is_toplevel(true);
+    isolate->debug()->OnNewSharedFunctionInfo(result);

[Yang, 2017/01/19 13:55:35]

I wonder whether it is easier to keep track of all the locations, or lazily
compute it, and cache it on the shared function info. We would need two bits on
the shared function info, one to cache, and one to state whether the cache is
up-to-date.

The advantage is that you would not have to keep track of all the places we add
new shared function info, and would not need to eagerly compute the blackboxing
state. We do the same thing for side-effect-free debug evaluate. See
SharedFunctionInfo::HasNoSideEffect.

When you reset the black box state, you would simply need to iterate all shared
function infos and reset the first bit. That's probably a lot less expensive
than computing the black box state for all of them at once.

[kozy, 2017/01/19 16:08:38]

Done.

     parse_info->set_shared_info(result);
     parse_info->set_function_literal_id(result->function_literal_id());
 
     // Compile the code.
     if (!CompileUnoptimizedCode(info)) {
       return Handle<SharedFunctionInfo>::null();
     }
 
     Handle<String> script_name =
         script->name()->IsString()
@@ skipping 560 matching lines @@
   Handle<SharedFunctionInfo> existing;
   if (maybe_existing.ToHandle(&existing)) {
     DCHECK(!existing->is_toplevel());
     return existing;
   }
 
   // Allocate a shared function info object which will be compiled lazily.
   Handle<SharedFunctionInfo> result =
       isolate->factory()->NewSharedFunctionInfoForLiteral(literal, script);
   result->set_is_toplevel(false);
+  isolate->debug()->OnNewSharedFunctionInfo(result);
   Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
   if (outer_scope) {
     result->set_outer_scope_info(*outer_scope->scope_info());
   }
   return result;
 }
 
 Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForNative(
     v8::Extension* extension, Handle<String> name) {
   Isolate* isolate = name->GetIsolate();
@@ skipping 83 matching lines @@
   }
 
   if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8