[builtins] Fix ConvertToRelativeIndex() callers to use uintptr indices

Bug: v8:4153
Change-Id: Icd346fae1dea9e56527b8669ace1aa6cfd46e87a
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1872393
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64475}

src/builtins/base.tq

@@ -3659,10 +3659,9 @@ extern macro AllocateSeqTwoByteString(uint32): String;
 
 // After converting an index to an integer, calculate a relative index:
 // return index < 0 ? max(length + index, 0) : min(index, length)
-// TODO(v8:4153): make length and result uintptr.
 @export
 transitioning macro ConvertToRelativeIndex(implicit context: Context)(
-    index: JSAny, length: intptr): intptr {
+    index: JSAny, length: uintptr): uintptr {
   const indexNumber: Number =
       ToInteger_Inline(context, index, kTruncateMinusZero);
   return ConvertToRelativeIndex(indexNumber, length);
@@ -3670,22 +3669,19 @@ transitioning macro ConvertToRelativeIndex(implicit context: Context)(
 
 // Calculate a relative index:
 // return index < 0 ? max(length + index, 0) : min(index, length)
-// TODO(v8:4153): make length and result uintptr.
 @export
-macro ConvertToRelativeIndex(indexNumber: Number, lengthIntPtr: intptr):
-    intptr {
-  const length: uintptr = Convert<uintptr>(lengthIntPtr);
+macro ConvertToRelativeIndex(indexNumber: Number, length: uintptr): uintptr {
   typeswitch (indexNumber) {
     case (indexSmi: Smi): {
       const indexIntPtr: intptr = Convert<intptr>(indexSmi);
       // The logic is implemented using unsigned types.
       if (indexIntPtr < 0) {
         const relativeIndex: uintptr = Unsigned(indexIntPtr) + length;
-        return Signed(relativeIndex < length ? relativeIndex : 0);
+        return relativeIndex < length ? relativeIndex : 0;
 
       } else {
         const relativeIndex: uintptr = Unsigned(indexIntPtr);
-        return Signed(relativeIndex < length ? relativeIndex : length);
+        return relativeIndex < length ? relativeIndex : length;
       }
     }
     case (indexHeapNumber: HeapNumber): {
@@ -3697,13 +3693,11 @@ macro ConvertToRelativeIndex(indexNumber: Number, lengthIntPtr: intptr):
       assert(lengthDouble <= kMaxSafeInteger);
       if (indexDouble < 0) {
         const relativeIndex: float64 = lengthDouble + indexDouble;
-        return relativeIndex > 0 ?
-            Signed(ChangeFloat64ToUintPtr(relativeIndex)) :
-            0;
+        return relativeIndex > 0 ? ChangeFloat64ToUintPtr(relativeIndex) : 0;
 
       } else {
-        return Signed(ChangeFloat64ToUintPtr(
-            indexDouble < lengthDouble ? indexDouble : lengthDouble));
+        return ChangeFloat64ToUintPtr(
+            indexDouble < lengthDouble ? indexDouble : lengthDouble);
       }
     }
   }

src/builtins/builtins-typed-array-gen.cc

@@ -479,8 +479,8 @@ void TypedArrayBuiltinsAssembler::CallCCopyTypedArrayElementsToTypedArray(
 }
 
 void TypedArrayBuiltinsAssembler::CallCCopyTypedArrayElementsSlice(
-    TNode<JSTypedArray> source, TNode<JSTypedArray> dest, TNode<IntPtrT> start,
-    TNode<IntPtrT> end) {
+    TNode<JSTypedArray> source, TNode<JSTypedArray> dest, TNode<UintPtrT> start,
+    TNode<UintPtrT> end) {
   TNode<ExternalReference> f =
       ExternalConstant(ExternalReference::copy_typed_array_elements_slice());
   CallCFunction(f, MachineType::AnyTagged(),

src/builtins/builtins-typed-array-gen.h

@@ -96,8 +96,8 @@ class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
 
   void CallCCopyTypedArrayElementsSlice(TNode<JSTypedArray> source,
                                         TNode<JSTypedArray> dest,
-                                        TNode<IntPtrT> start,
-                                        TNode<IntPtrT> end);
+                                        TNode<UintPtrT> start,
+                                        TNode<UintPtrT> end);
 
   using TypedArraySwitchCase = std::function<void(ElementsKind, int, int)>;
 

src/builtins/string-slice.tq

@@ -4,7 +4,7 @@
 
 namespace string_slice {
 
-  extern macro StringBuiltinsAssembler::SubString(String, intptr, intptr):
+  extern macro StringBuiltinsAssembler::SubString(String, uintptr, uintptr):
       String;
 
   // ES6 #sec-string.prototype.slice ( start, end )
@@ -16,17 +16,17 @@ namespace string_slice {
     const string: String = ToThisString(receiver, 'String.prototype.slice');
 
     // 3. Let len be the number of elements in S.
-    const length: intptr = string.length_intptr;
+    const length: uintptr = string.length_uintptr;
 
     // Convert {start} to a relative index.
     const arg0 = arguments[0];
-    const start: intptr =
+    const start: uintptr =
         arg0 != Undefined ? ConvertToRelativeIndex(arg0, length) : 0;
 
     // 5. If end is undefined, let intEnd be len;
     // else Convert {end} to a relative index.
     const arg1 = arguments[1];
-    const end: intptr =
+    const end: uintptr =
         arg1 != Undefined ? ConvertToRelativeIndex(arg1, length) : length;
 
     if (end <= start) {

src/builtins/string-substr.tq

@@ -4,7 +4,7 @@
 
 namespace string_substr {
 
-  extern macro StringBuiltinsAssembler::SubString(String, intptr, intptr):
+  extern macro StringBuiltinsAssembler::SubString(String, uintptr, uintptr):
       String;
 
   // String.prototype.substr ( start, length )
@@ -17,12 +17,12 @@ namespace string_substr {
     const string: String = ToThisString(receiver, methodName);
 
     // 5. Let size be the number of code units in S.
-    const size: intptr = string.length_intptr;
+    const size: uintptr = string.length_uintptr;
 
     // 3. Let intStart be ? ToInteger(start).
     // 6. If intStart < 0, set intStart to max(size + intStart, 0).
     const start = arguments[0];
-    const initStart: intptr =
+    const initStart: uintptr =
         start != Undefined ? ConvertToRelativeIndex(start, size) : 0;
 
     // 4. If length is undefined,
@@ -30,9 +30,9 @@ namespace string_substr {
     // 7. Let resultLength be min(max(end, 0), size - intStart).
     const length = arguments[1];
     const lengthLimit = size - initStart;
-    assert(lengthLimit >= 0);
-    const resultLength: intptr = length != Undefined ?
-        Signed(ClampToIndexRange(length, Unsigned(lengthLimit))) :
+    assert(lengthLimit <= size);
+    const resultLength: uintptr = length != Undefined ?
+        ClampToIndexRange(length, lengthLimit) :
         lengthLimit;
 
     // 8. If resultLength ≤ 0, return the empty String "".

src/builtins/typed-array-slice.tq

@@ -8,10 +8,10 @@ namespace typed_array {
   const kBuiltinNameSlice: constexpr string = '%TypedArray%.prototype.slice';
 
   extern macro TypedArrayBuiltinsAssembler::CallCCopyTypedArrayElementsSlice(
-      JSTypedArray, JSTypedArray, intptr, intptr): void;
+      JSTypedArray, JSTypedArray, uintptr, uintptr): void;
 
   macro FastCopy(
-      src: typed_array::AttachedJSTypedArray, dest: JSTypedArray, k: intptr,
+      src: typed_array::AttachedJSTypedArray, dest: JSTypedArray, k: uintptr,
       count: PositiveSmi) labels IfSlow {
     if (IsForceSlowPath()) goto IfSlow;
 
@@ -30,7 +30,7 @@ namespace typed_array {
     const countBytes: uintptr =
         destInfo.CalculateByteLength(count) otherwise unreachable;
     const startOffset: uintptr =
-        destInfo.CalculateByteLength(Convert<PositiveSmi>(k))
+        destInfo.CalculateByteLength(Convert<PositiveSmi>(Signed(k)))
         otherwise unreachable;
     const srcPtr: RawPtr = src.data_ptr + Convert<intptr>(startOffset);
 
@@ -41,7 +41,7 @@ namespace typed_array {
   }
 
   macro SlowCopy(implicit context: Context)(
-      src: JSTypedArray, dest: JSTypedArray, k: intptr, final: intptr) {
+      src: JSTypedArray, dest: JSTypedArray, k: uintptr, final: uintptr) {
     if (typed_array::IsBigInt64ElementsKind(src.elements_kind) !=
         typed_array::IsBigInt64ElementsKind(dest.elements_kind))
       deferred {
@@ -63,13 +63,13 @@ namespace typed_array {
         typed_array::ValidateTypedArray(context, receiver, kBuiltinNameSlice);
 
     // 3. Let len be O.[[ArrayLength]].
-    const len = Convert<intptr>(src.length);
+    const len: uintptr = src.length;
 
     // 4. Let relativeStart be ? ToInteger(start).
     // 5. If relativeStart < 0, let k be max((len + relativeStart), 0);
     //    else let k be min(relativeStart, len).
     const start = arguments[0];
-    const k: intptr =
+    const k: uintptr =
         start != Undefined ? ConvertToRelativeIndex(start, len) : 0;
 
     // 6. If end is undefined, let relativeEnd be len;
@@ -77,11 +77,11 @@ namespace typed_array {
     // 7. If relativeEnd < 0, let final be max((len + relativeEnd), 0);
     //    else let final be min(relativeEnd, len).
     const end = arguments[1];
-    const final: intptr =
+    const final: uintptr =
         end != Undefined ? ConvertToRelativeIndex(end, len) : len;
 
     // 8. Let count be max(final - k, 0).
-    const count = Convert<PositiveSmi>(IntPtrMax(final - k, 0));
+    const count = Convert<PositiveSmi>(IntPtrMax(Signed(final - k), 0));
 
     // 9. Let A be ? TypedArraySpeciesCreate(O, « count »).
     const dest: JSTypedArray = TypedArraySpeciesCreateByLength(

src/builtins/typed-array-subarray.tq

@@ -19,14 +19,14 @@ namespace typed_array {
     const buffer = typed_array::GetBuffer(source);
 
     // 6. Let srcLength be O.[[ArrayLength]].
-    const srcLength = Convert<intptr>(source.length);
+    const srcLength: uintptr = source.length;
 
     // 7. Let relativeBegin be ? ToInteger(begin).
     // 8. If relativeBegin < 0, let beginIndex be max((srcLength +
     // relativeBegin), 0); else let beginIndex be min(relativeBegin,
     // srcLength).
     const arg0 = arguments[0];
-    const begin: intptr =
+    const begin: uintptr =
         arg0 != Undefined ? ConvertToRelativeIndex(arg0, srcLength) : 0;
 
     // 9. If end is undefined, let relativeEnd be srcLength;
@@ -34,11 +34,11 @@ namespace typed_array {
     // 10. If relativeEnd < 0, let endIndex be max((srcLength + relativeEnd),
     // 0); else let endIndex be min(relativeEnd, srcLength).
     const arg1 = arguments[1];
-    const end: intptr =
+    const end: uintptr =
         arg1 != Undefined ? ConvertToRelativeIndex(arg1, srcLength) : srcLength;
 
     // 11. Let newLength be max(endIndex - beginIndex, 0).
-    const newLength = Convert<PositiveSmi>(IntPtrMax(end - begin, 0));
+    const newLength = Convert<PositiveSmi>(IntPtrMax(Signed(end - begin), 0));
 
     // 12. Let constructorName be the String value of O.[[TypedArrayName]].
     // 13. Let elementSize be the Number value of the Element Size value
@@ -50,7 +50,7 @@ namespace typed_array {
 
     // 15. Let beginByteOffset be srcByteOffset + beginIndex × elementSize.
     const beginByteOffset = srcByteOffset +
-        elementsInfo.CalculateByteLength(Convert<PositiveSmi>(begin))
+        elementsInfo.CalculateByteLength(Convert<PositiveSmi>(Signed(begin)))
         otherwise ThrowRangeError(kInvalidArrayBufferLength);
 
     // 16. Let argumentsList be « buffer, beginByteOffset, newLength ».

test/cctest/test-code-stub-assembler.cc

@@ -342,8 +342,7 @@ TEST(ConvertToRelativeIndex) {
     TNode<UintPtrT> expected =
         m.ChangeNonnegativeNumberToUintPtr(expected_relative_index);
 
-    TNode<UintPtrT> result =
-        m.Unsigned(m.ConvertToRelativeIndex(index, m.Signed(length)));
+    TNode<UintPtrT> result = m.ConvertToRelativeIndex(index, length);
 
     m.Return(m.SelectBooleanConstant(m.WordEqual(result, expected)));
   }