[Interpreter] Local flow control in the bytecode graph builder.

src/compiler/bytecode-graph-builder.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/bytecode-graph-builder.h"
 
+#include "src/compiler/bytecode-basic-block-analysis.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/operator-properties.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecodes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Issues:
@@ skipping 31 matching lines @@
   // Registers
   register_base_ = static_cast<int>(values()->size());
   Node* undefined_constant = builder->jsgraph()->UndefinedConstant();
   values()->insert(values()->end(), register_count, undefined_constant);
 
   // Accumulator
   accumulator_ = undefined_constant;
 }
 
 
+BytecodeGraphBuilder::Environment::Environment(
+    const BytecodeGraphBuilder::Environment* other)
+    : builder_(other->builder_),
+      register_count_(other->register_count_),
+      parameter_count_(other->parameter_count_),
+      accumulator_(other->accumulator_),
+      context_(other->context_),
+      control_dependency_(other->control_dependency_),
+      effect_dependency_(other->effect_dependency_),
+      values_(other->zone()),
+      register_base_(other->register_base_) {
+  values_ = other->values_;
+}
+
+
 int BytecodeGraphBuilder::Environment::RegisterToValuesIndex(
     interpreter::Register the_register) const {
   if (the_register.is_parameter()) {
     return the_register.ToParameterIndex(parameter_count());
   } else {
     return the_register.index() + register_base();
   }
 }
 
 
@@ skipping 32 matching lines @@
 bool BytecodeGraphBuilder::Environment::IsMarkedAsUnreachable() const {
   return GetControlDependency()->opcode() == IrOpcode::kDead;
 }
 
 
 void BytecodeGraphBuilder::Environment::MarkAsUnreachable() {
   UpdateControlDependency(builder()->jsgraph()->Dead());
 }
 
 
+BytecodeGraphBuilder::Environment*
+BytecodeGraphBuilder::Environment::CopyForLoop() {
+  PrepareForLoop();
+  return new (zone()) Environment(this);
+}
+
+
+BytecodeGraphBuilder::Environment*
+BytecodeGraphBuilder::Environment::CopyForConditional() const {
+  return new (zone()) Environment(this);
+}
+
+
+void BytecodeGraphBuilder::Environment::Merge(
+    BytecodeGraphBuilder::Environment* other) {
+  // Nothing to do if the other environment is dead.
+  if (other->IsMarkedAsUnreachable()) {
+    return;
+  }
+
+  // Create a merge of the control dependencies of both environments and update
+  // the current environment's control dependency accordingly.
+  Node* control = builder()->MergeControl(GetControlDependency(),
+                                          other->GetControlDependency());
+  UpdateControlDependency(control);
+
+  // Create a merge of the effect dependencies of both environments and update
+  // the current environment's effect dependency accordingly.
+  Node* effect = builder()->MergeEffect(GetEffectDependency(),
+                                        other->GetEffectDependency(), control);
+  UpdateEffectDependency(effect);
+
+  // Introduce Phi nodes for values that have differing input at merge points,
+  // potentially extending an existing Phi node if possible.
+  accumulator_ =
+      builder()->MergeValue(accumulator_, other->accumulator_, control);
+  context_ = builder()->MergeValue(context_, other->context_, control);
+  for (int i = 0; i < static_cast<int>(values_.size()); i++) {
+    values_[i] = builder()->MergeValue(values_[i], other->values_[i], control);
+  }
+}
+
+
+void BytecodeGraphBuilder::Environment::PrepareForLoop() {
+  Node* control = builder()->NewLoop();
+  accumulator_ = builder()->NewPhi(1, accumulator_, control);
+  context_ = builder()->NewPhi(1, context_, control);
+
+  int size = static_cast<int>(values()->size());
+  for (int i = 0; i < size; i++) {
+    values()->at(i) = builder()->NewPhi(1, values()->at(i), control);
+  }
+  Node* effect = builder_->NewEffectPhi(1, GetEffectDependency(), control);
+  UpdateEffectDependency(effect);
+
+  Node* terminate = builder()->graph()->NewNode(
+      builder()->common()->Terminate(), effect, control);
+  builder()->exit_controls_.push_back(terminate);
+}
+
+
 BytecodeGraphBuilder::BytecodeGraphBuilder(Zone* local_zone,
                                            CompilationInfo* compilation_info,
                                            JSGraph* jsgraph)
     : local_zone_(local_zone),
       info_(compilation_info),
       jsgraph_(jsgraph),
