[stubs] Removes the BranchIf.*() methods from CodeAssembler, changes their uses to Branch().

src/interpreter/interpreter-assembler.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/interpreter/interpreter-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 79 matching lines @@
 
   Variable cur_depth(this, MachineRepresentation::kWord32);
   cur_depth.Bind(depth);
 
   Label context_found(this);
 
   Variable* context_search_loop_variables[2] = {&cur_depth, &cur_context};
   Label context_search(this, 2, context_search_loop_variables);
 
   // Fast path if the depth is 0.
-  BranchIfWord32Equal(depth, Int32Constant(0), &context_found, &context_search);
+  Branch(Word32Equal(depth, Int32Constant(0)), &context_found, &context_search);
 
   // Loop until the depth is 0.
   Bind(&context_search);
   {
     cur_depth.Bind(Int32Sub(cur_depth.value(), Int32Constant(1)));
     cur_context.Bind(
         LoadContextSlot(cur_context.value(), Context::PREVIOUS_INDEX));
 
-    BranchIfWord32Equal(cur_depth.value(), Int32Constant(0), &context_found,
-                        &context_search);
+    Branch(Word32Equal(cur_depth.value(), Int32Constant(0)), &context_found,
+           &context_search);
   }
 
   Bind(&context_found);
   return cur_context.value();
 }
 
 void InterpreterAssembler::GotoIfHasContextExtensionUpToDepth(Node* context,
                                                               Node* depth,
                                                               Label* target) {
   Variable cur_context(this, MachineRepresentation::kTaggedPointer);
@@ skipping 451 matching lines @@
   // Slot id of 0 is used to indicate no typefeedback is available. Call using
   // call builtin.
   STATIC_ASSERT(TypeFeedbackVector::kReservedIndexCount > 0);
   Node* is_feedback_unavailable = Word32Equal(slot_id, Int32Constant(0));
   GotoIf(is_feedback_unavailable, &call_without_feedback);
 
   // The checks. First, does function match the recorded monomorphic target?
   Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id);
   Node* feedback_value = LoadWeakCellValue(feedback_element);
   Node* is_monomorphic = WordEqual(function, feedback_value);
-  BranchIf(is_monomorphic, &handle_monomorphic, &extra_checks);
+  Branch(is_monomorphic, &handle_monomorphic, &extra_checks);
 
   Bind(&handle_monomorphic);
   {
     // The compare above could have been a SMI/SMI comparison. Guard against
     // this convincing us that we have a monomorphic JSFunction.
     Node* is_smi = TaggedIsSmi(function);
     GotoIf(is_smi, &extra_checks);
 
     // Increment the call count.
     IncrementCallCount(type_feedback_vector, slot_id);
@@ skipping 10 matching lines @@
 
   Bind(&extra_checks);
   {
     Label check_initialized(this, Label::kDeferred), mark_megamorphic(this),
         check_allocation_site(this),
         create_allocation_site(this, Label::kDeferred);
     // Check if it is a megamorphic target
     Node* is_megamorphic = WordEqual(
         feedback_element,
         HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())));
