[turbofan] Remove global InstructionOperand caches.

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/pipeline.h"
@@ skipping 12 matching lines @@
       linkage_(linkage),
       sequence_(sequence),
       source_positions_(source_positions),
       features_(features),
       schedule_(schedule),
       current_block_(NULL),
       instructions_(zone),
       defined_(node_count, false, zone),
       used_(node_count, false, zone),
       virtual_registers_(node_count,
-                         UnallocatedOperand::kInvalidVirtualRegister, zone) {
+                         InstructionOperand::kInvalidVirtualRegister, zone) {
   instructions_.reserve(node_count);
 }
 
 
 void InstructionSelector::SelectInstructions() {
   // Mark the inputs of all phis in loop headers as used.
   BasicBlockVector* blocks = schedule()->rpo_order();
   for (auto const block : *blocks) {
     if (!block->IsLoopHeader()) continue;
     DCHECK_LE(2u, block->PredecessorCount());
@@ skipping 131 matching lines @@
   return node->OwnedBy(user) &&
          schedule()->block(node) == schedule()->block(user);
 }
 
 
 int InstructionSelector::GetVirtualRegister(const Node* node) {
   DCHECK_NOT_NULL(node);
   size_t const id = node->id();
   DCHECK_LT(id, virtual_registers_.size());
   int virtual_register = virtual_registers_[id];
-  if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
+  if (virtual_register == InstructionOperand::kInvalidVirtualRegister) {
     virtual_register = sequence()->NextVirtualRegister();
     virtual_registers_[id] = virtual_register;
   }
   return virtual_register;
 }
 
 
 const std::map<NodeId, int> InstructionSelector::GetVirtualRegistersForTesting()
     const {
   std::map<NodeId, int> virtual_registers;
   for (size_t n = 0; n < virtual_registers_.size(); ++n) {
-    if (virtual_registers_[n] != UnallocatedOperand::kInvalidVirtualRegister) {
+    if (virtual_registers_[n] != InstructionOperand::kInvalidVirtualRegister) {
       NodeId const id = static_cast<NodeId>(n);
       virtual_registers.insert(std::make_pair(id, virtual_registers_[n]));
     }
   }
   return virtual_registers;
 }
 
 
 bool InstructionSelector::IsDefined(Node* node) const {
   DCHECK_NOT_NULL(node);
@@ skipping 24 matching lines @@
   DCHECK_NOT_NULL(node);
   size_t const id = node->id();
   DCHECK_LT(id, used_.size());
   used_[id] = true;
 }
 
 
 bool InstructionSelector::IsDouble(const Node* node) const {
   DCHECK_NOT_NULL(node);
   int const virtual_register = virtual_registers_[node->id()];
-  if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
+  if (virtual_register == InstructionOperand::kInvalidVirtualRegister) {
     return false;
   }
   return sequence()->IsDouble(virtual_register);
 }
 
 
 void InstructionSelector::MarkAsDouble(Node* node) {
   DCHECK_NOT_NULL(node);
   DCHECK(!IsReference(node));
   sequence()->MarkAsDouble(GetVirtualRegister(node));
 }
 
 
 bool InstructionSelector::IsReference(const Node* node) const {
   DCHECK_NOT_NULL(node);
   int const virtual_register = virtual_registers_[node->id()];
-  if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
+  if (virtual_register == InstructionOperand::kInvalidVirtualRegister) {
     return false;
   }
   return sequence()->IsReference(virtual_register);
 }
 
 
 void InstructionSelector::MarkAsReference(Node* node) {
   DCHECK_NOT_NULL(node);
   DCHECK(!IsDouble(node));
   sequence()->MarkAsReference(GetVirtualRegister(node));
@@ skipping 906 matching lines @@
 MachineOperatorBuilder::Flags
 InstructionSelector::SupportedMachineOperatorFlags() {
   return MachineOperatorBuilder::Flag::kNoFlags;
 }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8