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

src/lithium.h

 // Copyright 2012 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_LITHIUM_H_
 #define V8_LITHIUM_H_
 
 #include <set>
 
 #include "allocation.h"
@@ skipping 17 matching lines @@
   enum Kind {
     INVALID,
     UNALLOCATED,
     CONSTANT_OPERAND,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER
   };
 
-  LOperand() : value_(KindField::encode(INVALID)) { }
+  LOperand() : value_(KindField::encode(INVALID)), parent_linstr_(NULL) { }
 
   Kind kind() const { return KindField::decode(value_); }
   int index() const { return static_cast<int>(value_) >> kKindFieldWidth; }
 #define LITHIUM_OPERAND_PREDICATE(name, type, number) \
   bool Is##name() const { return kind() == type; }
   LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_PREDICATE)
   LITHIUM_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
   LITHIUM_OPERAND_PREDICATE(Ignored, INVALID, 0)
 #undef LITHIUM_OPERAND_PREDICATE
   bool Equals(LOperand* other) const { return value_ == other->value_; }
 
+  bool IsInMemory() const { return IsStackSlot() || IsDoubleStackSlot(); }
+  bool IsInRegister() const { return IsRegister() || IsDoubleRegister(); }
+
   void PrintTo(StringStream* stream);
   void ConvertTo(Kind kind, int index) {
     value_ = KindField::encode(kind);
     value_ |= index << kKindFieldWidth;
     ASSERT(this->index() == index);
   }
 
+  void set_parent_linstr(LInstruction* instr) { parent_linstr_ = instr; }
+  LInstruction* parent_linstr() const { return parent_linstr_; }
+
   // Calls SetUpCache()/TearDownCache() for each subclass.
   static void SetUpCaches();
   static void TearDownCaches();
 
  protected:
   static const int kKindFieldWidth = 3;
   class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
 
-  LOperand(Kind kind, int index) { ConvertTo(kind, index); }
+  LOperand(Kind kind, int index) : parent_linstr_(NULL) {
+    ConvertTo(kind, index);
+  }
 
   unsigned value_;
+  LInstruction* parent_linstr_;
 };
 
 
 class LUnallocated : public LOperand {
  public:
   enum BasicPolicy {
     FIXED_SLOT,
     EXTENDED_POLICY
   };
 
@@ skipping 46 matching lines @@
   LUnallocated(ExtendedPolicy policy, Lifetime lifetime)
       : LOperand(UNALLOCATED, 0) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
   }
 
   LUnallocated* CopyUnconstrained(Zone* zone) {
     LUnallocated* result = new(zone) LUnallocated(ANY);
     result->set_virtual_register(virtual_register());
+    result->set_parent_linstr(parent_linstr());
     return result;
   }
 
   static LUnallocated* cast(LOperand* op) {
     ASSERT(op->IsUnallocated());
     return reinterpret_cast<LUnallocated*>(op);
   }
 
   // The encoding used for LUnallocated operands depends on the policy that is
   // stored within the operand. The FIXED_SLOT policy uses a compact encoding
@@ skipping 136 matching lines @@
   // A move is redundant if it's been eliminated, if its source and
   // destination are the same, or if its destination is unneeded.
   bool IsRedundant() const {
     return IsEliminated() || source_->Equals(destination_) || IsIgnored();
   }
 
   bool IsIgnored() const {
     return destination_ != NULL && destination_->IsIgnored();
   }
 
+  bool UsesRegeneration() const;
+
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = NULL; }
   bool IsEliminated() const {
     ASSERT(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   LOperand* source_;
   LOperand* destination_;
 };
 
 
 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
 class LSubKindOperand V8_FINAL : public LOperand {
  public:
-  static LSubKindOperand* Create(int index, Zone* zone) {
+  static LSubKindOperand* Create(int index, Zone* zone,
+                                 bool allow_use_cache = true) {
     ASSERT(index >= 0);
-    if (index < kNumCachedOperands) return &cache[index];
+    if (allow_use_cache && (index < kNumCachedOperands)) return &cache[index];
     return new(zone) LSubKindOperand(index);
   }
 
   static LSubKindOperand* cast(LOperand* op) {
     ASSERT(op->kind() == kOperandKind);
     return reinterpret_cast<LSubKindOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
@@ skipping 424 matching lines @@
  private:
   LChunk* chunk_;
 
   DISALLOW_COPY_AND_ASSIGN(LPhase);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_