[turbofan] Jump threading awareness of frame elision.

src/compiler/jump-threading.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/jump-threading.h"
 #include "src/compiler/code-generator-impl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 35 matching lines @@
       TRACE("  fw %d -> %d (forward)\n", from.ToInt(), to.ToInt());
       result[from.ToInt()] = to_to;  // forward the block.
       forwarded = true;
     }
     if (pop) stack.pop();
   }
   RpoNumber unvisited() { return RpoNumber::FromInt(-1); }
   RpoNumber onstack() { return RpoNumber::FromInt(-2); }
 };
 
-
 bool JumpThreading::ComputeForwarding(Zone* local_zone,
                                       ZoneVector<RpoNumber>& result,
-                                      InstructionSequence* code) {
+                                      InstructionSequence* code,
+                                      bool frame_at_start) {
   ZoneStack<RpoNumber> stack(local_zone);
   JumpThreadingState state = {false, result, stack};
   state.Clear(code->InstructionBlockCount());
 
   // Iterate over the blocks forward, pushing the blocks onto the stack.
   for (auto const block : code->instruction_blocks()) {
     RpoNumber current = block->rpo_number();
     state.PushIfUnvisited(current);
 
     // Process the stack, which implements DFS through empty blocks.
@@ skipping 14 matching lines @@
           // can't skip instructions with flags continuations.
           TRACE("  flags\n");
           fallthru = false;
         } else if (instr->IsNop()) {
           // skip nops.
           TRACE("  nop\n");
           continue;
         } else if (instr->arch_opcode() == kArchJmp) {
           // try to forward the jump instruction.
           TRACE("  jmp\n");
-          fw = code->InputRpo(instr, 0);
+          // if this block deconstructs the frame, we can't forward it.
+          // TODO(mtrofin): we can still forward if we end up building
+          // the frame at start. So we should move the decision of whether
+          // to build a frame or not in the register allocator, and trickle it
+          // here and to the code generator.
+          if (frame_at_start || !block->must_deconstruct_frame()) {
+            fw = code->InputRpo(instr, 0);
+          }
           fallthru = false;
         } else {
           // can't skip other instructions.
           TRACE("  other\n");
           fallthru = false;
         }
         break;
       }
       if (fallthru) {
         int next = 1 + block->rpo_number().ToInt();
@@ skipping 78 matching lines @@
     if (block->IsDeferred()) {
       block->set_ao_number(RpoNumber::FromInt(ao));
       if (!skip[block->rpo_number().ToInt()]) ao++;
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8