[array] Simplify index calculation in Array.p.indexOf

src/builtins/builtins-array-gen.cc

 // Copyright 2017 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/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1661 matching lines @@
   const int kSearchElementArg = 0;
   const int kFromIndexArg = 1;
 
   Node* argc =
       ChangeInt32ToIntPtr(Parameter(BuiltinDescriptor::kArgumentsCount));
   CodeStubArguments args(this, argc);
 
   Node* array = args.GetReceiver();
   Node* search_element =
       args.GetOptionalArgumentValue(kSearchElementArg, UndefinedConstant());
-  Node* start_from =
-      args.GetOptionalArgumentValue(kFromIndexArg, UndefinedConstant());
   Node* context = Parameter(BuiltinDescriptor::kContext);
 
   Node* intptr_zero = IntPtrConstant(0);
   Node* intptr_one = IntPtrConstant(1);
 
-  VARIABLE(len_var, MachineType::PointerRepresentation());
-  VARIABLE(index_var, MachineType::PointerRepresentation());
-  VARIABLE(start_from_var, MachineType::PointerRepresentation());
-
-  Label init_k(this), return_found(this), return_not_found(this),
+  Label init_index(this), return_found(this), return_not_found(this),
       call_runtime(this);
 
-  Label init_len(this);
-
-  index_var.Bind(intptr_zero);
-  len_var.Bind(intptr_zero);
-
   // Take slow path if not a JSArray, if retrieving elements requires
   // traversing prototype, or if access checks are required.
   BranchIfFastJSArray(array, context, FastJSArrayAccessMode::INBOUNDS_READ,
-                      &init_len, &call_runtime);
+                      &init_index, &call_runtime);
 
-  BIND(&init_len);
-  {
-    // JSArray length is always an Smi for fast arrays.
-    CSA_ASSERT(this,
-               TaggedIsSmi(LoadObjectField(array, JSArray::kLengthOffset)));
-    Node* len = LoadAndUntagObjectField(array, JSArray::kLengthOffset);
+  BIND(&init_index);
+  VARIABLE(index_var, MachineType::PointerRepresentation(), intptr_zero);
 
-    len_var.Bind(len);
-    Branch(WordEqual(len_var.value(), intptr_zero), &return_not_found, &init_k);
-  }
+  // JSArray length is always a positive Smi for fast arrays.
+  CSA_ASSERT(this, TaggedIsPositiveSmi(LoadJSArrayLength(array)));
+  Node* array_length = SmiUntag(LoadJSArrayLength(array));
 
-  BIND(&init_k);
   {
     // For now only deal with undefined and Smis here; we must be really careful
     // with side-effects from the ToInteger conversion as the side-effects might
     // render our assumptions about the receiver being a fast JSArray and the
     // length invalid.
-    Label done(this), init_k_smi(this), init_k_other(this), init_k_zero(this),
-        init_k_n(this);
-    Branch(TaggedIsSmi(start_from), &init_k_smi, &init_k_other);
+    Label done(this);
 
-    BIND(&init_k_smi);
+    // If no fromIndex was passed, default to 0.
+    GotoIf(IntPtrLessThanOrEqual(argc, IntPtrConstant(kFromIndexArg)), &done);
+
+    // Handle Smis here and everything else in runtime.
+    Node* start_from = args.AtIndex(kFromIndexArg);
+    GotoIfNot(TaggedIsSmi(start_from), &call_runtime);
+
+    Node* intptr_start_from = SmiUntag(start_from);
+    index_var.Bind(intptr_start_from);
+
+    Label if_negative(this);
+    Branch(IntPtrLessThan(intptr_start_from, intptr_zero), &if_negative, &done);
+
+    BIND(&if_negative);
     {
-      // The fromIndex is a Smi.
-      start_from_var.Bind(SmiUntag(start_from));
-      Goto(&init_k_n);
+      Node* len_minus_start_from = IntPtrAdd(array_length, intptr_start_from);
+      index_var.Bind(IntPtrMax(len_minus_start_from, intptr_zero));
+      Goto(&done);
     }
 
-    BIND(&init_k_other);
-    {
-      // The fromIndex must be undefined then, otherwise bailout and let the
-      // runtime deal with the full ToInteger conversion.
-      GotoIfNot(IsUndefined(start_from), &call_runtime);
-      start_from_var.Bind(intptr_zero);
-      Goto(&init_k_n);
-    }
+    BIND(&done);
+  }
 
