[interpreter] Bytecode register optimizer.

src/interpreter/bytecode-register-allocator.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-register-allocator.h"
 
 #include "src/interpreter/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 TemporaryRegisterAllocator::TemporaryRegisterAllocator(Zone* zone,
                                                        int allocation_base)
     : free_temporaries_(zone),
       allocation_base_(allocation_base),
-      allocation_count_(0) {}
+      allocation_count_(0),
+      observer_(nullptr) {}
 
 Register TemporaryRegisterAllocator::first_temporary_register() const {
   DCHECK(allocation_count() > 0);
   return Register(allocation_base());
 }
 
 Register TemporaryRegisterAllocator::last_temporary_register() const {
   DCHECK(allocation_count() > 0);
   return Register(allocation_base() + allocation_count() - 1);
 }
 
+void TemporaryRegisterAllocator::set_observer(
+    TemporaryRegisterObserver* observer) {
+  DCHECK(observer_ == nullptr);
+  observer_ = observer;
+}
+
 int TemporaryRegisterAllocator::AllocateTemporaryRegister() {
   allocation_count_ += 1;
   return allocation_base() + allocation_count() - 1;
 }
 
 int TemporaryRegisterAllocator::BorrowTemporaryRegister() {
   if (free_temporaries_.empty()) {
     return AllocateTemporaryRegister();
   } else {
     auto pos = free_temporaries_.begin();
@@ skipping 94 matching lines @@
 
 void TemporaryRegisterAllocator::BorrowConsecutiveTemporaryRegister(
     int reg_index) {
   DCHECK(free_temporaries_.find(reg_index) != free_temporaries_.end());
   free_temporaries_.erase(reg_index);
 }
 
 void TemporaryRegisterAllocator::ReturnTemporaryRegister(int reg_index) {
   DCHECK(free_temporaries_.find(reg_index) == free_temporaries_.end());
   free_temporaries_.insert(reg_index);
+  if (observer_) {
+    observer_->TemporaryRegisterFreeEvent(Register(reg_index));
+  }
 }
 
 BytecodeRegisterAllocator::BytecodeRegisterAllocator(
     Zone* zone, TemporaryRegisterAllocator* allocator)
     : base_allocator_(allocator),
       allocated_(zone),
       next_consecutive_register_(-1),
       next_consecutive_count_(-1) {}
 
 BytecodeRegisterAllocator::~BytecodeRegisterAllocator() {
   for (auto i = allocated_.rbegin(); i != allocated_.rend(); i++) {
     base_allocator()->ReturnTemporaryRegister(*i);
   }
   allocated_.clear();
 }
 
-
 Register BytecodeRegisterAllocator::NewRegister() {
   int allocated = -1;
   if (next_consecutive_count_ <= 0) {
     allocated = base_allocator()->BorrowTemporaryRegister();
   } else {
     allocated = base_allocator()->BorrowTemporaryRegisterNotInRange(
         next_consecutive_register_,
         next_consecutive_register_ + next_consecutive_count_ - 1);
   }
   allocated_.push_back(allocated);
   return Register(allocated);
 }
 
-
 bool BytecodeRegisterAllocator::RegisterIsAllocatedInThisScope(
     Register reg) const {
   for (auto i = allocated_.begin(); i != allocated_.end(); i++) {
     if (*i == reg.index()) return true;
   }
   return false;
 }
 
-
 void BytecodeRegisterAllocator::PrepareForConsecutiveAllocations(size_t count) {
   if (static_cast<int>(count) > next_consecutive_count_) {
     next_consecutive_register_ =
         base_allocator()->PrepareForConsecutiveTemporaryRegisters(count);
     next_consecutive_count_ = static_cast<int>(count);
   }
 }
 
-
 Register BytecodeRegisterAllocator::NextConsecutiveRegister() {
   DCHECK_GE(next_consecutive_register_, 0);
   DCHECK_GT(next_consecutive_count_, 0);
   base_allocator()->BorrowConsecutiveTemporaryRegister(
       next_consecutive_register_);
   allocated_.push_back(next_consecutive_register_);
   next_consecutive_count_--;
   return Register(next_consecutive_register_++);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8