ARM64: Regenerate instead of spilling and restoring cheap lithium instructions.

src/arm64/lithium-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 "v8.h"
 
 #include "lithium-allocator-inl.h"
 #include "arm64/lithium-arm64.h"
 #include "arm64/lithium-codegen-arm64.h"
 #include "hydrogen-osr.h"
@@ skipping 355 matching lines @@
 }
 
 
 LUnallocated* LChunkBuilder::ToUnallocated(DoubleRegister reg) {
   return new(zone()) LUnallocated(LUnallocated::FIXED_DOUBLE_REGISTER,
                                   DoubleRegister::ToAllocationIndex(reg));
 }
 
 
 LOperand* LChunkBuilder::Use(HValue* value, LUnallocated* operand) {
-  if (value->EmitAtUses()) {
+  LInstruction* l_instr;
+  if (value->IsConstant() &&
+      (l_instr = CachedLInstructionFor(HConstant::cast(value),
+                                       current_block_))) {
+    operand->set_parent_linstr(l_instr);
+  } else if (value->EmitAtUses()) {
     HInstruction* instr = HInstruction::cast(value);
-    if (value->IsConstant() && IsCachedConstant(HConstant::cast(value),
-                                                current_block_)) {
-      // We will reuse the cached value.
-    } else {
-      VisitInstruction(instr);
-    }
+    VisitInstruction(instr);
   }
   operand->set_virtual_register(value->id());
   return operand;
 }
 
 
 LOperand* LChunkBuilder::UseFixed(HValue* value, Register fixed_register) {
   return Use(value, ToUnallocated(fixed_register));
 }
 
@@ skipping 38 matching lines @@
 
 LOperand* LChunkBuilder::UseAny(HValue* value) {
   return value->IsConstant()
       ? UseConstant(value)
       : Use(value, new(zone()) LUnallocated(LUnallocated::ANY));
 }
 
 
 LInstruction* LChunkBuilder::Define(LTemplateResultInstruction<1>* instr,
                                     LUnallocated* result) {
+  result->set_parent_linstr(instr);
   result->set_virtual_register(current_instruction_->id());
   instr->set_result(result);
   return instr;
 }
 
 
 LInstruction* LChunkBuilder::DefineAsRegister(
     LTemplateResultInstruction<1>* instr) {
   return Define(instr,
                 new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER));
@@ skipping 880 matching lines @@
 
 LInstruction* LChunkBuilder::DoCompareMap(HCompareMap* instr) {
   ASSERT(instr->value()->representation().IsTagged());
   LOperand* value = UseRegisterAtStart(instr->value());
   LOperand* temp = TempRegister();
   return new(zone()) LCmpMapAndBranch(value, temp);
 }
 
 
 LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
-  CacheConstant(instr, current_block_);
+  LInstruction* res;
   Representation r = instr->representation();
   if (r.IsSmi()) {
-    return DefineAsRegister(new(zone()) LConstantS);
+    res =  DefineAsRegister(new(zone()) LConstantS);
   } else if (r.IsInteger32()) {
-    return DefineAsRegister(new(zone()) LConstantI);
+    res =  DefineAsRegister(new(zone()) LConstantI);
   } else if (r.IsDouble()) {
-    return DefineAsRegister(new(zone()) LConstantD);
+    res =  DefineAsRegister(new(zone()) LConstantD);
   } else if (r.IsExternal()) {
-    return DefineAsRegister(new(zone()) LConstantE);
+    res =  DefineAsRegister(new(zone()) LConstantE);
   } else if (r.IsTagged()) {
-    return DefineAsRegister(new(zone()) LConstantT);
+    res =  DefineAsRegister(new(zone()) LConstantT);
   } else {
     UNREACHABLE();
-    return NULL;
+    res =  NULL;
   }
+  CacheConstant(instr, res, current_block_);
+  return res;
 }
 
 
 LInstruction* LChunkBuilder::DoContext(HContext* instr) {
   if (instr->HasNoUses()) return NULL;
 
   if (info()->IsStub()) {
     return DefineFixed(new(zone()) LContext, cp);
   }
 
@@ skipping 1344 matching lines @@
 
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegister(instr->function());
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal