[type profile] Collect return types.

src/ast/ast-numbering.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/ast/ast-numbering.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/objects-inl.h"
@@ skipping 15 matching lines @@
         slot_cache_(zone),
         disable_crankshaft_reason_(kNoReason),
         dont_optimize_reason_(kNoReason),
         catch_prediction_(HandlerTable::UNCAUGHT),
         collect_type_profile_(collect_type_profile) {
     InitializeAstVisitor(stack_limit);
   }
 
   bool Renumber(FunctionLiteral* node);
 
+  FeedbackSlot TypeProfileSlotForReturnValue() const {
+    if (collect_type_profile_) {
+      DCHECK(!type_profile_for_return_value_.IsInvalid());
+    }
+    return type_profile_for_return_value_;
+  }
+
  private:
 // AST node visitor interface.
 #define DEFINE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
   void VisitVariableProxy(VariableProxy* node, TypeofMode typeof_mode);
   void VisitVariableProxyReference(VariableProxy* node);
   void VisitPropertyReference(Property* node);
   void VisitReference(Expression* expr);
@@ skipping 51 matching lines @@
   int next_id_;
   int yield_count_;
   AstProperties properties_;
   LanguageMode language_mode_;
   // The slot cache allows us to reuse certain feedback slots.
   FeedbackSlotCache slot_cache_;
   BailoutReason disable_crankshaft_reason_;
   BailoutReason dont_optimize_reason_;
   HandlerTable::CatchPrediction catch_prediction_;
   bool collect_type_profile_;
+  FeedbackSlot type_profile_for_return_value_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
   DISALLOW_COPY_AND_ASSIGN(AstNumberingVisitor);
 };
 
 
 void AstNumberingVisitor::VisitVariableDeclaration(VariableDeclaration* node) {
   IncrementNodeCount();
   VisitVariableProxy(node->proxy());
 }
@@ skipping 113 matching lines @@
 void AstNumberingVisitor::VisitExpressionStatement(ExpressionStatement* node) {
   IncrementNodeCount();
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitReturnStatement(ReturnStatement* node) {
   IncrementNodeCount();
   Visit(node->expression());
 
+  node->SetTypeProfileSlot(TypeProfileSlotForReturnValue());
+
   DCHECK(!node->is_async_return() ||
          properties_.flags() & AstProperties::kMustUseIgnitionTurbo);
 }
 
 
 void AstNumberingVisitor::VisitYield(Yield* node) {
   node->set_yield_id(yield_count_);
   yield_count_++;
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Yield::num_ids()));
@@ skipping 407 matching lines @@
 
 void AstNumberingVisitor::VisitRewritableExpression(
     RewritableExpression* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(RewritableExpression::num_ids()));
   Visit(node->expression());
 }
 
 
 bool AstNumberingVisitor::Renumber(FunctionLiteral* node) {
+  if (collect_type_profile_) {
+    type_profile_for_return_value_ =

[Michael Starzinger, 2017/03/20 09:29:26]

nit: Please move this down to after the global compiler and into the language
mode scope (i.e. to line 708 ideally).

[Franzi, 2017/03/20 15:38:39]

Done.

+        properties_.get_spec()->AddTypeProfileSlot();
+  }
+
   DeclarationScope* scope = node->scope();
   DCHECK(!scope->HasBeenRemoved());
 
   if (scope->new_target_var() != nullptr ||
       scope->this_function_var() != nullptr) {
     DisableFullCodegenAndCrankshaft(kSuperReference);
   }
 
   if (scope->arguments() != nullptr &&
       !scope->arguments()->IsStackAllocated()) {
@@ skipping 46 matching lines @@
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
 
   AstNumberingVisitor visitor(stack_limit, zone, eager_literals,
                               collect_type_profile);
   return visitor.Renumber(function);
 }
 }  // namespace internal
 }  // namespace v8