ARM64: Avoid regeneration of constants.

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 357 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()) {
     HInstruction* instr = HInstruction::cast(value);
-    VisitInstruction(instr);
+    if (value->IsConstant() && IsCachedConstant(HConstant::cast(value),
+                                                current_block_)) {
+      // We will reuse the cached value.
+    } else {
+      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 190 matching lines @@
   }
   status_ = DONE;
   return chunk_;
 }
 
 
 void LChunkBuilder::DoBasicBlock(HBasicBlock* block) {
   ASSERT(is_building());
   current_block_ = block;
 
+  if (graph()->has_osr() &&
+      (block == graph()->osr()->osr_entry())) {
+    constant_cache_.Clear();
+  }
+
   if (block->IsStartBlock()) {
+    constant_cache_.Clear();
     block->UpdateEnvironment(graph_->start_environment());
     argument_count_ = 0;
   } else if (block->predecessors()->length() == 1) {
     // We have a single predecessor => copy environment and outgoing
     // argument count from the predecessor.
     ASSERT(block->phis()->length() == 0);
     HBasicBlock* pred = block->predecessors()->at(0);
     HEnvironment* last_environment = pred->last_environment();
     ASSERT(last_environment != NULL);
 
@@ skipping 721 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_);
   Representation r = instr->representation();
   if (r.IsSmi()) {
     return DefineAsRegister(new(zone()) LConstantS);
   } else if (r.IsInteger32()) {
     return DefineAsRegister(new(zone()) LConstantI);
   } else if (r.IsDouble()) {
     return DefineAsRegister(new(zone()) LConstantD);
   } else if (r.IsExternal()) {
     return DefineAsRegister(new(zone()) LConstantE);
   } else if (r.IsTagged()) {
@@ skipping 1359 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