Bug 1983704 - Stop passing alignment around to nsTArray_base. r=nika

emilio · emilio · commit 05503dcf89f0 · 2025-08-19T00:59:53.000Z
After the previous patch it's unused. Conceptually it's the right thing to do if nsTArray wanted to ever deal with over-aligned types. But that doesn't seem to be the case for now, so maybe worth taking the simplification? Differential Revision: https://phabricator.services.mozilla.com/D257932
diff --git a/xpcom/ds/nsTArray-inl.h b/xpcom/ds/nsTArray-inl.h
@@ -161,7 +161,7 @@ nsTArray_base<Alloc, RelocationStrategy>::EnsureCapacityImpl(
 // shrink the capacity will leave the array unchanged.
 template <class Alloc, class RelocationStrategy>
 void nsTArray_base<Alloc, RelocationStrategy>::ShrinkCapacity(
-    size_type aElemSize, size_t aElemAlign) {
+    size_type aElemSize) {
   if (HasEmptyHeader() || UsesAutoArrayBuffer()) {
     return;
   }
@@ -211,7 +211,7 @@ void nsTArray_base<Alloc, RelocationStrategy>::ShrinkCapacity(
 
 template <class Alloc, class RelocationStrategy>
 void nsTArray_base<Alloc, RelocationStrategy>::ShrinkCapacityToZero(
-    size_type aElemSize, size_t aElemAlign) {
+    size_type aElemSize) {
   MOZ_ASSERT(mHdr->mLength == 0);
 
   if (HasEmptyHeader() || UsesAutoArrayBuffer()) {
@@ -227,8 +227,7 @@ template <typename ActualAlloc>
 void nsTArray_base<Alloc, RelocationStrategy>::ShiftData(index_type aStart,
                                                          size_type aOldLen,
                                                          size_type aNewLen,
-                                                         size_type aElemSize,
-                                                         size_t aElemAlign) {
+                                                         size_type aElemSize) {
   if (aOldLen == aNewLen) {
     return;
   }
@@ -239,7 +238,7 @@ void nsTArray_base<Alloc, RelocationStrategy>::ShiftData(index_type aStart,
   // Compute the resulting length of the array
   mHdr->mLength += aNewLen - aOldLen;
   if (mHdr->mLength == 0) {
-    ShrinkCapacityToZero(aElemSize, aElemAlign);
+    ShrinkCapacityToZero(aElemSize);
   } else {
     // Maybe nothing needs to be shifted
     if (num == 0) {
@@ -257,10 +256,8 @@ void nsTArray_base<Alloc, RelocationStrategy>::ShiftData(index_type aStart,
 
 template <class Alloc, class RelocationStrategy>
 template <typename ActualAlloc>
-void nsTArray_base<Alloc, RelocationStrategy>::SwapFromEnd(index_type aStart,
-                                                           size_type aCount,
-                                                           size_type aElemSize,
-                                                           size_t aElemAlign) {
+void nsTArray_base<Alloc, RelocationStrategy>::SwapFromEnd(
+    index_type aStart, size_type aCount, size_type aElemSize) {
   // This method is part of the implementation of
   // nsTArray::SwapRemoveElement{s,}At. For more information, read the
   // documentation on that method.
@@ -275,7 +272,7 @@ void nsTArray_base<Alloc, RelocationStrategy>::SwapFromEnd(index_type aStart,
 
   if (mHdr->mLength == 0) {
     // If we have no elements remaining in the array, we can free our buffer.
-    ShrinkCapacityToZero(aElemSize, aElemAlign);
+    ShrinkCapacityToZero(aElemSize);
     return;
   }
 
@@ -311,8 +308,7 @@ template <typename ActualAlloc>
 typename ActualAlloc::ResultTypeProxy
 nsTArray_base<Alloc, RelocationStrategy>::InsertSlotsAt(index_type aIndex,
                                                         size_type aCount,
-                                                        size_type aElemSize,
-                                                        size_t aElemAlign) {
+                                                        size_type aElemSize) {
   if (MOZ_UNLIKELY(aIndex > Length())) {
     mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
   }
@@ -324,7 +320,7 @@ nsTArray_base<Alloc, RelocationStrategy>::InsertSlotsAt(index_type aIndex,
 
   // Move the existing elements as needed.  Note that this will
   // change our mLength, so no need to call IncrementLength.
-  ShiftData<ActualAlloc>(aIndex, 0, aCount, aElemSize, aElemAlign);
+  ShiftData<ActualAlloc>(aIndex, 0, aCount, aElemSize);
 
   return ActualAlloc::SuccessResult();
 }
@@ -333,8 +329,7 @@ template <class Alloc, class RelocationStrategy>
 template <typename ActualAlloc, class Allocator>
 typename ActualAlloc::ResultTypeProxy
 nsTArray_base<Alloc, RelocationStrategy>::SwapArrayElements(
-    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
-    size_t aElemAlign) {
+    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize) {
   // If neither array uses an auto buffer which is big enough to store the
   // other array's elements, then ensure that both arrays use malloc'ed storage
   // and swap their mHdr pointers.
@@ -438,8 +433,7 @@ nsTArray_base<Alloc, RelocationStrategy>::SwapArrayElements(
 template <class Alloc, class RelocationStrategy>
 template <class Allocator>
 void nsTArray_base<Alloc, RelocationStrategy>::MoveInit(
-    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
-    size_t aElemAlign) {
+    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize) {
   // This method is similar to SwapArrayElements, but specialized for the case
   // where the target array is empty with no allocated heap storage. It is
   // provided and used to simplify template instantiation and enable better code
@@ -491,8 +485,7 @@ void nsTArray_base<Alloc, RelocationStrategy>::MoveInit(
 template <class Alloc, class RelocationStrategy>
 template <class Allocator>
 void nsTArray_base<Alloc, RelocationStrategy>::MoveConstructNonAutoArray(
-    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
-    size_t aElemAlign) {
+    nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize) {
   // We know that we are not an (Copyable)AutoTArray and we know that we are
   // empty, so don't use SwapArrayElements which doesn't know either of these
   // facts and is very complex. Use nsTArrayInfallibleAllocator regardless of
diff --git a/xpcom/ds/nsTArray.h b/xpcom/ds/nsTArray.h
@@ -492,14 +492,12 @@ class nsTArray_base {
   // Tries to resize the storage to the minimum required amount. If this fails,
   // the array is left as-is.
   // @param aElemSize  The size of an array element.
-  // @param aElemAlign The alignment in bytes of an array element.
-  void ShrinkCapacity(size_type aElemSize, size_t aElemAlign);
+  void ShrinkCapacity(size_type aElemSize);
 
   // Resizes the storage to 0. This may only be called when Length() is already
   // 0.
   // @param aElemSize  The size of an array element.
-  // @param aElemAlign The alignment in bytes of an array element.
-  void ShrinkCapacityToZero(size_type aElemSize, size_t aElemAlign);
+  void ShrinkCapacityToZero(size_type aElemSize);
 
   // This method may be called to resize a "gap" in the array by shifting
   // elements around.  It updates mLength appropriately.  If the resulting
@@ -508,21 +506,18 @@ class nsTArray_base {
   // @param aOldLen    The current length of the gap.
   // @param aNewLen    The desired length of the gap.
   // @param aElemSize  The size of an array element.
-  // @param aElemAlign The alignment in bytes of an array element.
   template <typename ActualAlloc>
   void ShiftData(index_type aStart, size_type aOldLen, size_type aNewLen,
-                 size_type aElemSize, size_t aElemAlign);
+                 size_type aElemSize);
 
   // This method may be called to swap elements from the end of the array to
   // fill a "gap" in the array. If the resulting array has zero elements, then
   // the array's memory is free'd.
   // @param aStart     The starting index of the gap.
   // @param aCount     The length of the gap.
   // @param aElemSize  The size of an array element.
-  // @param aElemAlign The alignment in bytes of an array element.
   template <typename ActualAlloc>
-  void SwapFromEnd(index_type aStart, size_type aCount, size_type aElemSize,
-                   size_t aElemAlign);
+  void SwapFromEnd(index_type aStart, size_type aCount, size_type aElemSize);
 
   // This method increments the length member of the array's header.
   // Note that mHdr may actually be sEmptyTArrayHeader in the case where a
@@ -544,26 +539,24 @@ class nsTArray_base {
   //               greater than the current length of the array.
   // @param aCount the number of slots to insert
   // @param aElementSize the size of an array element.
-  // @param aElemAlign the alignment in bytes of an array element.
   template <typename ActualAlloc>
   typename ActualAlloc::ResultTypeProxy InsertSlotsAt(index_type aIndex,
                                                       size_type aCount,
-                                                      size_type aElementSize,
-                                                      size_t aElemAlign);
+                                                      size_type aElementSize);
 
   template <typename ActualAlloc, class Allocator>
   typename ActualAlloc::ResultTypeProxy SwapArrayElements(
-      nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
-      size_t aElemAlign);
+      nsTArray_base<Allocator, RelocationStrategy>& aOther,
+      size_type aElemSize);
 
   template <class Allocator>
   void MoveConstructNonAutoArray(
-      nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
-      size_t aElemAlign);
+      nsTArray_base<Allocator, RelocationStrategy>& aOther,
+      size_type aElemSize);
 
   template <class Allocator>
   void MoveInit(nsTArray_base<Allocator, RelocationStrategy>& aOther,
-                size_type aElemSize, size_t aElemAlign);
+                size_type aElemSize);
 
   // Helper function for move construction and SwapArrayElements.
   // Takes the storage from the nsTArray as a non-auto Header pointer.
@@ -1036,8 +1029,7 @@ class nsTArray_Impl
     MOZ_ASSERT(!this->UsesAutoArrayBuffer());
 
     // This does not use SwapArrayElements because that's unnecessarily complex.
-    this->MoveConstructNonAutoArray(aOther, sizeof(value_type),
-                                    alignof(value_type));
+    this->MoveConstructNonAutoArray(aOther, sizeof(value_type));
   }
 
   // The array's copy-constructor performs a 'deep' copy of the given array.
@@ -1082,7 +1074,7 @@ class nsTArray_Impl
   self_type& operator=(self_type&& aOther) {
     if (this != &aOther) {
       Clear();
-      this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+      this->MoveInit(aOther, sizeof(value_type));
     }
     return *this;
   }
@@ -1128,7 +1120,7 @@ class nsTArray_Impl
   template <typename Allocator>
   self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
     Clear();
-    this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+    this->MoveInit(aOther, sizeof(value_type));
     return *this;
   }
 
@@ -1447,7 +1439,7 @@ class nsTArray_Impl
   template <class Allocator>
   void Assign(nsTArray_Impl<E, Allocator>&& aOther) {
     Clear();
-    this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+    this->MoveInit(aOther, sizeof(value_type));
   }
 
   // This method call the destructor on each element of the array, empties it,
@@ -1922,7 +1914,7 @@ class nsTArray_Impl
 
   void Clear() {
     ClearAndRetainStorage();
-    base_type::ShrinkCapacityToZero(sizeof(value_type), alignof(value_type));
+    base_type::ShrinkCapacityToZero(sizeof(value_type));
   }
 
   // This method removes elements based on the return value of the
@@ -1987,8 +1979,8 @@ class nsTArray_Impl
     // The only case this might fail were if someone called this with a
     // AutoTArray upcast to nsTArray_Impl, under the conditions mentioned in the
     // overload for AutoTArray below.
-    this->template SwapArrayElements<InfallibleAlloc>(
-        aOther, sizeof(value_type), alignof(value_type));
+    this->template SwapArrayElements<InfallibleAlloc>(aOther,
+                                                      sizeof(value_type));
   }
 
   template <size_t N>
@@ -1998,8 +1990,8 @@ class nsTArray_Impl
     // small inline sizes, and crash in the rare case of a small OOM error.
     static_assert(!std::is_same_v<Alloc, FallibleAlloc> ||
                   sizeof(E) * N <= 1024);
-    this->template SwapArrayElements<InfallibleAlloc>(
-        aOther, sizeof(value_type), alignof(value_type));
+    this->template SwapArrayElements<InfallibleAlloc>(aOther,
+                                                      sizeof(value_type));
   }
 
   template <class Allocator>
@@ -2008,8 +2000,8 @@ class nsTArray_Impl
     // Allocation might fail if Alloc==FallibleAlloc and
     // Allocator==InfallibleAlloc and aOther uses auto storage.
     return FallibleAlloc::Result(
-        this->template SwapArrayElements<FallibleAlloc>(
-            aOther, sizeof(value_type), alignof(value_type)));
+        this->template SwapArrayElements<FallibleAlloc>(aOther,
+                                                        sizeof(value_type)));
   }
 
  private:
@@ -2285,7 +2277,7 @@ class nsTArray_Impl
   template <typename ActualAlloc>
   value_type* InsertElementsAtInternal(index_type aIndex, size_type aCount) {
     if (!ActualAlloc::Successful(this->template InsertSlotsAt<ActualAlloc>(
-            aIndex, aCount, sizeof(value_type), alignof(value_type)))) {
+            aIndex, aCount, sizeof(value_type)))) {
       return nullptr;
     }
 
@@ -2328,7 +2320,7 @@ class nsTArray_Impl
   }
 
   // This method may be called to minimize the memory used by this array.
-  void Compact() { ShrinkCapacity(sizeof(value_type), alignof(value_type)); }
+  void Compact() { ShrinkCapacity(sizeof(value_type)); }
 
   //
   // Sorting
@@ -2472,8 +2464,8 @@ auto nsTArray_Impl<E, Alloc>::ReplaceElementsAtInternal(index_type aStart,
     return nullptr;
   }
   DestructRange(aStart, aCount);
-  this->template ShiftData<ActualAlloc>(
-      aStart, aCount, aArrayLen, sizeof(value_type), alignof(value_type));
+  this->template ShiftData<ActualAlloc>(aStart, aCount, aArrayLen,
+                                        sizeof(value_type));
   AssignRange(aStart, aArrayLen, aArray);
   return Elements() + aStart;
 }
@@ -2497,8 +2489,8 @@ template <typename E, class Alloc>
 void nsTArray_Impl<E, Alloc>::RemoveElementsAtUnsafe(index_type aStart,
                                                      size_type aCount) {
   DestructRange(aStart, aCount);
-  this->template ShiftData<InfallibleAlloc>(
-      aStart, aCount, 0, sizeof(value_type), alignof(value_type));
+  this->template ShiftData<InfallibleAlloc>(aStart, aCount, 0,
+                                            sizeof(value_type));
 }
 
 template <typename E, class Alloc>
@@ -2517,8 +2509,8 @@ void nsTArray_Impl<E, Alloc>::UnorderedRemoveElementsAt(index_type aStart,
   // replace them from the end. See the docs on the declaration of this
   // function.
   DestructRange(aStart, aCount);
-  this->template SwapFromEnd<InfallibleAlloc>(
-      aStart, aCount, sizeof(value_type), alignof(value_type));
+  this->template SwapFromEnd<InfallibleAlloc>(aStart, aCount,
+                                              sizeof(value_type));
 }
 
 template <typename E, class Alloc>
@@ -2561,7 +2553,7 @@ auto nsTArray_Impl<E, Alloc>::InsertElementsAtInternal(index_type aIndex,
                                                        const Item& aItem)
     -> value_type* {
   if (!ActualAlloc::Successful(this->template InsertSlotsAt<ActualAlloc>(
-          aIndex, aCount, sizeof(value_type), alignof(value_type)))) {
+          aIndex, aCount, sizeof(value_type)))) {
     return nullptr;
   }
 
@@ -2588,8 +2580,7 @@ auto nsTArray_Impl<E, Alloc>::InsertElementAtInternal(index_type aIndex)
           Length() + 1, sizeof(value_type)))) {
     return nullptr;
   }
-  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type),
-                                        alignof(value_type));
+  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type));
   value_type* elem = Elements() + aIndex;
   elem_traits::Construct(elem);
   return elem;
