Assign yield ids in ast-numbering rather than in bytecode-generator.

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"
 
 namespace v8 {
@@ skipping 54 matching lines @@
   }
 
   template <typename Node>
   void ReserveFeedbackSlots(Node* node) {
     node->AssignFeedbackVectorSlots(isolate_, properties_.get_spec(),
                                     &slot_cache_);
   }
 
   BailoutReason dont_optimize_reason() const { return dont_optimize_reason_; }
 
-  int GetAndResetYieldCount() {
-    int old_yield_count = yield_count_;
-    yield_count_ = 0;
-    return old_yield_count;
-  }
-
-  void StoreAndUpdateYieldCount(IterationStatement* node, int old_yield_count) {
-    node->set_yield_count(yield_count_);
-    yield_count_ += old_yield_count;
-  }
-
   Isolate* isolate_;
   Zone* zone_;
   int next_id_;
   int yield_count_;
   AstProperties properties_;
   // The slot cache allows us to reuse certain feedback vector slots.
   FeedbackVectorSlotCache slot_cache_;
   BailoutReason dont_optimize_reason_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
@@ skipping 125 matching lines @@
 }
 
 
 void AstNumberingVisitor::VisitReturnStatement(ReturnStatement* node) {
   IncrementNodeCount();
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitYield(Yield* node) {
+  node->set_yield_id(yield_count_);
   yield_count_++;
   IncrementNodeCount();
   DisableOptimization(kYield);
   ReserveFeedbackSlots(node);
   node->set_base_id(ReserveIdRange(Yield::num_ids()));
   Visit(node->generator_object());
   Visit(node->expression());
 }
 
 
@@ skipping 48 matching lines @@
   node->set_base_id(ReserveIdRange(WithStatement::num_ids()));
   Visit(node->expression());
   Visit(node->statement());
 }
 
 
 void AstNumberingVisitor::VisitDoWhileStatement(DoWhileStatement* node) {
   IncrementNodeCount();
   DisableSelfOptimization();
   node->set_base_id(ReserveIdRange(DoWhileStatement::num_ids()));
-  int old_yield_count = GetAndResetYieldCount();
+  node->set_first_yield_id(yield_count_);
   Visit(node->body());
   Visit(node->cond());
-  StoreAndUpdateYieldCount(node, old_yield_count);
+  node->set_yield_count(yield_count_ - node->first_yield_id());
 }
 
 
 void AstNumberingVisitor::VisitWhileStatement(WhileStatement* node) {
   IncrementNodeCount();
   DisableSelfOptimization();
   node->set_base_id(ReserveIdRange(WhileStatement::num_ids()));
-  int old_yield_count = GetAndResetYieldCount();
+  node->set_first_yield_id(yield_count_);
   Visit(node->cond());
   Visit(node->body());
-  StoreAndUpdateYieldCount(node, old_yield_count);
+  node->set_yield_count(yield_count_ - node->first_yield_id());
 }
 
 
 void AstNumberingVisitor::VisitTryCatchStatement(TryCatchStatement* node) {
   IncrementNodeCount();
   DisableOptimization(kTryCatchStatement);
   Visit(node->try_block());
   Visit(node->catch_block());
 }
 
@@ skipping 63 matching lines @@
 void AstNumberingVisitor::VisitEmptyParentheses(EmptyParentheses* node) {
   UNREACHABLE();
 }
 
 
 void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
   IncrementNodeCount();
   DisableSelfOptimization();
   node->set_base_id(ReserveIdRange(ForInStatement::num_ids()));
   Visit(node->enumerable());  // Not part of loop.
-  int old_yield_count = GetAndResetYieldCount();
+  node->set_first_yield_id(yield_count_);
   Visit(node->each());
   Visit(node->body());
-  StoreAndUpdateYieldCount(node, old_yield_count);
+  node->set_yield_count(yield_count_ - node->first_yield_id());
   ReserveFeedbackSlots(node);
 }
 
 
 void AstNumberingVisitor::VisitForOfStatement(ForOfStatement* node) {
   IncrementNodeCount();
   DisableCrankshaft(kForOfStatement);
   node->set_base_id(ReserveIdRange(ForOfStatement::num_ids()));
   Visit(node->assign_iterator());  // Not part of loop.
-  int old_yield_count = GetAndResetYieldCount();
+  node->set_first_yield_id(yield_count_);
   Visit(node->next_result());
   Visit(node->result_done());
   Visit(node->assign_each());
   Visit(node->body());
-  StoreAndUpdateYieldCount(node, old_yield_count);
+  node->set_yield_count(yield_count_ - node->first_yield_id());
   ReserveFeedbackSlots(node);
 }
 
 
 void AstNumberingVisitor::VisitConditional(Conditional* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Conditional::num_ids()));
   Visit(node->condition());
   Visit(node->then_expression());
   Visit(node->else_expression());
@@ skipping 28 matching lines @@
   if (!node->is_default()) Visit(node->label());
   VisitStatements(node->statements());
 }
 
 
 void AstNumberingVisitor::VisitForStatement(ForStatement* node) {
   IncrementNodeCount();
   DisableSelfOptimization();
   node->set_base_id(ReserveIdRange(ForStatement::num_ids()));
   if (node->init() != NULL) Visit(node->init());  // Not part of loop.
-  int old_yield_count = GetAndResetYieldCount();
+  node->set_first_yield_id(yield_count_);
   if (node->cond() != NULL) Visit(node->cond());
   if (node->next() != NULL) Visit(node->next());
   Visit(node->body());
-  StoreAndUpdateYieldCount(node, old_yield_count);
+  node->set_yield_count(yield_count_ - node->first_yield_id());
 }
 
 
 void AstNumberingVisitor::VisitClassLiteral(ClassLiteral* node) {
   IncrementNodeCount();
   DisableCrankshaft(kClassLiteral);
   node->set_base_id(ReserveIdRange(node->num_ids()));
   if (node->extends()) Visit(node->extends());
   if (node->constructor()) Visit(node->constructor());
   if (node->class_variable_proxy()) {
@@ skipping 120 matching lines @@
 }
 
 
 bool AstNumbering::Renumber(Isolate* isolate, Zone* zone,
                             FunctionLiteral* function) {
   AstNumberingVisitor visitor(isolate, zone);
   return visitor.Renumber(function);
 }
 }  // namespace internal
 }  // namespace v8