-    BIND(&init_k_n);
-    {
-      Label if_positive(this), if_negative(this), done(this);
-      Branch(IntPtrLessThan(start_from_var.value(), intptr_zero), &if_negative,
-             &if_positive);
-
-      BIND(&if_positive);
-      {
-        index_var.Bind(start_from_var.value());
-        Goto(&done);
-      }
-
-      BIND(&if_negative);
-      {
-        index_var.Bind(IntPtrAdd(len_var.value(), start_from_var.value()));
-        Branch(IntPtrLessThan(index_var.value(), intptr_zero), &init_k_zero,
-               &done);
-      }
-
-      BIND(&init_k_zero);
-      {
-        index_var.Bind(intptr_zero);
-        Goto(&done);
-      }
-
-      BIND(&done);
-    }
-  }
+  // Fail early if startIndex >= array.length.
+  GotoIf(IntPtrGreaterThanOrEqual(index_var.value(), array_length),
+         &return_not_found);
 
   static int32_t kElementsKind[] = {
       FAST_SMI_ELEMENTS,   FAST_HOLEY_SMI_ELEMENTS, FAST_ELEMENTS,
       FAST_HOLEY_ELEMENTS, FAST_DOUBLE_ELEMENTS,    FAST_HOLEY_DOUBLE_ELEMENTS,
   };
 
   Label if_smiorobjects(this), if_packed_doubles(this), if_holey_doubles(this);
   Label* element_kind_handlers[] = {&if_smiorobjects,   &if_smiorobjects,
                                     &if_smiorobjects,   &if_smiorobjects,
                                     &if_packed_doubles, &if_holey_doubles};
