From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- mfbt/PodOperations.h | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 mfbt/PodOperations.h (limited to 'mfbt/PodOperations.h') diff --git a/mfbt/PodOperations.h b/mfbt/PodOperations.h new file mode 100644 index 000000000..e6f4df21e --- /dev/null +++ b/mfbt/PodOperations.h @@ -0,0 +1,196 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * Operations for zeroing POD types, arrays, and so on. + * + * These operations are preferable to memset, memcmp, and the like because they + * don't require remembering to multiply by sizeof(T), array lengths, and so on + * everywhere. + */ + +#ifndef mozilla_PodOperations_h +#define mozilla_PodOperations_h + +#include "mozilla/Array.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" + +#include +#include + +namespace mozilla { + +/** Set the contents of |aT| to 0. */ +template +static MOZ_ALWAYS_INLINE void +PodZero(T* aT) +{ + memset(aT, 0, sizeof(T)); +} + +/** Set the contents of |aNElem| elements starting at |aT| to 0. */ +template +static MOZ_ALWAYS_INLINE void +PodZero(T* aT, size_t aNElem) +{ + /* + * This function is often called with 'aNElem' small; we use an inline loop + * instead of calling 'memset' with a non-constant length. The compiler + * should inline the memset call with constant size, though. + */ + for (T* end = aT + aNElem; aT < end; aT++) { + memset(aT, 0, sizeof(T)); + } +} + +/* + * Arrays implicitly convert to pointers to their first element, which is + * dangerous when combined with the above PodZero definitions. Adding an + * overload for arrays is ambiguous, so we need another identifier. The + * ambiguous overload is left to catch mistaken uses of PodZero; if you get a + * compile error involving PodZero and array types, use PodArrayZero instead. + */ +template +static void PodZero(T (&aT)[N]) = delete; +template +static void PodZero(T (&aT)[N], size_t aNElem) = delete; + +/** Set the contents of the array |aT| to zero. */ +template +static MOZ_ALWAYS_INLINE void +PodArrayZero(T (&aT)[N]) +{ + memset(aT, 0, N * sizeof(T)); +} + +template +static MOZ_ALWAYS_INLINE void +PodArrayZero(Array& aArr) +{ + memset(&aArr[0], 0, N * sizeof(T)); +} + +/** + * Assign |*aSrc| to |*aDst|. The locations must not be the same and must not + * overlap. + */ +template +static MOZ_ALWAYS_INLINE void +PodAssign(T* aDst, const T* aSrc) +{ + MOZ_ASSERT(aDst + 1 <= aSrc || aSrc + 1 <= aDst, + "destination and source must not overlap"); + memcpy(reinterpret_cast(aDst), reinterpret_cast(aSrc), + sizeof(T)); +} + +/** + * Copy |aNElem| T elements from |aSrc| to |aDst|. The two memory ranges must + * not overlap! + */ +template +static MOZ_ALWAYS_INLINE void +PodCopy(T* aDst, const T* aSrc, size_t aNElem) +{ + MOZ_ASSERT(aDst + aNElem <= aSrc || aSrc + aNElem <= aDst, + "destination and source must not overlap"); + if (aNElem < 128) { + /* + * Avoid using operator= in this loop, as it may have been + * intentionally deleted by the POD type. + */ + for (const T* srcend = aSrc + aNElem; aSrc < srcend; aSrc++, aDst++) { + PodAssign(aDst, aSrc); + } + } else { + memcpy(aDst, aSrc, aNElem * sizeof(T)); + } +} + +template +static MOZ_ALWAYS_INLINE void +PodCopy(volatile T* aDst, const volatile T* aSrc, size_t aNElem) +{ + MOZ_ASSERT(aDst + aNElem <= aSrc || aSrc + aNElem <= aDst, + "destination and source must not overlap"); + + /* + * Volatile |aDst| requires extra work, because it's undefined behavior to + * modify volatile objects using the mem* functions. Just write out the + * loops manually, using operator= rather than memcpy for the same reason, + * and let the compiler optimize to the extent it can. + */ + for (const volatile T* srcend = aSrc + aNElem; + aSrc < srcend; + aSrc++, aDst++) { + *aDst = *aSrc; + } +} + +/* + * Copy the contents of the array |aSrc| into the array |aDst|, both of size N. + * The arrays must not overlap! + */ +template +static MOZ_ALWAYS_INLINE void +PodArrayCopy(T (&aDst)[N], const T (&aSrc)[N]) +{ + PodCopy(aDst, aSrc, N); +} + +/** + * Copy the memory for |aNElem| T elements from |aSrc| to |aDst|. If the two + * memory ranges overlap, then the effect is as if the |aNElem| elements are + * first copied from |aSrc| to a temporary array, and then from the temporary + * array to |aDst|. + */ +template +static MOZ_ALWAYS_INLINE void +PodMove(T* aDst, const T* aSrc, size_t aNElem) +{ + MOZ_ASSERT(aNElem <= SIZE_MAX / sizeof(T), + "trying to move an impossible number of elements"); + memmove(aDst, aSrc, aNElem * sizeof(T)); +} + +/** + * Determine whether the |len| elements at |one| are memory-identical to the + * |len| elements at |two|. + */ +template +static MOZ_ALWAYS_INLINE bool +PodEqual(const T* one, const T* two, size_t len) +{ + if (len < 128) { + const T* p1end = one + len; + const T* p1 = one; + const T* p2 = two; + for (; p1 < p1end; p1++, p2++) { + if (*p1 != *p2) { + return false; + } + } + return true; + } + + return !memcmp(one, two, len * sizeof(T)); +} + +/* + * Determine whether the |N| elements at |one| are memory-identical to the + * |N| elements at |two|. + */ +template +static MOZ_ALWAYS_INLINE bool +PodEqual(const T (&one)[N], const T (&two)[N]) +{ + return PodEqual(one, two, N); +} + +} // namespace mozilla + +#endif /* mozilla_PodOperations_h */ -- cgit v1.2.3