@@ -2609,8 +2600,7 @@ auto nsTArray_Impl<E, Alloc>::InsertElementAtInternal(index_type aIndex,
           Length() + 1, sizeof(value_type)))) {
     return nullptr;
   }
-  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type),
-                                        alignof(value_type));
+  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type));
   value_type* elem = Elements() + aIndex;
   elem_traits::Construct(elem, std::forward<Item>(aItem));
   return elem;
@@ -2641,8 +2631,8 @@ auto nsTArray_Impl<E, Alloc>::AppendElementsInternal(
   if (Length() == 0) {
     // XXX This might still be optimized. If aArray uses auto-storage but we
     // won't, we might better retain our storage if it's sufficiently large.
-    this->ShrinkCapacityToZero(sizeof(value_type), alignof(value_type));
-    this->MoveInit(aArray, sizeof(value_type), alignof(value_type));
+    this->ShrinkCapacityToZero(sizeof(value_type));
+    this->MoveInit(aArray, sizeof(value_type));
     return Elements();
   }
 
@@ -2655,8 +2645,7 @@ auto nsTArray_Impl<E, Alloc>::AppendElementsInternal(
   relocation_type::RelocateNonOverlappingRegion(
       Elements() + len, aArray.Elements(), otherLen, sizeof(value_type));
   this->IncrementLength(otherLen);
-  aArray.template ShiftData<ActualAlloc>(0, otherLen, 0, sizeof(value_type),
-                                         alignof(value_type));
+  aArray.template ShiftData<ActualAlloc>(0, otherLen, 0, sizeof(value_type));
   return Elements() + len;
 }
 
@@ -3021,18 +3010,18 @@ class MOZ_NON_MEMMOVABLE MOZ_GSL_OWNER AutoTArray : public nsTArray<E> {
 
   AutoTArray(self_type&& aOther) : nsTArray<E>() {
     Init();
-    this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+    this->MoveInit(aOther, sizeof(value_type));
   }
 
   explicit AutoTArray(base_type&& aOther) : mAlign() {
     Init();
-    this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+    this->MoveInit(aOther, sizeof(value_type));
   }
 
   template <typename Allocator>
   explicit AutoTArray(nsTArray_Impl<value_type, Allocator>&& aOther) {
     Init();
-    this->MoveInit(aOther, sizeof(value_type), alignof(value_type));
+    this->MoveInit(aOther, sizeof(value_type));
   }
 
   MOZ_IMPLICIT AutoTArray(std::initializer_list<E> aIL) : mAlign() {
