[interpreter] Wide register support.

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 {
 
-class BytecodeArrayBuilder::PreviousBytecodeHelper {
+class BytecodeArrayBuilder::PreviousBytecodeHelper BASE_EMBEDDED {
  public:
   explicit PreviousBytecodeHelper(const BytecodeArrayBuilder& array_builder)
       : array_builder_(array_builder),
         previous_bytecode_start_(array_builder_.last_bytecode_start_) {
     // This helper is expected to be instantiated only when the last bytecode is
     // in the same basic block.
     DCHECK(array_builder_.LastBytecodeInSameBlock());
   }
 
   // Returns the previous bytecode in the same basic block.
   MUST_USE_RESULT Bytecode GetBytecode() const {
     DCHECK_EQ(array_builder_.last_bytecode_start_, previous_bytecode_start_);
     return Bytecodes::FromByte(
         array_builder_.bytecodes()->at(previous_bytecode_start_));
   }
 
   // Returns the operand at operand_index for the previous bytecode in the
   // same basic block.
   MUST_USE_RESULT uint32_t GetOperand(int operand_index) const {
     DCHECK_EQ(array_builder_.last_bytecode_start_, previous_bytecode_start_);
     Bytecode bytecode = GetBytecode();
     DCHECK_GE(operand_index, 0);
     DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode));
     size_t operand_offset =
         previous_bytecode_start_ +
         Bytecodes::GetOperandOffset(bytecode, operand_index);
     OperandSize size = Bytecodes::GetOperandSize(bytecode, operand_index);
     switch (size) {
-      default:
       case OperandSize::kNone:
         UNREACHABLE();
+        break;
       case OperandSize::kByte:
         return static_cast<uint32_t>(
             array_builder_.bytecodes()->at(operand_offset));
       case OperandSize::kShort:
         uint16_t operand =
             (array_builder_.bytecodes()->at(operand_offset) << 8) +
             array_builder_.bytecodes()->at(operand_offset + 1);
         return static_cast<uint32_t>(operand);
     }
+    return 0;
   }
 
   Handle<Object> GetConstantForIndexOperand(int operand_index) const {
     return array_builder_.constant_array_builder()->At(
         GetOperand(operand_index));
   }
 
  private:
   const BytecodeArrayBuilder& array_builder_;
   size_t previous_bytecode_start_;
 
   DISALLOW_COPY_AND_ASSIGN(PreviousBytecodeHelper);
 };
 
 
+class BytecodeArrayBuilder::RegisterTranslationScope BASE_EMBEDDED {
+ public:
+  static const Bytecode kInvalidBytecode = static_cast<Bytecode>(-1);
+
+  RegisterTranslationScope(BytecodeArrayBuilder* builder,
+                           Bytecode bytecode = kInvalidBytecode)
+      : builder_(builder), bytecode_(bytecode) {
+    builder->set_register_translation_scope(this);

[rmcilroy, 2016/01/22 17:50:56]

DCHECK_EQ(nullptr, builder()->register_translation_scope());

+  }
+
+  ~RegisterTranslationScope() {
+    translator()->CompleteTranslations();
+    builder()->set_register_translation_scope(nullptr);
+  }
+
+  Register Translate(Register reg) {
+    return translator()->Translate(bytecode(), reg);
+  }
+
+  void set_bytecode(Bytecode bytecode) { bytecode_ = bytecode; }
+  Bytecode bytecode() const { return bytecode_; }
+
+ private:
+  BytecodeArrayBuilder* builder() const { return builder_; }
+  RegisterTranslator* translator() { return builder()->register_translator(); }
+
+  BytecodeArrayBuilder* builder_;
+  Bytecode bytecode_;
+
+  DISALLOW_COPY_AND_ASSIGN(RegisterTranslationScope);
+};
+
+
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
       zone_(zone),
       bytecodes_(zone),
       bytecode_generated_(false),
       constant_array_builder_(isolate, zone),
       handler_table_builder_(isolate, zone),
       last_block_end_(0),
       last_bytecode_start_(~0),
       exit_seen_in_block_(false),
       unbound_jumps_(0),
       parameter_count_(-1),
       local_register_count_(-1),
       context_register_count_(-1),
       temporary_register_count_(0),
-      free_temporaries_(zone) {}
+      free_temporaries_(zone),
+      register_translator_(this),
+      register_translation_scope_(nullptr) {}
 
 
 BytecodeArrayBuilder::~BytecodeArrayBuilder() { DCHECK_EQ(0, unbound_jumps_); }
 
 
 void BytecodeArrayBuilder::set_locals_count(int number_of_locals) {
   local_register_count_ = number_of_locals;
   DCHECK_LE(context_register_count_, 0);
 }
 
@@ skipping 48 matching lines @@
   return temporary_register_count_ > 0 && first_temporary_register() <= reg &&
          reg <= last_temporary_register();
 }
 
 
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(bytecode_generated_, false);
   EnsureReturn();
 
   int bytecode_size = static_cast<int>(bytecodes_.size());
