handle WASM trap in the instruction scheduler.

src/compiler/instruction-scheduler.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/instruction-scheduler.h"
 
 #include "src/base/adapters.h"
 #include "src/base/utils/random-number-generator.h"
 
 namespace v8 {
@@ skipping 59 matching lines @@
       start_cycle_(-1) {
 }
 
 
 void InstructionScheduler::ScheduleGraphNode::AddSuccessor(
     ScheduleGraphNode* node) {
   successors_.push_back(node);
   node->unscheduled_predecessors_count_++;
 }
 
-
 InstructionScheduler::InstructionScheduler(Zone* zone,
                                            InstructionSequence* sequence)
     : zone_(zone),
       sequence_(sequence),
       graph_(zone),
       last_side_effect_instr_(nullptr),
       pending_loads_(zone),
       last_live_in_reg_marker_(nullptr),
-      last_deopt_(nullptr),
+      last_deopt_or_trap_(nullptr),
       operands_map_(zone) {}
 
-
 void InstructionScheduler::StartBlock(RpoNumber rpo) {
   DCHECK(graph_.empty());
   DCHECK(last_side_effect_instr_ == nullptr);
   DCHECK(pending_loads_.empty());
   DCHECK(last_live_in_reg_marker_ == nullptr);
-  DCHECK(last_deopt_ == nullptr);
+  DCHECK(last_deopt_or_trap_ == nullptr);
   DCHECK(operands_map_.empty());
   sequence()->StartBlock(rpo);
 }
 
 
 void InstructionScheduler::EndBlock(RpoNumber rpo) {
   if (FLAG_turbo_stress_instruction_scheduling) {
     ScheduleBlock<StressSchedulerQueue>();
   } else {
     ScheduleBlock<CriticalPathFirstQueue>();
   }
   sequence()->EndBlock(rpo);
   graph_.clear();
   last_side_effect_instr_ = nullptr;
   pending_loads_.clear();
   last_live_in_reg_marker_ = nullptr;
-  last_deopt_ = nullptr;
+  last_deopt_or_trap_ = nullptr;
   operands_map_.clear();
 }
 
 
 void InstructionScheduler::AddInstruction(Instruction* instr) {
   ScheduleGraphNode* new_node = new (zone()) ScheduleGraphNode(zone(), instr);
 
   if (IsBlockTerminator(instr)) {
     // Make sure that basic block terminators are not moved by adding them
     // as successor of every instruction.
     for (ScheduleGraphNode* node : graph_) {
       node->AddSuccessor(new_node);
     }
   } else if (IsFixedRegisterParameter(instr)) {
     if (last_live_in_reg_marker_ != nullptr) {
       last_live_in_reg_marker_->AddSuccessor(new_node);
     }
     last_live_in_reg_marker_ = new_node;
   } else {
     if (last_live_in_reg_marker_ != nullptr) {
       last_live_in_reg_marker_->AddSuccessor(new_node);
     }
 
     // Make sure that instructions are not scheduled before the last
-    // deoptimization point when they depend on it.
-    if ((last_deopt_ != nullptr) && DependsOnDeoptimization(instr)) {
-      last_deopt_->AddSuccessor(new_node);
+    // deoptimization or trap point when they depend on it.
+    if ((last_deopt_or_trap_ != nullptr) && DependsOnDeoptOrTrap(instr)) {
+      last_deopt_or_trap_->AddSuccessor(new_node);
     }
 
     // Instructions with side effects and memory operations can't be
     // reordered with respect to each other.
     if (HasSideEffect(instr)) {
       if (last_side_effect_instr_ != nullptr) {
         last_side_effect_instr_->AddSuccessor(new_node);
       }
       for (ScheduleGraphNode* load : pending_loads_) {
         load->AddSuccessor(new_node);
       }
       pending_loads_.clear();
       last_side_effect_instr_ = new_node;
     } else if (IsLoadOperation(instr)) {
       // Load operations can't be reordered with side effects instructions but
       // independent loads can be reordered with respect to each other.
       if (last_side_effect_instr_ != nullptr) {
         last_side_effect_instr_->AddSuccessor(new_node);
       }
       pending_loads_.push_back(new_node);
-    } else if (instr->IsDeoptimizeCall()) {
-      // Ensure that deopts are not reordered with respect to side-effect
-      // instructions.
+    } else if (instr->IsDeoptimizeCall() || instr->IsTrap()) {
+      // Ensure that deopts or traps are not reordered with respect to
+      // side-effect instructions.
       if (last_side_effect_instr_ != nullptr) {
         last_side_effect_instr_->AddSuccessor(new_node);
       }
-      last_deopt_ = new_node;
+      last_deopt_or_trap_ = new_node;
     }
 
     // Look for operand dependencies.
     for (size_t i = 0; i < instr->InputCount(); ++i) {
       const InstructionOperand* input = instr->InputAt(i);
       if (input->IsUnallocated()) {
         int32_t vreg = UnallocatedOperand::cast(input)->virtual_register();
         auto it = operands_map_.find(vreg);
         if (it != operands_map_.end()) {
           it->second->AddSuccessor(new_node);
@@ skipping 210 matching lines @@
       }
     }
 
     node->set_total_latency(max_latency + node->latency());
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8