[turbofan] Push layout descriptors to InstructionOperand subclasses.

src/compiler/instruction.h

 // Copyright 2014 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_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 17 matching lines @@
 const InstructionCode kSourcePositionInstruction = -1;
 
 class InstructionOperand {
  public:
   static const int kInvalidVirtualRegister = -1;
 
   // TODO(dcarney): recover bit. INVALID can be represented as UNALLOCATED with
   // kInvalidVirtualRegister and some DCHECKS.
   enum Kind { INVALID, UNALLOCATED, CONSTANT, IMMEDIATE, ALLOCATED };
 
-  InstructionOperand()
-      : InstructionOperand(INVALID, 0, kInvalidVirtualRegister) {}
+  InstructionOperand() : InstructionOperand(INVALID) {}
 
   Kind kind() const { return KindField::decode(value_); }
 
 #define INSTRUCTION_OPERAND_PREDICATE(name, type) \
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_PREDICATE(Invalid, INVALID)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED)
   INSTRUCTION_OPERAND_PREDICATE(Constant, CONSTANT)
   INSTRUCTION_OPERAND_PREDICATE(Immediate, IMMEDIATE)
   INSTRUCTION_OPERAND_PREDICATE(Allocated, ALLOCATED)
@@ skipping 18 matching lines @@
     void* buffer = zone->New(sizeof(op));
     return new (buffer) SubKindOperand(op);
   }
 
   static void ReplaceWith(InstructionOperand* dest,
                           const InstructionOperand* src) {
     *dest = *src;
   }
 
  protected:
-  InstructionOperand(Kind kind, int index, int virtual_register) {
-    if (kind != UNALLOCATED && kind != CONSTANT) {
-      DCHECK(virtual_register == kInvalidVirtualRegister);
-    }
-    value_ = KindField::encode(kind);
-    value_ |=
-        VirtualRegisterField::encode(static_cast<uint32_t>(virtual_register));
-    value_ |= static_cast<int64_t>(index) << IndexField::kShift;
-  }
+  explicit InstructionOperand(Kind kind) : value_(KindField::encode(kind)) {}
 
-  typedef BitField64<Kind, 0, 3> KindField;
-  typedef BitField64<uint32_t, 3, 32> VirtualRegisterField;
-  typedef BitField64<int32_t, 35, 29> IndexField;
+  class KindField : public BitField64<Kind, 0, 3> {};
 
   uint64_t value_;
 };
 
 struct PrintableInstructionOperand {
   const RegisterConfiguration* register_configuration_;
   const InstructionOperand* op_;
 };
 
 std::ostream& operator<<(std::ostream& os,
@@ skipping 38 matching lines @@
     // output).
     USED_AT_START,
 
     // USED_AT_END operand is treated as live until the end of
     // instruction. This means that register allocator will not reuse it's
     // register for any other operand inside instruction.
     USED_AT_END
   };
 
   UnallocatedOperand(ExtendedPolicy policy, int virtual_register)
-      : InstructionOperand(UNALLOCATED, 0, virtual_register) {
+      : UnallocatedOperand(virtual_register) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
   }
 
   UnallocatedOperand(BasicPolicy policy, int index, int virtual_register)