-    BranchIf(is_megamorphic, &call, &check_allocation_site);
+    Branch(is_megamorphic, &call, &check_allocation_site);
 
     Bind(&check_allocation_site);
     {
       Node* is_allocation_site =
           WordEqual(LoadMap(feedback_element),
                     LoadRoot(Heap::kAllocationSiteMapRootIndex));
       GotoUnless(is_allocation_site, &check_initialized);
 
       // If it is not the Array() function, mark megamorphic.
       Node* context_slot =
@@ skipping 150 matching lines @@
   GotoIf(is_feedback_unavailable, &call_construct);
 
   // Check that the constructor is not a smi.
   Node* is_smi = TaggedIsSmi(constructor);
   GotoIf(is_smi, &call_construct);
 
   // Check that constructor is a JSFunction.
   Node* instance_type = LoadInstanceType(constructor);
   Node* is_js_function =
       WordEqual(instance_type, Int32Constant(JS_FUNCTION_TYPE));
-  BranchIf(is_js_function, &js_function, &call_construct);
+  Branch(is_js_function, &js_function, &call_construct);
 
   Bind(&js_function);
   {
     // Cache the called function in a feedback vector slot. Cache states
     // are uninitialized, monomorphic (indicated by a JSFunction), and
     // megamorphic.
     // TODO(mythria/v8:5210): Check if it is better to mark extra_checks as a
     // deferred block so that call_construct_function will be scheduled.
     Label extra_checks(this), call_construct_function(this);
 
     Node* feedback_element =
         LoadFixedArrayElement(type_feedback_vector, slot_id);
     Node* feedback_value = LoadWeakCellValue(feedback_element);
     Node* is_monomorphic = WordEqual(constructor, feedback_value);
-    BranchIf(is_monomorphic, &call_construct_function, &extra_checks);
+    Branch(is_monomorphic, &call_construct_function, &extra_checks);
 
     Bind(&extra_checks);
     {
       Label mark_megamorphic(this), initialize(this),
           check_allocation_site(this), check_initialized(this),
           set_alloc_feedback_and_call(this);
       {
         // Check if it is a megamorphic target
         Comment("check if megamorphic");
         Node* is_megamorphic = WordEqual(
             feedback_element,
             HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())));
         GotoIf(is_megamorphic, &call_construct_function);
 
         Comment("check if weak cell");
         Node* is_weak_cell = WordEqual(LoadMap(feedback_element),
                                        LoadRoot(Heap::kWeakCellMapRootIndex));
         GotoUnless(is_weak_cell, &check_allocation_site);
         // If the weak cell is cleared, we have a new chance to become
         // monomorphic.
         Comment("check if weak cell is cleared");
         Node* is_smi = TaggedIsSmi(feedback_value);
-        BranchIf(is_smi, &initialize, &mark_megamorphic);
+        Branch(is_smi, &initialize, &mark_megamorphic);
       }
 
       Bind(&check_allocation_site);
       {
         Comment("check if it is an allocation site");
         Node* is_allocation_site =
             WordEqual(LoadObjectField(feedback_element, 0),
                       LoadRoot(Heap::kAllocationSiteMapRootIndex));
         GotoUnless(is_allocation_site, &check_initialized);
 
         // Make sure the function is the Array() function
         Node* context_slot =
             LoadFixedArrayElement(LoadNativeContext(context),
                                   Int32Constant(Context::ARRAY_FUNCTION_INDEX));
         Node* is_array_function = WordEqual(context_slot, constructor);
-        BranchIf(is_array_function, &set_alloc_feedback_and_call,
-                 &mark_megamorphic);
+        Branch(is_array_function, &set_alloc_feedback_and_call,
+               &mark_megamorphic);
       }
 
       Bind(&set_alloc_feedback_and_call);
       {
         allocation_feedback.Bind(feedback_element);
         Goto(&call_construct_function);
       }
 
       Bind(&check_initialized);
       {
         // Check if it is uninitialized.
         Comment("check if uninitialized");
         Node* is_uninitialized = WordEqual(
             feedback_element, LoadRoot(Heap::kuninitialized_symbolRootIndex));
-        BranchIf(is_uninitialized, &initialize, &mark_megamorphic);
+        Branch(is_uninitialized, &initialize, &mark_megamorphic);
       }
 
       Bind(&initialize);
       {
         Label create_weak_cell(this), create_allocation_site(this);
         Comment("initialize the feedback element");
         // Check that it is the Array() function.
         Node* context_slot =
             LoadFixedArrayElement(LoadNativeContext(context),
                                   Int32Constant(Context::ARRAY_FUNCTION_INDEX));
         Node* is_array_function = WordEqual(context_slot, constructor);
-        BranchIf(is_array_function, &create_allocation_site, &create_weak_cell);
+        Branch(is_array_function, &create_allocation_site, &create_weak_cell);
 
         Bind(&create_allocation_site);
         {
           Node* site = CreateAllocationSiteInFeedbackVector(
               type_feedback_vector, SmiTag(slot_id));
           allocation_feedback.Bind(site);
           Goto(&call_construct_function);
         }
 
         Bind(&create_weak_cell);
@@ skipping 123 matching lines @@
 
   UpdateInterruptBudget(delta);
   Node* new_bytecode_offset = Advance(delta);
   Node* target_bytecode = LoadBytecode(new_bytecode_offset);
   return DispatchToBytecode(target_bytecode, new_bytecode_offset);
 }
 
 void InterpreterAssembler::JumpConditional(Node* condition, Node* delta) {
   Label match(this), no_match(this);
 
-  BranchIf(condition, &match, &no_match);
+  Branch(condition, &match, &no_match);
   Bind(&match);
   Jump(delta);
   Bind(&no_match);
   Dispatch();
 }
 
 void InterpreterAssembler::JumpIfWordEqual(Node* lhs, Node* rhs, Node* delta) {
   JumpConditional(WordEqual(lhs, rhs), delta);
 }
 
@@ skipping 12 matching lines @@
 }
 
 Node* InterpreterAssembler::StarDispatchLookahead(Node* target_bytecode) {
   Label do_inline_star(this), done(this);
 
   Variable var_bytecode(this, MachineType::PointerRepresentation());
   var_bytecode.Bind(target_bytecode);
 
   Node* star_bytecode = IntPtrConstant(static_cast<int>(Bytecode::kStar));
   Node* is_star = WordEqual(target_bytecode, star_bytecode);
-  BranchIf(is_star, &do_inline_star, &done);
+  Branch(is_star, &do_inline_star, &done);
 
   Bind(&do_inline_star);
   {
     InlineStar();
     var_bytecode.Bind(LoadBytecode(BytecodeOffset()));
     Goto(&done);
   }
   Bind(&done);
   return var_bytecode.value();
 }