+      block_environment_infos_(local_zone),
       input_buffer_size_(0),
       input_buffer_(nullptr),
       exit_controls_(local_zone) {
   bytecode_array_ = handle(info()->shared_info()->bytecode_array());
 }
 
 
 Node* BytecodeGraphBuilder::GetNewTarget() {
   if (!new_target_.is_set()) {
     int params = bytecode_array()->parameter_count();
@@ skipping 108 matching lines @@
   Node* end = graph()->NewNode(common()->End(input_count), input_count, inputs);
   graph()->SetEnd(end);
 
   return true;
 }
 
 
 void BytecodeGraphBuilder::CreateGraphBody(bool stack_check) {
   // TODO(oth): Review ast-graph-builder equivalent, i.e. arguments
   // object setup, this function variable if used, tracing hooks.
-  VisitBytecodes();
+  VisitBasicBlocks();
 }
 
 
-void BytecodeGraphBuilder::VisitBytecodes() {
+void BytecodeGraphBuilder::VisitBasicBlocks() {
+  BytecodeBasicBlockAnalysis analyzer(local_zone(), bytecode_array());
+  const ZoneVector<BytecodeBasicBlock*>* blocks = analyzer.Analyze();
+
+  block_environment_infos_.resize(blocks->size());
+  for (auto block_iter = blocks->begin(); block_iter != blocks->end();
+       block_iter++) {
+    VisitBytecodesInBasicBlock(*block_iter);
+  }
+}
+
+void BytecodeGraphBuilder::VisitBytecodesInBasicBlock(
+    BytecodeBasicBlock* block) {
+  set_basic_block(block);
+  PrepareForNewBasicBlockVisit();
+
   interpreter::BytecodeArrayIterator iterator(bytecode_array());
-  while (!iterator.done()) {
+  iterator.AdvanceToOffset(basic_block()->start());
+  while (!iterator.done() &&
+         iterator.current_offset() != basic_block()->end()) {
     switch (iterator.current_bytecode()) {
 #define BYTECODE_CASE(name, ...)       \
   case interpreter::Bytecode::k##name: \
     Visit##name(iterator);             \
     break;
       BYTECODE_LIST(BYTECODE_CASE)
 #undef BYTECODE_CODE
     }
     iterator.Advance();
   }
+  CompleteNewBasicBlockVisit();
 }
 
 
 void BytecodeGraphBuilder::VisitLdaZero(
     const interpreter::BytecodeArrayIterator& iterator) {
   Node* node = jsgraph()->ZeroConstant();
   environment()->BindAccumulator(node);
 }
 
 
@@ skipping 840 matching lines @@
 
 
 void BytecodeGraphBuilder::VisitToObject(
     const interpreter::BytecodeArrayIterator& iterator) {
   BuildCastOperator(javascript()->ToObject(), iterator);
 }
 
 
 void BytecodeGraphBuilder::VisitJump(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  BuildJump();
 }
 
 
 void BytecodeGraphBuilder::VisitJumpConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  BuildJump();
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfTrue(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->TrueConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfTrueConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->TrueConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);

[rmcilroy, 2015/12/08 13:25:07]

Please factor out the common code here into a BuildJumpIfValueEquals(Node*
comperand) helper function, and call it from
VisitJumpIfTrue/Constant/False/Null/Undefined, etc.

[oth, 2015/12/09 11:26:45]

I'd like to keep the control flow aspects and condition building separate so
these methods now look like:

Node* condition = BuildConditionForJump...
BuildConditionalJump(condition)

 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfFalse(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->FalseConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfFalseConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->FalseConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfToBooleanTrue(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* to_boolean =
+      NewNode(javascript()->ToBoolean(ToBooleanHint::kAny), accumulator);
+  Node* comperand = jsgraph()->TrueConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), to_boolean, comperand);
+  BuildConditionalJump(comparison);

[rmcilroy, 2015/12/08 13:25:07]

ditto, with a BuildJumpIfToBooleanValueEquals(...)

[oth, 2015/12/09 11:26:45]

Done.

 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfToBooleanTrueConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* to_boolean =
+      NewNode(javascript()->ToBoolean(ToBooleanHint::kAny), accumulator);
+  Node* comperand = jsgraph()->TrueConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), to_boolean, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfToBooleanFalse(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* to_boolean =
+      NewNode(javascript()->ToBoolean(ToBooleanHint::kAny), accumulator);
+  Node* comperand = jsgraph()->FalseConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), to_boolean, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfToBooleanFalseConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* to_boolean =
+      NewNode(javascript()->ToBoolean(ToBooleanHint::kAny), accumulator);
+  Node* comperand = jsgraph()->FalseConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), to_boolean, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfNull(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->NullConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfNullConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->NullConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfUndefined(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->UndefinedConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitJumpIfUndefinedConstant(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  Node* accumulator = environment()->LookupAccumulator();
+  Node* comperand = jsgraph()->UndefinedConstant();
+  Node* comparison =
+      NewNode(javascript()->StrictEqual(), accumulator, comperand);
+  BuildConditionalJump(comparison);
 }
 
 
 void BytecodeGraphBuilder::VisitReturn(
     const interpreter::BytecodeArrayIterator& iterator) {
   Node* control =
       NewNode(common()->Return(), environment()->LookupAccumulator());
   UpdateControlDependencyToLeaveFunction(control);
+  BuildReturn();
 }
 
 
 void BytecodeGraphBuilder::VisitForInPrepare(
     const interpreter::BytecodeArrayIterator& iterator) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGraphBuilder::VisitForInNext(
     const interpreter::BytecodeArrayIterator& iterator) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGraphBuilder::VisitForInDone(
     const interpreter::BytecodeArrayIterator& iterator) {
   UNIMPLEMENTED();
 }
 
 
+void BytecodeGraphBuilder::PrepareForNewBasicBlockVisit() {

[rmcilroy, 2015/12/08 13:25:07]

nit - I would drop the "new" here, but don't really mind if you want to keep it.

[oth, 2015/12/09 11:26:45]

Done.

+  int block_id = basic_block()->rpo_id();
+
+  DCHECK_NULL(block_environment_infos_[block_id]);
+  block_environment_infos_[block_id] =
+      new (local_zone()) BlockEnvironmentInfo();
+
+  // Count number of forward and back links to this block
+  int back_edges = 0;
+
+  // Merge forward links and check for backwards edges
+  bool default_done = false;
+  for (size_t i = 0; i < basic_block()->incoming_count(); i++) {
+    const BytecodeBasicBlock* incoming = basic_block()->incoming(i);
+    if (incoming->is_dominated_by(basic_block())) {
+      back_edges++;
+    } else {
+      Environment* preceding_environment;
+      if (incoming->if_true() == basic_block()) {
+        preceding_environment =
+            block_environment_infos_[incoming->rpo_id()]->if_true_environment();
+      } else {
+        DCHECK_EQ(incoming->if_false(), basic_block());
+        preceding_environment = block_environment_infos_[incoming->rpo_id()]
+                                    ->if_false_environment();
+      }
+
+      DCHECK_NOT_NULL(preceding_environment);
+      if (default_done) {

[rmcilroy, 2015/12/08 13:25:07]

Could you get rid of the default_done boolean by adding a
DCHECK_NULL(environment()) at the top of this function, and then doing: 
  if (environment()) {
    environment()->Merge(preceding_environment);
  } else {
    set_environment(preceding_environment);
  }

If this doesn't work, could you rename "default_done" to something else (the
"default" is a bit confusing to me since it makes me think this incoming path
has some kind of special control flow or something).

[oth, 2015/12/09 11:26:45]

Done.

+        environment()->Merge(preceding_environment);
+      } else {
+        set_environment(preceding_environment);
+        default_done = true;
+      }
+    }
+  }
+
+  if (back_edges) {

[rmcilroy, 2015/12/08 13:25:07]

nit - back_edges != 0

[oth, 2015/12/09 11:26:45]

Done.

+    Environment* loop_env = environment()->CopyForLoop();
+    block_environment_infos_[block_id]->set_loop_header_environment(loop_env);
+  }
+}
+
+
+void BytecodeGraphBuilder::CompleteNewBasicBlockVisit() {

[rmcilroy, 2015/12/08 13:25:07]

ditto

[oth, 2015/12/09 11:26:45]

Done.

+  if (!basic_block()->is_exit()) {
+    int last_offset = basic_block()->last_bytecode_offset();
+    interpreter::Bytecode last_bytecode =
+        interpreter::Bytecodes::FromByte(bytecode_array()->get(last_offset));
+    if (!interpreter::Bytecodes::IsLocalControlFlow(last_bytecode)) {

[rmcilroy, 2015/12/08 13:25:08]

Could you do the IsLocalControlFlow check in the bytecode analyzer and add a
flag for it on the basic_block?

[oth, 2015/12/09 11:26:45]

Done.

+      DCHECK_NOT_NULL(basic_block()->if_true());
+      DCHECK_NULL(basic_block()->if_false());
+      DCHECK(basic_block()->if_true() != nullptr);
+      DCHECK_NOT_NULL(environment());

[rmcilroy, 2015/12/08 13:25:08]

Should environment not always be non-null at this point? Could we move this
DCHECK out of the conditinoals to the start of the function?

[oth, 2015/12/09 11:26:45]

Change to make the invariant true.

+      int block_id = basic_block()->rpo_id();
+      block_environment_infos_[block_id]->set_if_true_environment(
+          environment());
+      BuildBackEdgeIfRequired(basic_block()->if_true());

[rmcilroy, 2015/12/08 13:25:07]

Would be good to have a comment here one why what appears to be a fallthrough
basic block might actually be a back edge from the point of view of the TF graph
due to loop headers 

[oth, 2015/12/09 11:26:45]

Done.

+    }
+  }
+  set_environment(nullptr);
+}
+
+
+void BytecodeGraphBuilder::BuildReturn() {
+  DCHECK_NOT_NULL(basic_block()->if_true());
+  DCHECK_NULL(basic_block()->if_false());
+  int block_id = basic_block()->rpo_id();
+  block_environment_infos_[block_id]->set_if_true_environment(environment());
+  set_environment(nullptr);
+}
+
+
+void BytecodeGraphBuilder::BuildBackEdgeIfRequired(BytecodeBasicBlock* target) {

[rmcilroy, 2015/12/08 13:25:07]

nit - move above BuildReturn (group BuildReturn / Jump / etc.)

[oth, 2015/12/09 11:26:45]

Done.

+  if (basic_block()->is_dominated_by(target)) {
+    BytecodeBasicBlock* loop_header = target;
+    BlockEnvironmentInfo* info =
+        block_environment_infos_[loop_header->rpo_id()];
+    info->loop_header_environment()->Merge(environment());
+  }
+}
+
+
+void BytecodeGraphBuilder::BuildJump() {
+  DCHECK_NOT_NULL(basic_block()->if_true());
+  DCHECK_NULL(basic_block()->if_false());
+  int block_id = basic_block()->rpo_id();
+  block_environment_infos_[block_id]->set_if_true_environment(environment());
+  BuildBackEdgeIfRequired(basic_block()->if_true());
+  set_environment(nullptr);
+}
+
+
+void BytecodeGraphBuilder::BuildConditionalJump(Node* condition) {
+  DCHECK_NOT_NULL(basic_block()->if_true());
+  DCHECK_NOT_NULL(basic_block()->if_false());
+  int block_id = basic_block()->rpo_id();
+  NewBranch(condition);
+  // Save environment for false branch.
+  Environment* saved_env = environment()->CopyForConditional();
+  // Process true branch.
+  NewIfTrue();
+  block_environment_infos_[block_id]->set_if_true_environment(environment());
+  BuildBackEdgeIfRequired(basic_block()->if_true());
+  // Restore environment and process false branch.
+  set_environment(saved_env);
+  NewIfFalse();
+  block_environment_infos_[block_id]->set_if_false_environment(environment());
+  BuildBackEdgeIfRequired(basic_block()->if_false());
+  set_environment(nullptr);
+}
+
+
 Node** BytecodeGraphBuilder::EnsureInputBufferSize(int size) {
   if (size > input_buffer_size_) {
     size = size + kInputBufferSizeIncrement + input_buffer_size_;
     input_buffer_ = local_zone()->NewArray<Node*>(size);
     input_buffer_size_ = size;
   }
   return input_buffer_;
 }
 
 
@@ skipping 52 matching lines @@
         Node* on_success = graph()->NewNode(if_success, result);
         environment_->UpdateControlDependency(on_success);
       }
     }
   }
 
   return result;
 }
 
 