@@ skipping 20 matching lines @@
     search_num.Bind(LoadHeapNumberValue(search_element));
     Goto(&heap_num_loop);
 
     BIND(&not_heap_num);
     Node* search_type = LoadMapInstanceType(map);
     GotoIf(IsStringInstanceType(search_type), &string_loop);
     Goto(&ident_loop);
 
     BIND(&ident_loop);
     {
-      GotoIfNot(UintPtrLessThan(index_var.value(), len_var.value()),
+      GotoIfNot(UintPtrLessThan(index_var.value(), array_length),
                 &return_not_found);
       Node* element_k = LoadFixedArrayElement(elements, index_var.value());
       GotoIf(WordEqual(element_k, search_element), &return_found);
 
       index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
       Goto(&ident_loop);
     }
 
     BIND(&heap_num_loop);
     {
       Label not_nan_loop(this, &index_var);
       BranchIfFloat64IsNaN(search_num.value(), &return_not_found,
                            &not_nan_loop);
 
       BIND(&not_nan_loop);
       {
         Label continue_loop(this), not_smi(this);
-        GotoIfNot(UintPtrLessThan(index_var.value(), len_var.value()),
+        GotoIfNot(UintPtrLessThan(index_var.value(), array_length),
                   &return_not_found);
         Node* element_k = LoadFixedArrayElement(elements, index_var.value());
         GotoIfNot(TaggedIsSmi(element_k), &not_smi);
         Branch(Float64Equal(search_num.value(), SmiToFloat64(element_k)),
                &return_found, &continue_loop);
 
         BIND(&not_smi);
         GotoIfNot(IsHeapNumber(element_k), &continue_loop);
         Branch(Float64Equal(search_num.value(), LoadHeapNumberValue(element_k)),
                &return_found, &continue_loop);
 
         BIND(&continue_loop);
         index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
         Goto(&not_nan_loop);
       }
     }
 
     BIND(&string_loop);
     {
+      CSA_ASSERT(this, IsString(search_element));
       Label continue_loop(this);
-      GotoIfNot(UintPtrLessThan(index_var.value(), len_var.value()),
+      GotoIfNot(UintPtrLessThan(index_var.value(), array_length),
                 &return_not_found);
       Node* element_k = LoadFixedArrayElement(elements, index_var.value());
       GotoIf(TaggedIsSmi(element_k), &continue_loop);
       GotoIfNot(IsString(element_k), &continue_loop);
 
       // TODO(bmeurer): Consider inlining the StringEqual logic here.
       Callable callable = CodeFactory::StringEqual(isolate());
       Node* result = CallStub(callable, context, search_element, element_k);
       Branch(WordEqual(BooleanConstant(true), result), &return_found,
              &continue_loop);
 
       BIND(&continue_loop);
-      index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
+      Increment(index_var);
       Goto(&string_loop);
     }
   }
 
   BIND(&if_packed_doubles);
   {
     Label not_nan_loop(this, &index_var), search_notnan(this);
     VARIABLE(search_num, MachineRepresentation::kFloat64);
 
     GotoIfNot(TaggedIsSmi(search_element), &search_notnan);
     search_num.Bind(SmiToFloat64(search_element));
     Goto(&not_nan_loop);
 
     BIND(&search_notnan);
     GotoIfNot(IsHeapNumber(search_element), &return_not_found);
 
     search_num.Bind(LoadHeapNumberValue(search_element));
 
     BranchIfFloat64IsNaN(search_num.value(), &return_not_found, &not_nan_loop);
 
     // Search for HeapNumber
     BIND(&not_nan_loop);
     {
-      GotoIfNot(UintPtrLessThan(index_var.value(), len_var.value()),
+      GotoIfNot(UintPtrLessThan(index_var.value(), array_length),
                 &return_not_found);
       Node* element_k = LoadFixedDoubleArrayElement(elements, index_var.value(),
                                                     MachineType::Float64());
       GotoIf(Float64Equal(element_k, search_num.value()), &return_found);
 
       index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
       Goto(&not_nan_loop);
     }
   }
 
@@ skipping 10 matching lines @@
     GotoIfNot(IsHeapNumber(search_element), &return_not_found);
 
     search_num.Bind(LoadHeapNumberValue(search_element));
 
     BranchIfFloat64IsNaN(search_num.value(), &return_not_found, &not_nan_loop);
 
     // Search for HeapNumber
     BIND(&not_nan_loop);
     {
       Label continue_loop(this);
-      GotoIfNot(UintPtrLessThan(index_var.value(), len_var.value()),
+      GotoIfNot(UintPtrLessThan(index_var.value(), array_length),
                 &return_not_found);
 
       // Load double value or continue if it contains a double hole.
       Node* element_k = LoadFixedDoubleArrayElement(
           elements, index_var.value(), MachineType::Float64(), 0,
           INTPTR_PARAMETERS, &continue_loop);
 
       Branch(Float64Equal(element_k, search_num.value()), &return_found,
              &continue_loop);
       BIND(&continue_loop);
       index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
       Goto(&not_nan_loop);
     }
   }
 
   BIND(&return_found);
   args.PopAndReturn(SmiTag(index_var.value()));
 
   BIND(&return_not_found);
   args.PopAndReturn(NumberConstant(-1));
 
   BIND(&call_runtime);
-  args.PopAndReturn(CallRuntime(Runtime::kArrayIndexOf, context, array,
-                                search_element, start_from));
+  {
+    Node* start_from =
+        args.GetOptionalArgumentValue(kFromIndexArg, UndefinedConstant());
+    args.PopAndReturn(CallRuntime(Runtime::kArrayIndexOf, context, array,
+                                  search_element, start_from));
+  }
 }
 
 class ArrayPrototypeIterationAssembler : public CodeStubAssembler {
  public:
   explicit ArrayPrototypeIterationAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
  protected:
   void Generate_ArrayPrototypeIterationMethod(Node* context, Node* receiver,
                                               IterationKind iteration_kind) {
@@ skipping 463 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8