[turbofan] make zone allocation of InstructionOperand explicit

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 42 matching lines @@
   InstructionOperand() : virtual_register_(kInvalidVirtualRegister) {
     ConvertTo(INVALID, 0);
   }
 
   InstructionOperand(Kind kind, int index)
       : virtual_register_(kInvalidVirtualRegister) {
     DCHECK(kind != INVALID);
     ConvertTo(kind, index);
   }
 
+  static InstructionOperand* New(Zone* zone, Kind kind, int index) {
+    return New(zone, InstructionOperand(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) \
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_PREDICATE)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED)
   INSTRUCTION_OPERAND_PREDICATE(Invalid, INVALID)
 #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;
   }
 
-  // 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:
+  template <typename SubKindOperand>
+  static SubKindOperand* New(Zone* zone, const SubKindOperand& op) {
+    void* buffer = zone->New(sizeof(op));
+    return new (buffer) SubKindOperand(op);
   }
-  void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
 
- 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_;
 };
@@ skipping 58 matching lines @@
   }
 
   UnallocatedOperand(ExtendedPolicy policy, Lifetime lifetime,
                      int virtual_register)
       : InstructionOperand(UNALLOCATED, 0, 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());
+    return New(zone, UnallocatedOperand(ANY, virtual_register()));
   }
 
   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);
@@ skipping 161 matching lines @@
 std::ostream& operator<<(std::ostream& os, const PrintableMoveOperands& mo);
 
 
 #define INSTRUCTION_SUBKIND_OPERAND_CLASS(SubKind, kOperandKind)        \
   class SubKind##Operand FINAL : public InstructionOperand {            \
    public:                                                              \
     explicit SubKind##Operand(int index)                                \
         : InstructionOperand(kOperandKind, index) {}                    \
                                                                         \
     static SubKind##Operand* New(int index, Zone* zone) {               \
-      return new (zone) SubKind##Operand(index);                        \
+      return InstructionOperand::New(zone, SubKind##Operand(index));    \
     }                                                                   \
                                                                         \
     static SubKind##Operand* cast(InstructionOperand* op) {             \
       DCHECK(op->kind() == kOperandKind);                               \
       return reinterpret_cast<SubKind##Operand*>(op);                   \
     }                                                                   \
                                                                         \
     static const SubKind##Operand* cast(const InstructionOperand* op) { \
       DCHECK(op->kind() == kOperandKind);                               \
       return reinterpret_cast<const SubKind##Operand*>(op);             \
@@ skipping 66 matching lines @@
   friend std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
 
   ZoneList<InstructionOperand*> pointer_operands_;
   ZoneList<InstructionOperand*> untagged_operands_;
   int instruction_position_;
 };
 
 std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
 
 // TODO(titzer): s/PointerMap/ReferenceMap/
-class Instruction : public ZoneObject {
+class Instruction {
  public:
   size_t OutputCount() const { return OutputCountField::decode(bit_field_); }
   const InstructionOperand* OutputAt(size_t i) const {
     DCHECK(i < OutputCount());
     return &operands_[i];
   }
   InstructionOperand* OutputAt(size_t i) {
     DCHECK(i < OutputCount());
     return &operands_[i];
   }
@@ skipping 78 matching lines @@
   bool ClobbersTemps() const { return IsCall(); }
   bool ClobbersDoubleRegisters() const { return IsCall(); }
   PointerMap* pointer_map() const { return pointer_map_; }
 
   void set_pointer_map(PointerMap* map) {
     DCHECK(NeedsPointerMap());
     DCHECK(!pointer_map_);
     pointer_map_ = map;
   }
 
-  // Placement new operator so that we can smash instructions into
-  // zone-allocated memory.
-  void* operator new(size_t, void* location) { return location; }
-
-  void operator delete(void* pointer, void* location) { UNREACHABLE(); }
-
   void OverwriteWithNop() {
     opcode_ = ArchOpcodeField::encode(kArchNop);
     bit_field_ = 0;
     pointer_map_ = NULL;
   }
 
   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);
 
- 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_;
   InstructionOperand operands_[1];
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 struct PrintableInstruction {
   const RegisterConfiguration* register_configuration_;
   const Instruction* instr_;
 };
 std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
 
 
@@ skipping 467 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_