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

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 "heap.h"
 #include "hydrogen.h"
 #include "lithium-allocator.h"
 #include "lithium.h"
 #include "safepoint-table.h"
 #include "utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
@@ skipping 206 matching lines @@
   bool Is##type() const { return opcode() == k##type; }
   LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)
 #undef DECLARE_PREDICATE
 
   // Declare virtual predicates for instructions that don't have
   // an opcode.
   virtual bool IsGap() const { return false; }
 
   virtual bool IsControl() const { return false; }
 
+  // Indicates wether it is more efficient to regenerate the value rather than
+  // spill and reload it.
+  virtual bool PreferRegenerateToSpill() const { return false; }
+
   void set_environment(LEnvironment* env) { environment_ = env; }
   LEnvironment* environment() const { return environment_; }
   bool HasEnvironment() const { return environment_ != NULL; }
 
   void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }
   LPointerMap* pointer_map() const { return pointer_map_.get(); }
   bool HasPointerMap() const { return pointer_map_.is_set(); }
 
   void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
   HValue* hydrogen_value() const { return hydrogen_value_; }
@@ skipping 947 matching lines @@
 
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 };
 
 
 class LConstantD V8_FINAL : public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
   DECLARE_HYDROGEN_ACCESSOR(Constant)
 
+  virtual bool PreferRegenerateToSpill() const V8_OVERRIDE { return true; }
+
   double value() const { return hydrogen()->DoubleValue(); }
 };
 
 
 class LConstantE V8_FINAL : public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
   DECLARE_HYDROGEN_ACCESSOR(Constant)
 
+  virtual bool PreferRegenerateToSpill() const V8_OVERRIDE { return true; }
+
   ExternalReference value() const {
     return hydrogen()->ExternalReferenceValue();
   }
 };
 
 
 class LConstantI V8_FINAL : public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
   DECLARE_HYDROGEN_ACCESSOR(Constant)
 
+  virtual bool PreferRegenerateToSpill() const V8_OVERRIDE { return true; }
+
   int32_t value() const { return hydrogen()->Integer32Value(); }
 };
 
 
 class LConstantS V8_FINAL : public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
   DECLARE_HYDROGEN_ACCESSOR(Constant)
 
+  virtual bool PreferRegenerateToSpill() const V8_OVERRIDE { return true; }
+
   Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); }
 };
 
 
 class LConstantT V8_FINAL : public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
   DECLARE_HYDROGEN_ACCESSOR(Constant)
 
   Handle<Object> value(Isolate* isolate) const {
@@ skipping 1771 matching lines @@
   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();
+    void Cache(HConstant* constant, LInstruction* instr) {
+      cached_constants_[constant] = instr;
+    }
+    LInstruction* CachedLInstructionFor(HConstant* constant) {
+      std::map<HConstant*, LInstruction*>::iterator it;
+      it = cached_constants_.find(constant);
+      return (it == cached_constants_.end()) ? NULL : it->second;
     }
 
    private:
-    std::set<HConstant*> cached_constants_;
+    std::map<HConstant*, LInstruction*> cached_constants_;
   };
 
   void Clear() { cache_levels_.clear(); }
 
-  void Cache(HConstant* constant, HBasicBlock* block) {
-    cache_levels_[block].Cache(constant);
+  void Cache(HConstant* constant, LInstruction* instr, HBasicBlock* block) {
+    cache_levels_[block].Cache(constant, instr);
   }
 
-  bool IsCached(HConstant* constant, HBasicBlock* block) {
+  LInstruction* CachedLInstructionFor(HConstant* constant, HBasicBlock* block) {
     HBasicBlock* base_block = block;
     std::map<HBasicBlock*, ConstantCacheLevel>::iterator it;
+    LInstruction* instr;
+    // Look for the constant in the specified block or the dominator blocks.
     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);
+      if (it != cache_levels_.end()) {
+        instr = it->second.CachedLInstructionFor(constant);
+        if (instr != NULL) {
+          if (base_block != block) {
+            // Avoid traversing the dominator blocks multiple times for the same
+            // constant.
+            cache_levels_[block].Cache(constant, instr);
+          }
+          return instr;
         }
-        return true;
       }
       block = block->dominator();
     }
-    return false;
+    return NULL;
   }
 
  private:
   std::map<HBasicBlock*, ConstantCacheLevel> cache_levels_;
 };
 
 
 class LChunkBuilder;
 class LPlatformChunk V8_FINAL : public LChunk {
  public:
@@ skipping 30 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);
+  LInstruction* CachedLInstructionFor(HConstant* constant, HBasicBlock* block) {
+    return constant_cache_.CachedLInstructionFor(constant, block);
   }
-  void CacheConstant(HConstant* constant, HBasicBlock* block) {
-    constant_cache_.Cache(constant, block);
+  void CacheConstant(HConstant* constant, LInstruction* instr,
+                     HBasicBlock* block) {
+    constant_cache_.Cache(constant, instr, block);
   }
 
  private:
   enum Status {
     UNUSED,
     BUILDING,
     DONE,
     ABORTED
   };
 
@@ skipping 143 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_ARM64_H_