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

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 818 matching lines @@
 
     Bind(&if_valueisheapnumber);
     {
       // Load the floating point value of {value}.
       Node* value_value = LoadObjectField(value, HeapNumber::kValueOffset,
                                           MachineType::Float64());
 
       // Check if the floating point {value} is neither 0.0, -0.0 nor NaN.
       Node* zero = Float64Constant(0.0);
       GotoIf(Float64LessThan(zero, value_value), if_true);
-      BranchIfFloat64LessThan(value_value, zero, if_true, if_false);
+      Branch(Float64LessThan(value_value, zero), if_true, if_false);
     }
 
     Bind(&if_valueisother);
     {
       // Load the bit field from the {value}s map. The {value} is now either
       // Null or Undefined, which have the undetectable bit set (so we always
       // return false for those), or a Symbol or Simd128Value, whose maps never
       // have the undetectable bit set (so we always return true for those), or
       // a JSReceiver, which may or may not have the undetectable bit set.
       Node* value_map_bitfield = LoadMapBitField(value_map);
       Node* value_map_undetectable = Word32And(
           value_map_bitfield, Int32Constant(1 << Map::kIsUndetectable));
 
       // Check if the {value} is undetectable.
-      BranchIfWord32Equal(value_map_undetectable, Int32Constant(0), if_true,
-                          if_false);
+      Branch(Word32Equal(value_map_undetectable, Int32Constant(0)), if_true,
+             if_false);
     }
   }
 }
 
 compiler::Node* CodeStubAssembler::LoadFromFrame(int offset, MachineType rep) {
   Node* frame_pointer = LoadFramePointer();
   return Load(rep, frame_pointer, IntPtrConstant(offset));
 }
 
 compiler::Node* CodeStubAssembler::LoadFromParentFrame(int offset,
@@ skipping 1307 matching lines @@
   Node* value32 = RoundFloat64ToInt32(value);
   Node* value64 = ChangeInt32ToFloat64(value32);
 
   Label if_valueisint32(this), if_valueisheapnumber(this), if_join(this);
 
   Label if_valueisequal(this), if_valueisnotequal(this);
   Branch(Float64Equal(value, value64), &if_valueisequal, &if_valueisnotequal);
   Bind(&if_valueisequal);
   {
     GotoUnless(Word32Equal(value32, Int32Constant(0)), &if_valueisint32);
-    BranchIfInt32LessThan(Float64ExtractHighWord32(value), Int32Constant(0),
-                          &if_valueisheapnumber, &if_valueisint32);
+    Branch(Int32LessThan(Float64ExtractHighWord32(value), Int32Constant(0)),
+           &if_valueisheapnumber, &if_valueisint32);
   }
   Bind(&if_valueisnotequal);
   Goto(&if_valueisheapnumber);
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Bind(&if_valueisint32);
   {
     if (Is64()) {
       Node* result = SmiTag(ChangeInt32ToInt64(value32));
       var_result.Bind(result);
@@ skipping 1468 matching lines @@
       Word32And(hash, Int32Constant(Name::kIsNotArrayIndexMask));
   GotoIf(Word32Equal(not_an_index, Int32Constant(0)), if_bailout);
   // Finally, check if |key| is internalized.
   STATIC_ASSERT(kNotInternalizedTag != 0);
   Node* not_internalized =
       Word32And(key_instance_type, Int32Constant(kIsNotInternalizedMask));
   GotoIf(Word32NotEqual(not_internalized, Int32Constant(0)), if_bailout);
   Goto(if_keyisunique);
 
   Bind(&if_hascachedindex);
-  var_index->Bind(BitFieldDecode<Name::ArrayIndexValueBits>(hash));
+  var_index->Bind(BitFieldDecodeWord<Name::ArrayIndexValueBits>(hash));
   Goto(if_keyisindex);
 }
 
 template <typename Dictionary>
 Node* CodeStubAssembler::EntryToIndex(Node* entry, int field_index) {
   Node* entry_index = IntPtrMul(entry, IntPtrConstant(Dictionary::kEntrySize));
   return IntPtrAdd(entry_index, IntPtrConstant(Dictionary::kElementsStartIndex +
                                                field_index));
 }
 
@@ skipping 303 matching lines @@
     Node* field_index =
         BitFieldDecodeWord<PropertyDetails::FieldIndexField>(details);
     Node* representation =
         BitFieldDecode<PropertyDetails::RepresentationField>(details);
 
     Node* inobject_properties = LoadMapInobjectProperties(map);
 
     Label if_inobject(this), if_backing_store(this);
     Variable var_double_value(this, MachineRepresentation::kFloat64);
     Label rebox_double(this, &var_double_value);
-    BranchIfUintPtrLessThan(field_index, inobject_properties, &if_inobject,
-                            &if_backing_store);
+    Branch(UintPtrLessThan(field_index, inobject_properties), &if_inobject,
+           &if_backing_store);
     Bind(&if_inobject);
     {
       Comment("if_inobject");
       Node* field_offset =
           IntPtrMul(IntPtrSub(LoadMapInstanceSize(map),
                               IntPtrSub(inobject_properties, field_index)),
                     IntPtrConstant(kPointerSize));
 
       Label if_double(this), if_tagged(this);
-      BranchIfWord32NotEqual(representation,
-                             Int32Constant(Representation::kDouble), &if_tagged,
-                             &if_double);
+      Branch(Word32NotEqual(representation,
+                            Int32Constant(Representation::kDouble)),
+             &if_tagged, &if_double);
       Bind(&if_tagged);
       {
         var_value->Bind(LoadObjectField(object, field_offset));
         Goto(&done);
       }
       Bind(&if_double);
       {
         if (FLAG_unbox_double_fields) {
           var_double_value.Bind(
               LoadObjectField(object, field_offset, MachineType::Float64()));
         } else {
           Node* mutable_heap_number = LoadObjectField(object, field_offset);
           var_double_value.Bind(LoadHeapNumberValue(mutable_heap_number));
         }
         Goto(&rebox_double);
       }
     }
     Bind(&if_backing_store);
     {
       Comment("if_backing_store");
       Node* properties = LoadProperties(object);
       field_index = IntPtrSub(field_index, inobject_properties);
       Node* value = LoadFixedArrayElement(properties, field_index);
 
       Label if_double(this), if_tagged(this);
-      BranchIfWord32NotEqual(representation,
-                             Int32Constant(Representation::kDouble), &if_tagged,
-                             &if_double);
+      Branch(Word32NotEqual(representation,
+                            Int32Constant(Representation::kDouble)),
+             &if_tagged, &if_double);
       Bind(&if_tagged);
       {
         var_value->Bind(value);
         Goto(&done);
       }
       Bind(&if_double);
       {
         var_double_value.Bind(LoadHeapNumberValue(value));
         Goto(&rebox_double);
       }
@@ skipping 2143 matching lines @@
   // These variables are updated in the loop below.
   Variable* loop_vars[2] = {&current_js_object, &current_map};
   Label loop(this, 2, loop_vars), next(this);
 
   // Check if the enum length field is properly initialized, indicating that
   // there is an enum cache.
   {
     Node* invalid_enum_cache_sentinel =
         SmiConstant(Smi::FromInt(kInvalidEnumCacheSentinel));
     Node* enum_length = EnumLength(current_map.value());
-    BranchIfWordEqual(enum_length, invalid_enum_cache_sentinel, use_runtime,
-                      &loop);
+    Branch(WordEqual(enum_length, invalid_enum_cache_sentinel), use_runtime,
+           &loop);
   }
 
   // Check that there are no elements. |current_js_object| contains
   // the current JS object we've reached through the prototype chain.
   Bind(&loop);
   {
     Label if_elements(this), if_no_elements(this);
     Node* elements = LoadElements(current_js_object.value());
     Node* empty_fixed_array = LoadRoot(Heap::kEmptyFixedArrayRootIndex);
     // Check that there are no elements.
-    BranchIfWordEqual(elements, empty_fixed_array, &if_no_elements,
-                      &if_elements);
+    Branch(WordEqual(elements, empty_fixed_array), &if_no_elements,
+           &if_elements);
     Bind(&if_elements);
     {
       // Second chance, the object may be using the empty slow element
       // dictionary.
       Node* slow_empty_dictionary =
           LoadRoot(Heap::kEmptySlowElementDictionaryRootIndex);
-      BranchIfWordNotEqual(elements, slow_empty_dictionary, use_runtime,
-                           &if_no_elements);
+      Branch(WordNotEqual(elements, slow_empty_dictionary), use_runtime,
+             &if_no_elements);
     }
 
     Bind(&if_no_elements);
     {
       // Update map prototype.
       current_js_object.Bind(LoadMapPrototype(current_map.value()));
-      BranchIfWordEqual(current_js_object.value(), NullConstant(), use_cache,
-                        &next);
+      Branch(WordEqual(current_js_object.value(), NullConstant()), use_cache,
+             &next);
     }
   }
 
   Bind(&next);
   {
     // For all objects but the receiver, check that the cache is empty.
     current_map.Bind(LoadMap(current_js_object.value()));
     Node* enum_length = EnumLength(current_map.value());
     Node* zero_constant = SmiConstant(Smi::kZero);
-    BranchIf(WordEqual(enum_length, zero_constant), &loop, use_runtime);
+    Branch(WordEqual(enum_length, zero_constant), &loop, use_runtime);
   }
 }
 
 Node* CodeStubAssembler::CreateAllocationSiteInFeedbackVector(
     Node* feedback_vector, Node* slot) {
   Node* size = IntPtrConstant(AllocationSite::kSize);
   Node* site = Allocate(size, CodeStubAssembler::kPretenured);
 
   // Store the map
   StoreObjectFieldRoot(site, AllocationSite::kMapOffset,
@@ skipping 62 matching lines @@
   var.Bind(start_index);
   Label loop(this, &var);
   Label after_loop(this);
   // Introduce an explicit second check of the termination condition before the
   // loop that helps turbofan generate better code. If there's only a single
   // check, then the CodeStubAssembler forces it to be at the beginning of the
   // loop requiring a backwards branch at the end of the loop (it's not possible
   // to force the loop header check at the end of the loop and branch forward to
   // it from the pre-header). The extra branch is slower in the case that the
   // loop actually iterates.
-  BranchIf(WordEqual(var.value(), end_index), &after_loop, &loop);
+  Branch(WordEqual(var.value(), end_index), &after_loop, &loop);
   Bind(&loop);
   {
     if (mode == IndexAdvanceMode::kPre) {
       var.Bind(IntPtrAdd(var.value(), IntPtrConstant(increment)));
     }
     body(this, var.value());
     if (mode == IndexAdvanceMode::kPost) {
       var.Bind(IntPtrAdd(var.value(), IntPtrConstant(increment)));
     }
-    BranchIf(WordNotEqual(var.value(), end_index), &loop, &after_loop);
+    Branch(WordNotEqual(var.value(), end_index), &loop, &after_loop);
   }
   Bind(&after_loop);
 }
 
 void CodeStubAssembler::BuildFastFixedArrayForEach(
     compiler::Node* fixed_array, ElementsKind kind,
     compiler::Node* first_element_inclusive,
     compiler::Node* last_element_exclusive,
     std::function<void(CodeStubAssembler* assembler,
                        compiler::Node* fixed_array, compiler::Node* offset)>
@@ skipping 132 matching lines @@
 
   Bind(&do_fcmp);
   {
     // Load the {lhs} and {rhs} floating point values.
     Node* lhs = var_fcmp_lhs.value();
     Node* rhs = var_fcmp_rhs.value();
 
     // Perform a fast floating point comparison.
     switch (mode) {
       case kLessThan:
-        BranchIfFloat64LessThan(lhs, rhs, if_true, if_false);
+        Branch(Float64LessThan(lhs, rhs), if_true, if_false);
         break;
       case kLessThanOrEqual:
-        BranchIfFloat64LessThanOrEqual(lhs, rhs, if_true, if_false);
+        Branch(Float64LessThanOrEqual(lhs, rhs), if_true, if_false);
         break;
       case kGreaterThan:
-        BranchIfFloat64GreaterThan(lhs, rhs, if_true, if_false);
+        Branch(Float64GreaterThan(lhs, rhs), if_true, if_false);
         break;
       case kGreaterThanOrEqual:
-        BranchIfFloat64GreaterThanOrEqual(lhs, rhs, if_true, if_false);
+        Branch(Float64GreaterThanOrEqual(lhs, rhs), if_true, if_false);
         break;
     }
   }
 }
 
 void CodeStubAssembler::GotoUnlessNumberLessThan(compiler::Node* lhs,
                                                  compiler::Node* rhs,
                                                  Label* if_false) {
   Label if_true(this);
   BranchIfNumericRelationalComparison(kLessThan, lhs, rhs, &if_true, if_false);
@@ skipping 285 matching lines @@
 
   Bind(&do_fcmp);
   {
     // Load the {lhs} and {rhs} floating point values.
     Node* lhs = var_fcmp_lhs.value();
     Node* rhs = var_fcmp_rhs.value();
 
     // Perform a fast floating point comparison.
     switch (mode) {
       case kLessThan:
-        BranchIfFloat64LessThan(lhs, rhs, &return_true, &return_false);
+        Branch(Float64LessThan(lhs, rhs), &return_true, &return_false);
         break;
       case kLessThanOrEqual:
-        BranchIfFloat64LessThanOrEqual(lhs, rhs, &return_true, &return_false);
+        Branch(Float64LessThanOrEqual(lhs, rhs), &return_true, &return_false);
         break;
       case kGreaterThan:
-        BranchIfFloat64GreaterThan(lhs, rhs, &return_true, &return_false);
+        Branch(Float64GreaterThan(lhs, rhs), &return_true, &return_false);
         break;
       case kGreaterThanOrEqual:
-        BranchIfFloat64GreaterThanOrEqual(lhs, rhs, &return_true,
-                                          &return_false);
+        Branch(Float64GreaterThanOrEqual(lhs, rhs), &return_true,
+               &return_false);
         break;
     }
   }
 
   Bind(&return_true);
   {
     result.Bind(BooleanConstant(true));
     Goto(&end);
   }
 
@@ skipping 393 matching lines @@
                 Goto(&loop);
               }
             }
 
             Bind(&if_lhsisnotboolean);
             {
               // The {lhs} is either Null or Undefined; check if the {rhs} is
               // undetectable (i.e. either also Null or Undefined or some
               // undetectable JSReceiver).
               Node* rhs_bitfield = LoadMapBitField(rhs_map);
-              BranchIfWord32Equal(
-                  Word32And(rhs_bitfield,
-                            Int32Constant(1 << Map::kIsUndetectable)),
-                  Int32Constant(0), &if_notequal, &if_equal);
+              Branch(Word32Equal(
+                         Word32And(rhs_bitfield,
+                                   Int32Constant(1 << Map::kIsUndetectable)),
+                         Int32Constant(0)),
+                     &if_notequal, &if_equal);
             }
           }
 
           Bind(&if_lhsissymbol);
           {
             // Check if the {rhs} is a JSReceiver.
             Label if_rhsisreceiver(this), if_rhsisnotreceiver(this);
             STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
             Branch(IsJSReceiverInstanceType(rhs_instance_type),
                    &if_rhsisreceiver, &if_rhsisnotreceiver);
@@ skipping 74 matching lines @@
             }
 
             Bind(&if_rhsisnotreceiver);
             {
               // Check if {rhs} is Null or Undefined (an undetectable check
               // is sufficient here, since we already know that {rhs} is not
               // a JSReceiver).
               Label if_rhsisundetectable(this),
                   if_rhsisnotundetectable(this, Label::kDeferred);
               Node* rhs_bitfield = LoadMapBitField(rhs_map);
-              BranchIfWord32Equal(
-                  Word32And(rhs_bitfield,
-                            Int32Constant(1 << Map::kIsUndetectable)),
-                  Int32Constant(0), &if_rhsisnotundetectable,
-                  &if_rhsisundetectable);
+              Branch(Word32Equal(
+                         Word32And(rhs_bitfield,
+                                   Int32Constant(1 << Map::kIsUndetectable)),
+                         Int32Constant(0)),
+                     &if_rhsisnotundetectable, &if_rhsisundetectable);
 
               Bind(&if_rhsisundetectable);
               {
                 // Check if {lhs} is an undetectable JSReceiver.
                 Node* lhs_bitfield = LoadMapBitField(lhs_map);
-                BranchIfWord32Equal(
-                    Word32And(lhs_bitfield,
-                              Int32Constant(1 << Map::kIsUndetectable)),
-                    Int32Constant(0), &if_notequal, &if_equal);
+                Branch(Word32Equal(
+                           Word32And(lhs_bitfield,
+                                     Int32Constant(1 << Map::kIsUndetectable)),
+                           Int32Constant(0)),
+                       &if_notequal, &if_equal);
               }
 
               Bind(&if_rhsisnotundetectable);
               {
                 // The {rhs} is some Primitive different from Null and
                 // Undefined, need to convert {lhs} to Primitive first.
                 Callable callable =
                     CodeFactory::NonPrimitiveToPrimitive(isolate());
                 var_lhs.Bind(CallStub(callable, context, lhs));
                 Goto(&loop);
@@ skipping 12 matching lines @@
     }
   }
 
   Bind(&do_fcmp);
   {
     // Load the {lhs} and {rhs} floating point values.
     Node* lhs = var_fcmp_lhs.value();
     Node* rhs = var_fcmp_rhs.value();
 
     // Perform a fast floating point comparison.
-    BranchIfFloat64Equal(lhs, rhs, &if_equal, &if_notequal);
+    Branch(Float64Equal(lhs, rhs), &if_equal, &if_notequal);
   }
 
   Bind(&if_equal);
   {
     result.Bind(BooleanConstant(mode == kDontNegateResult));
     Goto(&end);
   }
 
   Bind(&if_notequal);
   {
@@ skipping 99 matching lines @@
         Label if_rhsissmi(this), if_rhsisnotsmi(this);
         Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
 
         Bind(&if_rhsissmi);
         {
           // Convert {lhs} and {rhs} to floating point values.
           Node* lhs_value = LoadHeapNumberValue(lhs);
           Node* rhs_value = SmiToFloat64(rhs);
 
           // Perform a floating point comparison of {lhs} and {rhs}.
-          BranchIfFloat64Equal(lhs_value, rhs_value, &if_equal, &if_notequal);
+          Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
         }
 
         Bind(&if_rhsisnotsmi);
         {
           // Load the map of {rhs}.
           Node* rhs_map = LoadMap(rhs);
 
           // Check if {rhs} is also a HeapNumber.
           Label if_rhsisnumber(this), if_rhsisnotnumber(this);
           Branch(WordEqual(rhs_map, number_map), &if_rhsisnumber,
                  &if_rhsisnotnumber);
 
           Bind(&if_rhsisnumber);
           {
             // Convert {lhs} and {rhs} to floating point values.
             Node* lhs_value = LoadHeapNumberValue(lhs);
             Node* rhs_value = LoadHeapNumberValue(rhs);
 
             // Perform a floating point comparison of {lhs} and {rhs}.
-            BranchIfFloat64Equal(lhs_value, rhs_value, &if_equal, &if_notequal);
+            Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
           }
 
           Bind(&if_rhsisnotnumber);
           Goto(&if_notequal);
         }
       }
 
       Bind(&if_lhsisnotnumber);
       {
         // Check if {rhs} is a Smi or a HeapObject.
@@ skipping 85 matching lines @@
         Branch(WordEqual(rhs_map, number_map), &if_rhsisnumber,
                &if_rhsisnotnumber);
 
         Bind(&if_rhsisnumber);
         {
           // Convert {lhs} and {rhs} to floating point values.
           Node* lhs_value = SmiToFloat64(lhs);
           Node* rhs_value = LoadHeapNumberValue(rhs);
 
           // Perform a floating point comparison of {lhs} and {rhs}.
-          BranchIfFloat64Equal(lhs_value, rhs_value, &if_equal, &if_notequal);
+          Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
         }
 
         Bind(&if_rhsisnotnumber);
         Goto(&if_notequal);
       }
     }
   }
 
   Bind(&if_equal);
   {
@@ skipping 441 matching lines @@
   Node* buffer_bit_field = LoadObjectField(
       buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8