LCOV - code coverage report
Current view: top level - src/compiler - instruction-selector.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 747 1111 67.2 %
Date: 2017-04-26 Functions: 58 203 28.6 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler/instruction-selector.h"
       6             : 
       7             : #include <limits>
       8             : 
       9             : #include "src/assembler-inl.h"
      10             : #include "src/base/adapters.h"
      11             : #include "src/compiler/compiler-source-position-table.h"
      12             : #include "src/compiler/instruction-selector-impl.h"
      13             : #include "src/compiler/node-matchers.h"
      14             : #include "src/compiler/pipeline.h"
      15             : #include "src/compiler/schedule.h"
      16             : #include "src/compiler/state-values-utils.h"
      17             : #include "src/deoptimizer.h"
      18             : #include "src/objects-inl.h"
      19             : 
      20             : namespace v8 {
      21             : namespace internal {
      22             : namespace compiler {
      23             : 
      24      916090 : InstructionSelector::InstructionSelector(
      25             :     Zone* zone, size_t node_count, Linkage* linkage,
      26             :     InstructionSequence* sequence, Schedule* schedule,
      27             :     SourcePositionTable* source_positions, Frame* frame,
      28             :     SourcePositionMode source_position_mode, Features features,
      29             :     EnableScheduling enable_scheduling,
      30             :     EnableSerialization enable_serialization)
      31             :     : zone_(zone),
      32             :       linkage_(linkage),
      33             :       sequence_(sequence),
      34             :       source_positions_(source_positions),
      35             :       source_position_mode_(source_position_mode),
      36             :       features_(features),
      37             :       schedule_(schedule),
      38             :       current_block_(nullptr),
      39             :       instructions_(zone),
      40             :       defined_(node_count, false, zone),
      41             :       used_(node_count, false, zone),
      42             :       effect_level_(node_count, 0, zone),
      43             :       virtual_registers_(node_count,
      44             :                          InstructionOperand::kInvalidVirtualRegister, zone),
      45             :       virtual_register_rename_(zone),
      46             :       scheduler_(nullptr),
      47             :       enable_scheduling_(enable_scheduling),
      48             :       enable_serialization_(enable_serialization),
      49             :       frame_(frame),
      50     1832205 :       instruction_selection_failed_(false) {
      51      916115 :   instructions_.reserve(node_count);
      52      916118 : }
      53             : 
      54    24755749 : bool InstructionSelector::SelectInstructions() {
      55             :   // Mark the inputs of all phis in loop headers as used.
      56             :   BasicBlockVector* blocks = schedule()->rpo_order();
      57    13294167 :   for (auto const block : *blocks) {
      58    11461935 :     if (!block->IsLoopHeader()) continue;
      59             :     DCHECK_LE(2u, block->PredecessorCount());
      60     1073998 :     for (Node* const phi : *block) {
      61      867390 :       if (phi->opcode() != IrOpcode::kPhi) continue;
      62             : 
      63             :       // Mark all inputs as used.
      64      793169 :       for (Node* const input : phi->inputs()) {
      65             :         MarkAsUsed(input);
      66             :       }
      67             :     }
      68             :   }
      69             : 
      70             :   // Visit each basic block in post order.
      71    12377886 :   for (auto i = blocks->rbegin(); i != blocks->rend(); ++i) {
      72    11461780 :     VisitBlock(*i);
      73    11461765 :     if (instruction_selection_failed()) return false;
      74             :   }
      75             : 
      76             :   // Schedule the selected instructions.
      77      916106 :   if (UseInstructionScheduling()) {
      78           0 :     scheduler_ = new (zone()) InstructionScheduler(zone(), sequence());
      79             :   }
      80             : 
      81    36217519 :   for (auto const block : *blocks) {
      82    22923528 :     InstructionBlock* instruction_block =
      83    11461762 :         sequence()->InstructionBlockAt(RpoNumber::FromInt(block->rpo_number()));
      84    25590674 :     for (size_t i = 0; i < instruction_block->phis().size(); i++) {
      85     1333573 :       UpdateRenamesInPhi(instruction_block->PhiAt(i));
      86             :     }
      87    11461764 :     size_t end = instruction_block->code_end();
      88    11461764 :     size_t start = instruction_block->code_start();
      89             :     DCHECK_LE(end, start);
      90    11461764 :     StartBlock(RpoNumber::FromInt(block->rpo_number()));
      91    61136972 :     while (start-- > end) {
      92    76426788 :       UpdateRenames(instructions_[start]);
      93    38213465 :       AddInstruction(instructions_[start]);
      94             :     }
      95    11461798 :     EndBlock(RpoNumber::FromInt(block->rpo_number()));
      96             :   }
      97             : #if DEBUG
      98             :   sequence()->ValidateSSA();
      99             : #endif
     100             :   return true;
     101             : }
     102             : 
     103    22923508 : void InstructionSelector::StartBlock(RpoNumber rpo) {
     104    11461754 :   if (UseInstructionScheduling()) {
     105             :     DCHECK_NOT_NULL(scheduler_);
     106           0 :     scheduler_->StartBlock(rpo);
     107             :   } else {
     108    11461754 :     sequence()->StartBlock(rpo);
     109             :   }
     110    11461788 : }
     111             : 
     112             : 
     113    22923548 : void InstructionSelector::EndBlock(RpoNumber rpo) {
     114    11461774 :   if (UseInstructionScheduling()) {
     115             :     DCHECK_NOT_NULL(scheduler_);
     116           0 :     scheduler_->EndBlock(rpo);
     117             :   } else {
     118    11461774 :     sequence()->EndBlock(rpo);
     119             :   }
     120    11461764 : }
     121             : 
     122             : 
     123    76426960 : void InstructionSelector::AddInstruction(Instruction* instr) {
     124    38213480 :   if (UseInstructionScheduling()) {
     125             :     DCHECK_NOT_NULL(scheduler_);
     126           0 :     scheduler_->AddInstruction(instr);
     127             :   } else {
     128    38213480 :     sequence()->AddInstruction(instr);
     129             :   }
     130    38213449 : }
     131             : 
     132    11341846 : Instruction* InstructionSelector::Emit(InstructionCode opcode,
     133             :                                        InstructionOperand output,
     134             :                                        size_t temp_count,
     135             :                                        InstructionOperand* temps) {
     136    11341846 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     137    11341846 :   return Emit(opcode, output_count, &output, 0, nullptr, temp_count, temps);
     138             : }
     139             : 
     140             : 
     141    10539285 : Instruction* InstructionSelector::Emit(InstructionCode opcode,
     142             :                                        InstructionOperand output,
     143             :                                        InstructionOperand a, size_t temp_count,
     144             :                                        InstructionOperand* temps) {
     145    10539285 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     146    10539285 :   return Emit(opcode, output_count, &output, 1, &a, temp_count, temps);
     147             : }
     148             : 
     149             : 
     150     1467708 : Instruction* InstructionSelector::Emit(InstructionCode opcode,
     151             :                                        InstructionOperand output,
     152             :                                        InstructionOperand a,
     153             :                                        InstructionOperand b, size_t temp_count,
     154             :                                        InstructionOperand* temps) {
     155     1467708 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     156     1467708 :   InstructionOperand inputs[] = {a, b};
     157             :   size_t input_count = arraysize(inputs);
     158             :   return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
     159     1467708 :               temps);
     160             : }
     161             : 
     162             : 
     163       14234 : Instruction* InstructionSelector::Emit(InstructionCode opcode,
     164             :                                        InstructionOperand output,
     165             :                                        InstructionOperand a,
     166             :                                        InstructionOperand b,
     167             :                                        InstructionOperand c, size_t temp_count,
     168             :                                        InstructionOperand* temps) {
     169       14234 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     170       14234 :   InstructionOperand inputs[] = {a, b, c};
     171             :   size_t input_count = arraysize(inputs);
     172             :   return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
     173       14234 :               temps);
     174             : }
     175             : 
     176             : 
     177     2268984 : Instruction* InstructionSelector::Emit(
     178             :     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
     179             :     InstructionOperand b, InstructionOperand c, InstructionOperand d,
     180             :     size_t temp_count, InstructionOperand* temps) {
     181     2268984 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     182     2268984 :   InstructionOperand inputs[] = {a, b, c, d};
     183             :   size_t input_count = arraysize(inputs);
     184             :   return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
     185     2268984 :               temps);
     186             : }
     187             : 
     188             : 
     189       53151 : Instruction* InstructionSelector::Emit(
     190             :     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
     191             :     InstructionOperand b, InstructionOperand c, InstructionOperand d,
     192             :     InstructionOperand e, size_t temp_count, InstructionOperand* temps) {
     193       53151 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     194       53151 :   InstructionOperand inputs[] = {a, b, c, d, e};
     195             :   size_t input_count = arraysize(inputs);
     196             :   return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
     197       53151 :               temps);
     198             : }
     199             : 
     200             : 
     201           0 : Instruction* InstructionSelector::Emit(
     202             :     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
     203             :     InstructionOperand b, InstructionOperand c, InstructionOperand d,
     204             :     InstructionOperand e, InstructionOperand f, size_t temp_count,
     205             :     InstructionOperand* temps) {
     206           0 :   size_t output_count = output.IsInvalid() ? 0 : 1;
     207           0 :   InstructionOperand inputs[] = {a, b, c, d, e, f};
     208             :   size_t input_count = arraysize(inputs);
     209             :   return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
     210           0 :               temps);
     211             : }
     212             : 
     213             : 
     214    38212900 : Instruction* InstructionSelector::Emit(
     215             :     InstructionCode opcode, size_t output_count, InstructionOperand* outputs,
     216             :     size_t input_count, InstructionOperand* inputs, size_t temp_count,
     217             :     InstructionOperand* temps) {
     218    76425800 :   if (output_count >= Instruction::kMaxOutputCount ||
     219    76425722 :       input_count >= Instruction::kMaxInputCount ||
     220             :       temp_count >= Instruction::kMaxTempCount) {
     221             :     set_instruction_selection_failed();
     222           0 :     return nullptr;
     223             :   }
     224             : 
     225             :   Instruction* instr =
     226             :       Instruction::New(instruction_zone(), opcode, output_count, outputs,
     227    38212900 :                        input_count, inputs, temp_count, temps);
     228    38213063 :   return Emit(instr);
     229             : }
     230             : 
     231             : 
     232           0 : Instruction* InstructionSelector::Emit(Instruction* instr) {
     233    38213101 :   instructions_.push_back(instr);
     234    38213063 :   return instr;
     235             : }
     236             : 
     237             : 
     238    25492639 : bool InstructionSelector::CanCover(Node* user, Node* node) const {
     239             :   // 1. Both {user} and {node} must be in the same basic block.
     240    14126939 :   if (schedule()->block(node) != schedule()->block(user)) {
     241             :     return false;
     242             :   }
     243             :   // 2. Pure {node}s must be owned by the {user}.
     244     6412610 :   if (node->op()->HasProperty(Operator::kPure)) {
     245     4953090 :     return node->OwnedBy(user);
     246             :   }
     247             :   // 3. Impure {node}s must match the effect level of {user}.
     248     1459520 :   if (GetEffectLevel(node) != GetEffectLevel(user)) {
     249             :     return false;
     250             :   }
     251             :   // 4. Only {node} must have value edges pointing to {user}.
     252     6474777 :   for (Edge const edge : node->use_edges()) {
     253     2575734 :     if (edge.from() != user && NodeProperties::IsValueEdge(edge)) {
     254      107848 :       return false;
     255             :     }
     256             :   }
     257     1323309 :   return true;
     258             : }
     259             : 
     260           0 : bool InstructionSelector::IsOnlyUserOfNodeInSameBlock(Node* user,
     261           0 :                                                       Node* node) const {
     262           0 :   BasicBlock* bb_user = schedule()->block(user);
     263           0 :   BasicBlock* bb_node = schedule()->block(node);
     264           0 :   if (bb_user != bb_node) return false;
     265           0 :   for (Edge const edge : node->use_edges()) {
     266             :     Node* from = edge.from();
     267           0 :     if ((from != user) && (schedule()->block(from) == bb_user)) {
     268             :       return false;
     269             :     }
     270             :   }
     271           0 :   return true;
     272             : }
     273             : 
     274   158682022 : void InstructionSelector::UpdateRenames(Instruction* instruction) {
     275   240937242 :   for (size_t i = 0; i < instruction->InputCount(); i++) {
     276    82255131 :     TryRename(instruction->InputAt(i));
     277             :   }
     278    38213490 : }
     279             : 
     280     1333568 : void InstructionSelector::UpdateRenamesInPhi(PhiInstruction* phi) {
     281     9318182 :   for (size_t i = 0; i < phi->operands().size(); i++) {
     282     3325519 :     int vreg = phi->operands()[i];
     283             :     int renamed = GetRename(vreg);
     284     3325519 :     if (vreg != renamed) {
     285       15973 :       phi->RenameInput(i, renamed);
     286             :     }
     287             :   }
     288     1333572 : }
     289             : 
     290           0 : int InstructionSelector::GetRename(int virtual_register) {
     291             :   int rename = virtual_register;
     292             :   while (true) {
     293    98990936 :     if (static_cast<size_t>(rename) >= virtual_register_rename_.size()) break;
     294     8938224 :     int next = virtual_register_rename_[rename];
     295     8938224 :     if (next == InstructionOperand::kInvalidVirtualRegister) {
     296             :       break;
     297             :     }
     298             :     rename = next;
     299             :   }
     300           0 :   return rename;
     301             : }
     302             : 
     303    82255149 : void InstructionSelector::TryRename(InstructionOperand* op) {
     304   164510298 :   if (!op->IsUnallocated()) return;
     305             :   int vreg = UnallocatedOperand::cast(op)->virtual_register();
     306             :   int rename = GetRename(vreg);
     307    46029119 :   if (rename != vreg) {
     308             :     UnallocatedOperand::cast(op)->set_virtual_register(rename);
     309             :   }
     310             : }
     311             : 
     312      110406 : void InstructionSelector::SetRename(const Node* node, const Node* rename) {
     313      110406 :   int vreg = GetVirtualRegister(node);
     314      331221 :   if (static_cast<size_t>(vreg) >= virtual_register_rename_.size()) {
     315      104260 :     int invalid = InstructionOperand::kInvalidVirtualRegister;
     316      104260 :     virtual_register_rename_.resize(vreg + 1, invalid);
     317             :   }
     318      110407 :   virtual_register_rename_[vreg] = GetVirtualRegister(rename);
     319      110407 : }
     320             : 
     321   115187137 : int InstructionSelector::GetVirtualRegister(const Node* node) {
     322             :   DCHECK_NOT_NULL(node);
     323    92321468 :   size_t const id = node->id();
     324             :   DCHECK_LT(id, virtual_registers_.size());
     325   207508680 :   int virtual_register = virtual_registers_[id];
     326    92321468 :   if (virtual_register == InstructionOperand::kInvalidVirtualRegister) {
     327    22865669 :     virtual_register = sequence()->NextVirtualRegister();
     328    22865744 :     virtual_registers_[id] = virtual_register;
     329             :   }
     330    92321543 :   return virtual_register;
     331             : }
     332             : 
     333             : 
     334         242 : const std::map<NodeId, int> InstructionSelector::GetVirtualRegistersForTesting()
     335             :     const {
     336             :   std::map<NodeId, int> virtual_registers;
     337        4502 :   for (size_t n = 0; n < virtual_registers_.size(); ++n) {
     338        4260 :     if (virtual_registers_[n] != InstructionOperand::kInvalidVirtualRegister) {
     339         705 :       NodeId const id = static_cast<NodeId>(n);
     340        1410 :       virtual_registers.insert(std::make_pair(id, virtual_registers_[n]));
     341             :     }
     342             :   }
     343         242 :   return virtual_registers;
     344             : }
     345             : 
     346             : 
     347    26318889 : bool InstructionSelector::IsDefined(Node* node) const {
     348             :   DCHECK_NOT_NULL(node);
     349    26318889 :   size_t const id = node->id();
     350             :   DCHECK_LT(id, defined_.size());
     351    26801374 :   return defined_[id];
     352             : }
     353             : 
     354             : 
     355    21422003 : void InstructionSelector::MarkAsDefined(Node* node) {
     356             :   DCHECK_NOT_NULL(node);
     357    21422003 :   size_t const id = node->id();
     358             :   DCHECK_LT(id, defined_.size());
     359    21422003 :   defined_[id] = true;
     360     6350598 : }
     361             : 
     362             : 
     363   115698861 : bool InstructionSelector::IsUsed(Node* node) const {
     364             :   DCHECK_NOT_NULL(node);
     365             :   // TODO(bmeurer): This is a terrible monster hack, but we have to make sure
     366             :   // that the Retain is actually emitted, otherwise the GC will mess up.
     367    60995867 :   if (node->opcode() == IrOpcode::kRetain) return true;
     368    60989465 :   if (!node->op()->HasProperty(Operator::kEliminatable)) return true;
     369    54702994 :   size_t const id = node->id();
     370             :   DCHECK_LT(id, used_.size());
     371   109405988 :   return used_[id];
     372             : }
     373             : 
     374             : 
     375    53865272 : void InstructionSelector::MarkAsUsed(Node* node) {
     376             :   DCHECK_NOT_NULL(node);
     377    53865272 :   size_t const id = node->id();
     378             :   DCHECK_LT(id, used_.size());
     379    53865272 :   used_[id] = true;
     380    18631297 : }
     381             : 
     382    10839604 : int InstructionSelector::GetEffectLevel(Node* node) const {
     383             :   DCHECK_NOT_NULL(node);
     384    10839604 :   size_t const id = node->id();
     385             :   DCHECK_LT(id, effect_level_.size());
     386    20219688 :   return effect_level_[id];
     387             : }
     388             : 
     389    65444792 : void InstructionSelector::SetEffectLevel(Node* node, int effect_level) {
     390             :   DCHECK_NOT_NULL(node);
     391    65444792 :   size_t const id = node->id();
     392             :   DCHECK_LT(id, effect_level_.size());
     393   130889584 :   effect_level_[id] = effect_level;
     394           0 : }
     395             : 
     396     5688921 : bool InstructionSelector::CanAddressRelativeToRootsRegister() const {
     397    10279007 :   return enable_serialization_ == kDisableSerialization &&
     398     5688921 :          CanUseRootsRegister();
     399             : }
     400             : 
     401     6615168 : bool InstructionSelector::CanUseRootsRegister() const {
     402             :   return linkage()->GetIncomingDescriptor()->flags() &
     403     2025082 :          CallDescriptor::kCanUseRoots;
     404             : }
     405             : 
     406           0 : void InstructionSelector::MarkAsRepresentation(MachineRepresentation rep,
     407     3503003 :                                                const InstructionOperand& op) {
     408             :   UnallocatedOperand unalloc = UnallocatedOperand::cast(op);
     409     3503003 :   sequence()->MarkAsRepresentation(rep, unalloc.virtual_register());
     410           0 : }
     411             : 
     412             : 
     413    12881146 : void InstructionSelector::MarkAsRepresentation(MachineRepresentation rep,
     414    12881197 :                                                Node* node) {
     415    25762343 :   sequence()->MarkAsRepresentation(rep, GetVirtualRegister(node));
     416    12881207 : }
     417             : 
     418             : namespace {
     419             : 
     420    18966275 : InstructionOperand OperandForDeopt(Isolate* isolate, OperandGenerator* g,
     421    18966271 :                                    Node* input, FrameStateInputKind kind,
     422             :                                    MachineRepresentation rep) {
     423    18966275 :   if (rep == MachineRepresentation::kNone) {
     424           4 :     return g->TempImmediate(FrameStateDescriptor::kImpossibleValue);
     425             :   }
     426             : 
     427    18966271 :   switch (input->opcode()) {
     428             :     case IrOpcode::kInt32Constant:
     429             :     case IrOpcode::kInt64Constant:
     430             :     case IrOpcode::kNumberConstant:
     431             :     case IrOpcode::kFloat32Constant:
     432             :     case IrOpcode::kFloat64Constant:
     433      971181 :       return g->UseImmediate(input);
     434             :     case IrOpcode::kHeapConstant: {
     435     4393350 :       if (!CanBeTaggedPointer(rep)) {
     436             :         // If we have inconsistent static and dynamic types, e.g. if we
     437             :         // smi-check a string, we can get here with a heap object that
     438             :         // says it is a smi. In that case, we return an invalid instruction
     439             :         // operand, which will be interpreted as an optimized-out value.
     440             : 
     441             :         // TODO(jarin) Ideally, we should turn the current instruction
     442             :         // into an abort (we should never execute it).
     443           0 :         return InstructionOperand();
     444             :       }
     445             : 
     446     4393350 :       Handle<HeapObject> constant = OpParameter<Handle<HeapObject>>(input);
     447             :       Heap::RootListIndex root_index;
     448     4393350 :       if (isolate->heap()->IsRootHandle(constant, &root_index) &&
     449             :           root_index == Heap::kOptimizedOutRootIndex) {
     450             :         // For an optimized-out object we return an invalid instruction
     451             :         // operand, so that we take the fast path for optimized-out values.
     452         205 :         return InstructionOperand();
     453             :       }
     454             : 
     455     4393145 :       return g->UseImmediate(input);
     456             :     }
     457             :     case IrOpcode::kArgumentsElementsState:
     458             :     case IrOpcode::kArgumentsLengthState:
     459             :     case IrOpcode::kObjectState:
     460             :     case IrOpcode::kTypedObjectState:
     461           0 :       UNREACHABLE();
     462             :       break;
     463             :     default:
     464    13601740 :       switch (kind) {
     465             :         case FrameStateInputKind::kStackSlot:
     466    12140969 :           return g->UseUniqueSlot(input);
     467             :         case FrameStateInputKind::kAny:
     468             :           // Currently deopts "wrap" other operations, so the deopt's inputs
     469             :           // are potentially needed untill the end of the deoptimising code.
     470     1460771 :           return g->UseAnyAtEnd(input);
     471             :       }
     472             :   }
     473           0 :   UNREACHABLE();
     474             :   return InstructionOperand();
     475             : }
     476             : 
     477             : }  // namespace
     478             : 
     479             : class StateObjectDeduplicator {
     480             :  public:
     481             :   explicit StateObjectDeduplicator(Zone* zone) : objects_(zone) {}
     482             :   static const size_t kNotDuplicated = SIZE_MAX;
     483             : 
     484             :   size_t GetObjectId(Node* node) {
     485       23491 :     for (size_t i = 0; i < objects_.size(); ++i) {
     486       24991 :       if (objects_[i] == node) {
     487             :         return i;
     488             :       }
     489             :     }
     490             :     return kNotDuplicated;
     491             :   }
     492             : 
     493             :   size_t InsertObject(Node* node) {
     494             :     size_t id = objects_.size();
     495       17771 :     objects_.push_back(node);
     496             :     return id;
     497             :   }
     498             : 
     499             :  private:
     500             :   ZoneVector<Node*> objects_;
     501             : };
     502             : 
     503             : // Returns the number of instruction operands added to inputs.
     504    45041028 : size_t InstructionSelector::AddOperandToStateValueDescriptor(
     505             :     StateValueList* values, InstructionOperandVector* inputs,
     506    19000177 :     OperandGenerator* g, StateObjectDeduplicator* deduplicator, Node* input,
     507             :     MachineType type, FrameStateInputKind kind, Zone* zone) {
     508    45041028 :   if (input == nullptr) {
     509             :     values->PushOptimizedOut();
     510    26054746 :     return 0;
     511             :   }
     512             : 
     513    18986508 :   switch (input->opcode()) {
     514             :     case IrOpcode::kArgumentsElementsState: {
     515        2602 :       values->PushArgumentsElements(IsRestOf(input->op()));
     516             :       // The elements backing store of an arguments object participates in the
     517             :       // duplicate object counting, but can itself never appear duplicated.
     518             :       DCHECK_EQ(StateObjectDeduplicator::kNotDuplicated,
     519             :                 deduplicator->GetObjectId(input));
     520             :       deduplicator->InsertObject(input);
     521        2602 :       return 0;
     522             :     }
     523             :     case IrOpcode::kArgumentsLengthState: {
     524        2634 :       values->PushArgumentsLength(IsRestOf(input->op()));
     525        2634 :       return 0;
     526             :     }
     527             :     case IrOpcode::kObjectState: {
     528           0 :       UNREACHABLE();
     529             :       return 0;
     530             :     }
     531             :     case IrOpcode::kTypedObjectState: {
     532             :       size_t id = deduplicator->GetObjectId(input);
     533       15169 :       if (id == StateObjectDeduplicator::kNotDuplicated) {
     534             :         size_t entries = 0;
     535             :         id = deduplicator->InsertObject(input);
     536       13669 :         StateValueList* nested = values->PushRecursiveField(zone, id);
     537       13669 :         int const input_count = input->op()->ValueInputCount();
     538       13669 :         ZoneVector<MachineType> const* types = MachineTypesOf(input->op());
     539       78149 :         for (int i = 0; i < input_count; ++i) {
     540             :           entries += AddOperandToStateValueDescriptor(
     541       64480 :               nested, inputs, g, deduplicator, input->InputAt(i), types->at(i),
     542       64480 :               kind, zone);
     543             :         }
     544             :         return entries;
     545             :       } else {
     546             :         // Crankshaft counts duplicate objects for the running id, so we have
     547             :         // to push the input again.
     548             :         deduplicator->InsertObject(input);
     549             :         values->PushDuplicate(id);
     550        1500 :         return 0;
     551             :       }
     552             :     }
     553             :     default: {
     554             :       InstructionOperand op =
     555    18966103 :           OperandForDeopt(isolate(), g, input, kind, type.representation());
     556    18966016 :       if (op.kind() == InstructionOperand::INVALID) {
     557             :         // Invalid operand means the value is impossible or optimized-out.
     558             :         values->PushOptimizedOut();
     559         211 :         return 0;
     560             :       } else {
     561    18965811 :         inputs->push_back(op);
     562             :         values->PushPlain(type);
     563    18966030 :         return 1;
     564             :       }
     565             :     }
     566             :   }
     567             : }
     568             : 
     569             : 
     570             : // Returns the number of instruction operands added to inputs.
     571     2916217 : size_t InstructionSelector::AddInputsToFrameStateDescriptor(
     572     5832446 :     FrameStateDescriptor* descriptor, Node* state, OperandGenerator* g,
     573             :     StateObjectDeduplicator* deduplicator, InstructionOperandVector* inputs,
     574             :     FrameStateInputKind kind, Zone* zone) {
     575             :   DCHECK_EQ(IrOpcode::kFrameState, state->op()->opcode());
     576             : 
     577             :   size_t entries = 0;
     578             :   size_t initial_size = inputs->size();
     579             :   USE(initial_size);  // initial_size is only used for debug.
     580             : 
     581     2916217 :   if (descriptor->outer_state()) {
     582             :     entries += AddInputsToFrameStateDescriptor(
     583             :         descriptor->outer_state(), state->InputAt(kFrameStateOuterStateInput),
     584      219838 :         g, deduplicator, inputs, kind, zone);
     585             :   }
     586             : 
     587             :   Node* parameters = state->InputAt(kFrameStateParametersInput);
     588             :   Node* locals = state->InputAt(kFrameStateLocalsInput);
     589             :   Node* stack = state->InputAt(kFrameStateStackInput);
     590             :   Node* context = state->InputAt(kFrameStateContextInput);
     591             :   Node* function = state->InputAt(kFrameStateFunctionInput);
     592             : 
     593             :   DCHECK_EQ(descriptor->parameters_count(),
     594             :             StateValuesAccess(parameters).size());
     595             :   DCHECK_EQ(descriptor->locals_count(), StateValuesAccess(locals).size());
     596             :   DCHECK_EQ(descriptor->stack_count(), StateValuesAccess(stack).size());
     597             : 
     598     2916212 :   StateValueList* values_descriptor = descriptor->GetStateValueDescriptors();
     599             : 
     600             :   DCHECK_EQ(values_descriptor->size(), 0u);
     601             :   values_descriptor->ReserveSize(
     602     2916212 :       descriptor->GetSize(OutputFrameStateCombine::Ignore()));
     603             : 
     604             :   entries += AddOperandToStateValueDescriptor(
     605             :       values_descriptor, inputs, g, deduplicator, function,
     606     2916222 :       MachineType::AnyTagged(), FrameStateInputKind::kStackSlot, zone);
     607     6002769 :   for (StateValuesAccess::TypedNode input_node :
     608     6002718 :        StateValuesAccess(parameters)) {
     609             :     entries += AddOperandToStateValueDescriptor(values_descriptor, inputs, g,
     610             :                                                 deduplicator, input_node.node,
     611     6002689 :                                                 input_node.type, kind, zone);
     612             :   }
     613     2916229 :   if (descriptor->HasContext()) {
     614             :     entries += AddOperandToStateValueDescriptor(
     615             :         values_descriptor, inputs, g, deduplicator, context,
     616     2854489 :         MachineType::AnyTagged(), FrameStateInputKind::kStackSlot, zone);
     617             :   }
     618    60713464 :   for (StateValuesAccess::TypedNode input_node : StateValuesAccess(locals)) {
     619             :     entries += AddOperandToStateValueDescriptor(values_descriptor, inputs, g,
     620             :                                                 deduplicator, input_node.node,
     621    30356416 :                                                 input_node.type, kind, zone);
     622             :   }
     623     5693167 :   for (StateValuesAccess::TypedNode input_node : StateValuesAccess(stack)) {
     624             :     entries += AddOperandToStateValueDescriptor(values_descriptor, inputs, g,
     625             :                                                 deduplicator, input_node.node,
     626     2846575 :                                                 input_node.type, kind, zone);
     627             :   }
     628             :   DCHECK_EQ(initial_size + entries, inputs->size());
     629     2916231 :   return entries;
     630             : }
     631             : 
     632             : 
     633             : // An internal helper class for generating the operands to calls.
     634             : // TODO(bmeurer): Get rid of the CallBuffer business and make
     635             : // InstructionSelector::VisitCall platform independent instead.
     636             : struct CallBuffer {
     637    10650451 :   CallBuffer(Zone* zone, const CallDescriptor* descriptor,
     638    10650564 :              FrameStateDescriptor* frame_state)
     639             :       : descriptor(descriptor),
     640             :         frame_state_descriptor(frame_state),
     641             :         output_nodes(zone),
     642             :         outputs(zone),
     643             :         instruction_args(zone),
     644     3550142 :         pushed_nodes(zone) {
     645     3550142 :     output_nodes.reserve(descriptor->ReturnCount());
     646     3550167 :     outputs.reserve(descriptor->ReturnCount());
     647     3550182 :     pushed_nodes.reserve(input_count());
     648     3550191 :     instruction_args.reserve(input_count() + frame_state_value_count());
     649     3550165 :   }
     650             : 
     651             : 
     652             :   const CallDescriptor* descriptor;
     653             :   FrameStateDescriptor* frame_state_descriptor;
     654             :   NodeVector output_nodes;
     655             :   InstructionOperandVector outputs;
     656             :   InstructionOperandVector instruction_args;
     657             :   ZoneVector<PushParameter> pushed_nodes;
     658             : 
     659    10650505 :   size_t input_count() const { return descriptor->InputCount(); }
     660             : 
     661             :   size_t frame_state_count() const { return descriptor->FrameStateCount(); }
     662             : 
     663             :   size_t frame_state_value_count() const {
     664             :     return (frame_state_descriptor == nullptr)
     665             :                ? 0
     666     2413433 :                : (frame_state_descriptor->GetTotalSize() +
     667     5963624 :                   1);  // Include deopt id.
     668             :   }
     669             : };
     670             : 
     671             : 
     672             : // TODO(bmeurer): Get rid of the CallBuffer business and make
     673             : // InstructionSelector::VisitCall platform independent instead.
     674     7100198 : void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
     675             :                                                CallBufferFlags flags,
     676     2413422 :                                                int stack_param_delta) {
     677             :   OperandGenerator g(this);
     678             :   DCHECK_LE(call->op()->ValueOutputCount(),
     679             :             static_cast<int>(buffer->descriptor->ReturnCount()));
     680             :   DCHECK_EQ(
     681             :       call->op()->ValueInputCount(),
     682             :       static_cast<int>(buffer->input_count() + buffer->frame_state_count()));
     683             : 
     684    20069543 :   if (buffer->descriptor->ReturnCount() > 0) {
     685             :     // Collect the projections that represent multiple outputs from this call.
     686     3499303 :     if (buffer->descriptor->ReturnCount() == 1) {
     687    10506276 :       buffer->output_nodes.push_back(call);
     688             :     } else {
     689        3199 :       buffer->output_nodes.resize(buffer->descriptor->ReturnCount(), nullptr);
     690       41620 :       for (Edge const edge : call->use_edges()) {
     691       17611 :         if (!NodeProperties::IsValueEdge(edge)) continue;
     692             :         DCHECK(edge.from()->opcode() == IrOpcode::kProjection);
     693        6851 :         size_t const index = ProjectionIndexOf(edge.from()->op());
     694             :         DCHECK_LT(index, buffer->output_nodes.size());
     695             :         DCHECK(!buffer->output_nodes[index]);
     696        6851 :         buffer->output_nodes[index] = edge.from();
     697             :       }
     698             :     }
     699             : 
     700             :     // Filter out the outputs that aren't live because no projection uses them.
     701             :     size_t outputs_needed_by_framestate =
     702     3500084 :         buffer->frame_state_descriptor == nullptr
     703             :             ? 0
     704             :             : buffer->frame_state_descriptor->state_combine()
     705     6998568 :                   .ConsumedOutputCount();
     706    10507358 :     for (size_t i = 0; i < buffer->output_nodes.size(); i++) {
     707     3503961 :       bool output_is_live = buffer->output_nodes[i] != nullptr ||
     708             :                             i < outputs_needed_by_framestate;
     709     3503961 :       if (output_is_live) {
     710             :         MachineRepresentation rep =
     711     3502933 :             buffer->descriptor->GetReturnType(static_cast<int>(i))
     712             :                 .representation();
     713             :         LinkageLocation location =
     714     7005866 :             buffer->descriptor->GetReturnLocation(static_cast<int>(i));
     715             : 
     716             :         Node* output = buffer->output_nodes[i];
     717             :         InstructionOperand op = output == nullptr
     718             :                                     ? g.TempLocation(location)
     719     3502933 :                                     : g.DefineAsLocation(output, location);
     720             :         MarkAsRepresentation(rep, op);
     721             : 
     722     3503008 :         buffer->outputs.push_back(op);
     723             :       }
     724             :     }
     725             :   }
     726             : 
     727             :   // The first argument is always the callee code.
     728     6948294 :   Node* callee = call->InputAt(0);
     729             :   bool call_code_immediate = (flags & kCallCodeImmediate) != 0;
     730             :   bool call_address_immediate = (flags & kCallAddressImmediate) != 0;
     731     7100246 :   switch (buffer->descriptor->kind()) {
     732             :     case CallDescriptor::kCallCodeObject:
     733             :       buffer->instruction_args.push_back(
     734     3372351 :           (call_code_immediate && callee->opcode() == IrOpcode::kHeapConstant)
     735             :               ? g.UseImmediate(callee)
     736    10113401 :               : g.UseRegister(callee));
     737     3372363 :       break;
     738             :     case CallDescriptor::kCallAddress:
     739             :       buffer->instruction_args.push_back(
     740       25820 :           (call_address_immediate &&
     741             :            callee->opcode() == IrOpcode::kExternalConstant)
     742             :               ? g.UseImmediate(callee)
     743       53264 :               : g.UseRegister(callee));
     744       25820 :       break;
     745             :     case CallDescriptor::kCallJSFunction:
     746             :       buffer->instruction_args.push_back(
     747      303887 :           g.UseLocation(callee, buffer->descriptor->GetInputLocation(0)));
     748      151944 :       break;
     749             :   }
     750             :   DCHECK_EQ(1u, buffer->instruction_args.size());
     751             : 
     752             :   // If the call needs a frame state, we insert the state information as
     753             :   // follows (n is the number of value inputs to the frame state):
     754             :   // arg 1               : deoptimization id.
     755             :   // arg 2 - arg (n + 1) : value inputs to the frame state.
     756             :   size_t frame_state_entries = 0;
     757             :   USE(frame_state_entries);  // frame_state_entries is only used for debug.
     758     3550118 :   if (buffer->frame_state_descriptor != nullptr) {
     759             :     Node* frame_state =
     760     4826844 :         call->InputAt(static_cast<int>(buffer->descriptor->InputCount()));
     761             : 
     762             :     // If it was a syntactic tail call we need to drop the current frame and
     763             :     // all the frames on top of it that are either an arguments adaptor frame
     764             :     // or a tail caller frame.
     765     2413422 :     if (buffer->descriptor->SupportsTailCalls()) {
     766         212 :       frame_state = NodeProperties::GetFrameStateInput(frame_state);
     767             :       buffer->frame_state_descriptor =
     768         424 :           buffer->frame_state_descriptor->outer_state();
     769        1412 :       while (buffer->frame_state_descriptor != nullptr &&
     770             :              (buffer->frame_state_descriptor->type() ==
     771         222 :                   FrameStateType::kArgumentsAdaptor ||
     772             :               buffer->frame_state_descriptor->type() ==
     773             :                   FrameStateType::kTailCallerFunction)) {
     774         188 :         frame_state = NodeProperties::GetFrameStateInput(frame_state);
     775             :         buffer->frame_state_descriptor =
     776         376 :             buffer->frame_state_descriptor->outer_state();
     777             :       }
     778             :     }
     779             : 
     780             :     int const state_id = sequence()->AddDeoptimizationEntry(
     781             :         buffer->frame_state_descriptor, DeoptimizeKind::kEager,
     782     4826844 :         DeoptimizeReason::kNoReason);
     783     4826861 :     buffer->instruction_args.push_back(g.TempImmediate(state_id));
     784             : 
     785             :     StateObjectDeduplicator deduplicator(instruction_zone());
     786             : 
     787             :     frame_state_entries =
     788             :         1 + AddInputsToFrameStateDescriptor(
     789             :                 buffer->frame_state_descriptor, frame_state, &g, &deduplicator,
     790             :                 &buffer->instruction_args, FrameStateInputKind::kStackSlot,
     791     2413435 :                 instruction_zone());
     792             : 
     793             :     DCHECK_EQ(1 + frame_state_entries, buffer->instruction_args.size());
     794             :   }
     795             : 
     796             :   size_t input_count = static_cast<size_t>(buffer->input_count());
     797             : 
     798             :   // Split the arguments into pushed_nodes and instruction_args. Pushed
     799             :   // arguments require an explicit push instruction before the call and do
     800             :   // not appear as arguments to the call. Everything else ends up
     801             :   // as an InstructionOperand argument to the call.
     802     3550132 :   auto iter(call->inputs().begin());
     803             :   size_t pushed_count = 0;
     804     3550132 :   bool call_tail = (flags & kCallTail) != 0;
     805    22862067 :   for (size_t index = 0; index < input_count; ++iter, ++index) {
     806             :     DCHECK(iter != call->inputs().end());
     807             :     DCHECK((*iter)->op()->opcode() != IrOpcode::kFrameState);
     808    22861996 :     if (index == 0) continue;  // The first argument (callee) is already done.
     809             : 
     810    15761822 :     LinkageLocation location = buffer->descriptor->GetInputLocation(index);
     811    15761846 :     if (call_tail) {
     812             :       location = LinkageLocation::ConvertToTailCallerLocation(
     813             :           location, stack_param_delta);
     814             :     }
     815    15761846 :     InstructionOperand op = g.UseLocation(*iter, location);
     816    15761906 :     if (UnallocatedOperand::cast(op).HasFixedSlotPolicy() && !call_tail) {
     817     3687032 :       int stack_index = -UnallocatedOperand::cast(op).fixed_slot_index() - 1;
     818    11061097 :       if (static_cast<size_t>(stack_index) >= buffer->pushed_nodes.size()) {
     819     1531054 :         buffer->pushed_nodes.resize(stack_index + 1);
     820             :       }
     821     3687033 :       PushParameter parameter(*iter, buffer->descriptor->GetInputType(index));
     822     3687033 :       buffer->pushed_nodes[stack_index] = parameter;
     823             :       pushed_count++;
     824             :     } else {
     825    12074874 :       buffer->instruction_args.push_back(op);
     826             :     }
     827             :   }
     828             :   DCHECK_EQ(input_count, buffer->instruction_args.size() + pushed_count -
     829             :                              frame_state_entries);
     830     3550158 :   if (V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK && call_tail &&
     831     3550158 :       stack_param_delta != 0) {
     832             :     // For tail calls that change the size of their parameter list and keep
     833             :     // their return address on the stack, move the return address to just above
     834             :     // the parameters.
     835             :     LinkageLocation saved_return_location =
     836             :         LinkageLocation::ForSavedCallerReturnAddress();
     837             :     InstructionOperand return_address =
     838             :         g.UsePointerLocation(LinkageLocation::ConvertToTailCallerLocation(
     839             :                                  saved_return_location, stack_param_delta),
     840       12164 :                              saved_return_location);
     841       12164 :     buffer->instruction_args.push_back(return_address);
     842             :   }
     843     3550158 : }
     844             : 
     845     8326895 : bool InstructionSelector::IsSourcePositionUsed(Node* node) {
     846    18919095 :   return (source_position_mode_ == kAllSourcePositions ||
     847     6165650 :           node->opcode() == IrOpcode::kCall ||
     848    16757194 :           node->opcode() == IrOpcode::kTrapIf ||
     849           0 :           node->opcode() == IrOpcode::kTrapUnless);
     850             : }
     851             : 
     852    45847167 : void InstructionSelector::VisitBlock(BasicBlock* block) {
     853             :   DCHECK(!current_block_);
     854    11461844 :   current_block_ = block;
     855             :   auto current_num_instructions = [&] {
     856             :     DCHECK_GE(kMaxInt, instructions_.size());
     857   148728672 :     return static_cast<int>(instructions_.size());
     858    11461844 :   };
     859             :   int current_block_end = current_num_instructions();
     860             : 
     861             :   int effect_level = 0;
     862   144087630 :   for (Node* const node : *block) {
     863             :     SetEffectLevel(node, effect_level);
     864   118827382 :     if (node->opcode() == IrOpcode::kStore ||
     865    58248659 :         node->opcode() == IrOpcode::kUnalignedStore ||
     866    58195701 :         node->opcode() == IrOpcode::kCheckedStore ||
     867    55025401 :         node->opcode() == IrOpcode::kCall ||
     868   115605940 :         node->opcode() == IrOpcode::kProtectedLoad ||
     869             :         node->opcode() == IrOpcode::kProtectedStore) {
     870     5559715 :       ++effect_level;
     871             :     }
     872             :   }
     873             : 
     874             :   // We visit the control first, then the nodes in the block, so the block's
     875             :   // control input should be on the same effect level as the last node.
     876    11461844 :   if (block->control_input() != nullptr) {
     877             :     SetEffectLevel(block->control_input(), effect_level);
     878             :   }
     879             : 
     880    37181658 :   auto FinishEmittedInstructions = [&](Node* node, int instruction_start) {
     881    41624554 :     if (instruction_selection_failed()) return false;
     882    74363716 :     if (current_num_instructions() == instruction_start) return true;
     883             :     std::reverse(instructions_.begin() + instruction_start,
     884    38568030 :                  instructions_.end());
     885    34125134 :     if (!node) return true;
     886    28440648 :     SourcePosition source_position = source_positions_->GetSourcePosition(node);
     887    39032878 :     if (source_position.IsKnown() && IsSourcePositionUsed(node)) {
     888     4442896 :       sequence()->SetSourcePosition(instructions_[instruction_start],
     889     8885792 :                                     source_position);
     890             :     }
     891             :     return true;
     892    11461844 :   };
     893             : 
     894             :   // Generate code for the block control "top down", but schedule the code
     895             :   // "bottom up".
     896    11461844 :   VisitControl(block);
     897    11461714 :   if (!FinishEmittedInstructions(block->control_input(), current_block_end))
     898           0 :     return;
     899             : 
     900             :   // Visit code in reverse control flow order, because architecture-specific
     901             :   // matching may cover more than one node at a time.
     902   132626413 :   for (auto node : base::Reversed(*block)) {
     903             :     // Skip nodes that are unused or already defined.
     904    86418728 :     if (!IsUsed(node) || IsDefined(node)) continue;
     905             :     // Generate code for this node "top down", but schedule the code "bottom
     906             :     // up".
     907             :     int current_node_end = current_num_instructions();
     908    25720634 :     VisitNode(node);
     909    25720631 :     if (!FinishEmittedInstructions(node, current_node_end)) return;
     910             :   }
     911             : 
     912             :   // We're done with the block.
     913             :   InstructionBlock* instruction_block =
     914    11461765 :       sequence()->InstructionBlockAt(RpoNumber::FromInt(block->rpo_number()));
     915    22923478 :   instruction_block->set_code_start(static_cast<int>(instructions_.size()));
     916             :   instruction_block->set_code_end(current_block_end);
     917             : 
     918    11461739 :   current_block_ = nullptr;
     919             : }
     920             : 
     921             : 
     922    11484970 : void InstructionSelector::VisitControl(BasicBlock* block) {
     923             : #ifdef DEBUG
     924             :   // SSA deconstruction requires targets of branches not to have phis.
     925             :   // Edge split form guarantees this property, but is more strict.
     926             :   if (block->SuccessorCount() > 1) {
     927             :     for (BasicBlock* const successor : block->successors()) {
     928             :       for (Node* const node : *successor) {
     929             :         // If this CHECK fails, you might have specified merged variables
     930             :         // for a label with only one predecessor.
     931             :         CHECK(!IrOpcode::IsPhiOpcode(node->opcode()));
     932             :       }
     933             :     }
     934             :   }
     935             : #endif
     936             : 
     937       16280 :   Node* input = block->control_input();
     938    11461838 :   switch (block->control()) {
     939             :     case BasicBlock::kGoto:
     940     5684860 :       return VisitGoto(block->SuccessorAt(0));
     941             :     case BasicBlock::kCall: {
     942             :       DCHECK_EQ(IrOpcode::kCall, input->opcode());
     943             :       BasicBlock* success = block->SuccessorAt(0);
     944             :       BasicBlock* exception = block->SuccessorAt(1);
     945      231390 :       return VisitCall(input, exception), VisitGoto(success);
     946             :     }
     947             :     case BasicBlock::kTailCall: {
     948             :       DCHECK_EQ(IrOpcode::kTailCall, input->opcode());
     949      149226 :       return VisitTailCall(input);
     950             :     }
     951             :     case BasicBlock::kBranch: {
     952             :       DCHECK_EQ(IrOpcode::kBranch, input->opcode());
     953             :       BasicBlock* tbranch = block->SuccessorAt(0);
     954             :       BasicBlock* fbranch = block->SuccessorAt(1);
     955     3308771 :       if (tbranch == fbranch) return VisitGoto(tbranch);
     956     3308771 :       return VisitBranch(input, tbranch, fbranch);
     957             :     }
     958             :     case BasicBlock::kSwitch: {
     959             :       DCHECK_EQ(IrOpcode::kSwitch, input->opcode());
     960             :       SwitchInfo sw;
     961             :       // Last successor must be Default.
     962       23132 :       sw.default_branch = block->successors().back();
     963             :       DCHECK_EQ(IrOpcode::kIfDefault, sw.default_branch->front()->opcode());
     964             :       // All other successors must be cases.
     965       23132 :       sw.case_count = block->SuccessorCount() - 1;
     966       23132 :       sw.case_branches = &block->successors().front();
     967             :       // Determine case values and their min/max.
     968       23132 :       sw.case_values = zone()->NewArray<int32_t>(sw.case_count);
     969       23132 :       sw.min_value = std::numeric_limits<int32_t>::max();
     970       23132 :       sw.max_value = std::numeric_limits<int32_t>::min();
     971      168280 :       for (size_t index = 0; index < sw.case_count; ++index) {
     972      145148 :         BasicBlock* branch = sw.case_branches[index];
     973      145148 :         int32_t value = OpParameter<int32_t>(branch->front()->op());
     974      145148 :         sw.case_values[index] = value;
     975      145148 :         if (sw.min_value > value) sw.min_value = value;
     976      145148 :         if (sw.max_value < value) sw.max_value = value;
     977             :       }
     978             :       DCHECK_LE(sw.min_value, sw.max_value);
     979             :       // Note that {value_range} can be 0 if {min_value} is -2^31 and
     980             :       // {max_value}
     981             :       // is 2^31-1, so don't assume that it's non-zero below.
     982       23132 :       sw.value_range = 1u + bit_cast<uint32_t>(sw.max_value) -
     983       23132 :                        bit_cast<uint32_t>(sw.min_value);
     984       23132 :       return VisitSwitch(input, sw);
     985             :     }
     986             :     case BasicBlock::kReturn: {
     987             :       DCHECK_EQ(IrOpcode::kReturn, input->opcode());
     988     1093942 :       return VisitReturn(input);
     989             :     }
     990             :     case BasicBlock::kDeoptimize: {
     991       16280 :       DeoptimizeParameters p = DeoptimizeParametersOf(input->op());
     992             :       Node* value = input->InputAt(0);
     993             :       return VisitDeoptimize(p.kind(), p.reason(), value);
     994             :     }
     995             :     case BasicBlock::kThrow:
     996             :       DCHECK_EQ(IrOpcode::kThrow, input->opcode());
     997             :       return VisitThrow(input);
     998             :     case BasicBlock::kNone: {
     999             :       // Exit block doesn't have control.
    1000             :       DCHECK_NULL(input);
    1001             :       break;
    1002             :     }
    1003             :     default:
    1004           0 :       UNREACHABLE();
    1005             :       break;
    1006             :   }
    1007             : }
    1008             : 
    1009           0 : void InstructionSelector::MarkPairProjectionsAsWord32(Node* node) {
    1010           0 :   Node* projection0 = NodeProperties::FindProjection(node, 0);
    1011           0 :   if (projection0) {
    1012             :     MarkAsWord32(projection0);
    1013             :   }
    1014           0 :   Node* projection1 = NodeProperties::FindProjection(node, 1);
    1015           0 :   if (projection1) {
    1016             :     MarkAsWord32(projection1);
    1017             :   }
    1018           0 : }
    1019             : 
    1020    27511722 : void InstructionSelector::VisitNode(Node* node) {
    1021             :   DCHECK_NOT_NULL(schedule()->block(node));  // should only use scheduled nodes.
    1022    25720672 :   switch (node->opcode()) {
    1023             :     case IrOpcode::kStart:
    1024             :     case IrOpcode::kLoop:
    1025             :     case IrOpcode::kEnd:
    1026             :     case IrOpcode::kBranch:
    1027             :     case IrOpcode::kIfTrue:
    1028             :     case IrOpcode::kIfFalse:
    1029             :     case IrOpcode::kIfSuccess:
    1030             :     case IrOpcode::kSwitch:
    1031             :     case IrOpcode::kIfValue:
    1032             :     case IrOpcode::kIfDefault:
    1033             :     case IrOpcode::kEffectPhi:
    1034             :     case IrOpcode::kMerge:
    1035             :     case IrOpcode::kTerminate:
    1036             :     case IrOpcode::kBeginRegion:
    1037             :       // No code needed for these graph artifacts.
    1038             :       return;
    1039             :     case IrOpcode::kIfException:
    1040      209287 :       return MarkAsReference(node), VisitIfException(node);
    1041             :     case IrOpcode::kFinishRegion:
    1042             :       return MarkAsReference(node), VisitFinishRegion(node);
    1043             :     case IrOpcode::kParameter: {
    1044             :       MachineType type =
    1045     3582130 :           linkage()->GetParameterType(ParameterIndexOf(node->op()));
    1046     1791086 :       MarkAsRepresentation(type.representation(), node);
    1047     1791092 :       return VisitParameter(node);
    1048             :     }
    1049             :     case IrOpcode::kOsrValue:
    1050       25895 :       return MarkAsReference(node), VisitOsrValue(node);
    1051             :     case IrOpcode::kPhi: {
    1052     1333566 :       MachineRepresentation rep = PhiRepresentationOf(node->op());
    1053     1333566 :       if (rep == MachineRepresentation::kNone) return;
    1054     1333569 :       MarkAsRepresentation(rep, node);
    1055     1333570 :       return VisitPhi(node);
    1056             :     }
    1057             :     case IrOpcode::kProjection:
    1058      330922 :       return VisitProjection(node);
    1059             :     case IrOpcode::kInt32Constant:
    1060             :     case IrOpcode::kInt64Constant:
    1061             :     case IrOpcode::kExternalConstant:
    1062             :     case IrOpcode::kRelocatableInt32Constant:
    1063             :     case IrOpcode::kRelocatableInt64Constant:
    1064     3659927 :       return VisitConstant(node);
    1065             :     case IrOpcode::kFloat32Constant:
    1066        8425 :       return MarkAsFloat32(node), VisitConstant(node);
    1067             :     case IrOpcode::kFloat64Constant:
    1068      238924 :       return MarkAsFloat64(node), VisitConstant(node);
    1069             :     case IrOpcode::kHeapConstant:
    1070     2915353 :       return MarkAsReference(node), VisitConstant(node);
    1071             :     case IrOpcode::kNumberConstant: {
    1072     2224509 :       double value = OpParameter<double>(node);
    1073     2224509 :       if (!IsSmiDouble(value)) MarkAsReference(node);
    1074     2224509 :       return VisitConstant(node);
    1075             :     }
    1076             :     case IrOpcode::kCall:
    1077     3169541 :       return VisitCall(node);
    1078             :     case IrOpcode::kDeoptimizeIf:
    1079       95921 :       return VisitDeoptimizeIf(node);
    1080             :     case IrOpcode::kDeoptimizeUnless:
    1081      170753 :       return VisitDeoptimizeUnless(node);
    1082             :     case IrOpcode::kTrapIf:
    1083             :       return VisitTrapIf(node, static_cast<Runtime::FunctionId>(
    1084         657 :                                    OpParameter<int32_t>(node->op())));
    1085             :     case IrOpcode::kTrapUnless:
    1086             :       return VisitTrapUnless(node, static_cast<Runtime::FunctionId>(
    1087       15640 :                                        OpParameter<int32_t>(node->op())));
    1088             :     case IrOpcode::kFrameState:
    1089             :     case IrOpcode::kStateValues:
    1090             :     case IrOpcode::kObjectState:
    1091             :       return;
    1092             :     case IrOpcode::kDebugBreak:
    1093             :       VisitDebugBreak(node);
    1094             :       return;
    1095             :     case IrOpcode::kComment:
    1096           0 :       VisitComment(node);
    1097           0 :       return;
    1098             :     case IrOpcode::kRetain:
    1099        6514 :       VisitRetain(node);
    1100        6514 :       return;
    1101             :     case IrOpcode::kLoad: {
    1102     2777328 :       LoadRepresentation type = LoadRepresentationOf(node->op());
    1103     2777329 :       MarkAsRepresentation(type.representation(), node);
    1104     2777331 :       return VisitLoad(node);
    1105             :     }
    1106             :     case IrOpcode::kStore:
    1107     2334400 :       return VisitStore(node);
    1108             :     case IrOpcode::kProtectedStore:
    1109         180 :       return VisitProtectedStore(node);
    1110             :     case IrOpcode::kWord32And:
    1111       84560 :       return MarkAsWord32(node), VisitWord32And(node);
    1112             :     case IrOpcode::kWord32Or:
    1113       13949 :       return MarkAsWord32(node), VisitWord32Or(node);
    1114             :     case IrOpcode::kWord32Xor:
    1115       13814 :       return MarkAsWord32(node), VisitWord32Xor(node);
    1116             :     case IrOpcode::kWord32Shl:
    1117       12367 :       return MarkAsWord32(node), VisitWord32Shl(node);
    1118             :     case IrOpcode::kWord32Shr:
    1119       35862 :       return MarkAsWord32(node), VisitWord32Shr(node);
    1120             :     case IrOpcode::kWord32Sar:
    1121       13542 :       return MarkAsWord32(node), VisitWord32Sar(node);
    1122             :     case IrOpcode::kWord32Ror:
    1123         933 :       return MarkAsWord32(node), VisitWord32Ror(node);
    1124             :     case IrOpcode::kWord32Equal:
    1125       36265 :       return VisitWord32Equal(node);
    1126             :     case IrOpcode::kWord32Clz:
    1127         849 :       return MarkAsWord32(node), VisitWord32Clz(node);
    1128             :     case IrOpcode::kWord32Ctz:
    1129         468 :       return MarkAsWord32(node), VisitWord32Ctz(node);
    1130             :     case IrOpcode::kWord32ReverseBits:
    1131           0 :       return MarkAsWord32(node), VisitWord32ReverseBits(node);
    1132             :     case IrOpcode::kWord32ReverseBytes:
    1133           0 :       return MarkAsWord32(node), VisitWord32ReverseBytes(node);
    1134             :     case IrOpcode::kInt32AbsWithOverflow:
    1135           0 :       return MarkAsWord32(node), VisitInt32AbsWithOverflow(node);
    1136             :     case IrOpcode::kWord32Popcnt:
    1137          98 :       return MarkAsWord32(node), VisitWord32Popcnt(node);
    1138             :     case IrOpcode::kWord64Popcnt:
    1139          35 :       return MarkAsWord32(node), VisitWord64Popcnt(node);
    1140             :     case IrOpcode::kWord64And:
    1141      139328 :       return MarkAsWord64(node), VisitWord64And(node);
    1142             :     case IrOpcode::kWord64Or:
    1143       17920 :       return MarkAsWord64(node), VisitWord64Or(node);
    1144             :     case IrOpcode::kWord64Xor:
    1145         454 :       return MarkAsWord64(node), VisitWord64Xor(node);
    1146             :     case IrOpcode::kWord64Shl:
    1147      282571 :       return MarkAsWord64(node), VisitWord64Shl(node);
    1148             :     case IrOpcode::kWord64Shr:
    1149       98915 :       return MarkAsWord64(node), VisitWord64Shr(node);
    1150             :     case IrOpcode::kWord64Sar:
    1151       46646 :       return MarkAsWord64(node), VisitWord64Sar(node);
    1152             :     case IrOpcode::kWord64Ror:
    1153          70 :       return MarkAsWord64(node), VisitWord64Ror(node);
    1154             :     case IrOpcode::kWord64Clz:
    1155          28 :       return MarkAsWord64(node), VisitWord64Clz(node);
    1156             :     case IrOpcode::kWord64Ctz:
    1157          13 :       return MarkAsWord64(node), VisitWord64Ctz(node);
    1158             :     case IrOpcode::kWord64ReverseBits:
    1159           0 :       return MarkAsWord64(node), VisitWord64ReverseBits(node);
    1160             :     case IrOpcode::kWord64ReverseBytes:
    1161           0 :       return MarkAsWord64(node), VisitWord64ReverseBytes(node);
    1162             :     case IrOpcode::kInt64AbsWithOverflow:
    1163           0 :       return MarkAsWord64(node), VisitInt64AbsWithOverflow(node);
    1164             :     case IrOpcode::kWord64Equal:
    1165       27433 :       return VisitWord64Equal(node);
    1166             :     case IrOpcode::kInt32Add:
    1167      193755 :       return MarkAsWord32(node), VisitInt32Add(node);
    1168             :     case IrOpcode::kInt32AddWithOverflow:
    1169       18150 :       return MarkAsWord32(node), VisitInt32AddWithOverflow(node);
    1170             :     case IrOpcode::kInt32Sub:
    1171       28279 :       return MarkAsWord32(node), VisitInt32Sub(node);
    1172             :     case IrOpcode::kInt32SubWithOverflow:
    1173       18150 :       return VisitInt32SubWithOverflow(node);
    1174             :     case IrOpcode::kInt32Mul:
    1175       35249 :       return MarkAsWord32(node), VisitInt32Mul(node);
    1176             :     case IrOpcode::kInt32MulWithOverflow:
    1177       18150 :       return MarkAsWord32(node), VisitInt32MulWithOverflow(node);
    1178             :     case IrOpcode::kInt32MulHigh:
    1179        5418 :       return VisitInt32MulHigh(node);
    1180             :     case IrOpcode::kInt32Div:
    1181        1016 :       return MarkAsWord32(node), VisitInt32Div(node);
    1182             :     case IrOpcode::kInt32Mod:
    1183        1748 :       return MarkAsWord32(node), VisitInt32Mod(node);
    1184             :     case IrOpcode::kInt32LessThan:
    1185        1827 :       return VisitInt32LessThan(node);
    1186             :     case IrOpcode::kInt32LessThanOrEqual:
    1187        1199 :       return VisitInt32LessThanOrEqual(node);
    1188             :     case IrOpcode::kUint32Div:
    1189         558 :       return MarkAsWord32(node), VisitUint32Div(node);
    1190             :     case IrOpcode::kUint32LessThan:
    1191        2506 :       return VisitUint32LessThan(node);
    1192             :     case IrOpcode::kUint32LessThanOrEqual:
    1193        3734 :       return VisitUint32LessThanOrEqual(node);
    1194             :     case IrOpcode::kUint32Mod:
    1195         530 :       return MarkAsWord32(node), VisitUint32Mod(node);
    1196             :     case IrOpcode::kUint32MulHigh:
    1197         857 :       return VisitUint32MulHigh(node);
    1198             :     case IrOpcode::kInt64Add:
    1199     1018442 :       return MarkAsWord64(node), VisitInt64Add(node);
    1200             :     case IrOpcode::kInt64AddWithOverflow:
    1201       36504 :       return MarkAsWord64(node), VisitInt64AddWithOverflow(node);
    1202             :     case IrOpcode::kInt64Sub:
    1203       28926 :       return MarkAsWord64(node), VisitInt64Sub(node);
    1204             :     case IrOpcode::kInt64SubWithOverflow:
    1205       36504 :       return MarkAsWord64(node), VisitInt64SubWithOverflow(node);
    1206             :     case IrOpcode::kInt64Mul:
    1207        4157 :       return MarkAsWord64(node), VisitInt64Mul(node);
    1208             :     case IrOpcode::kInt64Div:
    1209         482 :       return MarkAsWord64(node), VisitInt64Div(node);
    1210             :     case IrOpcode::kInt64Mod:
    1211         412 :       return MarkAsWord64(node), VisitInt64Mod(node);
    1212             :     case IrOpcode::kInt64LessThan:
    1213         577 :       return VisitInt64LessThan(node);
    1214             :     case IrOpcode::kInt64LessThanOrEqual:
    1215         533 :       return VisitInt64LessThanOrEqual(node);
    1216             :     case IrOpcode::kUint64Div:
    1217         412 :       return MarkAsWord64(node), VisitUint64Div(node);
    1218             :     case IrOpcode::kUint64LessThan:
    1219         427 :       return VisitUint64LessThan(node);
    1220             :     case IrOpcode::kUint64LessThanOrEqual:
    1221         426 :       return VisitUint64LessThanOrEqual(node);
    1222             :     case IrOpcode::kUint64Mod:
    1223         412 :       return MarkAsWord64(node), VisitUint64Mod(node);
    1224             :     case IrOpcode::kBitcastTaggedToWord:
    1225           0 :       return MarkAsRepresentation(MachineType::PointerRepresentation(), node),
    1226             :              VisitBitcastTaggedToWord(node);
    1227             :     case IrOpcode::kBitcastWordToTagged:
    1228      239211 :       return MarkAsReference(node), VisitBitcastWordToTagged(node);
    1229             :     case IrOpcode::kBitcastWordToTaggedSigned:
    1230           0 :       return MarkAsRepresentation(MachineRepresentation::kTaggedSigned, node),
    1231           0 :              EmitIdentity(node);
    1232             :     case IrOpcode::kChangeFloat32ToFloat64:
    1233       11259 :       return MarkAsFloat64(node), VisitChangeFloat32ToFloat64(node);
    1234             :     case IrOpcode::kChangeInt32ToFloat64:
    1235      249969 :       return MarkAsFloat64(node), VisitChangeInt32ToFloat64(node);
    1236             :     case IrOpcode::kChangeUint32ToFloat64:
    1237        2002 :       return MarkAsFloat64(node), VisitChangeUint32ToFloat64(node);
    1238             :     case IrOpcode::kChangeFloat64ToInt32:
    1239        6689 :       return MarkAsWord32(node), VisitChangeFloat64ToInt32(node);
    1240             :     case IrOpcode::kChangeFloat64ToUint32:
    1241         421 :       return MarkAsWord32(node), VisitChangeFloat64ToUint32(node);
    1242             :     case IrOpcode::kChangeFloat64ToUint64:
    1243         129 :       return MarkAsWord64(node), VisitChangeFloat64ToUint64(node);
    1244             :     case IrOpcode::kFloat64SilenceNaN:
    1245             :       MarkAsFloat64(node);
    1246        2007 :       if (CanProduceSignalingNaN(node->InputAt(0))) {
    1247        1765 :         return VisitFloat64SilenceNaN(node);
    1248             :       } else {
    1249         242 :         return EmitIdentity(node);
    1250             :       }
    1251             :     case IrOpcode::kTruncateFloat64ToUint32:
    1252           7 :       return MarkAsWord32(node), VisitTruncateFloat64ToUint32(node);
    1253             :     case IrOpcode::kTruncateFloat32ToInt32:
    1254         132 :       return MarkAsWord32(node), VisitTruncateFloat32ToInt32(node);
    1255             :     case IrOpcode::kTruncateFloat32ToUint32:
    1256          13 :       return MarkAsWord32(node), VisitTruncateFloat32ToUint32(node);
    1257             :     case IrOpcode::kTryTruncateFloat32ToInt64:
    1258          26 :       return MarkAsWord64(node), VisitTryTruncateFloat32ToInt64(node);
    1259             :     case IrOpcode::kTryTruncateFloat64ToInt64:
    1260          49 :       return MarkAsWord64(node), VisitTryTruncateFloat64ToInt64(node);
    1261             :     case IrOpcode::kTryTruncateFloat32ToUint64:
    1262          26 :       return MarkAsWord64(node), VisitTryTruncateFloat32ToUint64(node);
    1263             :     case IrOpcode::kTryTruncateFloat64ToUint64:
    1264          26 :       return MarkAsWord64(node), VisitTryTruncateFloat64ToUint64(node);
    1265             :     case IrOpcode::kChangeInt32ToInt64:
    1266       66903 :       return MarkAsWord64(node), VisitChangeInt32ToInt64(node);
    1267             :     case IrOpcode::kChangeUint32ToUint64:
    1268       78216 :       return MarkAsWord64(node), VisitChangeUint32ToUint64(node);
    1269             :     case IrOpcode::kTruncateFloat64ToFloat32:
    1270        8039 :       return MarkAsFloat32(node), VisitTruncateFloat64ToFloat32(node);
    1271             :     case IrOpcode::kTruncateFloat64ToWord32:
    1272       70367 :       return MarkAsWord32(node), VisitTruncateFloat64ToWord32(node);
    1273             :     case IrOpcode::kTruncateInt64ToInt32:
    1274      279134 :       return MarkAsWord32(node), VisitTruncateInt64ToInt32(node);
    1275             :     case IrOpcode::kRoundFloat64ToInt32:
    1276       76349 :       return MarkAsWord32(node), VisitRoundFloat64ToInt32(node);
    1277             :     case IrOpcode::kRoundInt64ToFloat32:
    1278          13 :       return MarkAsFloat32(node), VisitRoundInt64ToFloat32(node);
    1279             :     case IrOpcode::kRoundInt32ToFloat32:
    1280         309 :       return MarkAsFloat32(node), VisitRoundInt32ToFloat32(node);
    1281             :     case IrOpcode::kRoundInt64ToFloat64:
    1282         759 :       return MarkAsFloat64(node), VisitRoundInt64ToFloat64(node);
    1283             :     case IrOpcode::kBitcastFloat32ToInt32:
    1284         114 :       return MarkAsWord32(node), VisitBitcastFloat32ToInt32(node);
    1285             :     case IrOpcode::kRoundUint32ToFloat32:
    1286          37 :       return MarkAsFloat32(node), VisitRoundUint32ToFloat32(node);
    1287             :     case IrOpcode::kRoundUint64ToFloat32:
    1288          13 :       return MarkAsFloat64(node), VisitRoundUint64ToFloat32(node);
    1289             :     case IrOpcode::kRoundUint64ToFloat64:
    1290          13 :       return MarkAsFloat64(node), VisitRoundUint64ToFloat64(node);
    1291             :     case IrOpcode::kBitcastFloat64ToInt64:
    1292         257 :       return MarkAsWord64(node), VisitBitcastFloat64ToInt64(node);
    1293             :     case IrOpcode::kBitcastInt32ToFloat32:
    1294          52 :       return MarkAsFloat32(node), VisitBitcastInt32ToFloat32(node);
    1295             :     case IrOpcode::kBitcastInt64ToFloat64:
    1296         131 :       return MarkAsFloat64(node), VisitBitcastInt64ToFloat64(node);
    1297             :     case IrOpcode::kFloat32Add:
    1298         118 :       return MarkAsFloat32(node), VisitFloat32Add(node);
    1299             :     case IrOpcode::kFloat32Sub:
    1300        1456 :       return MarkAsFloat32(node), VisitFloat32Sub(node);
    1301             :     case IrOpcode::kFloat32Neg:
    1302          28 :       return MarkAsFloat32(node), VisitFloat32Neg(node);
    1303             :     case IrOpcode::kFloat32Mul:
    1304          47 :       return MarkAsFloat32(node), VisitFloat32Mul(node);
    1305             :     case IrOpcode::kFloat32Div:
    1306          44 :       return MarkAsFloat32(node), VisitFloat32Div(node);
    1307             :     case IrOpcode::kFloat32Abs:
    1308          52 :       return MarkAsFloat32(node), VisitFloat32Abs(node);
    1309             :     case IrOpcode::kFloat32Sqrt:
    1310          30 :       return MarkAsFloat32(node), VisitFloat32Sqrt(node);
    1311             :     case IrOpcode::kFloat32Equal:
    1312         121 :       return VisitFloat32Equal(node);
    1313             :     case IrOpcode::kFloat32LessThan:
    1314          59 :       return VisitFloat32LessThan(node);
    1315             :     case IrOpcode::kFloat32LessThanOrEqual:
    1316          49 :       return VisitFloat32LessThanOrEqual(node);
    1317             :     case IrOpcode::kFloat32Max:
    1318          29 :       return MarkAsFloat32(node), VisitFloat32Max(node);
    1319             :     case IrOpcode::kFloat32Min:
    1320          29 :       return MarkAsFloat32(node), VisitFloat32Min(node);
    1321             :     case IrOpcode::kFloat64Add:
    1322       54725 :       return MarkAsFloat64(node), VisitFloat64Add(node);
    1323             :     case IrOpcode::kFloat64Sub:
    1324       25324 :       return MarkAsFloat64(node), VisitFloat64Sub(node);
    1325             :     case IrOpcode::kFloat64Neg:
    1326        9815 :       return MarkAsFloat64(node), VisitFloat64Neg(node);
    1327             :     case IrOpcode::kFloat64Mul:
    1328       15570 :       return MarkAsFloat64(node), VisitFloat64Mul(node);
    1329             :     case IrOpcode::kFloat64Div:
    1330       12521 :       return MarkAsFloat64(node), VisitFloat64Div(node);
    1331             :     case IrOpcode::kFloat64Mod:
    1332        1022 :       return MarkAsFloat64(node), VisitFloat64Mod(node);
    1333             :     case IrOpcode::kFloat64Min:
    1334         153 :       return MarkAsFloat64(node), VisitFloat64Min(node);
    1335             :     case IrOpcode::kFloat64Max:
    1336          97 :       return MarkAsFloat64(node), VisitFloat64Max(node);
    1337             :     case IrOpcode::kFloat64Abs:
    1338         245 :       return MarkAsFloat64(node), VisitFloat64Abs(node);
    1339             :     case IrOpcode::kFloat64Acos:
    1340             :       return MarkAsFloat64(node), VisitFloat64Acos(node);
    1341             :     case IrOpcode::kFloat64Acosh:
    1342             :       return MarkAsFloat64(node), VisitFloat64Acosh(node);
    1343             :     case IrOpcode::kFloat64Asin:
    1344             :       return MarkAsFloat64(node), VisitFloat64Asin(node);
    1345             :     case IrOpcode::kFloat64Asinh:
    1346             :       return MarkAsFloat64(node), VisitFloat64Asinh(node);
    1347             :     case IrOpcode::kFloat64Atan:
    1348             :       return MarkAsFloat64(node), VisitFloat64Atan(node);
    1349             :     case IrOpcode::kFloat64Atanh:
    1350             :       return MarkAsFloat64(node), VisitFloat64Atanh(node);
    1351             :     case IrOpcode::kFloat64Atan2:
    1352             :       return MarkAsFloat64(node), VisitFloat64Atan2(node);
    1353             :     case IrOpcode::kFloat64Cbrt:
    1354             :       return MarkAsFloat64(node), VisitFloat64Cbrt(node);
    1355             :     case IrOpcode::kFloat64Cos:
    1356             :       return MarkAsFloat64(node), VisitFloat64Cos(node);
    1357             :     case IrOpcode::kFloat64Cosh:
    1358             :       return MarkAsFloat64(node), VisitFloat64Cosh(node);
    1359             :     case IrOpcode::kFloat64Exp:
    1360             :       return MarkAsFloat64(node), VisitFloat64Exp(node);
    1361             :     case IrOpcode::kFloat64Expm1:
    1362             :       return MarkAsFloat64(node), VisitFloat64Expm1(node);
    1363             :     case IrOpcode::kFloat64Log:
    1364             :       return MarkAsFloat64(node), VisitFloat64Log(node);
    1365             :     case IrOpcode::kFloat64Log1p:
    1366             :       return MarkAsFloat64(node), VisitFloat64Log1p(node);
    1367             :     case IrOpcode::kFloat64Log10:
    1368             :       return MarkAsFloat64(node), VisitFloat64Log10(node);
    1369             :     case IrOpcode::kFloat64Log2:
    1370             :       return MarkAsFloat64(node), VisitFloat64Log2(node);
    1371             :     case IrOpcode::kFloat64Pow:
    1372             :       return MarkAsFloat64(node), VisitFloat64Pow(node);
    1373             :     case IrOpcode::kFloat64Sin:
    1374             :       return MarkAsFloat64(node), VisitFloat64Sin(node);
    1375             :     case IrOpcode::kFloat64Sinh:
    1376             :       return MarkAsFloat64(node), VisitFloat64Sinh(node);
    1377             :     case IrOpcode::kFloat64Sqrt:
    1378         258 :       return MarkAsFloat64(node), VisitFloat64Sqrt(node);
    1379             :     case IrOpcode::kFloat64Tan:
    1380             :       return MarkAsFloat64(node), VisitFloat64Tan(node);
    1381             :     case IrOpcode::kFloat64Tanh:
    1382             :       return MarkAsFloat64(node), VisitFloat64Tanh(node);
    1383             :     case IrOpcode::kFloat64Equal:
    1384        5913 :       return VisitFloat64Equal(node);
    1385             :     case IrOpcode::kFloat64LessThan:
    1386        7359 :       return VisitFloat64LessThan(node);
    1387             :     case IrOpcode::kFloat64LessThanOrEqual:
    1388        1445 :       return VisitFloat64LessThanOrEqual(node);
    1389             :     case IrOpcode::kFloat32RoundDown:
    1390          40 :       return MarkAsFloat32(node), VisitFloat32RoundDown(node);
    1391             :     case IrOpcode::kFloat64RoundDown:
    1392        9016 :       return MarkAsFloat64(node), VisitFloat64RoundDown(node);
    1393             :     case IrOpcode::kFloat32RoundUp:
    1394          40 :       return MarkAsFloat32(node), VisitFloat32RoundUp(node);
    1395             :     case IrOpcode::kFloat64RoundUp:
    1396        5897 :       return MarkAsFloat64(node), VisitFloat64RoundUp(node);
    1397             :     case IrOpcode::kFloat32RoundTruncate:
    1398         146 :       return MarkAsFloat32(node), VisitFloat32RoundTruncate(node);
    1399             :     case IrOpcode::kFloat64RoundTruncate:
    1400        3147 :       return MarkAsFloat64(node), VisitFloat64RoundTruncate(node);
    1401             :     case IrOpcode::kFloat64RoundTiesAway:
    1402           0 :       return MarkAsFloat64(node), VisitFloat64RoundTiesAway(node);
    1403             :     case IrOpcode::kFloat32RoundTiesEven:
    1404          13 :       return MarkAsFloat32(node), VisitFloat32RoundTiesEven(node);
    1405             :     case IrOpcode::kFloat64RoundTiesEven:
    1406         436 :       return MarkAsFloat64(node), VisitFloat64RoundTiesEven(node);
    1407             :     case IrOpcode::kFloat64ExtractLowWord32:
    1408           6 :       return MarkAsWord32(node), VisitFloat64ExtractLowWord32(node);
    1409             :     case IrOpcode::kFloat64ExtractHighWord32:
    1410       44203 :       return MarkAsWord32(node), VisitFloat64ExtractHighWord32(node);
    1411             :     case IrOpcode::kFloat64InsertLowWord32:
    1412           6 :       return MarkAsFloat64(node), VisitFloat64InsertLowWord32(node);
    1413             :     case IrOpcode::kFloat64InsertHighWord32:
    1414           6 :       return MarkAsFloat64(node), VisitFloat64InsertHighWord32(node);
    1415             :     case IrOpcode::kStackSlot:
    1416        1418 :       return VisitStackSlot(node);
    1417             :     case IrOpcode::kLoadStackPointer:
    1418          43 :       return VisitLoadStackPointer(node);
    1419             :     case IrOpcode::kLoadFramePointer:
    1420        4808 :       return VisitLoadFramePointer(node);
    1421             :     case IrOpcode::kLoadParentFramePointer:
    1422       53041 :       return VisitLoadParentFramePointer(node);
    1423             :     case IrOpcode::kUnalignedLoad: {
    1424             :       UnalignedLoadRepresentation type =
    1425           0 :           UnalignedLoadRepresentationOf(node->op());
    1426           0 :       MarkAsRepresentation(type.representation(), node);
    1427           0 :       return VisitUnalignedLoad(node);
    1428             :     }
    1429             :     case IrOpcode::kUnalignedStore:
    1430           0 :       return VisitUnalignedStore(node);
    1431             :     case IrOpcode::kCheckedLoad: {
    1432             :       MachineRepresentation rep =
    1433       74190 :           CheckedLoadRepresentationOf(node->op()).representation();
    1434       74190 :       MarkAsRepresentation(rep, node);
    1435       74190 :       return VisitCheckedLoad(node);
    1436             :     }
    1437             :     case IrOpcode::kCheckedStore:
    1438       53151 :       return VisitCheckedStore(node);
    1439             :     case IrOpcode::kInt32PairAdd:
    1440             :       MarkAsWord32(node);
    1441           0 :       MarkPairProjectionsAsWord32(node);
    1442           0 :       return VisitInt32PairAdd(node);
    1443             :     case IrOpcode::kInt32PairSub:
    1444             :       MarkAsWord32(node);
    1445           0 :       MarkPairProjectionsAsWord32(node);
    1446           0 :       return VisitInt32PairSub(node);
    1447             :     case IrOpcode::kInt32PairMul:
    1448             :       MarkAsWord32(node);
    1449           0 :       MarkPairProjectionsAsWord32(node);
    1450           0 :       return VisitInt32PairMul(node);
    1451             :     case IrOpcode::kWord32PairShl:
    1452             :       MarkAsWord32(node);
    1453           0 :       MarkPairProjectionsAsWord32(node);
    1454           0 :       return VisitWord32PairShl(node);
    1455             :     case IrOpcode::kWord32PairShr:
    1456             :       MarkAsWord32(node);
    1457           0 :       MarkPairProjectionsAsWord32(node);
    1458           0 :       return VisitWord32PairShr(node);
    1459             :     case IrOpcode::kWord32PairSar:
    1460             :       MarkAsWord32(node);
    1461           0 :       MarkPairProjectionsAsWord32(node);
    1462           0 :       return VisitWord32PairSar(node);
    1463             :     case IrOpcode::kAtomicLoad: {
    1464         258 :       LoadRepresentation type = LoadRepresentationOf(node->op());
    1465         258 :       MarkAsRepresentation(type.representation(), node);
    1466         258 :       return VisitAtomicLoad(node);
    1467             :     }
    1468             :     case IrOpcode::kAtomicStore:
    1469         129 :       return VisitAtomicStore(node);
    1470             : #define ATOMIC_CASE(name)                                    \
    1471             :   case IrOpcode::kAtomic##name: {                            \
    1472             :     MachineType type = AtomicOpRepresentationOf(node->op()); \
    1473             :     MarkAsRepresentation(type.representation(), node);       \
    1474             :     return VisitAtomic##name(node);                          \
    1475             :   }
    1476         258 :       ATOMIC_CASE(Exchange)
    1477         258 :       ATOMIC_CASE(CompareExchange)
    1478         258 :       ATOMIC_CASE(Add)
    1479         258 :       ATOMIC_CASE(Sub)
    1480         258 :       ATOMIC_CASE(And)
    1481         258 :       ATOMIC_CASE(Or)
    1482         258 :       ATOMIC_CASE(Xor)
    1483             : #undef ATOMIC_CASE
    1484             :     case IrOpcode::kProtectedLoad: {
    1485        1470 :       LoadRepresentation type = LoadRepresentationOf(node->op());
    1486        1470 :       MarkAsRepresentation(type.representation(), node);
    1487        1470 :       return VisitProtectedLoad(node);
    1488             :     }
    1489             :     case IrOpcode::kUnsafePointerAdd:
    1490        3661 :       MarkAsRepresentation(MachineType::PointerRepresentation(), node);
    1491             :       return VisitUnsafePointerAdd(node);
    1492             :     case IrOpcode::kF32x4Splat:
    1493           0 :       return MarkAsSimd128(node), VisitF32x4Splat(node);
    1494             :     case IrOpcode::kF32x4ExtractLane:
    1495           0 :       return MarkAsFloat32(node), VisitF32x4ExtractLane(node);
    1496             :     case IrOpcode::kF32x4ReplaceLane:
    1497           0 :       return MarkAsSimd128(node), VisitF32x4ReplaceLane(node);
    1498             :     case IrOpcode::kF32x4SConvertI32x4:
    1499           0 :       return MarkAsSimd128(node), VisitF32x4SConvertI32x4(node);
    1500             :     case IrOpcode::kF32x4UConvertI32x4:
    1501           0 :       return MarkAsSimd128(node), VisitF32x4UConvertI32x4(node);
    1502             :     case IrOpcode::kF32x4Abs:
    1503           0 :       return MarkAsSimd128(node), VisitF32x4Abs(node);
    1504             :     case IrOpcode::kF32x4Neg:
    1505           0 :       return MarkAsSimd128(node), VisitF32x4Neg(node);
    1506             :     case IrOpcode::kF32x4RecipApprox:
    1507           0 :       return MarkAsSimd128(node), VisitF32x4RecipApprox(node);
    1508             :     case IrOpcode::kF32x4RecipSqrtApprox:
    1509           0 :       return MarkAsSimd128(node), VisitF32x4RecipSqrtApprox(node);
    1510             :     case IrOpcode::kF32x4Add:
    1511           0 :       return MarkAsSimd128(node), VisitF32x4Add(node);
    1512             :     case IrOpcode::kF32x4AddHoriz:
    1513           0 :       return MarkAsSimd128(node), VisitF32x4AddHoriz(node);
    1514             :     case IrOpcode::kF32x4Sub:
    1515           0 :       return MarkAsSimd128(node), VisitF32x4Sub(node);
    1516             :     case IrOpcode::kF32x4Mul:
    1517           0 :       return MarkAsSimd128(node), VisitF32x4Mul(node);
    1518             :     case IrOpcode::kF32x4Min:
    1519           0 :       return MarkAsSimd128(node), VisitF32x4Min(node);
    1520             :     case IrOpcode::kF32x4Max:
    1521           0 :       return MarkAsSimd128(node), VisitF32x4Max(node);
    1522             :     case IrOpcode::kF32x4Eq:
    1523           0 :       return MarkAsSimd1x4(node), VisitF32x4Eq(node);
    1524             :     case IrOpcode::kF32x4Ne:
    1525           0 :       return MarkAsSimd1x4(node), VisitF32x4Ne(node);
    1526             :     case IrOpcode::kF32x4Lt:
    1527           0 :       return MarkAsSimd1x4(node), VisitF32x4Lt(node);
    1528             :     case IrOpcode::kF32x4Le:
    1529           0 :       return MarkAsSimd1x4(node), VisitF32x4Le(node);
    1530             :     case IrOpcode::kI32x4Splat:
    1531         210 :       return MarkAsSimd128(node), VisitI32x4Splat(node);
    1532             :     case IrOpcode::kI32x4ExtractLane:
    1533         504 :       return MarkAsWord32(node), VisitI32x4ExtractLane(node);
    1534             :     case IrOpcode::kI32x4ReplaceLane:
    1535          42 :       return MarkAsSimd128(node), VisitI32x4ReplaceLane(node);
    1536             :     case IrOpcode::kI32x4SConvertF32x4:
    1537           0 :       return MarkAsSimd128(node), VisitI32x4SConvertF32x4(node);
    1538             :     case IrOpcode::kI32x4SConvertI16x8Low:
    1539           0 :       return MarkAsSimd128(node), VisitI32x4SConvertI16x8Low(node);
    1540             :     case IrOpcode::kI32x4SConvertI16x8High:
    1541           0 :       return MarkAsSimd128(node), VisitI32x4SConvertI16x8High(node);
    1542             :     case IrOpcode::kI32x4Neg:
    1543           0 :       return MarkAsSimd128(node), VisitI32x4Neg(node);
    1544             :     case IrOpcode::kI32x4Shl:
    1545           7 :       return MarkAsSimd128(node), VisitI32x4Shl(node);
    1546             :     case IrOpcode::kI32x4ShrS:
    1547           7 :       return MarkAsSimd128(node), VisitI32x4ShrS(node);
    1548             :     case IrOpcode::kI32x4Add:
    1549           7 :       return MarkAsSimd128(node), VisitI32x4Add(node);
    1550             :     case IrOpcode::kI32x4AddHoriz:
    1551           0 :       return MarkAsSimd128(node), VisitI32x4AddHoriz(node);
    1552             :     case IrOpcode::kI32x4Sub:
    1553           7 :       return MarkAsSimd128(node), VisitI32x4Sub(node);
    1554             :     case IrOpcode::kI32x4Mul:
    1555           7 :       return MarkAsSimd128(node), VisitI32x4Mul(node);
    1556             :     case IrOpcode::kI32x4MinS:
    1557           7 :       return MarkAsSimd128(node), VisitI32x4MinS(node);
    1558             :     case IrOpcode::kI32x4MaxS:
    1559           7 :       return MarkAsSimd128(node), VisitI32x4MaxS(node);
    1560             :     case IrOpcode::kI32x4Eq:
    1561           7 :       return MarkAsSimd1x4(node), VisitI32x4Eq(node);
    1562             :     case IrOpcode::kI32x4Ne:
    1563          14 :       return MarkAsSimd1x4(node), VisitI32x4Ne(node);
    1564             :     case IrOpcode::kI32x4LtS:
    1565           0 :       return MarkAsSimd1x4(node), VisitI32x4LtS(node);
    1566             :     case IrOpcode::kI32x4LeS:
    1567           0 :       return MarkAsSimd1x4(node), VisitI32x4LeS(node);
    1568             :     case IrOpcode::kI32x4UConvertF32x4:
    1569           0 :       return MarkAsSimd128(node), VisitI32x4UConvertF32x4(node);
    1570             :     case IrOpcode::kI32x4UConvertI16x8Low:
    1571           0 :       return MarkAsSimd128(node), VisitI32x4UConvertI16x8Low(node);
    1572             :     case IrOpcode::kI32x4UConvertI16x8High:
    1573           0 :       return MarkAsSimd128(node), VisitI32x4UConvertI16x8High(node);
    1574             :     case IrOpcode::kI32x4ShrU:
    1575           7 :       return MarkAsSimd128(node), VisitI32x4ShrU(node);
    1576             :     case IrOpcode::kI32x4MinU:
    1577           7 :       return MarkAsSimd128(node), VisitI32x4MinU(node);
    1578             :     case IrOpcode::kI32x4MaxU:
    1579           7 :       return MarkAsSimd128(node), VisitI32x4MaxU(node);
    1580             :     case IrOpcode::kI32x4LtU:
    1581           0 :       return MarkAsSimd1x4(node), VisitI32x4LtU(node);
    1582             :     case IrOpcode::kI32x4LeU:
    1583           0 :       return MarkAsSimd1x4(node), VisitI32x4LeU(node);
    1584             :     case IrOpcode::kI16x8Splat:
    1585         266 :       return MarkAsSimd128(node), VisitI16x8Splat(node);
    1586             :     case IrOpcode::kI16x8ExtractLane:
    1587        1428 :       return MarkAsWord32(node), VisitI16x8ExtractLane(node);
    1588             :     case IrOpcode::kI16x8ReplaceLane:
    1589          70 :       return MarkAsSimd128(node), VisitI16x8ReplaceLane(node);
    1590             :     case IrOpcode::kI16x8SConvertI8x16Low:
    1591           0 :       return MarkAsSimd128(node), VisitI16x8SConvertI8x16Low(node);
    1592             :     case IrOpcode::kI16x8SConvertI8x16High:
    1593           0 :       return MarkAsSimd128(node), VisitI16x8SConvertI8x16High(node);
    1594             :     case IrOpcode::kI16x8Neg:
    1595           0 :       return MarkAsSimd128(node), VisitI16x8Neg(node);
    1596             :     case IrOpcode::kI16x8Shl:
    1597           7 :       return MarkAsSimd128(node), VisitI16x8Shl(node);
    1598             :     case IrOpcode::kI16x8ShrS:
    1599           7 :       return MarkAsSimd128(node), VisitI16x8ShrS(node);
    1600             :     case IrOpcode::kI16x8SConvertI32x4:
    1601           0 :       return MarkAsSimd128(node), VisitI16x8SConvertI32x4(node);
    1602             :     case IrOpcode::kI16x8Add:
    1603           7 :       return MarkAsSimd128(node), VisitI16x8Add(node);
    1604             :     case IrOpcode::kI16x8AddSaturateS:
    1605           7 :       return MarkAsSimd128(node), VisitI16x8AddSaturateS(node);
    1606             :     case IrOpcode::kI16x8AddHoriz:
    1607           0 :       return MarkAsSimd128(node), VisitI16x8AddHoriz(node);
    1608             :     case IrOpcode::kI16x8Sub:
    1609           7 :       return MarkAsSimd128(node), VisitI16x8Sub(node);
    1610             :     case IrOpcode::kI16x8SubSaturateS:
    1611           7 :       return MarkAsSimd128(node), VisitI16x8SubSaturateS(node);
    1612             :     case IrOpcode::kI16x8Mul:
    1613           7 :       return MarkAsSimd128(node), VisitI16x8Mul(node);
    1614             :     case IrOpcode::kI16x8MinS:
    1615           7 :       return MarkAsSimd128(node), VisitI16x8MinS(node);
    1616             :     case IrOpcode::kI16x8MaxS:
    1617           7 :       return MarkAsSimd128(node), VisitI16x8MaxS(node);
    1618             :     case IrOpcode::kI16x8Eq:
    1619           7 :       return MarkAsSimd1x8(node), VisitI16x8Eq(node);
    1620             :     case IrOpcode::kI16x8Ne:
    1621          14 :       return MarkAsSimd1x8(node), VisitI16x8Ne(node);
    1622             :     case IrOpcode::kI16x8LtS:
    1623           0 :       return MarkAsSimd1x8(node), VisitI16x8LtS(node);
    1624             :     case IrOpcode::kI16x8LeS:
    1625           0 :       return MarkAsSimd1x8(node), VisitI16x8LeS(node);
    1626             :     case IrOpcode::kI16x8UConvertI8x16Low:
    1627           0 :       return MarkAsSimd128(node), VisitI16x8UConvertI8x16Low(node);
    1628             :     case IrOpcode::kI16x8UConvertI8x16High:
    1629           0 :       return MarkAsSimd128(node), VisitI16x8UConvertI8x16High(node);
    1630             :     case IrOpcode::kI16x8ShrU:
    1631           7 :       return MarkAsSimd128(node), VisitI16x8ShrU(node);
    1632             :     case IrOpcode::kI16x8UConvertI32x4:
    1633           0 :       return MarkAsSimd128(node), VisitI16x8UConvertI32x4(node);
    1634             :     case IrOpcode::kI16x8AddSaturateU:
    1635           7 :       return MarkAsSimd128(node), VisitI16x8AddSaturateU(node);
    1636             :     case IrOpcode::kI16x8SubSaturateU:
    1637           7 :       return MarkAsSimd128(node), VisitI16x8SubSaturateU(node);
    1638             :     case IrOpcode::kI16x8MinU:
    1639           7 :       return MarkAsSimd128(node), VisitI16x8MinU(node);
    1640             :     case IrOpcode::kI16x8MaxU:
    1641           7 :       return MarkAsSimd128(node), VisitI16x8MaxU(node);
    1642             :     case IrOpcode::kI16x8LtU:
    1643           0 :       return MarkAsSimd1x8(node), VisitI16x8LtU(node);
    1644             :     case IrOpcode::kI16x8LeU:
    1645           0 :       return MarkAsSimd1x8(node), VisitI16x8LeU(node);
    1646             :     case IrOpcode::kI8x16Splat:
    1647         231 :       return MarkAsSimd128(node), VisitI8x16Splat(node);
    1648             :     case IrOpcode::kI8x16ExtractLane:
    1649        3220 :       return MarkAsWord32(node), VisitI8x16ExtractLane(node);
    1650             :     case IrOpcode::kI8x16ReplaceLane:
    1651         126 :       return MarkAsSimd128(node), VisitI8x16ReplaceLane(node);
    1652             :     case IrOpcode::kI8x16Neg:
    1653           0 :       return MarkAsSimd128(node), VisitI8x16Neg(node);
    1654             :     case IrOpcode::kI8x16Shl:
    1655           0 :       return MarkAsSimd128(node), VisitI8x16Shl(node);
    1656             :     case IrOpcode::kI8x16ShrS:
    1657           0 :       return MarkAsSimd128(node), VisitI8x16ShrS(node);
    1658             :     case IrOpcode::kI8x16SConvertI16x8:
    1659           0 :       return MarkAsSimd128(node), VisitI8x16SConvertI16x8(node);
    1660             :     case IrOpcode::kI8x16Add:
    1661           7 :       return MarkAsSimd128(node), VisitI8x16Add(node);
    1662             :     case IrOpcode::kI8x16AddSaturateS:
    1663           7 :       return MarkAsSimd128(node), VisitI8x16AddSaturateS(node);
    1664             :     case IrOpcode::kI8x16Sub:
    1665           7 :       return MarkAsSimd128(node), VisitI8x16Sub(node);
    1666             :     case IrOpcode::kI8x16SubSaturateS:
    1667           7 :       return MarkAsSimd128(node), VisitI8x16SubSaturateS(node);
    1668             :     case IrOpcode::kI8x16Mul:
    1669           0 :       return MarkAsSimd128(node), VisitI8x16Mul(node);
    1670             :     case IrOpcode::kI8x16MinS:
    1671           7 :       return MarkAsSimd128(node), VisitI8x16MinS(node);
    1672             :     case IrOpcode::kI8x16MaxS:
    1673           7 :       return MarkAsSimd128(node), VisitI8x16MaxS(node);
    1674             :     case IrOpcode::kI8x16Eq:
    1675           7 :       return MarkAsSimd1x16(node), VisitI8x16Eq(node);
    1676             :     case IrOpcode::kI8x16Ne:
    1677          14 :       return MarkAsSimd1x16(node), VisitI8x16Ne(node);
    1678             :     case IrOpcode::kI8x16LtS:
    1679           0 :       return MarkAsSimd1x16(node), VisitI8x16LtS(node);
    1680             :     case IrOpcode::kI8x16LeS:
    1681           0 :       return MarkAsSimd1x16(node), VisitI8x16LeS(node);
    1682             :     case IrOpcode::kI8x16ShrU:
    1683           0 :       return MarkAsSimd128(node), VisitI8x16ShrU(node);
    1684             :     case IrOpcode::kI8x16UConvertI16x8:
    1685           0 :       return MarkAsSimd128(node), VisitI8x16UConvertI16x8(node);
    1686             :     case IrOpcode::kI8x16AddSaturateU:
    1687           7 :       return MarkAsSimd128(node), VisitI8x16AddSaturateU(node);
    1688             :     case IrOpcode::kI8x16SubSaturateU:
    1689           7 :       return MarkAsSimd128(node), VisitI8x16SubSaturateU(node);
    1690             :     case IrOpcode::kI8x16MinU:
    1691           7 :       return MarkAsSimd128(node), VisitI8x16MinU(node);
    1692             :     case IrOpcode::kI8x16MaxU:
    1693           7 :       return MarkAsSimd128(node), VisitI8x16MaxU(node);
    1694             :     case IrOpcode::kI8x16LtU:
    1695           0 :       return MarkAsSimd1x16(node), VisitI8x16LtU(node);
    1696             :     case IrOpcode::kI8x16LeU:
    1697           0 :       return MarkAsSimd1x16(node), VisitI16x8LeU(node);
    1698             :     case IrOpcode::kS128Zero:
    1699           0 :       return MarkAsSimd128(node), VisitS128Zero(node);
    1700             :     case IrOpcode::kS128And:
    1701           0 :       return MarkAsSimd128(node), VisitS128And(node);
    1702             :     case IrOpcode::kS128Or:
    1703           0 :       return MarkAsSimd128(node), VisitS128Or(node);
    1704             :     case IrOpcode::kS128Xor:
    1705           0 :       return MarkAsSimd128(node), VisitS128Xor(node);
    1706             :     case IrOpcode::kS128Not:
    1707           0 :       return MarkAsSimd128(node), VisitS128Not(node);
    1708             :     case IrOpcode::kS32x4ZipLeft:
    1709           0 :       return MarkAsSimd128(node), VisitS32x4ZipLeft(node);
    1710             :     case IrOpcode::kS32x4ZipRight:
    1711           0 :       return MarkAsSimd128(node), VisitS32x4ZipRight(node);
    1712             :     case IrOpcode::kS32x4UnzipLeft:
    1713           0 :       return MarkAsSimd128(node), VisitS32x4UnzipLeft(node);
    1714             :     case IrOpcode::kS32x4UnzipRight:
    1715           0 :       return MarkAsSimd128(node), VisitS32x4UnzipRight(node);
    1716             :     case IrOpcode::kS32x4TransposeLeft:
    1717           0 :       return MarkAsSimd128(node), VisitS32x4TransposeLeft(node);
    1718             :     case IrOpcode::kS32x4TransposeRight:
    1719           0 :       return MarkAsSimd128(node), VisitS32x4TransposeRight(node);
    1720             :     case IrOpcode::kS32x4Select:
    1721          21 :       return MarkAsSimd128(node), VisitS32x4Select(node);
    1722             :     case IrOpcode::kS16x8ZipLeft:
    1723           0 :       return MarkAsSimd128(node), VisitS16x8ZipLeft(node);
    1724             :     case IrOpcode::kS16x8ZipRight:
    1725           0 :       return MarkAsSimd128(node), VisitS16x8ZipRight(node);
    1726             :     case IrOpcode::kS16x8UnzipLeft:
    1727           0 :       return MarkAsSimd128(node), VisitS16x8UnzipLeft(node);
    1728             :     case IrOpcode::kS16x8UnzipRight:
    1729           0 :       return MarkAsSimd128(node), VisitS16x8UnzipRight(node);
    1730             :     case IrOpcode::kS16x8TransposeLeft:
    1731           0 :       return MarkAsSimd128(node), VisitS16x8TransposeLeft(node);
    1732             :     case IrOpcode::kS16x8TransposeRight:
    1733           0 :       return MarkAsSimd128(node), VisitS16x8TransposeRight(node);
    1734             :     case IrOpcode::kS16x8Select:
    1735          21 :       return MarkAsSimd128(node), VisitS16x8Select(node);
    1736             :     case IrOpcode::kS8x16ZipLeft:
    1737           0 :       return MarkAsSimd128(node), VisitS8x16ZipLeft(node);
    1738             :     case IrOpcode::kS8x16ZipRight:
    1739           0 :       return MarkAsSimd128(node), VisitS8x16ZipRight(node);
    1740             :     case IrOpcode::kS8x16UnzipLeft:
    1741           0 :       return MarkAsSimd128(node), VisitS8x16UnzipLeft(node);
    1742             :     case IrOpcode::kS8x16UnzipRight:
    1743           0 :       return MarkAsSimd128(node), VisitS8x16UnzipRight(node);
    1744             :     case IrOpcode::kS8x16TransposeLeft:
    1745           0 :       return MarkAsSimd128(node), VisitS8x16TransposeLeft(node);
    1746             :     case IrOpcode::kS8x16TransposeRight:
    1747           0 :       return MarkAsSimd128(node), VisitS8x16TransposeRight(node);
    1748             :     case IrOpcode::kS8x16Select:
    1749          21 :       return MarkAsSimd128(node), VisitS8x16Select(node);
    1750             :     case IrOpcode::kS8x16Concat:
    1751           0 :       return MarkAsSimd128(node), VisitS8x16Concat(node);
    1752             :     case IrOpcode::kS32x2Reverse:
    1753           0 :       return MarkAsSimd128(node), VisitS32x2Reverse(node);
    1754             :     case IrOpcode::kS16x4Reverse:
    1755           0 :       return MarkAsSimd128(node), VisitS16x4Reverse(node);
    1756             :     case IrOpcode::kS16x2Reverse:
    1757           0 :       return MarkAsSimd128(node), VisitS16x2Reverse(node);
    1758             :     case IrOpcode::kS8x8Reverse:
    1759           0 :       return MarkAsSimd128(node), VisitS8x8Reverse(node);
    1760             :     case IrOpcode::kS8x4Reverse:
    1761           0 :       return MarkAsSimd128(node), VisitS8x4Reverse(node);
    1762             :     case IrOpcode::kS8x2Reverse:
    1763           0 :       return MarkAsSimd128(node), VisitS8x2Reverse(node);
    1764             :     case IrOpcode::kS1x4Zero:
    1765           0 :       return MarkAsSimd1x4(node), VisitS1x4Zero(node);
    1766             :     case IrOpcode::kS1x4And:
    1767           0 :       return MarkAsSimd1x4(node), VisitS1x4And(node);
    1768             :     case IrOpcode::kS1x4Or:
    1769           0 :       return MarkAsSimd1x4(node), VisitS1x4Or(node);
    1770             :     case IrOpcode::kS1x4Xor:
    1771           0 :       return MarkAsSimd1x4(node), VisitS1x4Xor(node);
    1772             :     case IrOpcode::kS1x4Not:
    1773           0 :       return MarkAsSimd1x4(node), VisitS1x4Not(node);
    1774             :     case IrOpcode::kS1x4AnyTrue:
    1775           0 :       return MarkAsWord32(node), VisitS1x4AnyTrue(node);
    1776             :     case IrOpcode::kS1x4AllTrue:
    1777           0 :       return MarkAsWord32(node), VisitS1x4AllTrue(node);
    1778             :     case IrOpcode::kS1x8Zero:
    1779           0 :       return MarkAsSimd1x8(node), VisitS1x8Zero(node);
    1780             :     case IrOpcode::kS1x8And:
    1781           0 :       return MarkAsSimd1x8(node), VisitS1x8And(node);
    1782             :     case IrOpcode::kS1x8Or:
    1783           0 :       return MarkAsSimd1x8(node), VisitS1x8Or(node);
    1784             :     case IrOpcode::kS1x8Xor:
    1785           0 :       return MarkAsSimd1x8(node), VisitS1x8Xor(node);
    1786             :     case IrOpcode::kS1x8Not:
    1787           0 :       return MarkAsSimd1x8(node), VisitS1x8Not(node);
    1788             :     case IrOpcode::kS1x8AnyTrue:
    1789           0 :       return MarkAsWord32(node), VisitS1x8AnyTrue(node);
    1790             :     case IrOpcode::kS1x8AllTrue:
    1791           0 :       return MarkAsWord32(node), VisitS1x8AllTrue(node);
    1792             :     case IrOpcode::kS1x16Zero:
    1793           0 :       return MarkAsSimd1x16(node), VisitS1x16Zero(node);
    1794             :     case IrOpcode::kS1x16And:
    1795           0 :       return MarkAsSimd1x16(node), VisitS1x16And(node);
    1796             :     case IrOpcode::kS1x16Or:
    1797           0 :       return MarkAsSimd1x16(node), VisitS1x16Or(node);
    1798             :     case IrOpcode::kS1x16Xor:
    1799           0 :       return MarkAsSimd1x16(node), VisitS1x16Xor(node);
    1800             :     case IrOpcode::kS1x16Not:
    1801           0 :       return MarkAsSimd1x16(node), VisitS1x16Not(node);
    1802             :     case IrOpcode::kS1x16AnyTrue:
    1803           0 :       return MarkAsWord32(node), VisitS1x16AnyTrue(node);
    1804             :     case IrOpcode::kS1x16AllTrue:
    1805           0 :       return MarkAsWord32(node), VisitS1x16AllTrue(node);
    1806             :     default:
    1807             :       V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
    1808           0 :                node->opcode(), node->op()->mnemonic(), node->id());
    1809             :       break;
    1810             :   }
    1811             : }
    1812             : 
    1813          43 : void InstructionSelector::VisitLoadStackPointer(Node* node) {
    1814             :   OperandGenerator g(this);
    1815          43 :   Emit(kArchStackPointer, g.DefineAsRegister(node));
    1816          43 : }
    1817             : 
    1818        4808 : void InstructionSelector::VisitLoadFramePointer(Node* node) {
    1819             :   OperandGenerator g(this);
    1820        4808 :   Emit(kArchFramePointer, g.DefineAsRegister(node));
    1821        4808 : }
    1822             : 
    1823       53041 : void InstructionSelector::VisitLoadParentFramePointer(Node* node) {
    1824             :   OperandGenerator g(this);
    1825       53041 :   Emit(kArchParentFramePointer, g.DefineAsRegister(node));
    1826       53041 : }
    1827             : 
    1828           0 : void InstructionSelector::VisitFloat64Acos(Node* node) {
    1829          50 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Acos);
    1830           0 : }
    1831             : 
    1832           0 : void InstructionSelector::VisitFloat64Acosh(Node* node) {
    1833          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Acosh);
    1834           0 : }
    1835             : 
    1836           0 : void InstructionSelector::VisitFloat64Asin(Node* node) {
    1837          50 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Asin);
    1838           0 : }
    1839             : 
    1840           0 : void InstructionSelector::VisitFloat64Asinh(Node* node) {
    1841          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Asinh);
    1842           0 : }
    1843             : 
    1844           0 : void InstructionSelector::VisitFloat64Atan(Node* node) {
    1845          66 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Atan);
    1846           0 : }
    1847             : 
    1848           0 : void InstructionSelector::VisitFloat64Atanh(Node* node) {
    1849          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Atanh);
    1850           0 : }
    1851             : 
    1852           0 : void InstructionSelector::VisitFloat64Atan2(Node* node) {
    1853          73 :   VisitFloat64Ieee754Binop(node, kIeee754Float64Atan2);
    1854           0 : }
    1855             : 
    1856           0 : void InstructionSelector::VisitFloat64Cbrt(Node* node) {
    1857          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Cbrt);
    1858           0 : }
    1859             : 
    1860           0 : void InstructionSelector::VisitFloat64Cos(Node* node) {
    1861         293 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Cos);
    1862           0 : }
    1863             : 
    1864           0 : void InstructionSelector::VisitFloat64Cosh(Node* node) {
    1865          58 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Cosh);
    1866           0 : }
    1867             : 
    1868           0 : void InstructionSelector::VisitFloat64Exp(Node* node) {
    1869          66 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Exp);
    1870           0 : }
    1871             : 
    1872           0 : void InstructionSelector::VisitFloat64Expm1(Node* node) {
    1873          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Expm1);
    1874           0 : }
    1875             : 
    1876           0 : void InstructionSelector::VisitFloat64Log(Node* node) {
    1877         168 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Log);
    1878           0 : }
    1879             : 
    1880           0 : void InstructionSelector::VisitFloat64Log1p(Node* node) {
    1881          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Log1p);
    1882           0 : }
    1883             : 
    1884           0 : void InstructionSelector::VisitFloat64Log2(Node* node) {
    1885          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Log2);
    1886           0 : }
    1887             : 
    1888           0 : void InstructionSelector::VisitFloat64Log10(Node* node) {
    1889          49 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Log10);
    1890           0 : }
    1891             : 
    1892           0 : void InstructionSelector::VisitFloat64Pow(Node* node) {
    1893         105 :   VisitFloat64Ieee754Binop(node, kIeee754Float64Pow);
    1894           0 : }
    1895             : 
    1896           0 : void InstructionSelector::VisitFloat64Sin(Node* node) {
    1897         293 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Sin);
    1898           0 : }
    1899             : 
    1900           0 : void InstructionSelector::VisitFloat64Sinh(Node* node) {
    1901          58 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Sinh);
    1902           0 : }
    1903             : 
    1904           0 : void InstructionSelector::VisitFloat64Tan(Node* node) {
    1905          66 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Tan);
    1906           0 : }
    1907             : 
    1908           0 : void InstructionSelector::VisitFloat64Tanh(Node* node) {
    1909          58 :   VisitFloat64Ieee754Unop(node, kIeee754Float64Tanh);
    1910           0 : }
    1911             : 
    1912        6091 : void InstructionSelector::EmitTableSwitch(const SwitchInfo& sw,
    1913        6091 :                                           InstructionOperand& index_operand) {
    1914             :   OperandGenerator g(this);
    1915        6091 :   size_t input_count = 2 + sw.value_range;
    1916             :   auto* inputs = zone()->NewArray<InstructionOperand>(input_count);
    1917        6091 :   inputs[0] = index_operand;
    1918        6091 :   InstructionOperand default_operand = g.Label(sw.default_branch);
    1919        6091 :   std::fill(&inputs[1], &inputs[input_count], default_operand);
    1920      100666 :   for (size_t index = 0; index < sw.case_count; ++index) {
    1921      100666 :     size_t value = sw.case_values[index] - sw.min_value;
    1922      100666 :     BasicBlock* branch = sw.case_branches[index];
    1923             :     DCHECK_LE(0u, value);
    1924             :     DCHECK_LT(value + 2, input_count);
    1925      100666 :     inputs[value + 2] = g.Label(branch);
    1926             :   }
    1927        6091 :   Emit(kArchTableSwitch, 0, nullptr, input_count, inputs, 0, nullptr);
    1928        6091 : }
    1929             : 
    1930             : 
    1931       17041 : void InstructionSelector::EmitLookupSwitch(const SwitchInfo& sw,
    1932       17041 :                                            InstructionOperand& value_operand) {
    1933             :   OperandGenerator g(this);
    1934       17041 :   size_t input_count = 2 + sw.case_count * 2;
    1935             :   auto* inputs = zone()->NewArray<InstructionOperand>(input_count);
    1936       17041 :   inputs[0] = value_operand;
    1937       17041 :   inputs[1] = g.Label(sw.default_branch);
    1938       78564 :   for (size_t index = 0; index < sw.case_count; ++index) {
    1939       44482 :     int32_t value = sw.case_values[index];
    1940       44482 :     BasicBlock* branch = sw.case_branches[index];
    1941       44482 :     inputs[index * 2 + 2 + 0] = g.TempImmediate(value);
    1942       44482 :     inputs[index * 2 + 2 + 1] = g.Label(branch);
    1943             :   }
    1944       17041 :   Emit(kArchLookupSwitch, 0, nullptr, input_count, inputs, 0, nullptr);
    1945       17041 : }
    1946             : 
    1947        2836 : void InstructionSelector::VisitStackSlot(Node* node) {
    1948        1418 :   int size = StackSlotSizeOf(node->op());
    1949        1418 :   int slot = frame_->AllocateSpillSlot(size);
    1950             :   OperandGenerator g(this);
    1951             : 
    1952             :   Emit(kArchStackSlot, g.DefineAsRegister(node),
    1953        2836 :        sequence()->AddImmediate(Constant(slot)), 0, nullptr);
    1954        1418 : }
    1955             : 
    1956           0 : void InstructionSelector::VisitBitcastTaggedToWord(Node* node) {
    1957           0 :   EmitIdentity(node);
    1958           0 : }
    1959             : 
    1960      239211 : void InstructionSelector::VisitBitcastWordToTagged(Node* node) {
    1961             :   OperandGenerator g(this);
    1962      239211 :   Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(node->InputAt(0)));
    1963      239214 : }
    1964             : 
    1965             : // 32 bit targets do not implement the following instructions.
    1966             : #if V8_TARGET_ARCH_32_BIT
    1967             : 
    1968             : void InstructionSelector::VisitWord64And(Node* node) { UNIMPLEMENTED(); }
    1969             : 
    1970             : 
    1971             : void InstructionSelector::VisitWord64Or(Node* node) { UNIMPLEMENTED(); }
    1972             : 
    1973             : 
    1974             : void InstructionSelector::VisitWord64Xor(Node* node) { UNIMPLEMENTED(); }
    1975             : 
    1976             : 
    1977             : void InstructionSelector::VisitWord64Shl(Node* node) { UNIMPLEMENTED(); }
    1978             : 
    1979             : 
    1980             : void InstructionSelector::VisitWord64Shr(Node* node) { UNIMPLEMENTED(); }
    1981             : 
    1982             : 
    1983             : void InstructionSelector::VisitWord64Sar(Node* node) { UNIMPLEMENTED(); }
    1984             : 
    1985             : 
    1986             : void InstructionSelector::VisitWord64Ror(Node* node) { UNIMPLEMENTED(); }
    1987             : 
    1988             : 
    1989             : void InstructionSelector::VisitWord64Clz(Node* node) { UNIMPLEMENTED(); }
    1990             : 
    1991             : 
    1992             : void InstructionSelector::VisitWord64Ctz(Node* node) { UNIMPLEMENTED(); }
    1993             : 
    1994             : 
    1995             : void InstructionSelector::VisitWord64ReverseBits(Node* node) {
    1996             :   UNIMPLEMENTED();
    1997             : }
    1998             : 
    1999             : 
    2000             : void InstructionSelector::VisitWord64Popcnt(Node* node) { UNIMPLEMENTED(); }
    2001             : 
    2002             : 
    2003             : void InstructionSelector::VisitWord64Equal(Node* node) { UNIMPLEMENTED(); }
    2004             : 
    2005             : 
    2006             : void InstructionSelector::VisitInt64Add(Node* node) { UNIMPLEMENTED(); }
    2007             : 
    2008             : 
    2009             : void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
    2010             :   UNIMPLEMENTED();
    2011             : }
    2012             : 
    2013             : 
    2014             : void InstructionSelector::VisitInt64Sub(Node* node) { UNIMPLEMENTED(); }
    2015             : 
    2016             : 
    2017             : void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
    2018             :   UNIMPLEMENTED();
    2019             : }
    2020             : 
    2021             : void InstructionSelector::VisitInt64Mul(Node* node) { UNIMPLEMENTED(); }
    2022             : 
    2023             : 
    2024             : void InstructionSelector::VisitInt64Div(Node* node) { UNIMPLEMENTED(); }
    2025             : 
    2026             : 
    2027             : void InstructionSelector::VisitInt64LessThan(Node* node) { UNIMPLEMENTED(); }
    2028             : 
    2029             : 
    2030             : void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
    2031             :   UNIMPLEMENTED();
    2032             : }
    2033             : 
    2034             : 
    2035             : void InstructionSelector::VisitUint64Div(Node* node) { UNIMPLEMENTED(); }
    2036             : 
    2037             : 
    2038             : void InstructionSelector::VisitInt64Mod(Node* node) { UNIMPLEMENTED(); }
    2039             : 
    2040             : 
    2041             : void InstructionSelector::VisitUint64LessThan(Node* node) { UNIMPLEMENTED(); }
    2042             : 
    2043             : 
    2044             : void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
    2045             :   UNIMPLEMENTED();
    2046             : }
    2047             : 
    2048             : 
    2049             : void InstructionSelector::VisitUint64Mod(Node* node) { UNIMPLEMENTED(); }
    2050             : 
    2051             : 
    2052             : void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
    2053             :   UNIMPLEMENTED();
    2054             : }
    2055             : 
    2056             : 
    2057             : void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
    2058             :   UNIMPLEMENTED();
    2059             : }
    2060             : 
    2061             : void InstructionSelector::VisitChangeFloat64ToUint64(Node* node) {
    2062             :   UNIMPLEMENTED();
    2063             : }
    2064             : 
    2065             : void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
    2066             :   UNIMPLEMENTED();
    2067             : }
    2068             : 
    2069             : 
    2070             : void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
    2071             :   UNIMPLEMENTED();
    2072             : }
    2073             : 
    2074             : 
    2075             : void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
    2076             :   UNIMPLEMENTED();
    2077             : }
    2078             : 
    2079             : 
    2080             : void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
    2081             :   UNIMPLEMENTED();
    2082             : }
    2083             : 
    2084             : 
    2085             : void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
    2086             :   UNIMPLEMENTED();
    2087             : }
    2088             : 
    2089             : 
    2090             : void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
    2091             :   UNIMPLEMENTED();
    2092             : }
    2093             : 
    2094             : 
    2095             : void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
    2096             :   UNIMPLEMENTED();
    2097             : }
    2098             : 
    2099             : 
    2100             : void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
    2101             :   UNIMPLEMENTED();
    2102             : }
    2103             : 
    2104             : 
    2105             : void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
    2106             :   UNIMPLEMENTED();
    2107             : }
    2108             : 
    2109             : void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
    2110             :   UNIMPLEMENTED();
    2111             : }
    2112             : 
    2113             : 
    2114             : void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
    2115             :   UNIMPLEMENTED();
    2116             : }
    2117             : #endif  // V8_TARGET_ARCH_32_BIT
    2118             : 
    2119             : // 64 bit targets do not implement the following instructions.
    2120             : #if V8_TARGET_ARCH_64_BIT
    2121           0 : void InstructionSelector::VisitInt32PairAdd(Node* node) { UNIMPLEMENTED(); }
    2122             : 
    2123           0 : void InstructionSelector::VisitInt32PairSub(Node* node) { UNIMPLEMENTED(); }
    2124             : 
    2125           0 : void InstructionSelector::VisitInt32PairMul(Node* node) { UNIMPLEMENTED(); }
    2126             : 
    2127           0 : void InstructionSelector::VisitWord32PairShl(Node* node) { UNIMPLEMENTED(); }
    2128             : 
    2129           0 : void InstructionSelector::VisitWord32PairShr(Node* node) { UNIMPLEMENTED(); }
    2130             : 
    2131           0 : void InstructionSelector::VisitWord32PairSar(Node* node) { UNIMPLEMENTED(); }
    2132             : #endif  // V8_TARGET_ARCH_64_BIT
    2133             : 
    2134             : #if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2135           0 : void InstructionSelector::VisitF32x4Splat(Node* node) { UNIMPLEMENTED(); }
    2136             : 
    2137           0 : void InstructionSelector::VisitF32x4ExtractLane(Node* node) { UNIMPLEMENTED(); }
    2138             : 
    2139           0 : void InstructionSelector::VisitF32x4ReplaceLane(Node* node) { UNIMPLEMENTED(); }
    2140             : 
    2141           0 : void InstructionSelector::VisitF32x4SConvertI32x4(Node* node) {
    2142           0 :   UNIMPLEMENTED();
    2143             : }
    2144             : 
    2145           0 : void InstructionSelector::VisitF32x4UConvertI32x4(Node* node) {
    2146           0 :   UNIMPLEMENTED();
    2147             : }
    2148             : 
    2149           0 : void InstructionSelector::VisitF32x4Abs(Node* node) { UNIMPLEMENTED(); }
    2150             : 
    2151           0 : void InstructionSelector::VisitF32x4Neg(Node* node) { UNIMPLEMENTED(); }
    2152             : 
    2153           0 : void InstructionSelector::VisitF32x4RecipSqrtApprox(Node* node) {
    2154           0 :   UNIMPLEMENTED();
    2155             : }
    2156             : 
    2157           0 : void InstructionSelector::VisitF32x4Add(Node* node) { UNIMPLEMENTED(); }
    2158             : #endif  // !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2159             : 
    2160             : #if !V8_TARGET_ARCH_ARM
    2161           0 : void InstructionSelector::VisitF32x4AddHoriz(Node* node) { UNIMPLEMENTED(); }
    2162             : #endif  // !V8_TARGET_ARCH_ARM
    2163             : 
    2164             : #if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2165           0 : void InstructionSelector::VisitF32x4Sub(Node* node) { UNIMPLEMENTED(); }
    2166             : 
    2167           0 : void InstructionSelector::VisitF32x4Mul(Node* node) { UNIMPLEMENTED(); }
    2168             : 
    2169           0 : void InstructionSelector::VisitF32x4Max(Node* node) { UNIMPLEMENTED(); }
    2170             : 
    2171           0 : void InstructionSelector::VisitF32x4Min(Node* node) { UNIMPLEMENTED(); }
    2172             : 
    2173           0 : void InstructionSelector::VisitF32x4RecipApprox(Node* node) { UNIMPLEMENTED(); }
    2174             : 
    2175           0 : void InstructionSelector::VisitF32x4Eq(Node* node) { UNIMPLEMENTED(); }
    2176             : 
    2177           0 : void InstructionSelector::VisitF32x4Ne(Node* node) { UNIMPLEMENTED(); }
    2178             : 
    2179           0 : void InstructionSelector::VisitF32x4Lt(Node* node) { UNIMPLEMENTED(); }
    2180             : 
    2181           0 : void InstructionSelector::VisitF32x4Le(Node* node) { UNIMPLEMENTED(); }
    2182             : #endif  // V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2183             : 
    2184             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_IA32 && \
    2185             :     !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2186             : void InstructionSelector::VisitI32x4Splat(Node* node) { UNIMPLEMENTED(); }
    2187             : 
    2188             : void InstructionSelector::VisitI32x4ExtractLane(Node* node) { UNIMPLEMENTED(); }
    2189             : 
    2190             : void InstructionSelector::VisitI32x4ReplaceLane(Node* node) { UNIMPLEMENTED(); }
    2191             : 
    2192             : void InstructionSelector::VisitI32x4Add(Node* node) { UNIMPLEMENTED(); }
    2193             : 
    2194             : void InstructionSelector::VisitI32x4Sub(Node* node) { UNIMPLEMENTED(); }
    2195             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_IA32 &&
    2196             :         // !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2197             : 
    2198             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && \
    2199             :     !V8_TARGET_ARCH_MIPS64
    2200             : void InstructionSelector::VisitI32x4Shl(Node* node) { UNIMPLEMENTED(); }
    2201             : 
    2202             : void InstructionSelector::VisitI32x4ShrS(Node* node) { UNIMPLEMENTED(); }
    2203             : 
    2204             : void InstructionSelector::VisitI32x4Mul(Node* node) { UNIMPLEMENTED(); }
    2205             : 
    2206             : void InstructionSelector::VisitI32x4MaxS(Node* node) { UNIMPLEMENTED(); }
    2207             : 
    2208             : void InstructionSelector::VisitI32x4MinS(Node* node) { UNIMPLEMENTED(); }
    2209             : 
    2210             : void InstructionSelector::VisitI32x4Eq(Node* node) { UNIMPLEMENTED(); }
    2211             : 
    2212             : void InstructionSelector::VisitI32x4Ne(Node* node) { UNIMPLEMENTED(); }
    2213             : 
    2214             : void InstructionSelector::VisitI32x4MinU(Node* node) { UNIMPLEMENTED(); }
    2215             : 
    2216             : void InstructionSelector::VisitI32x4MaxU(Node* node) { UNIMPLEMENTED(); }
    2217             : 
    2218             : void InstructionSelector::VisitI32x4ShrU(Node* node) { UNIMPLEMENTED(); }
    2219             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS &&
    2220             :         // !V8_TARGET_ARCH_MIPS64
    2221             : 
    2222             : #if !V8_TARGET_ARCH_ARM
    2223           0 : void InstructionSelector::VisitI32x4AddHoriz(Node* node) { UNIMPLEMENTED(); }
    2224             : #endif  // !V8_TARGET_ARCH_ARM
    2225             : 
    2226             : #if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2227           0 : void InstructionSelector::VisitI32x4SConvertF32x4(Node* node) {
    2228           0 :   UNIMPLEMENTED();
    2229             : }
    2230             : 
    2231           0 : void InstructionSelector::VisitI32x4UConvertF32x4(Node* node) {
    2232           0 :   UNIMPLEMENTED();
    2233             : }
    2234             : #endif  // !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
    2235             : 
    2236             : #if !V8_TARGET_ARCH_ARM
    2237           0 : void InstructionSelector::VisitI32x4SConvertI16x8Low(Node* node) {
    2238           0 :   UNIMPLEMENTED();
    2239             : }
    2240             : 
    2241           0 : void InstructionSelector::VisitI32x4SConvertI16x8High(Node* node) {
    2242           0 :   UNIMPLEMENTED();
    2243             : }
    2244             : 
    2245           0 : void InstructionSelector::VisitI32x4Neg(Node* node) { UNIMPLEMENTED(); }
    2246             : 
    2247           0 : void InstructionSelector::VisitI32x4LtS(Node* node) { UNIMPLEMENTED(); }
    2248             : 
    2249           0 : void InstructionSelector::VisitI32x4LeS(Node* node) { UNIMPLEMENTED(); }
    2250             : 
    2251           0 : void InstructionSelector::VisitI32x4UConvertI16x8Low(Node* node) {
    2252           0 :   UNIMPLEMENTED();
    2253             : }
    2254             : 
    2255           0 : void InstructionSelector::VisitI32x4UConvertI16x8High(Node* node) {
    2256           0 :   UNIMPLEMENTED();
    2257             : }
    2258             : 
    2259           0 : void InstructionSelector::VisitI32x4LtU(Node* node) { UNIMPLEMENTED(); }
    2260             : 
    2261           0 : void InstructionSelector::VisitI32x4LeU(Node* node) { UNIMPLEMENTED(); }
    2262             : #endif  // !V8_TARGET_ARCH_ARM
    2263             : 
    2264             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2265             : void InstructionSelector::VisitI16x8Splat(Node* node) { UNIMPLEMENTED(); }
    2266             : 
    2267             : void InstructionSelector::VisitI16x8ExtractLane(Node* node) { UNIMPLEMENTED(); }
    2268             : 
    2269             : void InstructionSelector::VisitI16x8ReplaceLane(Node* node) { UNIMPLEMENTED(); }
    2270             : 
    2271             : void InstructionSelector::VisitI16x8Shl(Node* node) { UNIMPLEMENTED(); }
    2272             : 
    2273             : void InstructionSelector::VisitI16x8ShrS(Node* node) { UNIMPLEMENTED(); }
    2274             : 
    2275             : void InstructionSelector::VisitI16x8Add(Node* node) { UNIMPLEMENTED(); }
    2276             : 
    2277             : void InstructionSelector::VisitI16x8AddSaturateS(Node* node) {
    2278             :   UNIMPLEMENTED();
    2279             : }
    2280             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2281             : 
    2282             : #if !V8_TARGET_ARCH_ARM
    2283           0 : void InstructionSelector::VisitI16x8AddHoriz(Node* node) { UNIMPLEMENTED(); }
    2284             : #endif  // !V8_TARGET_ARCH_ARM
    2285             : 
    2286             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2287             : void InstructionSelector::VisitI16x8Sub(Node* node) { UNIMPLEMENTED(); }
    2288             : 
    2289             : void InstructionSelector::VisitI16x8SubSaturateS(Node* node) {
    2290             :   UNIMPLEMENTED();
    2291             : }
    2292             : 
    2293             : void InstructionSelector::VisitI16x8Mul(Node* node) { UNIMPLEMENTED(); }
    2294             : 
    2295             : void InstructionSelector::VisitI16x8MinS(Node* node) { UNIMPLEMENTED(); }
    2296             : 
    2297             : void InstructionSelector::VisitI16x8MaxS(Node* node) { UNIMPLEMENTED(); }
    2298             : 
    2299             : void InstructionSelector::VisitI16x8Eq(Node* node) { UNIMPLEMENTED(); }
    2300             : 
    2301             : void InstructionSelector::VisitI16x8Ne(Node* node) { UNIMPLEMENTED(); }
    2302             : 
    2303             : void InstructionSelector::VisitI16x8ShrU(Node* node) { UNIMPLEMENTED(); }
    2304             : 
    2305             : void InstructionSelector::VisitI16x8AddSaturateU(Node* node) {
    2306             :   UNIMPLEMENTED();
    2307             : }
    2308             : 
    2309             : void InstructionSelector::VisitI16x8SubSaturateU(Node* node) {
    2310             :   UNIMPLEMENTED();
    2311             : }
    2312             : 
    2313             : void InstructionSelector::VisitI16x8MinU(Node* node) { UNIMPLEMENTED(); }
    2314             : 
    2315             : void InstructionSelector::VisitI16x8MaxU(Node* node) { UNIMPLEMENTED(); }
    2316             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2317             : 
    2318             : #if !V8_TARGET_ARCH_ARM
    2319           0 : void InstructionSelector::VisitI16x8Neg(Node* node) { UNIMPLEMENTED(); }
    2320             : 
    2321           0 : void InstructionSelector::VisitI16x8SConvertI32x4(Node* node) {
    2322           0 :   UNIMPLEMENTED();
    2323             : }
    2324             : 
    2325           0 : void InstructionSelector::VisitI16x8SConvertI8x16Low(Node* node) {
    2326           0 :   UNIMPLEMENTED();
    2327             : }
    2328             : 
    2329           0 : void InstructionSelector::VisitI16x8UConvertI8x16Low(Node* node) {
    2330           0 :   UNIMPLEMENTED();
    2331             : }
    2332             : 
    2333           0 : void InstructionSelector::VisitI16x8UConvertI8x16High(Node* node) {
    2334           0 :   UNIMPLEMENTED();
    2335             : }
    2336             : 
    2337           0 : void InstructionSelector::VisitI16x8SConvertI8x16High(Node* node) {
    2338           0 :   UNIMPLEMENTED();
    2339             : }
    2340             : 
    2341           0 : void InstructionSelector::VisitI16x8LtS(Node* node) { UNIMPLEMENTED(); }
    2342             : 
    2343           0 : void InstructionSelector::VisitI16x8LeS(Node* node) { UNIMPLEMENTED(); }
    2344             : 
    2345           0 : void InstructionSelector::VisitI16x8UConvertI32x4(Node* node) {
    2346           0 :   UNIMPLEMENTED();
    2347             : }
    2348             : 
    2349           0 : void InstructionSelector::VisitI16x8LtU(Node* node) { UNIMPLEMENTED(); }
    2350             : 
    2351           0 : void InstructionSelector::VisitI16x8LeU(Node* node) { UNIMPLEMENTED(); }
    2352             : #endif  // !V8_TARGET_ARCH_ARM
    2353             : 
    2354             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2355             : void InstructionSelector::VisitI8x16Splat(Node* node) { UNIMPLEMENTED(); }
    2356             : 
    2357             : void InstructionSelector::VisitI8x16ExtractLane(Node* node) { UNIMPLEMENTED(); }
    2358             : 
    2359             : void InstructionSelector::VisitI8x16ReplaceLane(Node* node) { UNIMPLEMENTED(); }
    2360             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2361             : 
    2362             : #if !V8_TARGET_ARCH_ARM
    2363           0 : void InstructionSelector::VisitI8x16Neg(Node* node) { UNIMPLEMENTED(); }
    2364             : 
    2365           0 : void InstructionSelector::VisitI8x16Shl(Node* node) { UNIMPLEMENTED(); }
    2366             : 
    2367           0 : void InstructionSelector::VisitI8x16ShrS(Node* node) { UNIMPLEMENTED(); }
    2368             : 
    2369           0 : void InstructionSelector::VisitI8x16SConvertI16x8(Node* node) {
    2370           0 :   UNIMPLEMENTED();
    2371             : }
    2372             : #endif  // !V8_TARGET_ARCH_ARM
    2373             : 
    2374             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2375             : void InstructionSelector::VisitI8x16Add(Node* node) { UNIMPLEMENTED(); }
    2376             : 
    2377             : void InstructionSelector::VisitI8x16AddSaturateS(Node* node) {
    2378             :   UNIMPLEMENTED();
    2379             : }
    2380             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2381             : 
    2382             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2383             : void InstructionSelector::VisitI8x16Sub(Node* node) { UNIMPLEMENTED(); }
    2384             : 
    2385             : void InstructionSelector::VisitI8x16SubSaturateS(Node* node) {
    2386             :   UNIMPLEMENTED();
    2387             : }
    2388             : 
    2389             : void InstructionSelector::VisitI8x16MinS(Node* node) { UNIMPLEMENTED(); }
    2390             : 
    2391             : void InstructionSelector::VisitI8x16MaxS(Node* node) { UNIMPLEMENTED(); }
    2392             : 
    2393             : void InstructionSelector::VisitI8x16Eq(Node* node) { UNIMPLEMENTED(); }
    2394             : 
    2395             : void InstructionSelector::VisitI8x16Ne(Node* node) { UNIMPLEMENTED(); }
    2396             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2397             : 
    2398             : #if !V8_TARGET_ARCH_ARM
    2399           0 : void InstructionSelector::VisitI8x16Mul(Node* node) { UNIMPLEMENTED(); }
    2400             : 
    2401           0 : void InstructionSelector::VisitI8x16LtS(Node* node) { UNIMPLEMENTED(); }
    2402             : 
    2403           0 : void InstructionSelector::VisitI8x16LeS(Node* node) { UNIMPLEMENTED(); }
    2404             : 
    2405           0 : void InstructionSelector::VisitI8x16ShrU(Node* node) { UNIMPLEMENTED(); }
    2406             : 
    2407           0 : void InstructionSelector::VisitI8x16UConvertI16x8(Node* node) {
    2408           0 :   UNIMPLEMENTED();
    2409             : }
    2410             : #endif  // !V8_TARGET_ARCH_ARM
    2411             : 
    2412             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2413             : void InstructionSelector::VisitI8x16AddSaturateU(Node* node) {
    2414             :   UNIMPLEMENTED();
    2415             : }
    2416             : 
    2417             : void InstructionSelector::VisitI8x16SubSaturateU(Node* node) {
    2418             :   UNIMPLEMENTED();
    2419             : }
    2420             : 
    2421             : void InstructionSelector::VisitI8x16MinU(Node* node) { UNIMPLEMENTED(); }
    2422             : 
    2423             : void InstructionSelector::VisitI8x16MaxU(Node* node) { UNIMPLEMENTED(); }
    2424             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2425             : 
    2426             : #if !V8_TARGET_ARCH_ARM
    2427           0 : void InstructionSelector::VisitI8x16LtU(Node* node) { UNIMPLEMENTED(); }
    2428             : 
    2429           0 : void InstructionSelector::VisitI8x16LeU(Node* node) { UNIMPLEMENTED(); }
    2430             : 
    2431           0 : void InstructionSelector::VisitS128And(Node* node) { UNIMPLEMENTED(); }
    2432             : 
    2433           0 : void InstructionSelector::VisitS128Or(Node* node) { UNIMPLEMENTED(); }
    2434             : 
    2435           0 : void InstructionSelector::VisitS128Xor(Node* node) { UNIMPLEMENTED(); }
    2436             : 
    2437           0 : void InstructionSelector::VisitS128Not(Node* node) { UNIMPLEMENTED(); }
    2438             : #endif  // !V8_TARGET_ARCH_ARM
    2439             : 
    2440             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && \
    2441             :     !V8_TARGET_ARCH_MIPS64
    2442             : void InstructionSelector::VisitS128Zero(Node* node) { UNIMPLEMENTED(); }
    2443             : 
    2444             : void InstructionSelector::VisitS1x4Zero(Node* node) { UNIMPLEMENTED(); }
    2445             : 
    2446             : void InstructionSelector::VisitS1x8Zero(Node* node) { UNIMPLEMENTED(); }
    2447             : 
    2448             : void InstructionSelector::VisitS1x16Zero(Node* node) { UNIMPLEMENTED(); }
    2449             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS &&
    2450             :         // !V8_TARGET_ARCH_MIPS64
    2451             : 
    2452             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS && \
    2453             :     !V8_TARGET_ARCH_MIPS64
    2454             : void InstructionSelector::VisitS32x4Select(Node* node) { UNIMPLEMENTED(); }
    2455             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS &&
    2456             :         // !V8_TARGET_ARCH_MIPS64
    2457             : 
    2458             : #if !V8_TARGET_ARCH_ARM
    2459           0 : void InstructionSelector::VisitS32x4ZipLeft(Node* node) { UNIMPLEMENTED(); }
    2460             : 
    2461           0 : void InstructionSelector::VisitS32x4ZipRight(Node* node) { UNIMPLEMENTED(); }
    2462             : 
    2463           0 : void InstructionSelector::VisitS32x4UnzipLeft(Node* node) { UNIMPLEMENTED(); }
    2464             : 
    2465           0 : void InstructionSelector::VisitS32x4UnzipRight(Node* node) { UNIMPLEMENTED(); }
    2466             : 
    2467           0 : void InstructionSelector::VisitS32x4TransposeLeft(Node* node) {
    2468           0 :   UNIMPLEMENTED();
    2469             : }
    2470             : 
    2471           0 : void InstructionSelector::VisitS32x4TransposeRight(Node* node) {
    2472           0 :   UNIMPLEMENTED();
    2473             : }
    2474             : 
    2475           0 : void InstructionSelector::VisitS16x8ZipLeft(Node* node) { UNIMPLEMENTED(); }
    2476             : 
    2477           0 : void InstructionSelector::VisitS16x8ZipRight(Node* node) { UNIMPLEMENTED(); }
    2478             : 
    2479           0 : void InstructionSelector::VisitS16x8UnzipLeft(Node* node) { UNIMPLEMENTED(); }
    2480             : 
    2481           0 : void InstructionSelector::VisitS16x8UnzipRight(Node* node) { UNIMPLEMENTED(); }
    2482             : 
    2483           0 : void InstructionSelector::VisitS16x8TransposeLeft(Node* node) {
    2484           0 :   UNIMPLEMENTED();
    2485             : }
    2486             : 
    2487           0 : void InstructionSelector::VisitS16x8TransposeRight(Node* node) {
    2488           0 :   UNIMPLEMENTED();
    2489             : }
    2490             : #endif  // !V8_TARGET_ARCH_ARM
    2491             : 
    2492             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2493             : void InstructionSelector::VisitS16x8Select(Node* node) { UNIMPLEMENTED(); }
    2494             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2495             : 
    2496             : #if !V8_TARGET_ARCH_ARM
    2497           0 : void InstructionSelector::VisitS8x16ZipLeft(Node* node) { UNIMPLEMENTED(); }
    2498             : 
    2499           0 : void InstructionSelector::VisitS8x16ZipRight(Node* node) { UNIMPLEMENTED(); }
    2500             : 
    2501           0 : void InstructionSelector::VisitS8x16UnzipLeft(Node* node) { UNIMPLEMENTED(); }
    2502             : 
    2503           0 : void InstructionSelector::VisitS8x16UnzipRight(Node* node) { UNIMPLEMENTED(); }
    2504             : 
    2505           0 : void InstructionSelector::VisitS8x16TransposeLeft(Node* node) {
    2506           0 :   UNIMPLEMENTED();
    2507             : }
    2508             : 
    2509           0 : void InstructionSelector::VisitS8x16TransposeRight(Node* node) {
    2510           0 :   UNIMPLEMENTED();
    2511             : }
    2512             : #endif  // !V8_TARGET_ARCH_ARM
    2513             : 
    2514             : #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2515             : void InstructionSelector::VisitS8x16Select(Node* node) { UNIMPLEMENTED(); }
    2516             : #endif  // !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_ARM
    2517             : 
    2518             : #if !V8_TARGET_ARCH_ARM
    2519           0 : void InstructionSelector::VisitS8x16Concat(Node* node) { UNIMPLEMENTED(); }
    2520             : 
    2521           0 : void InstructionSelector::VisitS32x2Reverse(Node* node) { UNIMPLEMENTED(); }
    2522             : 
    2523           0 : void InstructionSelector::VisitS16x4Reverse(Node* node) { UNIMPLEMENTED(); }
    2524             : 
    2525           0 : void InstructionSelector::VisitS16x2Reverse(Node* node) { UNIMPLEMENTED(); }
    2526             : 
    2527           0 : void InstructionSelector::VisitS8x8Reverse(Node* node) { UNIMPLEMENTED(); }
    2528             : 
    2529           0 : void InstructionSelector::VisitS8x4Reverse(Node* node) { UNIMPLEMENTED(); }
    2530             : 
    2531           0 : void InstructionSelector::VisitS8x2Reverse(Node* node) { UNIMPLEMENTED(); }
    2532             : 
    2533           0 : void InstructionSelector::VisitS1x4And(Node* node) { UNIMPLEMENTED(); }
    2534             : 
    2535           0 : void InstructionSelector::VisitS1x4Or(Node* node) { UNIMPLEMENTED(); }
    2536             : 
    2537           0 : void InstructionSelector::VisitS1x4Xor(Node* node) { UNIMPLEMENTED(); }
    2538             : 
    2539           0 : void InstructionSelector::VisitS1x4Not(Node* node) { UNIMPLEMENTED(); }
    2540             : 
    2541           0 : void InstructionSelector::VisitS1x4AnyTrue(Node* node) { UNIMPLEMENTED(); }
    2542             : 
    2543           0 : void InstructionSelector::VisitS1x4AllTrue(Node* node) { UNIMPLEMENTED(); }
    2544             : 
    2545           0 : void InstructionSelector::VisitS1x8And(Node* node) { UNIMPLEMENTED(); }
    2546             : 
    2547           0 : void InstructionSelector::VisitS1x8Or(Node* node) { UNIMPLEMENTED(); }
    2548             : 
    2549           0 : void InstructionSelector::VisitS1x8Xor(Node* node) { UNIMPLEMENTED(); }
    2550             : 
    2551           0 : void InstructionSelector::VisitS1x8Not(Node* node) { UNIMPLEMENTED(); }
    2552             : 
    2553           0 : void InstructionSelector::VisitS1x8AnyTrue(Node* node) { UNIMPLEMENTED(); }
    2554             : 
    2555           0 : void InstructionSelector::VisitS1x8AllTrue(Node* node) { UNIMPLEMENTED(); }
    2556             : 
    2557           0 : void InstructionSelector::VisitS1x16And(Node* node) { UNIMPLEMENTED(); }
    2558             : 
    2559           0 : void InstructionSelector::VisitS1x16Or(Node* node) { UNIMPLEMENTED(); }
    2560             : 
    2561           0 : void InstructionSelector::VisitS1x16Xor(Node* node) { UNIMPLEMENTED(); }
    2562             : 
    2563           0 : void InstructionSelector::VisitS1x16Not(Node* node) { UNIMPLEMENTED(); }
    2564             : 
    2565           0 : void InstructionSelector::VisitS1x16AnyTrue(Node* node) { UNIMPLEMENTED(); }
    2566             : 
    2567           0 : void InstructionSelector::VisitS1x16AllTrue(Node* node) { UNIMPLEMENTED(); }
    2568             : #endif  // !V8_TARGET_ARCH_ARM
    2569             : 
    2570       12945 : void InstructionSelector::VisitFinishRegion(Node* node) { EmitIdentity(node); }
    2571             : 
    2572     7602740 : void InstructionSelector::VisitParameter(Node* node) {
    2573             :   OperandGenerator g(this);
    2574     1791072 :   int index = ParameterIndexOf(node->op());
    2575             :   InstructionOperand op =
    2576     1791088 :       linkage()->ParameterHasSecondaryLocation(index)
    2577             :           ? g.DefineAsDualLocation(
    2578             :                 node, linkage()->GetParameterLocation(index),
    2579      876924 :                 linkage()->GetParameterSecondaryLocation(index))
    2580     3582133 :           : g.DefineAsLocation(node, linkage()->GetParameterLocation(index));
    2581             : 
    2582     1791089 :   Emit(kArchNop, op);
    2583     1791094 : }
    2584             : 
    2585             : namespace {
    2586             : LinkageLocation ExceptionLocation() {
    2587             :   return LinkageLocation::ForRegister(kReturnRegister0.code(),
    2588             :                                       MachineType::IntPtr());
    2589             : }
    2590             : }
    2591             : 
    2592      209287 : void InstructionSelector::VisitIfException(Node* node) {
    2593             :   OperandGenerator g(this);
    2594             :   DCHECK_EQ(IrOpcode::kCall, node->InputAt(1)->opcode());
    2595      209287 :   Emit(kArchNop, g.DefineAsLocation(node, ExceptionLocation()));
    2596      209288 : }
    2597             : 
    2598             : 
    2599       77685 : void InstructionSelector::VisitOsrValue(Node* node) {
    2600             :   OperandGenerator g(this);
    2601       25895 :   int index = OsrValueIndexOf(node->op());
    2602             :   Emit(kArchNop,
    2603       25895 :        g.DefineAsLocation(node, linkage()->GetOsrValueLocation(index)));
    2604       25895 : }
    2605             : 
    2606             : 
    2607     2667132 : void InstructionSelector::VisitPhi(Node* node) {
    2608     1333564 :   const int input_count = node->op()->ValueInputCount();
    2609             :   PhiInstruction* phi = new (instruction_zone())
    2610             :       PhiInstruction(instruction_zone(), GetVirtualRegister(node),
    2611     2667134 :                      static_cast<size_t>(input_count));
    2612             :   sequence()
    2613             :       ->InstructionBlockAt(RpoNumber::FromInt(current_block_->rpo_number()))
    2614     2667136 :       ->AddPhi(phi);
    2615     4659090 :   for (int i = 0; i < input_count; ++i) {
    2616             :     Node* const input = node->InputAt(i);
    2617             :     MarkAsUsed(input);
    2618     3325519 :     phi->SetInput(static_cast<size_t>(i), GetVirtualRegister(input));
    2619             :   }
    2620     1333571 : }
    2621             : 
    2622             : 
    2623      654995 : void InstructionSelector::VisitProjection(Node* node) {
    2624             :   OperandGenerator g(this);
    2625      330922 :   Node* value = node->InputAt(0);
    2626      330922 :   switch (value->opcode()) {
    2627             :     case IrOpcode::kInt32AddWithOverflow:
    2628             :     case IrOpcode::kInt32SubWithOverflow:
    2629             :     case IrOpcode::kInt32MulWithOverflow:
    2630             :     case IrOpcode::kInt64AddWithOverflow:
    2631             :     case IrOpcode::kInt64SubWithOverflow:
    2632             :     case IrOpcode::kTryTruncateFloat32ToInt64:
    2633             :     case IrOpcode::kTryTruncateFloat64ToInt64:
    2634             :     case IrOpcode::kTryTruncateFloat32ToUint64:
    2635             :     case IrOpcode::kTryTruncateFloat64ToUint64:
    2636             :     case IrOpcode::kInt32PairAdd:
    2637             :     case IrOpcode::kInt32PairSub:
    2638             :     case IrOpcode::kInt32PairMul:
    2639             :     case IrOpcode::kWord32PairShl:
    2640             :     case IrOpcode::kWord32PairShr:
    2641             :     case IrOpcode::kWord32PairSar:
    2642             :     case IrOpcode::kInt32AbsWithOverflow:
    2643             :     case IrOpcode::kInt64AbsWithOverflow:
    2644      324073 :       if (ProjectionIndexOf(node->op()) == 0u) {
    2645      196511 :         Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
    2646             :       } else {
    2647             :         DCHECK(ProjectionIndexOf(node->op()) == 1u);
    2648             :         MarkAsUsed(value);
    2649             :       }
    2650             :       break;
    2651             :     default:
    2652             :       break;
    2653             :   }
    2654      330922 : }
    2655             : 
    2656             : 
    2657     9047133 : void InstructionSelector::VisitConstant(Node* node) {
    2658             :   // We must emit a NOP here because every live range needs a defining
    2659             :   // instruction in the register allocator.
    2660             :   OperandGenerator g(this);
    2661     9047133 :   Emit(kArchNop, g.DefineAsConstant(node));
    2662     9047155 : }
    2663             : 
    2664             : 
    2665    17004579 : void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
    2666             :   OperandGenerator g(this);
    2667     9217304 :   const CallDescriptor* descriptor = CallDescriptorOf(node->op());
    2668             : 
    2669             :   FrameStateDescriptor* frame_state_descriptor = nullptr;
    2670     3400922 :   if (descriptor->NeedsFrameState()) {
    2671             :     frame_state_descriptor = GetFrameStateDescriptor(
    2672     4826862 :         node->InputAt(static_cast<int>(descriptor->InputCount())));
    2673             :   }
    2674             : 
    2675     3400920 :   CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
    2676             : 
    2677             :   // Compute InstructionOperands for inputs and outputs.
    2678             :   // TODO(turbofan): on some architectures it's probably better to use
    2679             :   // the code object in a register if there are multiple uses of it.
    2680             :   // Improve constant pool and the heuristics in the register allocator
    2681             :   // for where to emit constants.
    2682             :   CallBufferFlags call_buffer_flags(kCallCodeImmediate | kCallAddressImmediate);
    2683     3400939 :   InitializeCallBuffer(node, &buffer, call_buffer_flags);
    2684             : 
    2685     3400926 :   EmitPrepareArguments(&(buffer.pushed_nodes), descriptor, node);
    2686             : 
    2687             :   // Pass label of exception handler block.
    2688             :   CallDescriptor::Flags flags = descriptor->flags();
    2689     3400869 :   if (handler) {
    2690             :     DCHECK_EQ(IrOpcode::kIfException, handler->front()->opcode());
    2691             :     flags |= CallDescriptor::kHasExceptionHandler;
    2692      462780 :     buffer.instruction_args.push_back(g.Label(handler));
    2693             :   }
    2694             : 
    2695             :   bool from_native_stack = linkage()->GetIncomingDescriptor()->UseNativeStack();
    2696             :   bool to_native_stack = descriptor->UseNativeStack();
    2697     3400869 :   if (from_native_stack != to_native_stack) {
    2698             :     // (arm64 only) Mismatch in the use of stack pointers. One or the other
    2699             :     // has to be restored manually by the code generator.
    2700      177672 :     flags |= to_native_stack ? CallDescriptor::kRestoreJSSP
    2701             :                              : CallDescriptor::kRestoreCSP;
    2702             :   }
    2703             : 
    2704             :   // Select the appropriate opcode based on the call type.
    2705             :   InstructionCode opcode = kArchNop;
    2706     3400869 :   switch (descriptor->kind()) {
    2707             :     case CallDescriptor::kCallAddress:
    2708             :       opcode =
    2709        2084 :           kArchCallCFunction |
    2710        2084 :           MiscField::encode(static_cast<int>(descriptor->ParameterCount()));
    2711        2084 :       break;
    2712             :     case CallDescriptor::kCallCodeObject:
    2713     3247062 :       opcode = kArchCallCodeObject | MiscField::encode(flags);
    2714     3247062 :       break;
    2715             :     case CallDescriptor::kCallJSFunction:
    2716      151767 :       opcode = kArchCallJSFunction | MiscField::encode(flags);
    2717      151767 :       break;
    2718             :   }
    2719             : 
    2720             :   // Emit the call instruction.
    2721     3400869 :   size_t const output_count = buffer.outputs.size();
    2722     3400869 :   auto* outputs = output_count ? &buffer.outputs.front() : nullptr;
    2723             :   Instruction* call_instr =
    2724             :       Emit(opcode, output_count, outputs, buffer.instruction_args.size(),
    2725     6801738 :            &buffer.instruction_args.front());
    2726     6801900 :   if (instruction_selection_failed()) return;
    2727             :   call_instr->MarkAsCall();
    2728             : }
    2729             : 
    2730             : 
    2731     1044582 : void InstructionSelector::VisitTailCall(Node* node) {
    2732             :   OperandGenerator g(this);
    2733      298452 :   CallDescriptor const* descriptor = CallDescriptorOf(node->op());
    2734             :   DCHECK_NE(0, descriptor->flags() & CallDescriptor::kSupportsTailCalls);
    2735             : 
    2736             :   CallDescriptor* caller = linkage()->GetIncomingDescriptor();
    2737             :   DCHECK(caller->CanTailCall(node));
    2738      149226 :   const CallDescriptor* callee = CallDescriptorOf(node->op());
    2739      149226 :   int stack_param_delta = callee->GetStackParameterDelta(caller);
    2740      149226 :   CallBuffer buffer(zone(), descriptor, nullptr);
    2741             : 
    2742             :   // Compute InstructionOperands for inputs and outputs.
    2743             :   CallBufferFlags flags(kCallCodeImmediate | kCallTail);
    2744      149226 :   if (IsTailCallAddressImmediate()) {
    2745             :     flags |= kCallAddressImmediate;
    2746             :   }
    2747      149226 :   InitializeCallBuffer(node, &buffer, flags, stack_param_delta);
    2748             : 
    2749             :   // Select the appropriate opcode based on the call type.
    2750             :   InstructionCode opcode;
    2751             :   InstructionOperandVector temps(zone());
    2752      149226 :   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
    2753        1041 :     switch (descriptor->kind()) {
    2754             :       case CallDescriptor::kCallCodeObject:
    2755             :         opcode = kArchTailCallCodeObjectFromJSFunction;
    2756             :         break;
    2757             :       case CallDescriptor::kCallJSFunction:
    2758             :         opcode = kArchTailCallJSFunctionFromJSFunction;
    2759         177 :         break;
    2760             :       default:
    2761           0 :         UNREACHABLE();
    2762             :         return;
    2763             :     }
    2764        1041 :     int temps_count = GetTempsCountForTailCallFromJSFunction();
    2765        4164 :     for (int i = 0; i < temps_count; i++) {
    2766        6246 :       temps.push_back(g.TempRegister());
    2767             :     }
    2768             :   } else {
    2769      148185 :     switch (descriptor->kind()) {
    2770             :       case CallDescriptor::kCallCodeObject:
    2771             :         opcode = kArchTailCallCodeObject;
    2772             :         break;
    2773             :       case CallDescriptor::kCallAddress:
    2774             :         opcode = kArchTailCallAddress;
    2775       23736 :         break;
    2776             :       default:
    2777           0 :         UNREACHABLE();
    2778             :         return;
    2779             :     }
    2780             :   }
    2781      149226 :   opcode |= MiscField::encode(descriptor->flags());
    2782             : 
    2783      149226 :   Emit(kArchPrepareTailCall, g.NoOutput());
    2784             : 
    2785             :   int first_unused_stack_slot =
    2786             :       (V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK ? 1 : 0) +
    2787      149226 :       stack_param_delta;
    2788      298452 :   buffer.instruction_args.push_back(g.TempImmediate(first_unused_stack_slot));
    2789             : 
    2790             :   // Emit the tailcall instruction.
    2791             :   Emit(opcode, 0, nullptr, buffer.instruction_args.size(),
    2792             :        &buffer.instruction_args.front(), temps.size(),
    2793      447678 :        temps.empty() ? nullptr : &temps.front());
    2794      149226 : }
    2795             : 
    2796             : 
    2797     5916205 : void InstructionSelector::VisitGoto(BasicBlock* target) {
    2798             :   // jump to the next block.
    2799             :   OperandGenerator g(this);
    2800     5916205 :   Emit(kArchJmp, g.NoOutput(), g.Label(target));
    2801     5916252 : }
    2802             : 
    2803     5439605 : void InstructionSelector::VisitReturn(Node* ret) {
    2804             :   OperandGenerator g(this);
    2805     1093932 :   const int input_count = linkage()->GetIncomingDescriptor()->ReturnCount() == 0
    2806             :                               ? 1
    2807     2172469 :                               : ret->op()->ValueInputCount();
    2808             :   DCHECK_GE(input_count, 1);
    2809     1093932 :   auto value_locations = zone()->NewArray<InstructionOperand>(input_count);
    2810     1093925 :   Node* pop_count = ret->InputAt(0);
    2811         910 :   value_locations[0] = (pop_count->opcode() == IrOpcode::kInt32Constant ||
    2812             :                         pop_count->opcode() == IrOpcode::kInt64Constant)
    2813             :                            ? g.UseImmediate(pop_count)
    2814     2186940 :                            : g.UseRegister(pop_count);
    2815     1079302 :   for (int i = 1; i < input_count; ++i) {
    2816             :     value_locations[i] =
    2817     2158544 :         g.UseLocation(ret->InputAt(i), linkage()->GetReturnLocation(i - 1));
    2818             :   }
    2819     1093940 :   Emit(kArchRet, 0, nullptr, input_count, value_locations);
    2820     1093950 : }
    2821             : 
    2822           0 : Instruction* InstructionSelector::EmitDeoptimize(
    2823             :     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
    2824             :     DeoptimizeKind kind, DeoptimizeReason reason, Node* frame_state) {
    2825           0 :   size_t output_count = output.IsInvalid() ? 0 : 1;
    2826           0 :   InstructionOperand inputs[] = {a};
    2827             :   size_t input_count = arraysize(inputs);
    2828             :   return EmitDeoptimize(opcode, output_count, &output, input_count, inputs,
    2829           0 :                         kind, reason, frame_state);
    2830             : }
    2831             : 
    2832      127898 : Instruction* InstructionSelector::EmitDeoptimize(
    2833             :     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
    2834             :     InstructionOperand b, DeoptimizeKind kind, DeoptimizeReason reason,
    2835             :     Node* frame_state) {
    2836      127898 :   size_t output_count = output.IsInvalid() ? 0 : 1;
    2837      127898 :   InstructionOperand inputs[] = {a, b};
    2838             :   size_t input_count = arraysize(inputs);
    2839             :   return EmitDeoptimize(opcode, output_count, &output, input_count, inputs,
    2840      127898 :                         kind, reason, frame_state);
    2841             : }
    2842             : 
    2843      282952 : Instruction* InstructionSelector::EmitDeoptimize(
    2844             :     InstructionCode opcode, size_t output_count, InstructionOperand* outputs,
    2845             :     size_t input_count, InstructionOperand* inputs, DeoptimizeKind kind,
    2846      282960 :     DeoptimizeReason reason, Node* frame_state) {
    2847             :   OperandGenerator g(this);
    2848      282952 :   FrameStateDescriptor* const descriptor = GetFrameStateDescriptor(frame_state);
    2849             :   InstructionOperandVector args(instruction_zone());
    2850      282953 :   args.reserve(input_count + 1 + descriptor->GetTotalSize());
    2851      888259 :   for (size_t i = 0; i < input_count; ++i) {
    2852      605299 :     args.push_back(inputs[i]);
    2853             :   }
    2854      282960 :   opcode |= MiscField::encode(static_cast<int>(input_count));
    2855             :   int const state_id =
    2856      282960 :       sequence()->AddDeoptimizationEntry(descriptor, kind, reason);
    2857      565911 :   args.push_back(g.TempImmediate(state_id));
    2858             :   StateObjectDeduplicator deduplicator(instruction_zone());
    2859             :   AddInputsToFrameStateDescriptor(descriptor, frame_state, &g, &deduplicator,
    2860             :                                   &args, FrameStateInputKind::kAny,
    2861      282955 :                                   instruction_zone());
    2862             :   return Emit(opcode, output_count, outputs, args.size(), &args.front(), 0,
    2863      565922 :               nullptr);
    2864             : }
    2865             : 
    2866      110406 : void InstructionSelector::EmitIdentity(Node* node) {
    2867             :   OperandGenerator g(this);
    2868             :   MarkAsUsed(node->InputAt(0));
    2869      110406 :   SetRename(node, node->InputAt(0));
    2870      110407 : }
    2871             : 
    2872           0 : void InstructionSelector::VisitDeoptimize(DeoptimizeKind kind,
    2873             :                                           DeoptimizeReason reason,
    2874             :                                           Node* value) {
    2875       16280 :   EmitDeoptimize(kArchDeoptimize, 0, nullptr, 0, nullptr, kind, reason, value);
    2876           0 : }
    2877             : 
    2878           0 : void InstructionSelector::VisitThrow(Node* node) {
    2879             :   OperandGenerator g(this);
    2880       40076 :   Emit(kArchThrowTerminator, g.NoOutput());
    2881           0 : }
    2882             : 
    2883           0 : void InstructionSelector::VisitDebugBreak(Node* node) {
    2884             :   OperandGenerator g(this);
    2885        9087 :   Emit(kArchDebugBreak, g.NoOutput());
    2886           0 : }
    2887             : 
    2888           0 : void InstructionSelector::VisitComment(Node* node) {
    2889             :   OperandGenerator g(this);
    2890           0 :   InstructionOperand operand(g.UseImmediate(node));
    2891           0 :   Emit(kArchComment, 0, nullptr, 1, &operand);
    2892           0 : }
    2893             : 
    2894           0 : void InstructionSelector::VisitUnsafePointerAdd(Node* node) {
    2895             : #if V8_TARGET_ARCH_64_BIT
    2896        3661 :   VisitInt64Add(node);
    2897             : #else   // V8_TARGET_ARCH_64_BIT
    2898             :   VisitInt32Add(node);
    2899             : #endif  // V8_TARGET_ARCH_64_BIT
    2900           0 : }
    2901             : 
    2902        6514 : void InstructionSelector::VisitRetain(Node* node) {
    2903             :   OperandGenerator g(this);
    2904        6514 :   Emit(kArchNop, g.NoOutput(), g.UseAny(node->InputAt(0)));
    2905        6514 : }
    2906             : 
    2907        2007 : bool InstructionSelector::CanProduceSignalingNaN(Node* node) {
    2908             :   // TODO(jarin) Improve the heuristic here.
    2909        3805 :   if (node->opcode() == IrOpcode::kFloat64Add ||
    2910        3796 :       node->opcode() == IrOpcode::kFloat64Sub ||
    2911             :       node->opcode() == IrOpcode::kFloat64Mul) {
    2912             :     return false;
    2913             :   }
    2914           0 :   return true;
    2915             : }
    2916             : 
    2917     2916610 : FrameStateDescriptor* InstructionSelector::GetFrameStateDescriptor(
    2918             :     Node* state) {
    2919             :   DCHECK(state->opcode() == IrOpcode::kFrameState);
    2920             :   DCHECK_EQ(kFrameStateInputCount, state->InputCount());
    2921     2916610 :   FrameStateInfo state_info = OpParameter<FrameStateInfo>(state);
    2922             : 
    2923             :   int parameters = static_cast<int>(
    2924     2916610 :       StateValuesAccess(state->InputAt(kFrameStateParametersInput)).size());
    2925             :   int locals = static_cast<int>(
    2926     2916621 :       StateValuesAccess(state->InputAt(kFrameStateLocalsInput)).size());
    2927             :   int stack = static_cast<int>(
    2928     2916612 :       StateValuesAccess(state->InputAt(kFrameStateStackInput)).size());
    2929             : 
    2930             :   DCHECK_EQ(parameters, state_info.parameter_count());
    2931             :   DCHECK_EQ(locals, state_info.local_count());
    2932             : 
    2933             :   FrameStateDescriptor* outer_state = nullptr;
    2934     2916620 :   Node* outer_node = state->InputAt(kFrameStateOuterStateInput);
    2935     2916620 :   if (outer_node->opcode() == IrOpcode::kFrameState) {
    2936      220236 :     outer_state = GetFrameStateDescriptor(outer_node);
    2937             :   }
    2938             : 
    2939             :   return new (instruction_zone()) FrameStateDescriptor(
    2940             :       instruction_zone(), state_info.type(), state_info.bailout_id(),
    2941             :       state_info.state_combine(), parameters, locals, stack,
    2942     5833248 :       state_info.shared_info(), outer_state);
    2943             : }
    2944             : 
    2945             : 
    2946             : }  // namespace compiler
    2947             : }  // namespace internal
    2948             : }  // namespace v8

Generated by: LCOV version 1.10