ARM64: Avoid regeneration of constants.

src/arm64/lithium-arm64.h

 // 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.
 
 #ifndef V8_ARM64_LITHIUM_ARM64_H_
 #define V8_ARM64_LITHIUM_ARM64_H_
 
 #include "hydrogen.h"
 #include "lithium-allocator.h"
 #include "lithium.h"
@@ skipping 2994 matching lines @@
   }
 
   DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver")
   DECLARE_HYDROGEN_ACCESSOR(WrapReceiver)
 
   LOperand* receiver() { return inputs_[0]; }
   LOperand* function() { return inputs_[1]; }
 };
 
 
+class ConstantCache {
+ public:
+  ConstantCache() {}
+
+  class ConstantCacheLevel {
+   public:
+    void Cache(HConstant* constant) { cached_constants_.insert(constant); }
+    bool IsCached(HConstant* constant) {
+      return cached_constants_.find(constant) != cached_constants_.end();
+    }
+
+   private:
+    std::set<HConstant*> cached_constants_;
+  };
+
+  void Clear() { cache_levels_.clear(); }
+
+  void Cache(HConstant* constant, HBasicBlock* block) {
+    cache_levels_[block].Cache(constant);
+  }
+
+  bool IsCached(HConstant* constant, HBasicBlock* block) {
+    HBasicBlock* base_block = block;
+    std::map<HBasicBlock*, ConstantCacheLevel>::iterator it;
+    while (block != NULL) {
+      it = cache_levels_.find(block);
+      if (it != cache_levels_.end() && it->second.IsCached(constant)) {
+        if (base_block != block) {
+          // Avoid traversing the dominator blocks multiple times for the same
+          // constant.
+          cache_levels_[block].Cache(constant);
+        }
+        return true;
+      }
+      block = block->dominator();
+    }
+    return false;
+  }
+
+ private:
+  std::map<HBasicBlock*, ConstantCacheLevel> cache_levels_;
+};
+
+
 class LChunkBuilder;
 class LPlatformChunk V8_FINAL : public LChunk {
  public:
   LPlatformChunk(CompilationInfo* info, HGraph* graph)
       : LChunk(info, graph) { }
 
   int GetNextSpillIndex();
   LOperand* GetNextSpillSlot(RegisterKind kind);
 };
 
@@ skipping 23 matching lines @@
   LInstruction* DoDivI(HBinaryOperation* instr);
   LInstruction* DoModByPowerOf2I(HMod* instr);
   LInstruction* DoModByConstI(HMod* instr);
   LInstruction* DoModI(HMod* instr);
   LInstruction* DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr);
   LInstruction* DoFlooringDivByConstI(HMathFloorOfDiv* instr);
   LInstruction* DoFlooringDivI(HMathFloorOfDiv* instr);
 
   static bool HasMagicNumberForDivision(int32_t divisor);
 
+  bool IsCachedConstant(HConstant* constant, HBasicBlock* block) {
+    return constant_cache_.IsCached(constant, block);
+  }
+  void CacheConstant(HConstant* constant, HBasicBlock* block) {
+    constant_cache_.Cache(constant, block);
+  }
+
  private:
   enum Status {
     UNUSED,
     BUILDING,
     DONE,
     ABORTED
   };
 
   HGraph* graph() const { return graph_; }
   Isolate* isolate() const { return info_->isolate(); }
@@ skipping 130 matching lines @@
   LInstruction* DoArithmeticT(Token::Value op,
                               HBinaryOperation* instr);
 
   LPlatformChunk* chunk_;
   CompilationInfo* info_;
   HGraph* const graph_;
   Status status_;
   HInstruction* current_instruction_;
   HBasicBlock* current_block_;
   LAllocator* allocator_;
+  ConstantCache constant_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_ARM64_H_