-      : InstructionOperand(UNALLOCATED, 0, virtual_register) {
+      : UnallocatedOperand(virtual_register) {
     DCHECK(policy == FIXED_SLOT);
     value_ |= BasicPolicyField::encode(policy);
     value_ |= static_cast<int64_t>(index) << FixedSlotIndexField::kShift;
     DCHECK(this->fixed_slot_index() == index);
   }
 
   UnallocatedOperand(ExtendedPolicy policy, int index, int virtual_register)
-      : InstructionOperand(UNALLOCATED, 0, virtual_register) {
+      : UnallocatedOperand(virtual_register) {
     DCHECK(policy == FIXED_REGISTER || policy == FIXED_DOUBLE_REGISTER);
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
     value_ |= FixedRegisterField::encode(index);
   }
 
   UnallocatedOperand(ExtendedPolicy policy, Lifetime lifetime,
                      int virtual_register)
-      : InstructionOperand(UNALLOCATED, 0, virtual_register) {
+      : UnallocatedOperand(virtual_register) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(lifetime);
   }
 
   UnallocatedOperand* Copy(Zone* zone) { return New(zone, *this); }
 
   UnallocatedOperand* CopyUnconstrained(Zone* zone) {
     return New(zone, UnallocatedOperand(ANY, virtual_register()));
   }
 
-  // The encoding used for UnallocatedOperand operands depends on the policy
-  // that is
-  // stored within the operand. The FIXED_SLOT policy uses a compact encoding
-  // because it accommodates a larger pay-load.
-  //
-  // For FIXED_SLOT policy:
-  //     +------------------------------------------------+
-  //     |      slot_index   | 0 | virtual_register | 001 |
-  //     +------------------------------------------------+
-  //
-  // For all other (extended) policies:
-  //     +-----------------------------------------------------+
-  //     |  reg_index  | L | PPP |  1 | virtual_register | 001 |
-  //     +-----------------------------------------------------+
-  //     L ... Lifetime
-  //     P ... Policy
-  //
-  // The slot index is a signed value which requires us to decode it manually
-  // instead of using the BitField utility class.
-
-  // All bits fit into the index field.
-  STATIC_ASSERT(IndexField::kShift == 35);
-
-  // BitFields for all unallocated operands.
-  class BasicPolicyField : public BitField64<BasicPolicy, 35, 1> {};
-
-  // BitFields specific to BasicPolicy::FIXED_SLOT.
-  class FixedSlotIndexField : public BitField64<int, 36, 28> {};
-
-  // BitFields specific to BasicPolicy::EXTENDED_POLICY.
-  class ExtendedPolicyField : public BitField64<ExtendedPolicy, 36, 3> {};
-  class LifetimeField : public BitField64<Lifetime, 39, 1> {};
-  class FixedRegisterField : public BitField64<int, 40, 6> {};
-
   // Predicates for the operand policy.
   bool HasAnyPolicy() const {
     return basic_policy() == EXTENDED_POLICY && extended_policy() == ANY;
   }
   bool HasFixedPolicy() const {
     return basic_policy() == FIXED_SLOT ||
            extended_policy() == FIXED_REGISTER ||
            extended_policy() == FIXED_DOUBLE_REGISTER;
   }
   bool HasRegisterPolicy() const {
@@ skipping 55 matching lines @@
     value_ = VirtualRegisterField::update(value_, static_cast<uint32_t>(id));
   }
 
   // [lifetime]: Only for non-FIXED_SLOT.
   bool IsUsedAtStart() const {
     DCHECK(basic_policy() == EXTENDED_POLICY);
     return LifetimeField::decode(value_) == USED_AT_START;
   }
 
   INSTRUCTION_OPERAND_CASTS(UnallocatedOperand, UNALLOCATED);
+
+  // The encoding used for UnallocatedOperand operands depends on the policy
+  // that is
+  // stored within the operand. The FIXED_SLOT policy uses a compact encoding
+  // because it accommodates a larger pay-load.
+  //
+  // For FIXED_SLOT policy:
+  //     +------------------------------------------------+
+  //     |      slot_index   | 0 | virtual_register | 001 |
+  //     +------------------------------------------------+
+  //
+  // For all other (extended) policies:
+  //     +-----------------------------------------------------+
+  //     |  reg_index  | L | PPP |  1 | virtual_register | 001 |
+  //     +-----------------------------------------------------+
+  //     L ... Lifetime
+  //     P ... Policy
+  //
+  // The slot index is a signed value which requires us to decode it manually
+  // instead of using the BitField utility class.
+
+  STATIC_ASSERT(KindField::kSize == 3);
+
+  class VirtualRegisterField : public BitField64<uint32_t, 3, 32> {};
+
+  // BitFields for all unallocated operands.
+  class BasicPolicyField : public BitField64<BasicPolicy, 35, 1> {};
+
+  // BitFields specific to BasicPolicy::FIXED_SLOT.
+  class FixedSlotIndexField : public BitField64<int, 36, 28> {};
+
+  // BitFields specific to BasicPolicy::EXTENDED_POLICY.
+  class ExtendedPolicyField : public BitField64<ExtendedPolicy, 36, 3> {};
+  class LifetimeField : public BitField64<Lifetime, 39, 1> {};
+  class FixedRegisterField : public BitField64<int, 40, 6> {};
+
+ private:
+  explicit UnallocatedOperand(int virtual_register)
+      : InstructionOperand(UNALLOCATED) {
+    value_ |=
+        VirtualRegisterField::encode(static_cast<uint32_t>(virtual_register));
+  }
 };
 
 
 class ConstantOperand : public InstructionOperand {
  public:
   explicit ConstantOperand(int virtual_register)
-      : InstructionOperand(CONSTANT, 0, virtual_register) {}
+      : InstructionOperand(CONSTANT) {
+    value_ |=
+        VirtualRegisterField::encode(static_cast<uint32_t>(virtual_register));
+  }
 
   int32_t virtual_register() const {
     return static_cast<int32_t>(VirtualRegisterField::decode(value_));
   }
 
   static ConstantOperand* New(Zone* zone, int virtual_register) {
     return InstructionOperand::New(zone, ConstantOperand(virtual_register));
   }
 
   INSTRUCTION_OPERAND_CASTS(ConstantOperand, CONSTANT);
+
+  STATIC_ASSERT(KindField::kSize == 3);
+  class VirtualRegisterField : public BitField64<uint32_t, 3, 32> {};
 };
 
 
 class ImmediateOperand : public InstructionOperand {
  public:
-  explicit ImmediateOperand(int index)
-      : InstructionOperand(IMMEDIATE, index, kInvalidVirtualRegister) {}
+  explicit ImmediateOperand(int index) : InstructionOperand(IMMEDIATE) {
+    value_ |= static_cast<int64_t>(index) << IndexField::kShift;
+  }
 
   int index() const {
     return static_cast<int64_t>(value_) >> IndexField::kShift;
   }
 
   static ImmediateOperand* New(Zone* zone, int index) {
     return InstructionOperand::New(zone, ImmediateOperand(index));
   }
 
   INSTRUCTION_OPERAND_CASTS(ImmediateOperand, IMMEDIATE);
+
+  STATIC_ASSERT(KindField::kSize == 3);
+  class IndexField : public BitField64<int32_t, 35, 29> {};
 };
 
 
 class AllocatedOperand : public InstructionOperand {
  public:
   enum AllocatedKind {
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER
   };
 
   AllocatedOperand(AllocatedKind kind, int index)
-      : InstructionOperand(ALLOCATED, index, kInvalidVirtualRegister) {
-    if (kind == REGISTER || kind == DOUBLE_REGISTER) DCHECK(index >= 0);
-    value_ = AllocatedKindField::update(value_, kind);
+      : InstructionOperand(ALLOCATED) {
+    DCHECK_IMPLIES(kind == REGISTER || kind == DOUBLE_REGISTER, index >= 0);
+    value_ |= AllocatedKindField::encode(kind);
+    value_ |= static_cast<int64_t>(index) << IndexField::kShift;
   }
 
   int index() const {
     return static_cast<int64_t>(value_) >> IndexField::kShift;
   }
 
   AllocatedKind allocated_kind() const {
     return AllocatedKindField::decode(value_);
   }
 
   static AllocatedOperand* New(Zone* zone, AllocatedKind kind, int index) {
     return InstructionOperand::New(zone, AllocatedOperand(kind, index));
   }
 
   INSTRUCTION_OPERAND_CASTS(AllocatedOperand, ALLOCATED);
 
- private:
-  typedef BitField64<AllocatedKind, 3, 2> AllocatedKindField;
+  STATIC_ASSERT(KindField::kSize == 3);
+  class AllocatedKindField : public BitField64<AllocatedKind, 3, 2> {};
+  class IndexField : public BitField64<int32_t, 35, 29> {};
 };
 
 
 #undef INSTRUCTION_OPERAND_CASTS
 
 
 #define ALLOCATED_OPERAND_LIST(V)       \
   V(StackSlot, STACK_SLOT)              \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT) \
   V(Register, REGISTER)                 \
@@ skipping 741 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_