Revert of Remove register index/code indirection

src/arm64/lithium-codegen-arm64.cc

 // Copyright 2013 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/arm64/frames-arm64.h"
 #include "src/arm64/lithium-codegen-arm64.h"
 #include "src/arm64/lithium-gap-resolver-arm64.h"
 #include "src/base/bits.h"
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 575 matching lines @@
 void LCodeGen::SaveCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Save clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator iterator(doubles);
   int count = 0;
   while (!iterator.Done()) {
     // TODO(all): Is this supposed to save just the callee-saved doubles? It
     // looks like it's saving all of them.
-    FPRegister value = FPRegister::from_code(iterator.Current());
+    FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
     __ Poke(value, count * kDoubleSize);
     iterator.Advance();
     count++;
   }
 }
 
 
 void LCodeGen::RestoreCallerDoubles() {
   DCHECK(info()->saves_caller_doubles());
   DCHECK(NeedsEagerFrame());
   Comment(";;; Restore clobbered callee double registers");
   BitVector* doubles = chunk()->allocated_double_registers();
   BitVector::Iterator iterator(doubles);
   int count = 0;
   while (!iterator.Done()) {
     // TODO(all): Is this supposed to restore just the callee-saved doubles? It
     // looks like it's restoring all of them.
-    FPRegister value = FPRegister::from_code(iterator.Current());
+    FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
     __ Peek(value, count * kDoubleSize);
     iterator.Advance();
     count++;
   }
 }
 
 
 bool LCodeGen::GeneratePrologue() {
   DCHECK(is_generating());
 
@@ skipping 526 matching lines @@
       }
     }
   }
   last_lazy_deopt_pc_ = masm()->pc_offset();
 }
 
 
 Register LCodeGen::ToRegister(LOperand* op) const {
   // TODO(all): support zero register results, as ToRegister32.
   DCHECK((op != NULL) && op->IsRegister());
-  return Register::from_code(op->index());
+  return Register::FromAllocationIndex(op->index());
 }
 
 
 Register LCodeGen::ToRegister32(LOperand* op) const {
   DCHECK(op != NULL);
   if (op->IsConstantOperand()) {
     // If this is a constant operand, the result must be the zero register.
     DCHECK(ToInteger32(LConstantOperand::cast(op)) == 0);
     return wzr;
   } else {
     return ToRegister(op).W();
   }
 }
 
 
 Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   return Smi::FromInt(constant->Integer32Value());
 }
 
 
 DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
   DCHECK((op != NULL) && op->IsDoubleRegister());
-  return DoubleRegister::from_code(op->index());
+  return DoubleRegister::FromAllocationIndex(op->index());
 }
 
 
 Operand LCodeGen::ToOperand(LOperand* op) {
   DCHECK(op != NULL);
   if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsSmi()) {
@@ skipping 4816 matching lines @@
   Handle<ScopeInfo> scope_info = instr->scope_info();
   __ Push(scope_info);
   __ Push(ToRegister(instr->function()));
   CallRuntime(Runtime::kPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 }  // namespace internal
 }  // namespace v8