@@ skipping 180 matching lines @@
 void InterpreterAssembler::Abort(BailoutReason bailout_reason) {
   disable_stack_check_across_call_ = true;
   Node* abort_id = SmiTag(Int32Constant(bailout_reason));
   CallRuntime(Runtime::kAbort, GetContext(), abort_id);
   disable_stack_check_across_call_ = false;
 }
 
 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
                                                BailoutReason bailout_reason) {
   Label ok(this), abort(this, Label::kDeferred);
-  BranchIfWordEqual(lhs, rhs, &ok, &abort);
+  Branch(WordEqual(lhs, rhs), &ok, &abort);
 
   Bind(&abort);
   Abort(bailout_reason);
   Goto(&ok);
 
   Bind(&ok);
 }
 
 void InterpreterAssembler::TraceBytecode(Runtime::FunctionId function_id) {
   CallRuntime(function_id, GetContext(), BytecodeArrayTaggedPointer(),
               SmiTag(BytecodeOffset()), GetAccumulatorUnchecked());
 }
 
 void InterpreterAssembler::TraceBytecodeDispatch(Node* target_bytecode) {
   Node* counters_table = ExternalConstant(
       ExternalReference::interpreter_dispatch_counters(isolate()));
   Node* source_bytecode_table_index = IntPtrConstant(
       static_cast<int>(bytecode_) * (static_cast<int>(Bytecode::kLast) + 1));
 
   Node* counter_offset =
       WordShl(IntPtrAdd(source_bytecode_table_index, target_bytecode),
               IntPtrConstant(kPointerSizeLog2));
   Node* old_counter =
       Load(MachineType::IntPtr(), counters_table, counter_offset);
 
   Label counter_ok(this), counter_saturated(this, Label::kDeferred);
 
   Node* counter_reached_max = WordEqual(
       old_counter, IntPtrConstant(std::numeric_limits<uintptr_t>::max()));
-  BranchIf(counter_reached_max, &counter_saturated, &counter_ok);
+  Branch(counter_reached_max, &counter_saturated, &counter_ok);
 
   Bind(&counter_ok);
   {
     Node* new_counter = IntPtrAdd(old_counter, IntPtrConstant(1));
     StoreNoWriteBarrier(MachineType::PointerRepresentation(), counters_table,
                         counter_offset, new_counter);
     Goto(&counter_saturated);
   }
 
   Bind(&counter_saturated);
@@ skipping 86 matching lines @@
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8