[turbofan] make zone allocation of InstructionOperand explicit

src/compiler/move-optimizer.cc

 // 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.
 
 #include "src/compiler/move-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 11 matching lines @@
       replacement = curr;
       if (to_eliminate != nullptr) break;
     } else if (curr->destination()->Equals(move->destination())) {
       DCHECK(!to_eliminate);
       to_eliminate = curr;
       if (replacement != nullptr) break;
     }
   }
   DCHECK(!(replacement == to_eliminate && replacement != nullptr));
   if (replacement != nullptr) {
-    auto new_source = new (zone) InstructionOperand(
-        replacement->source()->kind(), replacement->source()->index());
+    auto new_source = InstructionOperand::New(
+        zone, replacement->source()->kind(), replacement->source()->index());
     move->set_source(new_source);
   }
   return to_eliminate;
 }
 
 
 bool GapsCanMoveOver(Instruction* instr) {
   DCHECK(!instr->IsGapMoves());
   return instr->IsSourcePosition() || instr->IsNop();
 }
@@ skipping 135 matching lines @@
       if (load->source()->Equals(move->source())) {
         found = load;
         break;
       }
     }
     // Not found so insert.
     if (found == nullptr) {
       loads.push_back(move);
       // Replace source with copy for later use.
       auto dest = move->destination();
-      move->set_destination(new (code_zone())
-                            InstructionOperand(dest->kind(), dest->index()));
+      move->set_destination(
+          InstructionOperand::New(code_zone(), dest->kind(), dest->index()));
       continue;
     }
     if ((found->destination()->IsStackSlot() ||
          found->destination()->IsDoubleStackSlot()) &&
         !(move->destination()->IsStackSlot() ||
           move->destination()->IsDoubleStackSlot())) {
       // Found a better source for this load.  Smash it in place to affect other
       // loads that have already been split.
       InstructionOperand::Kind found_kind = found->destination()->kind();
       int found_index = found->destination()->index();
       auto next_dest =
-          new (code_zone()) InstructionOperand(found_kind, found_index);
+          InstructionOperand::New(code_zone(), found_kind, found_index);
       auto dest = move->destination();
       found->destination()->ConvertTo(dest->kind(), dest->index());
       move->set_destination(next_dest);
     }
     // move from load destination.
     move->set_source(found->destination());
     new_moves.push_back(move);
   }
   loads.clear();
   if (new_moves.empty()) return;
   // Insert all new moves into slot 1.
   auto slot_1 = gap->GetOrCreateParallelMove(
       static_cast<GapInstruction::InnerPosition>(1), code_zone());
   DCHECK(slot_1->move_operands()->is_empty());
   slot_1->move_operands()->AddBlock(MoveOperands(nullptr, nullptr),
                                     static_cast<int>(new_moves.size()),
                                     code_zone());
   auto it = slot_1->move_operands()->begin();
   for (auto new_move : new_moves) {
     std::swap(*new_move, *it);
     ++it;
   }
   DCHECK_EQ(it, slot_1->move_operands()->end());
   new_moves.clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8