[turbofan] Don't allocate UnallocatedOperands in Zone memory during instruction selection

src/compiler/instruction.h

Index: src/compiler/instruction.h
diff --git a/src/compiler/instruction.h b/src/compiler/instruction.h
index 6614d479780948ab8b9a0bb5bca5825949c60032..d78a5e8abb2b9a47228812ea12156b1ea73a3f26 100644
--- a/src/compiler/instruction.h
+++ b/src/compiler/instruction.h
@@ -35,7 +35,7 @@ const InstructionCode kSourcePositionInstruction = -2;
   V(Register, REGISTER, RegisterConfiguration::kMaxGeneralRegisters) \
   V(DoubleRegister, DOUBLE_REGISTER, RegisterConfiguration::kMaxDoubleRegisters)
 
-class InstructionOperand : public ZoneObject {
+class InstructionOperand {
  public:
   static const int kInvalidVirtualRegister = -1;
 
@@ -50,6 +50,10 @@ class InstructionOperand : public ZoneObject {
     DOUBLE_REGISTER
   };
 
+  InstructionOperand() : virtual_register_(kInvalidVirtualRegister) {
+    ConvertTo(INVALID, 0);
+  }
+
   InstructionOperand(Kind kind, int index)
       : virtual_register_(kInvalidVirtualRegister) {
     DCHECK(kind != INVALID);
@@ -62,6 +66,7 @@ class InstructionOperand : public ZoneObject {
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_PREDICATE)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
+  INSTRUCTION_OPERAND_PREDICATE(Invalid, INVALID, 0)
 #undef INSTRUCTION_OPERAND_PREDICATE
   bool Equals(const InstructionOperand* other) const {
     return value_ == other->value_;
@@ -79,6 +84,12 @@ class InstructionOperand : public ZoneObject {
   static void SetUpCaches();
   static void TearDownCaches();
 
+  // TODO(dcarney): get rid of these
+  void* operator new(size_t, void* location) { return location; }
+  void* operator new(size_t size, Zone* zone) {
+    return zone->New(static_cast<int>(size));
+  }
+
  protected:
   InstructionOperand(Kind kind, int index, int virtual_register)
       : virtual_register_(virtual_register) {
@@ -91,8 +102,6 @@ class InstructionOperand : public ZoneObject {
   int32_t virtual_register_;
 };
 
-typedef ZoneVector<InstructionOperand*> InstructionOperandVector;
-
 struct PrintableInstructionOperand {
   const RegisterConfiguration* register_configuration_;
   const InstructionOperand* op_;
@@ -131,10 +140,6 @@ class UnallocatedOperand : public InstructionOperand {
   // TODO(dcarney): remove this.
   static const int kInvalidVirtualRegister = -1;
 
-  // This is only for array initialization.
-  UnallocatedOperand()
-      : InstructionOperand(INVALID, 0, kInvalidVirtualRegister) {}
-
   UnallocatedOperand(ExtendedPolicy policy, int virtual_register)
       : InstructionOperand(UNALLOCATED, 0, virtual_register) {
     value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
@@ -181,6 +186,11 @@ class UnallocatedOperand : public InstructionOperand {
     return static_cast<UnallocatedOperand*>(op);
   }
 
+  static UnallocatedOperand cast(const InstructionOperand& op) {
+    DCHECK(op.IsUnallocated());
+    return *static_cast<const UnallocatedOperand*>(&op);
+  }
+
   // The encoding used for UnallocatedOperand operands depends on the policy
   // that is
   // stored within the operand. The FIXED_SLOT policy uses a compact encoding
@@ -341,6 +351,9 @@ std::ostream& operator<<(std::ostream& os, const PrintableMoveOperands& mo);
 template <InstructionOperand::Kind kOperandKind, int kNumCachedOperands>
 class SubKindOperand FINAL : public InstructionOperand {
  public:
+  explicit SubKindOperand(int index)
+      : InstructionOperand(kOperandKind, index) {}
+
   static SubKindOperand* Create(int index, Zone* zone) {
     DCHECK(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
@@ -357,6 +370,11 @@ class SubKindOperand FINAL : public InstructionOperand {
     return reinterpret_cast<const SubKindOperand*>(op);
   }
 
+  static SubKindOperand cast(const InstructionOperand& op) {
+    DCHECK(op.kind() == kOperandKind);
+    return *static_cast<const SubKindOperand*>(&op);
+  }
+
   static void SetUpCache();
   static void TearDownCache();
 
@@ -364,8 +382,6 @@ class SubKindOperand FINAL : public InstructionOperand {
   static SubKindOperand* cache;
 
   SubKindOperand() : InstructionOperand(kOperandKind, 0) {}  // For the caches.
-  explicit SubKindOperand(int index)
-      : InstructionOperand(kOperandKind, index) {}
 };
 
 
@@ -492,9 +508,9 @@ class Instruction : public ZoneObject {
   }
 
   static Instruction* New(Zone* zone, InstructionCode opcode,
-                          size_t output_count, InstructionOperand** outputs,
-                          size_t input_count, InstructionOperand** inputs,
-                          size_t temp_count, InstructionOperand** temps) {
+                          size_t output_count, InstructionOperand* outputs,
+                          size_t input_count, InstructionOperand* inputs,
+                          size_t temp_count, InstructionOperand* temps) {
     DCHECK(opcode >= 0);
     DCHECK(output_count == 0 || outputs != NULL);
     DCHECK(input_count == 0 || inputs != NULL);
@@ -502,8 +518,8 @@ class Instruction : public ZoneObject {
     size_t total_extra_ops = output_count + input_count + temp_count;
     if (total_extra_ops != 0) total_extra_ops--;
     int size = static_cast<int>(
-        RoundUp(sizeof(Instruction), sizeof(UnallocatedOperand)) +
-        total_extra_ops * sizeof(UnallocatedOperand));
+        RoundUp(sizeof(Instruction), sizeof(InstructionOperand)) +
+        total_extra_ops * sizeof(InstructionOperand));
     return new (zone->New(size)) Instruction(
         opcode, output_count, outputs, input_count, inputs, temp_count, temps);
   }
@@ -559,9 +575,9 @@ class Instruction : public ZoneObject {
  protected:
   explicit Instruction(InstructionCode opcode);
   Instruction(InstructionCode opcode, size_t output_count,
-              InstructionOperand** outputs, size_t input_count,
-              InstructionOperand** inputs, size_t temp_count,
-              InstructionOperand** temps);
+              InstructionOperand* outputs, size_t input_count,
+              InstructionOperand* inputs, size_t temp_count,
+              InstructionOperand* temps);
 
  protected:
   typedef BitField<size_t, 0, 8> OutputCountField;
@@ -573,7 +589,7 @@ class Instruction : public ZoneObject {
   InstructionCode opcode_;
   uint32_t bit_field_;
   PointerMap* pointer_map_;
-  UnallocatedOperand operands_[1];
+  InstructionOperand operands_[1];
 };