+Node* BytecodeGraphBuilder::NewPhi(int count, Node* input, Node* control) {
+  const Operator* phi_op = common()->Phi(kMachAnyTagged, count);
+  Node** buffer = EnsureInputBufferSize(count + 1);
+  MemsetPointer(buffer, input, count);
+  buffer[count] = control;
+  return graph()->NewNode(phi_op, count + 1, buffer, true);
+}
+
+
+// TODO(mstarzinger): Revisit this once we have proper effect states.
+Node* BytecodeGraphBuilder::NewEffectPhi(int count, Node* input,
+                                         Node* control) {
+  const Operator* phi_op = common()->EffectPhi(count);
+  Node** buffer = EnsureInputBufferSize(count + 1);
+  MemsetPointer(buffer, input, count);
+  buffer[count] = control;
+  return graph()->NewNode(phi_op, count + 1, buffer, true);
+}
+
+
 Node* BytecodeGraphBuilder::MergeControl(Node* control, Node* other) {
   int inputs = control->op()->ControlInputCount() + 1;
   if (control->opcode() == IrOpcode::kLoop) {
     // Control node for loop exists, add input.
     const Operator* op = common()->Loop(inputs);
     control->AppendInput(graph_zone(), other);
     NodeProperties::ChangeOp(control, op);
   } else if (control->opcode() == IrOpcode::kMerge) {
     // Control node for merge exists, add input.
     const Operator* op = common()->Merge(inputs);
     control->AppendInput(graph_zone(), other);
     NodeProperties::ChangeOp(control, op);
   } else {
     // Control node is a singleton, introduce a merge.
     const Operator* op = common()->Merge(inputs);
     Node* merge_inputs[] = {control, other};
     control = graph()->NewNode(op, arraysize(merge_inputs), merge_inputs, true);
   }
   return control;
 }
 
 
