Skip to content

Commit

Permalink
Make static constexpr order consistent in PA and raw_ptr
Browse files Browse the repository at this point in the history 
Change-Id: Iaa9550633cb00b4821fb252ea4c834d1db1ccaf8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4318285
Commit-Queue: Bartek Nowierski <bartekn@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1114818}
  • Loading branch information
@bartekn-chromium
bartekn-chromium authored and Chromium LUCI CQ committed Mar 8, 2023
1 parent 334eb5e commit b0adf53
Show file tree
Hide file tree
Showing 7 changed files with 89 additions and 89 deletions.
6 changes: 3 additions & 3 deletions base/allocator/partition_allocator/partition_address_space.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -226,16 +226,16 @@ class PA_COMPONENT_EXPORT(PARTITION_ALLOC) PartitionAddressSpace {
static PA_ALWAYS_INLINE size_t BRPPoolSize();
#else
// The pool sizes should be as large as maximum whenever possible.
constexpr static PA_ALWAYS_INLINE size_t RegularPoolSize() {
static constexpr PA_ALWAYS_INLINE size_t RegularPoolSize() {
return kRegularPoolSize;
}
constexpr static PA_ALWAYS_INLINE size_t BRPPoolSize() {
static constexpr PA_ALWAYS_INLINE size_t BRPPoolSize() {
return kBRPPoolSize;
}
#endif // PA_CONFIG(DYNAMICALLY_SELECT_POOL_SIZE)

#if BUILDFLAG(ENABLE_PKEYS)
constexpr static PA_ALWAYS_INLINE size_t PkeyPoolSize() {
static constexpr PA_ALWAYS_INLINE size_t PkeyPoolSize() {
return kPkeyPoolSize;
}
#endif
Expand Down
2 changes: 1 addition & 1 deletion base/allocator/partition_allocator/partition_alloc_unittest.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3509,7 +3509,7 @@ TEST_P(PartitionAllocTest, SmallReallocDoesNotMoveTrailingCookie) {
}

TEST_P(PartitionAllocTest, ZeroFill) {
constexpr static size_t kAllZerosSentinel =
static constexpr size_t kAllZerosSentinel =
std::numeric_limits<size_t>::max();
for (size_t size : kTestSizes) {
char* p = static_cast<char*>(
Expand Down
6 changes: 3 additions & 3 deletions base/allocator/partition_allocator/partition_bucket_lookup.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,10 +104,10 @@ inline constexpr size_t kOrderSubIndexMask[PA_BITS_PER_SIZE_T + 1] = {
// The class used to generate the bucket lookup table at compile-time.
class BucketIndexLookup final {
public:
PA_ALWAYS_INLINE constexpr static uint16_t GetIndexForDenserBuckets(
PA_ALWAYS_INLINE static constexpr uint16_t GetIndexForDenserBuckets(
size_t size);
PA_ALWAYS_INLINE constexpr static uint16_t GetIndexFor8Buckets(size_t size);
PA_ALWAYS_INLINE constexpr static uint16_t GetIndex(size_t size);
PA_ALWAYS_INLINE static constexpr uint16_t GetIndexFor8Buckets(size_t size);
PA_ALWAYS_INLINE static constexpr uint16_t GetIndex(size_t size);

constexpr BucketIndexLookup() {
constexpr uint16_t sentinel_bucket_index = kNumBuckets;
Expand Down
76 changes: 38 additions & 38 deletions base/allocator/partition_allocator/pointers/raw_ptr.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -186,41 +186,41 @@ namespace internal {
struct RawPtrNoOpImpl {
// Wraps a pointer.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
return ptr;
}

// Notifies the allocator when a wrapped pointer is being removed or replaced.
template <typename T>
constexpr static PA_ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}
static constexpr PA_ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}

// Unwraps the pointer, while asserting that memory hasn't been freed. The
// function is allowed to crash on nullptr.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
T* wrapped_ptr) {
return wrapped_ptr;
}

// Unwraps the pointer, while asserting that memory hasn't been freed. The
// function must handle nullptr gracefully.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
T* wrapped_ptr) {
return wrapped_ptr;
}

// Unwraps the pointer, without making an assertion on whether memory was
// freed or not.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
T* wrapped_ptr) {
return wrapped_ptr;
}

// Upcasts the wrapped pointer.
template <typename To, typename From>
constexpr static PA_ALWAYS_INLINE To* Upcast(From* wrapped_ptr) {
static constexpr PA_ALWAYS_INLINE To* Upcast(From* wrapped_ptr) {
static_assert(std::is_convertible<From*, To*>::value,
"From must be convertible to To.");
// Note, this cast may change the address if upcasting to base that lies in
Expand All @@ -234,7 +234,7 @@ struct RawPtrNoOpImpl {
typename Z,
typename =
std::enable_if_t<partition_alloc::internal::is_offset_type<Z>, void>>
constexpr static PA_ALWAYS_INLINE T* Advance(T* wrapped_ptr, Z delta_elems) {
static constexpr PA_ALWAYS_INLINE T* Advance(T* wrapped_ptr, Z delta_elems) {
return wrapped_ptr + delta_elems;
}

Expand All @@ -244,32 +244,32 @@ struct RawPtrNoOpImpl {
typename Z,
typename =
std::enable_if_t<partition_alloc::internal::is_offset_type<Z>, void>>
constexpr static PA_ALWAYS_INLINE T* Retreat(T* wrapped_ptr, Z delta_elems) {
static constexpr PA_ALWAYS_INLINE T* Retreat(T* wrapped_ptr, Z delta_elems) {
return wrapped_ptr - delta_elems;
}

template <typename T>
constexpr static PA_ALWAYS_INLINE ptrdiff_t GetDeltaElems(T* wrapped_ptr1,
static constexpr PA_ALWAYS_INLINE ptrdiff_t GetDeltaElems(T* wrapped_ptr1,
T* wrapped_ptr2) {
return wrapped_ptr1 - wrapped_ptr2;
}

// Returns a copy of a wrapped pointer, without making an assertion on whether
// memory was freed or not.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
static constexpr PA_ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
return wrapped_ptr;
}

// `WrapRawPtrForDuplication` and `UnsafelyUnwrapPtrForDuplication` are used
// to create a new raw_ptr<T> from another raw_ptr<T> of a different flavor.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
return ptr;
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
T* wrapped_ptr) {
return wrapped_ptr;
}
Expand Down Expand Up @@ -326,7 +326,7 @@ struct MTECheckedPtrImpl {

// Wraps a pointer, and returns its uintptr_t representation.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return ptr;
}
Expand Down Expand Up @@ -376,12 +376,12 @@ struct MTECheckedPtrImpl {
// Notifies the allocator when a wrapped pointer is being removed or replaced.
// No-op for MTECheckedPtrImpl.
template <typename T>
constexpr static PA_ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}
static constexpr PA_ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}

// Unwraps the pointer's uintptr_t representation, while asserting that memory
// hasn't been freed. The function is allowed to crash on nullptr.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
T* wrapped_ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return wrapped_ptr;
Expand Down Expand Up @@ -414,7 +414,7 @@ struct MTECheckedPtrImpl {
// Unwraps the pointer as a T*, without making an assertion on whether
// memory was freed or not.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
T* wrapped_ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return wrapped_ptr;
Expand All @@ -431,7 +431,7 @@ struct MTECheckedPtrImpl {
// Unwraps the pointer's uintptr_t representation, without making an assertion
// on whether memory was freed or not.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
T* wrapped_ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return wrapped_ptr;
Expand All @@ -447,7 +447,7 @@ struct MTECheckedPtrImpl {

// Upcasts the wrapped pointer.
template <typename To, typename From>
constexpr static PA_ALWAYS_INLINE To* Upcast(From* wrapped_ptr) {
static constexpr PA_ALWAYS_INLINE To* Upcast(From* wrapped_ptr) {
static_assert(std::is_convertible<From*, To*>::value,
"From must be convertible to To.");

Expand All @@ -461,7 +461,7 @@ struct MTECheckedPtrImpl {
typename Z,
typename =
std::enable_if_t<partition_alloc::internal::is_offset_type<Z>, void>>
constexpr static PA_ALWAYS_INLINE T* Advance(T* wrapped_ptr, Z delta_elems) {
static constexpr PA_ALWAYS_INLINE T* Advance(T* wrapped_ptr, Z delta_elems) {
return wrapped_ptr + delta_elems;
}

Expand All @@ -471,12 +471,12 @@ struct MTECheckedPtrImpl {
typename Z,
typename =
std::enable_if_t<partition_alloc::internal::is_offset_type<Z>, void>>
constexpr static PA_ALWAYS_INLINE T* Retreat(T* wrapped_ptr, Z delta_elems) {
static constexpr PA_ALWAYS_INLINE T* Retreat(T* wrapped_ptr, Z delta_elems) {
return wrapped_ptr - delta_elems;
}

template <typename T>
constexpr static PA_ALWAYS_INLINE ptrdiff_t GetDeltaElems(T* wrapped_ptr1,
static constexpr PA_ALWAYS_INLINE ptrdiff_t GetDeltaElems(T* wrapped_ptr1,
T* wrapped_ptr2) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return wrapped_ptr1 - wrapped_ptr2;
Expand Down Expand Up @@ -509,22 +509,22 @@ struct MTECheckedPtrImpl {
// Returns a copy of a wrapped pointer, without making an assertion
// on whether memory was freed or not.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
static constexpr PA_ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
return wrapped_ptr;
}

// `WrapRawPtrForDuplication` and `UnsafelyUnwrapPtrForDuplication` are used
// to create a new raw_ptr<T> from another raw_ptr<T> of a different flavor.
template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return ptr;
}
return WrapRawPtr(ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
T* wrapped_ptr) {
if (partition_alloc::internal::base::is_constant_evaluated()) {
return wrapped_ptr;
Expand All @@ -533,9 +533,9 @@ struct MTECheckedPtrImpl {
}

// This is for accounting only, used by unit tests.
constexpr static PA_ALWAYS_INLINE void IncrementSwapCountForTest() {}
constexpr static PA_ALWAYS_INLINE void IncrementLessCountForTest() {}
constexpr static PA_ALWAYS_INLINE void
static constexpr PA_ALWAYS_INLINE void IncrementSwapCountForTest() {}
static constexpr PA_ALWAYS_INLINE void IncrementLessCountForTest() {}
static constexpr PA_ALWAYS_INLINE void
IncrementPointerToMemberOperatorCountForTest() {}

private:
Expand Down Expand Up @@ -576,65 +576,65 @@ struct RawPtrCountingImplWrapperForTest
using SuperImpl = typename raw_ptr_traits::TraitsToImpl<Traits>::Impl;

template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
++wrap_raw_ptr_cnt;
return SuperImpl::WrapRawPtr(ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE void ReleaseWrappedPtr(T* ptr) {
static constexpr PA_ALWAYS_INLINE void ReleaseWrappedPtr(T* ptr) {
++release_wrapped_ptr_cnt;
SuperImpl::ReleaseWrappedPtr(ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(
T* wrapped_ptr) {
++get_for_dereference_cnt;
return SuperImpl::SafelyUnwrapPtrForDereference(wrapped_ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
static constexpr PA_ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(
T* wrapped_ptr) {
++get_for_extraction_cnt;
return SuperImpl::SafelyUnwrapPtrForExtraction(wrapped_ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(
T* wrapped_ptr) {
++get_for_comparison_cnt;
return SuperImpl::UnsafelyUnwrapPtrForComparison(wrapped_ptr);
}

constexpr static PA_ALWAYS_INLINE void IncrementSwapCountForTest() {
static constexpr PA_ALWAYS_INLINE void IncrementSwapCountForTest() {
++wrapped_ptr_swap_cnt;
}

constexpr static PA_ALWAYS_INLINE void IncrementLessCountForTest() {
static constexpr PA_ALWAYS_INLINE void IncrementLessCountForTest() {
++wrapped_ptr_less_cnt;
}

constexpr static PA_ALWAYS_INLINE void
static constexpr PA_ALWAYS_INLINE void
IncrementPointerToMemberOperatorCountForTest() {
++pointer_to_member_operator_cnt;
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
static constexpr PA_ALWAYS_INLINE T* WrapRawPtrForDuplication(T* ptr) {
++wrap_raw_ptr_for_dup_cnt;
return SuperImpl::WrapRawPtrForDuplication(ptr);
}

template <typename T>
constexpr static PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
static constexpr PA_ALWAYS_INLINE T* UnsafelyUnwrapPtrForDuplication(
T* wrapped_ptr) {
++get_for_duplication_cnt;
return SuperImpl::UnsafelyUnwrapPtrForDuplication(wrapped_ptr);
}

constexpr static void ClearCounters() {
static constexpr void ClearCounters() {
wrap_raw_ptr_cnt = 0;
release_wrapped_ptr_cnt = 0;
get_for_dereference_cnt = 0;
Expand Down
Loading

0 comments on commit b0adf53

Please sign in to comment.