[Interpreter] Allocates new temporary register outside the reservation for consecutive registers.

src/interpreter/bytecode-array-builder.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-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 970 matching lines @@
     return last_temporary_register().index();
   } else {
     auto pos = free_temporaries_.begin();
     int retval = *pos;
     free_temporaries_.erase(pos);
     return retval;
   }
 }
 
 
+int BytecodeArrayBuilder::BorrowTemporaryRegisterNotInRange(int start_index,
+                                                            int end_index) {
+  auto index = free_temporaries_.lower_bound(start_index);
+  if (index == free_temporaries_.begin()) {
+    // If start_index is the first free register, check for a register
+    // greater than end_index.
+    index = free_temporaries_.upper_bound(end_index);
+  } else {
+    // If there is a free register < start_index
+    index--;
+  }
+  if (index == free_temporaries_.end()) {

[oth, 2015/12/21 12:48:19]

If this check only applies if upper_bound() has been called, the then block
could be moved directly after the upper_bound() call and the else block be run
unconditionally at the end of this function.

+    temporary_register_count_ += 1;
+    return last_temporary_register().index();
+  } else {
+    int retval = *index;
+    free_temporaries_.erase(index);
+    return retval;
+  }
+}
+
+
+int BytecodeArrayBuilder::AllocateAndBorrowTemporaryRegister() {
+  temporary_register_count_ += 1;
+  return last_temporary_register().index();
+}
+
+
 void BytecodeArrayBuilder::BorrowConsecutiveTemporaryRegister(int reg_index) {
   DCHECK(free_temporaries_.find(reg_index) != free_temporaries_.end());
   free_temporaries_.erase(reg_index);
 }
 
 
 void BytecodeArrayBuilder::ReturnTemporaryRegister(int reg_index) {
   DCHECK(free_temporaries_.find(reg_index) == free_temporaries_.end());
   free_temporaries_.insert(reg_index);
 }
@@ skipping 391 matching lines @@
 
 TemporaryRegisterScope::~TemporaryRegisterScope() {
   for (auto i = allocated_.rbegin(); i != allocated_.rend(); i++) {
     builder_->ReturnTemporaryRegister(*i);
   }
   allocated_.clear();
 }
 
 
 Register TemporaryRegisterScope::NewRegister() {
-  int allocated = builder_->BorrowTemporaryRegister();
+  int allocated = -1;
+  if (next_consecutive_count_ <= 0) {
+    allocated = builder_->BorrowTemporaryRegister();
+  } else {
+    allocated = builder_->BorrowTemporaryRegisterNotInRange(
+        next_consecutive_register_,
+        next_consecutive_register_ + next_consecutive_count_ - 1);
+  }
   allocated_.push_back(allocated);
   return Register(allocated);
 }
+
+
+Register TemporaryRegisterScope::AllocateNewRegister() {
+  int allocated = builder_->AllocateAndBorrowTemporaryRegister();
+  allocated_.push_back(allocated);
+  return Register(allocated);
+}
 
 
 bool TemporaryRegisterScope::RegisterIsAllocatedInThisScope(
     Register reg) const {
   for (auto i = allocated_.begin(); i != allocated_.end(); i++) {
     if (*i == reg.index()) return true;
   }
   return false;
 }
 
@@ skipping 12 matching lines @@
   DCHECK_GT(next_consecutive_count_, 0);
   builder_->BorrowConsecutiveTemporaryRegister(next_consecutive_register_);
   allocated_.push_back(next_consecutive_register_);
   next_consecutive_count_--;
   return Register(next_consecutive_register_++);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8