-  int register_count = fixed_register_count() + temporary_register_count_;
+  int register_count =
+      fixed_and_temporary_register_count() + translation_register_count();
   int frame_size = register_count * kPointerSize;
   Handle<FixedArray> constant_pool = constant_array_builder()->ToFixedArray();
   Handle<FixedArray> handler_table = handler_table_builder()->ToHandlerTable();
   Handle<BytecodeArray> output = isolate_->factory()->NewBytecodeArray(
       bytecode_size, &bytecodes_.front(), frame_size, parameter_count(),
       constant_pool);
   output->set_handler_table(*handler_table);
   bytecode_generated_ = true;
   return output;
 }
 
 
 template <size_t N>
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t(&operands)[N]) {
   // Don't output dead code.
   if (exit_seen_in_block_) return;
 
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), static_cast<int>(N));
+  DCHECK((register_translation_scope() == nullptr &&
+          Bytecodes::NumberOfRegisterOperands(bytecode) == 0) ||
+         (register_translation_scope() != nullptr &&
+          Bytecodes::NumberOfRegisterOperands(bytecode) > 0));
+  DCHECK(register_translator()->RegisterOperandsValid(bytecode, operands,
+                                                      static_cast<int>(N)));
+
   last_bytecode_start_ = bytecodes()->size();
   bytecodes()->push_back(Bytecodes::ToByte(bytecode));
   for (int i = 0; i < static_cast<int>(N); i++) {
     DCHECK(OperandIsValid(bytecode, i, operands[i]));
     switch (Bytecodes::GetOperandSize(bytecode, i)) {
       case OperandSize::kNone:
         UNREACHABLE();
+        break;
       case OperandSize::kByte:
         bytecodes()->push_back(static_cast<uint8_t>(operands[i]));
         break;
       case OperandSize::kShort: {
         uint8_t operand_bytes[2];
         WriteUnalignedUInt16(operand_bytes, operands[i]);
         bytecodes()->insert(bytecodes()->end(), operand_bytes,
                             operand_bytes + 2);
         break;
       }
@@ skipping 40 matching lines @@
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,
                                                             Register reg,
                                                             Strength strength) {
   if (is_strong(strength)) {
     UNIMPLEMENTED();
   }
 
-  Output(BytecodeForBinaryOperation(op), reg.ToRawOperand());
+  RegisterTranslationScope translator(this, BytecodeForBinaryOperation(op));
+  reg = translator.Translate(reg);
+  Output(translator.bytecode(), reg.ToRawOperand());

[rmcilroy, 2016/01/22 17:50:56]

To avoid the extra translate call, could we write this as:

  RegisterTranslationScope translator(this, BytecodeForBinaryOperation(op));
  Output(translator.bytecode(), translator.ToRawOperand(reg));

   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CountOperation(Token::Value op,
                                                            Strength strength) {
   if (is_strong(strength)) {
     UNIMPLEMENTED();
   }
 
@@ skipping 13 matching lines @@
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CompareOperation(
     Token::Value op, Register reg, Strength strength) {
   if (is_strong(strength)) {
     UNIMPLEMENTED();
   }
 
-  Output(BytecodeForCompareOperation(op), reg.ToRawOperand());
+  RegisterTranslationScope translator(this, BytecodeForCompareOperation(op));
+  reg = translator.Translate(reg);
+  Output(translator.bytecode(), reg.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
     v8::internal::Smi* smi) {
   int32_t raw_smi = smi->value();
   if (raw_smi == 0) {
     Output(Bytecode::kLdaZero);
   } else if (raw_smi >= -128 && raw_smi <= 127) {
@@ skipping 53 matching lines @@
     LoadTrue();
   } else {
     LoadFalse();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister(
     Register reg) {
+  RegisterTranslationScope translator(this, Bytecode::kLdar);
+  reg = translator.Translate(reg);
   if (!IsRegisterInAccumulator(reg)) {
-    Output(Bytecode::kLdar, reg.ToRawOperand());
+    Output(translator.bytecode(), reg.ToRawOperand());
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister(
     Register reg) {
+  RegisterTranslationScope translator(this, Bytecode::kStar);
+  reg = translator.Translate(reg);
   if (!IsRegisterInAccumulator(reg)) {
-    Output(Bytecode::kStar, reg.ToRawOperand());
+    Output(translator.bytecode(), reg.ToRawOperand());
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from,
                                                          Register to) {
   DCHECK(from != to);
-  if (FitsInReg8Operand(to) && FitsInReg8Operand(from)) {
-    Output(Bytecode::kMov, from.ToRawOperand(), to.ToRawOperand());
-  } else if (FitsInReg16Operand(to) && FitsInReg16Operand(from)) {
-    Output(Bytecode::kMovWide, from.ToRawOperand(), to.ToRawOperand());
+  RegisterTranslationScope translator(this);

[rmcilroy, 2016/01/22 17:50:56]

Personally I would prefer that the RegisterTranslationScope always takes a
bytecode in the constructor, and then you have a bytecode variable here which is
set based on the operand sizes (i.e., move the RegisterTranslationScope below
this if/else. Would that work? e.g.:
 
   Bytecode bytecode;
   if (FitsInReg8Operand(from) && FitsInReg8Operand(to)) {
     bytecode = Bytecode::kMov
   } else ....
     ...
   }
   RegisterTranslationScope translator(this, bytecode);
   Output(translator.bytecode(), translator.ToRawOperand(from),
translator.ToRawOperand(to));
   

+  if (FitsInReg8Operand(from) && FitsInReg8Operand(to)) {
+    translator.set_bytecode(Bytecode::kMov);
+  } else if (FitsInReg16Operand(from) && FitsInReg16Operand(to)) {
+    translator.set_bytecode(Bytecode::kMovWide);
   } else {
     UNIMPLEMENTED();
   }
+  from = translator.Translate(from);
+  to = translator.Translate(to);
+  Output(translator.bytecode(), from.ToRawOperand(), to.ToRawOperand());
   return *this;
 }
 
 
+bool BytecodeArrayBuilder::MoveRegisterUntranslated(Register from,
+                                                    Register to) {
+  if (!from.is_valid() || !to.is_valid()) {

[rmcilroy, 2016/01/22 17:50:56]

Just DCHECK(from.is_valid() && to.is_valid)) ?

+    UNIMPLEMENTED();
+    return false;
+  }
+
+  DCHECK(FitsInReg8OperandUntranslated(from) ||
+         FitsInReg8OperandUntranslated(to));
+  DCHECK(from != to);
+  if (FitsInReg16OperandUntranslated(from) &&
+      FitsInReg16OperandUntranslated(to)) {
+    Output(Bytecode::kMovWide, from.ToRawOperand(), to.ToRawOperand());
+    return true;
+  } else {
+    UNIMPLEMENTED();
+    return false;
+  }
+}
+
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(
     const Handle<String> name, int feedback_slot, LanguageMode language_mode,
     TypeofMode typeof_mode) {
   // TODO(rmcilroy): Potentially store language and typeof information in an
   // operand rather than having extra bytecodes.
   Bytecode bytecode = BytecodeForLoadGlobal(language_mode, typeof_mode);
   size_t name_index = GetConstantPoolEntry(name);
   if (FitsInIdx8Operand(name_index) && FitsInIdx8Operand(feedback_slot)) {
     Output(bytecode, static_cast<uint8_t>(name_index),
            static_cast<uint8_t>(feedback_slot));
@@ skipping 22 matching lines @@
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadContextSlot(Register context,
                                                             int slot_index) {
   DCHECK(slot_index >= 0);
+  RegisterTranslationScope translator(this);
   if (FitsInIdx8Operand(slot_index)) {
-    Output(Bytecode::kLdaContextSlot, context.ToRawOperand(),
-           static_cast<uint8_t>(slot_index));
+    translator.set_bytecode(Bytecode::kLdaContextSlot);
   } else if (FitsInIdx16Operand(slot_index)) {
-    Output(Bytecode::kLdaContextSlotWide, context.ToRawOperand(),
-           static_cast<uint16_t>(slot_index));
+    translator.set_bytecode(Bytecode::kLdaContextSlotWide);
   } else {
     UNIMPLEMENTED();
   }
+  context = translator.Translate(context);
+  Output(translator.bytecode(), context.ToRawOperand(),
+         static_cast<uint16_t>(slot_index));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreContextSlot(Register context,
                                                              int slot_index) {
   DCHECK(slot_index >= 0);
+  RegisterTranslationScope translator(this);
   if (FitsInIdx8Operand(slot_index)) {
-    Output(Bytecode::kStaContextSlot, context.ToRawOperand(),
-           static_cast<uint8_t>(slot_index));
+    translator.set_bytecode(Bytecode::kStaContextSlot);
   } else if (FitsInIdx16Operand(slot_index)) {
-    Output(Bytecode::kStaContextSlotWide, context.ToRawOperand(),
-           static_cast<uint16_t>(slot_index));
+    translator.set_bytecode(Bytecode::kStaContextSlotWide);
   } else {
     UNIMPLEMENTED();
   }
+  context = translator.Translate(context);
+  Output(translator.bytecode(), context.ToRawOperand(),
+         static_cast<uint16_t>(slot_index));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupSlot(
     const Handle<String> name, TypeofMode typeof_mode) {
   Bytecode bytecode = (typeof_mode == INSIDE_TYPEOF)
                           ? Bytecode::kLdaLookupSlotInsideTypeof
                           : Bytecode::kLdaLookupSlot;
   size_t name_index = GetConstantPoolEntry(name);
@@ skipping 21 matching lines @@
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
     Register object, const Handle<String> name, int feedback_slot,
     LanguageMode language_mode) {
-  Bytecode bytecode = BytecodeForLoadIC(language_mode);
+  RegisterTranslationScope translator(this);
   size_t name_index = GetConstantPoolEntry(name);
   if (FitsInIdx8Operand(name_index) && FitsInIdx8Operand(feedback_slot)) {
-    Output(bytecode, object.ToRawOperand(), static_cast<uint8_t>(name_index),
-           static_cast<uint8_t>(feedback_slot));
+    translator.set_bytecode(BytecodeForLoadIC(language_mode));
   } else if (FitsInIdx16Operand(name_index) &&
              FitsInIdx16Operand(feedback_slot)) {
-    Output(BytecodeForWideOperands(bytecode), object.ToRawOperand(),
-           static_cast<uint16_t>(name_index),
-           static_cast<uint16_t>(feedback_slot));
+    translator.set_bytecode(
+        BytecodeForWideOperands(BytecodeForLoadIC(language_mode)));
   } else {
     UNIMPLEMENTED();
   }
+  object = translator.Translate(object);
+  Output(translator.bytecode(), object.ToRawOperand(),
+         static_cast<uint16_t>(name_index),
+         static_cast<uint16_t>(feedback_slot));

[rmcilroy, 2016/01/22 17:50:56]

Maybe just cast directly to uint32_t now so that we don't accidentally down-cast
a 32bit value if we add 32bit operands (and given we do the checks in
OperandIsValid on size.

   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
-  Bytecode bytecode = BytecodeForKeyedLoadIC(language_mode);
+  RegisterTranslationScope translator(this);
   if (FitsInIdx8Operand(feedback_slot)) {
-    Output(bytecode, object.ToRawOperand(),
-           static_cast<uint8_t>(feedback_slot));
+    translator.set_bytecode(BytecodeForKeyedLoadIC(language_mode));
   } else if (FitsInIdx16Operand(feedback_slot)) {
-    Output(BytecodeForWideOperands(bytecode), object.ToRawOperand(),
-           static_cast<uint16_t>(feedback_slot));
+    translator.set_bytecode(
+        BytecodeForWideOperands(BytecodeForKeyedLoadIC(language_mode)));
   } else {
     UNIMPLEMENTED();
   }
+  object = translator.Translate(object);
+  Output(translator.bytecode(), object.ToRawOperand(),
+         static_cast<uint16_t>(feedback_slot));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(
     Register object, const Handle<String> name, int feedback_slot,
     LanguageMode language_mode) {
-  Bytecode bytecode = BytecodeForStoreIC(language_mode);
   size_t name_index = GetConstantPoolEntry(name);
+  RegisterTranslationScope translator(this);
   if (FitsInIdx8Operand(name_index) && FitsInIdx8Operand(feedback_slot)) {
-    Output(bytecode, object.ToRawOperand(), static_cast<uint8_t>(name_index),
-           static_cast<uint8_t>(feedback_slot));
+    translator.set_bytecode(BytecodeForStoreIC(language_mode));
   } else if (FitsInIdx16Operand(name_index) &&
              FitsInIdx16Operand(feedback_slot)) {
-    Output(BytecodeForWideOperands(bytecode), object.ToRawOperand(),
-           static_cast<uint16_t>(name_index),
-           static_cast<uint16_t>(feedback_slot));
+    translator.set_bytecode(
+        BytecodeForWideOperands(BytecodeForStoreIC(language_mode)));
   } else {
     UNIMPLEMENTED();
   }
+  object = translator.Translate(object);
+  Output(translator.bytecode(), object.ToRawOperand(),
+         static_cast<uint16_t>(name_index),
+         static_cast<uint16_t>(feedback_slot));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty(
     Register object, Register key, int feedback_slot,
     LanguageMode language_mode) {
-  Bytecode bytecode = BytecodeForKeyedStoreIC(language_mode);
+  RegisterTranslationScope translator(this);
   if (FitsInIdx8Operand(feedback_slot)) {
-    Output(bytecode, object.ToRawOperand(), key.ToRawOperand(),
-           static_cast<uint8_t>(feedback_slot));
+    translator.set_bytecode(BytecodeForKeyedStoreIC(language_mode));
   } else if (FitsInIdx16Operand(feedback_slot)) {
-    Output(BytecodeForWideOperands(bytecode), object.ToRawOperand(),
-           key.ToRawOperand(), static_cast<uint16_t>(feedback_slot));
+    translator.set_bytecode(
+        BytecodeForWideOperands(BytecodeForKeyedStoreIC(language_mode)));
   } else {
     UNIMPLEMENTED();
   }
+  object = translator.Translate(object);
+  key = translator.Translate(key);
+  Output(translator.bytecode(), object.ToRawOperand(), key.ToRawOperand(),
+         static_cast<uint16_t>(feedback_slot));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CreateClosure(
     Handle<SharedFunctionInfo> shared_info, PretenureFlag tenured) {
   size_t entry = GetConstantPoolEntry(shared_info);
   DCHECK(FitsInImm8Operand(tenured));
   if (FitsInIdx8Operand(entry)) {
     Output(Bytecode::kCreateClosure, static_cast<uint8_t>(entry),
@@ skipping 74 matching lines @@
            static_cast<uint16_t>(constant_properties_entry),
            static_cast<uint16_t>(literal_index), static_cast<uint8_t>(flags));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::PushContext(Register context) {
-  Output(Bytecode::kPushContext, context.ToRawOperand());
+  RegisterTranslationScope translator(this, Bytecode::kPushContext);
+  context = translator.Translate(context);
+  Output(translator.bytecode(), context.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::PopContext(Register context) {
-  Output(Bytecode::kPopContext, context.ToRawOperand());
+  RegisterTranslationScope translator(this, Bytecode::kPopContext);
+  context = translator.Translate(context);
+  Output(translator.bytecode(), context.ToRawOperand());
   return *this;
 }
 
 
 bool BytecodeArrayBuilder::NeedToBooleanCast() {
   if (!LastBytecodeInSameBlock()) {
     return true;
   }
   PreviousBytecodeHelper previous_bytecode(*this);
   switch (previous_bytecode.GetBytecode()) {
@@ skipping 302 matching lines @@
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Return() {
   Output(Bytecode::kReturn);
   exit_seen_in_block_ = true;
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare(
     Register cache_info_triple) {
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(cache_info_triple)) {
-    Output(Bytecode::kForInPrepare, cache_info_triple.ToRawOperand());
+    translator.set_bytecode(Bytecode::kForInPrepare);
   } else if (FitsInReg16Operand(cache_info_triple)) {
-    Output(Bytecode::kForInPrepareWide, cache_info_triple.ToRawOperand());
+    translator.set_bytecode(Bytecode::kForInPrepareWide);
   } else {
     UNIMPLEMENTED();
   }
+  cache_info_triple = translator.Translate(cache_info_triple);
+  Output(translator.bytecode(), cache_info_triple.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInDone(Register index,
                                                       Register cache_length) {
-  Output(Bytecode::kForInDone, index.ToRawOperand(),
+  RegisterTranslationScope translator(this, Bytecode::kForInDone);
+  index = translator.Translate(index);
+  cache_length = translator.Translate(cache_length);
+  Output(translator.bytecode(), index.ToRawOperand(),
          cache_length.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInNext(
     Register receiver, Register index, Register cache_type_array_pair) {
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(receiver) && FitsInReg8Operand(index) &&
       FitsInReg8Operand(cache_type_array_pair)) {
-    Output(Bytecode::kForInNext, receiver.ToRawOperand(), index.ToRawOperand(),
-           cache_type_array_pair.ToRawOperand());
+    translator.set_bytecode(Bytecode::kForInNext);
   } else if (FitsInReg16Operand(receiver) && FitsInReg16Operand(index) &&
              FitsInReg16Operand(cache_type_array_pair)) {
-    Output(Bytecode::kForInNextWide, receiver.ToRawOperand(),
-           index.ToRawOperand(), cache_type_array_pair.ToRawOperand());
+    translator.set_bytecode(Bytecode::kForInNextWide);
   } else {
     UNIMPLEMENTED();
   }
+  receiver = translator.Translate(receiver);
+  index = translator.Translate(index);
+  cache_type_array_pair = translator.Translate(cache_type_array_pair);
+  Output(translator.bytecode(), receiver.ToRawOperand(), index.ToRawOperand(),
+         cache_type_array_pair.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInStep(Register index) {
-  Output(Bytecode::kForInStep, index.ToRawOperand());
+  RegisterTranslationScope translator(this, Bytecode::kForInStep);
+  index = translator.Translate(index);
+  Output(translator.bytecode(), index.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkHandler(int handler_id,
                                                         bool will_catch) {
   handler_table_builder()->SetHandlerTarget(handler_id, bytecodes()->size());
   handler_table_builder()->SetPrediction(handler_id, will_catch);
   return *this;
 }
@@ skipping 24 matching lines @@
     LoadUndefined();
     Return();
   }
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
                                                  Register receiver,
                                                  size_t arg_count,
                                                  int feedback_slot) {
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(callable) && FitsInReg8Operand(receiver) &&
       FitsInIdx8Operand(arg_count) && FitsInIdx8Operand(feedback_slot)) {
-    Output(Bytecode::kCall, callable.ToRawOperand(), receiver.ToRawOperand(),
-           static_cast<uint8_t>(arg_count),
-           static_cast<uint8_t>(feedback_slot));
+    translator.set_bytecode(Bytecode::kCall);
   } else if (FitsInReg16Operand(callable) && FitsInReg16Operand(receiver) &&
              FitsInIdx16Operand(arg_count) &&
              FitsInIdx16Operand(feedback_slot)) {
-    Output(Bytecode::kCallWide, callable.ToRawOperand(),
-           receiver.ToRawOperand(), static_cast<uint16_t>(arg_count),
-           static_cast<uint16_t>(feedback_slot));
+    translator.set_bytecode(Bytecode::kCallWide);
   } else {
     UNIMPLEMENTED();
   }
+  callable = translator.Translate(callable);
+  receiver = translator.Translate(receiver);
+  Output(translator.bytecode(), callable.ToRawOperand(),
+         receiver.ToRawOperand(), static_cast<uint16_t>(arg_count),
+         static_cast<uint16_t>(feedback_slot));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::New(Register constructor,
                                                 Register first_arg,
                                                 size_t arg_count) {
   if (!first_arg.is_valid()) {
     DCHECK_EQ(0u, arg_count);
     first_arg = Register(0);
   }
 
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(constructor) && FitsInReg8Operand(first_arg) &&
       FitsInIdx8Operand(arg_count)) {
-    Output(Bytecode::kNew, constructor.ToRawOperand(), first_arg.ToRawOperand(),
-           static_cast<uint8_t>(arg_count));
+    translator.set_bytecode(Bytecode::kNew);
   } else if (FitsInReg16Operand(constructor) && FitsInReg16Operand(first_arg) &&
              FitsInIdx16Operand(arg_count)) {
-    Output(Bytecode::kNewWide, constructor.ToRawOperand(),
-           first_arg.ToRawOperand(), static_cast<uint16_t>(arg_count));
+    translator.set_bytecode(Bytecode::kNewWide);
   } else {
     UNIMPLEMENTED();
   }
+  constructor = translator.Translate(constructor);
+  first_arg = translator.Translate(first_arg);
+  Output(translator.bytecode(), constructor.ToRawOperand(),
+         first_arg.ToRawOperand(), static_cast<uint16_t>(arg_count));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntime(
     Runtime::FunctionId function_id, Register first_arg, size_t arg_count) {
   DCHECK_EQ(1, Runtime::FunctionForId(function_id)->result_size);
   DCHECK(FitsInIdx16Operand(function_id));
   if (!first_arg.is_valid()) {
     DCHECK_EQ(0u, arg_count);
     first_arg = Register(0);
   }
+
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(first_arg) && FitsInIdx8Operand(arg_count)) {
-    Output(Bytecode::kCallRuntime, static_cast<uint16_t>(function_id),
-           first_arg.ToRawOperand(), static_cast<uint8_t>(arg_count));
+    translator.set_bytecode(Bytecode::kCallRuntime);
   } else if (FitsInReg16Operand(first_arg) && FitsInIdx16Operand(arg_count)) {
-    Output(Bytecode::kCallRuntimeWide, static_cast<uint16_t>(function_id),
-           first_arg.ToRawOperand(), static_cast<uint16_t>(arg_count));
+    translator.set_bytecode(Bytecode::kCallRuntimeWide);
   } else {
     UNIMPLEMENTED();
   }
+  first_arg = translator.Translate(first_arg);
+  Output(translator.bytecode(), static_cast<uint16_t>(function_id),
+         first_arg.ToRawOperand(), static_cast<uint16_t>(arg_count));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntimeForPair(
     Runtime::FunctionId function_id, Register first_arg, size_t arg_count,
     Register first_return) {
   DCHECK_EQ(2, Runtime::FunctionForId(function_id)->result_size);
   DCHECK(FitsInIdx16Operand(function_id));
   if (!first_arg.is_valid()) {
     DCHECK_EQ(0u, arg_count);
     first_arg = Register(0);
   }
+
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(first_arg) && FitsInIdx8Operand(arg_count) &&
       FitsInReg8Operand(first_return)) {
-    Output(Bytecode::kCallRuntimeForPair, static_cast<uint16_t>(function_id),
-           first_arg.ToRawOperand(), static_cast<uint8_t>(arg_count),
-           first_return.ToRawOperand());
+    translator.set_bytecode(Bytecode::kCallRuntimeForPair);
   } else if (FitsInReg16Operand(first_arg) && FitsInIdx16Operand(arg_count) &&
              FitsInReg16Operand(first_return)) {
-    Output(Bytecode::kCallRuntimeForPairWide,
-           static_cast<uint16_t>(function_id), first_arg.ToRawOperand(),
-           static_cast<uint16_t>(arg_count), first_return.ToRawOperand());
+    translator.set_bytecode(Bytecode::kCallRuntimeForPairWide);
   } else {
     UNIMPLEMENTED();
   }
+  first_arg = translator.Translate(first_arg);
+  first_return = translator.Translate(first_return);
+  Output(translator.bytecode(), static_cast<uint16_t>(function_id),
+         first_arg.ToRawOperand(), static_cast<uint16_t>(arg_count),
+         first_return.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CallJSRuntime(int context_index,
                                                           Register receiver,
                                                           size_t arg_count) {
   DCHECK(FitsInIdx16Operand(context_index));
+
+  RegisterTranslationScope translator(this);
   if (FitsInReg8Operand(receiver) && FitsInIdx8Operand(arg_count)) {
-    Output(Bytecode::kCallJSRuntime, static_cast<uint16_t>(context_index),
-           receiver.ToRawOperand(), static_cast<uint8_t>(arg_count));
+    translator.set_bytecode(Bytecode::kCallJSRuntime);
   } else if (FitsInReg16Operand(receiver) && FitsInIdx16Operand(arg_count)) {
-    Output(Bytecode::kCallJSRuntimeWide, static_cast<uint16_t>(context_index),
-           receiver.ToRawOperand(), static_cast<uint16_t>(arg_count));
+    translator.set_bytecode(Bytecode::kCallJSRuntimeWide);
   } else {
     UNIMPLEMENTED();
   }
+  receiver = translator.Translate(receiver);
+  Output(translator.bytecode(), static_cast<uint16_t>(context_index),
+         receiver.ToRawOperand(), static_cast<uint16_t>(arg_count));
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Delete(Register object,
                                                    LanguageMode language_mode) {
-  Output(BytecodeForDelete(language_mode), object.ToRawOperand());
+  RegisterTranslationScope translator(this, BytecodeForDelete(language_mode));
+  object = translator.Translate(object);
+  Output(translator.bytecode(), object.ToRawOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::DeleteLookupSlot() {
   Output(Bytecode::kDeleteLookupSlot);
   return *this;
 }
 
 
 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   return constant_array_builder()->Insert(object);
 }
 
 
+void BytecodeArrayBuilder::ForgeTemporaryRegister() {
+  temporary_register_count_++;
+}
+
+
 int BytecodeArrayBuilder::BorrowTemporaryRegister() {
   if (free_temporaries_.empty()) {
-    temporary_register_count_ += 1;
+    ForgeTemporaryRegister();
     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);
     if (index == free_temporaries_.end()) {
-      temporary_register_count_ += 1;
+      ForgeTemporaryRegister();
       return last_temporary_register().index();
     }
   } else {
     // If there is a free register < start_index
     index--;
   }
 
   int retval = *index;
   free_temporaries_.erase(index);
   return retval;
@@ skipping 11 matching lines @@
   free_temporaries_.insert(reg_index);
 }
 
 
 int BytecodeArrayBuilder::PrepareForConsecutiveTemporaryRegisters(
     size_t count) {
   if (count == 0) {
     return -1;
   }
 
+  // TODO(oth): replace use of set<> here for free_temporaries with a
+  // more efficient structure. And/or partition into two searches -
+  // one before the translation window and one after.
+  if (free_temporaries_.empty()) {

[rmcilroy, 2016/01/22 17:50:56]

Please add a comment on why you are having to forge a new temporary reg here.

+    ForgeTemporaryRegister();
+    free_temporaries_.insert(last_temporary_register().index());
+  }
+
   // Search within existing temporaries for a run.
   auto start = free_temporaries_.begin();
   size_t run_length = 0;
   for (auto run_end = start; run_end != free_temporaries_.end(); run_end++) {
-    if (*run_end != *start + static_cast<int>(run_length)) {
+    int expected = *start + static_cast<int>(run_length);
+    if (*run_end != expected) {
       start = run_end;
       run_length = 0;
     }
+    Register reg_start(*start);
+    Register reg_expected(expected);
+    if (RegisterTranslator::DistanceToTranslationWindow(reg_start) > 0 &&
+        RegisterTranslator::DistanceToTranslationWindow(reg_expected) <= 0) {
+      // Run straddles the translation window boundary where there is
+      // a hidden discontinuity.

[rmcilroy, 2016/01/22 17:50:56]

/s/discontinuity/hole in allocatable registers ? 

+      start = run_end;
+      run_length = 0;
+    }
     if (++run_length == count) {
       return *start;
     }
   }
 
   // Continue run if possible across existing last temporary.
   if (temporary_register_count_ > 0 &&
       (start == free_temporaries_.end() ||
        *start + static_cast<int>(run_length) !=
            last_temporary_register().index() + 1)) {
     run_length = 0;
   }
 
+  // Pad temporaries if extended run would cross translation boundary.
+  Register reg_first(*start);
+  Register reg_last(*start + static_cast<int>(count) - 1);
+  DCHECK_GT(RegisterTranslator::DistanceToTranslationWindow(reg_first),
+            RegisterTranslator::DistanceToTranslationWindow(reg_last));
+  while (RegisterTranslator::DistanceToTranslationWindow(reg_first) > 0 &&
+         RegisterTranslator::DistanceToTranslationWindow(reg_last) <= 0) {
+    ForgeTemporaryRegister();
+    free_temporaries_.insert(last_temporary_register().index());
+    start = --free_temporaries_.end();
+    reg_first = Register(*start);
+    reg_last = Register(*start + static_cast<int>(count) - 1);
+    run_length = 0;
+  }
+
   // Ensure enough registers for run.
   while (run_length++ < count) {
-    temporary_register_count_++;
+    ForgeTemporaryRegister();
     free_temporaries_.insert(last_temporary_register().index());
   }
-  return last_temporary_register().index() - static_cast<int>(count) + 1;
+
+  int run_start =
+      last_temporary_register().index() - static_cast<int>(count) + 1;
+  DCHECK(RegisterTranslator::DistanceToTranslationWindow(Register(run_start)) <=
+             0 ||
+         RegisterTranslator::DistanceToTranslationWindow(
+             Register(run_start + static_cast<int>(count) - 1)) > 0);
+  return run_start;
 }
 
 
 bool BytecodeArrayBuilder::TemporaryRegisterIsLive(Register reg) const {
   if (temporary_register_count_ > 0) {
     DCHECK(reg.index() >= first_temporary_register().index() &&
            reg.index() <= last_temporary_register().index());
     return free_temporaries_.find(reg.index()) == free_temporaries_.end();
   } else {
     return false;
@@ skipping 50 matching lines @@
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool BytecodeArrayBuilder::RegisterIsValid(Register reg,
                                            OperandType reg_type) const {
   switch (Bytecodes::SizeOfOperand(reg_type)) {
     case OperandSize::kByte:
-      if (!FitsInReg8Operand(reg)) { return false; }
+      if (!FitsInReg8OperandUntranslated(reg)) {
+        return false;
+      }
       break;
     case OperandSize::kShort:
-      if (!FitsInReg16Operand(reg)) { return false; }
+      if (!FitsInReg16OperandUntranslated(reg)) {
+        return false;
+      }
       break;
     case OperandSize::kNone:
       UNREACHABLE();
       return false;
   }
 
   if (reg.is_function_context() || reg.is_function_closure() ||
       reg.is_new_target()) {
     return true;
   } else if (reg.is_parameter()) {
     int parameter_index = reg.ToParameterIndex(parameter_count_);
     return parameter_index >= 0 && parameter_index < parameter_count_;
-  } else if (reg.index() < fixed_register_count()) {
-    return true;
+  } else if (translation_register_count() == 0) {
+    if (reg.index() < fixed_register_count()) {
+      return true;
+    } else {
+      return TemporaryRegisterIsLive(reg);
+    }
   } else {
-    return TemporaryRegisterIsLive(reg);
+    return reg.index() < (fixed_and_temporary_register_count() +
+                          translation_register_count());

[rmcilroy, 2016/01/22 17:50:56]

Does this not check for the temp being live. Could you do this with checking
either TemporaryRegisterIsLive(reg) ||
RegisterTranslator::InTranslationWindow(reg) ?

   }
 }
 
 
 bool BytecodeArrayBuilder::LastBytecodeInSameBlock() const {
   return last_bytecode_start_ < bytecodes()->size() &&
          last_bytecode_start_ >= last_block_end_;
 }
 
 
 bool BytecodeArrayBuilder::IsRegisterInAccumulator(Register reg) {
   if (LastBytecodeInSameBlock()) {
     PreviousBytecodeHelper previous_bytecode(*this);
     Bytecode bytecode = previous_bytecode.GetBytecode();
-    if ((bytecode == Bytecode::kLdar || bytecode == Bytecode::kStar) &&
-        (reg == Register::FromOperand(previous_bytecode.GetOperand(0)))) {
-      return true;
+    if (bytecode == Bytecode::kLdar || bytecode == Bytecode::kStar) {
+      Register previous =

[rmcilroy, 2016/01/22 17:50:56]

nit - previous_reg

+          Register::FromOperand(previous_bytecode.GetOperand(0));
+      return previous == reg;
     }
   }
   return false;
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForBinaryOperation(Token::Value op) {
   switch (op) {
     case Token::Value::ADD:
@@ skipping 292 matching lines @@
 
 
 // static
 bool BytecodeArrayBuilder::FitsInIdx16Operand(size_t value) {
   return value <= static_cast<size_t>(kMaxUInt16);
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInReg8Operand(Register value) {
-  return kMinInt8 <= value.index() && value.index() <= kMaxInt8;
+  return RegisterTranslator::FitsInReg8Operand(value);
+}
+
+
+// static
+bool BytecodeArrayBuilder::FitsInReg8OperandUntranslated(Register value) {
+  return value.is_byte_operand();
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInReg16Operand(Register value) {
-  return kMinInt16 <= value.index() && value.index() <= kMaxInt16;
+  return RegisterTranslator::FitsInReg16Operand(value);
+}
+
+
+// static
+bool BytecodeArrayBuilder::FitsInReg16OperandUntranslated(Register value) {
+  return value.is_short_operand();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8