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

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 = -2;
 
 #define INSTRUCTION_OPERAND_LIST(V)                                  \
   V(Constant, CONSTANT, 0)                                           \
   V(Immediate, IMMEDIATE, 0)                                         \
   V(StackSlot, STACK_SLOT, 128)                                      \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128)                         \
   V(Register, REGISTER, RegisterConfiguration::kMaxGeneralRegisters) \
   V(DoubleRegister, DOUBLE_REGISTER, RegisterConfiguration::kMaxDoubleRegisters)
 
-class InstructionOperand : public ZoneObject {
+class InstructionOperand {
  public:
   static const int kInvalidVirtualRegister = -1;
 
   enum Kind {
     INVALID,
     UNALLOCATED,
     CONSTANT,
     IMMEDIATE,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER
   };
 
+  InstructionOperand() : virtual_register_(kInvalidVirtualRegister) {
+    ConvertTo(INVALID, 0);
+  }
+
   InstructionOperand(Kind kind, int index)
       : virtual_register_(kInvalidVirtualRegister) {
     DCHECK(kind != INVALID);
     ConvertTo(kind, index);
   }
 
   Kind kind() const { return KindField::decode(value_); }
   int index() const { return static_cast<int>(value_) >> KindField::kSize; }
 #define INSTRUCTION_OPERAND_PREDICATE(name, type, number) \
   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_;
   }
 
   void ConvertTo(Kind kind, int index) {
     if (kind == REGISTER || kind == DOUBLE_REGISTER) DCHECK(index >= 0);
     value_ = KindField::encode(kind);
     value_ |= bit_cast<unsigned>(index << KindField::kSize);
     DCHECK(this->index() == index);
     if (kind != UNALLOCATED) virtual_register_ = kInvalidVirtualRegister;
   }
 
   // Calls SetUpCache()/TearDownCache() for each subclass.
   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) {
     ConvertTo(kind, index);
   }
   typedef BitField<Kind, 0, 3> KindField;
 
   uint32_t value_;
   // TODO(dcarney): this should really be unsigned.
   int32_t virtual_register_;
 };
 
-typedef ZoneVector<InstructionOperand*> InstructionOperandVector;
-
 struct PrintableInstructionOperand {
   const RegisterConfiguration* register_configuration_;
   const InstructionOperand* op_;
 };
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionOperand& op);
 
 class UnallocatedOperand : public InstructionOperand {
  public:
@@ skipping 18 matching lines @@
 
     // 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
   };
 
   // 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);
     value_ |= ExtendedPolicyField::encode(policy);
     value_ |= LifetimeField::encode(USED_AT_END);
   }
 
   UnallocatedOperand(BasicPolicy policy, int index, int virtual_register)
       : InstructionOperand(UNALLOCATED, 0, virtual_register) {
     DCHECK(policy == FIXED_SLOT);
@@ skipping 26 matching lines @@
   static const UnallocatedOperand* cast(const InstructionOperand* op) {
     DCHECK(op->IsUnallocated());
     return static_cast<const UnallocatedOperand*>(op);
   }
 
   static UnallocatedOperand* cast(InstructionOperand* op) {
     DCHECK(op->IsUnallocated());
     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
   // because it accommodates a larger pay-load.
   //
   // For FIXED_SLOT policy:
   //     +-----------------------------+
   //     |      slot_index   | 0 | 001 |
   //     +-----------------------------+
   //
@@ skipping 140 matching lines @@
   const MoveOperands* move_operands_;
 };
 
 
 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];
     return new (zone) SubKindOperand(index);
   }
 
   static SubKindOperand* cast(InstructionOperand* op) {
     DCHECK(op->kind() == kOperandKind);
     return reinterpret_cast<SubKindOperand*>(op);
   }
 
   static const SubKindOperand* cast(const InstructionOperand* op) {
     DCHECK(op->kind() == kOperandKind);
     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();
 
  private:
   static SubKindOperand* cache;
 
   SubKindOperand() : InstructionOperand(kOperandKind, 0) {}  // For the caches.
-  explicit SubKindOperand(int index)
-      : InstructionOperand(kOperandKind, index) {}
 };
 
 
 #define INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS(name, type, number) \
   typedef SubKindOperand<InstructionOperand::type, number> name##Operand;
 INSTRUCTION_OPERAND_LIST(INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS)
 #undef INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS
 
 
 class ParallelMove FINAL : public ZoneObject {
@@ skipping 106 matching lines @@
   FlagsCondition flags_condition() const {
     return FlagsConditionField::decode(opcode());
   }
 
   // TODO(titzer): make control and call into flags.
   static Instruction* New(Zone* zone, InstructionCode opcode) {
     return New(zone, opcode, 0, NULL, 0, NULL, 0, NULL);
   }
 
   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);
     DCHECK(temp_count == 0 || temps != NULL);
     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);
   }
 
   // TODO(titzer): another holdover from lithium days; register allocator
   // should not need to know about control instructions.
   Instruction* MarkAsControl() {
     bit_field_ = IsControlField::update(bit_field_, true);
     return this;
   }
@@ skipping 35 matching lines @@
   }
 
   bool IsNop() const {
     return arch_opcode() == kArchNop && InputCount() == 0 &&
            OutputCount() == 0 && TempCount() == 0;
   }
 
  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;
   typedef BitField<size_t, 8, 16> InputCountField;
   typedef BitField<size_t, 24, 6> TempCountField;
   typedef BitField<bool, 30, 1> IsCallField;
   typedef BitField<bool, 31, 1> IsControlField;
 
   InstructionCode opcode_;
   uint32_t bit_field_;
   PointerMap* pointer_map_;
-  UnallocatedOperand operands_[1];
+  InstructionOperand operands_[1];
 };
 
 
 struct PrintableInstruction {
   const RegisterConfiguration* register_configuration_;
   const Instruction* instr_;
 };
 std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
 
 
@@ skipping 481 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_