Collect type profile for DevTools.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 903 matching lines @@
     case VariableLocation::LOOKUP: {
       DCHECK_EQ(VAR, variable->mode());
       DCHECK(!variable->binding_needs_init());
 
       Register name = register_allocator()->NewRegister();
 
       builder()
           ->LoadLiteral(variable->raw_name())
           .StoreAccumulatorInRegister(name)
           .CallRuntime(Runtime::kDeclareEvalVar, name);
+
       break;
     }
     case VariableLocation::MODULE:
       if (variable->IsExport() && variable->binding_needs_init()) {
         builder()->LoadTheHole();
         BuildVariableAssignment(variable, Token::INIT, FeedbackSlot::Invalid(),
                                 HoleCheckMode::kElided);
       }
       // Nothing to do for imports.
       break;
@@ skipping 1273 matching lines @@
   DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
   Register object, key;
   RegisterList super_property_args;
   const AstRawString* name;
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->target()->AsProperty();
   LhsKind assign_type = Property::GetAssignType(property);
 
   // Evaluate LHS expression.
+  Register lhs_name = register_allocator()->NewRegister();
+
   switch (assign_type) {
     case VARIABLE:
+      if (FLAG_type_profile) {

[Yang, 2017/02/22 10:39:28]

The issue with this flag and snapshot is: if the function is part of the
snapshot, it may already have a feedback metadata created with this flag off.
When compiling the function here, we assume the feedback metadata to have been
created with this flag on.

Either we clear the feedback metadata when we serialize, along with the code, or
we figure out from the feedback metadata, if it exists, whether we have slots
reserved for type profile, instead of relying on the flag. I'll test whether
clearing the feedback metadata during serialization can be done.

We should not collect type profile for functions for which
SharedFunctionInfo::IsSubjectToDebugging returns false though, which every
function in the default startup snapshot does.

+        builder()
+            ->LoadLiteral(expr->target()->AsVariableProxy()->var()->raw_name())
+            .StoreAccumulatorInRegister(lhs_name);
+      }
       // Nothing to do to evaluate variable assignment LHS.
       break;
     case NAMED_PROPERTY: {
       object = VisitForRegisterValue(property->obj());
       name = property->key()->AsLiteral()->AsRawPropertyName();
+      if (FLAG_type_profile) {
+        builder()->LoadLiteral(name).StoreAccumulatorInRegister(lhs_name);
+      }
       break;
     }
     case KEYED_PROPERTY: {
       object = VisitForRegisterValue(property->obj());
       key = VisitForRegisterValue(property->key());
+      if (FLAG_type_profile) {
+        builder()->StoreAccumulatorInRegister(lhs_name);
+      }
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       super_property_args = register_allocator()->NewRegisterList(4);
       SuperPropertyReference* super_property =
           property->obj()->AsSuperPropertyReference();
       VisitForRegisterValue(super_property->this_var(), super_property_args[0]);
       VisitForRegisterValue(super_property->home_object(),
                             super_property_args[1]);
       builder()
           ->LoadLiteral(property->key()->AsLiteral()->AsRawPropertyName())
           .StoreAccumulatorInRegister(super_property_args[2]);
+      if (FLAG_type_profile) {
+        builder()->StoreAccumulatorInRegister(lhs_name);
+      }
       break;
     }
     case KEYED_SUPER_PROPERTY: {
       super_property_args = register_allocator()->NewRegisterList(4);
       SuperPropertyReference* super_property =
           property->obj()->AsSuperPropertyReference();
       VisitForRegisterValue(super_property->this_var(), super_property_args[0]);
       VisitForRegisterValue(super_property->home_object(),
                             super_property_args[1]);
       VisitForRegisterValue(property->key(), super_property_args[2]);
+      if (FLAG_type_profile) {
+        builder()->StoreAccumulatorInRegister(lhs_name);
+      }
+
       break;
     }
   }
 
   // Evaluate the value and potentially handle compound assignments by loading
   // the left-hand side value and performing a binary operation.
   if (expr->is_compound()) {
     Register old_value = register_allocator()->NewRegister();
     switch (assign_type) {
       case VARIABLE: {
@@ skipping 68 matching lines @@
           .CallRuntime(StoreToSuperRuntimeId(), super_property_args);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
       builder()
           ->StoreAccumulatorInRegister(super_property_args[3])
           .CallRuntime(StoreKeyedToSuperRuntimeId(), super_property_args);
       break;
     }
   }
+
+  // Value is in accumulator.
+  if (FLAG_type_profile) {
+    Register value = register_allocator()->NewRegister();
+    builder()->StoreAccumulatorInRegister(value);
+
+    FeedbackSlot collect_type_feedback_slot = expr->CollectTypeProfileSlot();
+
+    builder()->CollectTypeProfile(lhs_name, value,

[Yang, 2017/02/22 10:39:28]

We would at some point need a mapping from feedback slot to source position and
name, so that when we harvest the data collected in the feedback slots, we can
tell where to attribute it to.

In that case, all we need as arguments here are the value, and the vector slot
pair. We can then use the mapping to get the name and source position. That's a
bit less intrusive than getting names.

+                                  feedback_index(collect_type_feedback_slot));
+  }
 }
 
 void BytecodeGenerator::VisitYield(Yield* expr) {
   builder()->SetExpressionPosition(expr);
   Register value = VisitForRegisterValue(expr->expression());
 
   Register generator = VisitForRegisterValue(expr->generator_object());
 
   // Save context, registers, and state. Then return.
   builder()
@@ skipping 1122 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8