[type-profile] Handle returns correctly.

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 168 matching lines @@
 }
 
 
 void AstNumberingVisitor::VisitAssignment(Assignment* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Assignment::num_ids()));
 
   if (node->is_compound()) VisitBinaryOperation(node->binary_operation());
   VisitReference(node->target());
   Visit(node->value());
-  node->AssignFeedbackSlots(properties_.get_spec(), language_mode_,
-                            &slot_cache_, collect_type_profile_);
+  ReserveFeedbackSlots(node);
 }
 
 
 void AstNumberingVisitor::VisitBinaryOperation(BinaryOperation* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(BinaryOperation::num_ids()));
   Visit(node->left());
   Visit(node->right());
   ReserveFeedbackSlots(node);
 }
@@ skipping 245 matching lines @@
     DisableFullCodegenAndCrankshaft(kGenerator);
   }
 
   if (IsClassConstructor(node->kind())) {
     DisableFullCodegenAndCrankshaft(kClassConstructorFunction);
   }
 
   LanguageModeScope language_mode_scope(this, node->language_mode());
 
   if (collect_type_profile_) {
-    type_profile_for_return_value_ =
-        properties_.get_spec()->AddTypeProfileSlot();
+    node->SetTypeProfileSlot(properties_.get_spec()->AddTypeProfileSlot());
   }
 
   VisitDeclarations(scope->declarations());
   VisitStatements(node->body());
 
   node->set_ast_properties(&properties_);
   node->set_dont_optimize_reason(dont_optimize_reason());
   node->set_yield_count(yield_count_);
 
   if (FLAG_trace_opt) {
@@ skipping 21 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