+Node* BytecodeGraphBuilder::MergeEffect(Node* value, Node* other,
+                                        Node* control) {
+  int inputs = control->op()->ControlInputCount();
+  if (value->opcode() == IrOpcode::kEffectPhi &&
+      NodeProperties::GetControlInput(value) == control) {
+    // Phi already exists, add input.
+    value->InsertInput(graph_zone(), inputs - 1, other);
+    NodeProperties::ChangeOp(value, common()->EffectPhi(inputs));
+  } else if (value != other) {
+    // Phi does not exist yet, introduce one.
+    value = NewEffectPhi(inputs, value, control);
+    value->ReplaceInput(inputs - 1, other);
+  }
+  return value;
+}
+
+
+Node* BytecodeGraphBuilder::MergeValue(Node* value, Node* other,
+                                       Node* control) {
+  int inputs = control->op()->ControlInputCount();
+  if (value->opcode() == IrOpcode::kPhi &&
+      NodeProperties::GetControlInput(value) == control) {
+    // Phi already exists, add input.
+    value->InsertInput(graph_zone(), inputs - 1, other);
+    NodeProperties::ChangeOp(value, common()->Phi(kMachAnyTagged, inputs));
+  } else if (value != other) {
+    // Phi does not exist yet, introduce one.
+    value = NewPhi(inputs, value, control);
+    value->ReplaceInput(inputs - 1, other);
+  }
+  return value;
+}
+
+
 void BytecodeGraphBuilder::UpdateControlDependencyToLeaveFunction(Node* exit) {
   if (environment()->IsMarkedAsUnreachable()) return;
   environment()->MarkAsUnreachable();
   exit_controls_.push_back(exit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8