3party/crashpad
0
0
Fork 0
mirror of https://github.com/chromium/crashpad.git synced 2025-03-09 14:06:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Limit alignas to 64

Browse Source 
Although GCC will silently accept larger alignments with
__attribute__((aligned())), it warn on alignas() with an alignment
larger than the target’s supported maximum. 8c35d92ae403 switched to
alignas() where possible.

The maxima are at least 128 on x86, x86_64, and arm64, and 64 on arm, in
the common configurations, but may be even larger with certain features
such as AVX enabled. These are ultimately derived from BIGGEST_ALIGNMENT
in gcc/config/*/*.h.

One alignment request in a test specified 1024 as a big alignment
constraint, solely as a test that alignment worked correctly. For this,
it’s perfectly reasonable to limit the alignment request to what GCC
supports on the most constrained target we’ll encounter.

Test: crashapd_util_test AlignedAllocator.AlignedVector
Change-Id: I42af443f437e01228934ab34dc04983742f0ab3f
Reviewed-on: https://chromium-review.googlesource.com/550236
Reviewed-by: Scott Graham <scottmg@chromium.org>
Commit-Queue: Mark Mentovai <mark@chromium.org>
This commit is contained in:
Mark Mentovai 2017-06-27 11:13:16 -04:00 committed by Commit Bot
parent 376cddee9e
commit 6823f67830
1 changed files with 6 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
util/stdlib/aligned_allocator_test.cc
View File

@ -52,10 +52,10 @@ TEST(AlignedAllocator, AlignedVector) {
IsAligned(&natural_aligned_vector[2], alignof(NaturalAlignedStruct)));
// Test a structure that declares its own alignment.
struct alignas(32) AlignedStruct {
struct alignas(16) AlignedStruct {
int i;
};
ASSERT_EQ(alignof(AlignedStruct), 32u);
ASSERT_EQ(alignof(AlignedStruct), 16u);
AlignedVector<AlignedStruct> aligned_vector;
aligned_vector.push_back(AlignedStruct());
@ -69,15 +69,15 @@ TEST(AlignedAllocator, AlignedVector) {
// Try a custom alignment. Since the structure itself doesn’t specify an
// alignment constraint, only the base address will be aligned to the
// requested boundary.
AlignedVector<NaturalAlignedStruct, 64> custom_aligned_vector;
AlignedVector<NaturalAlignedStruct, 32> custom_aligned_vector;
custom_aligned_vector.push_back(NaturalAlignedStruct());
EXPECT_TRUE(IsAligned(&custom_aligned_vector[0], 64));
EXPECT_TRUE(IsAligned(&custom_aligned_vector[0], 32));
// Try a structure with a pretty big alignment request.
struct alignas(1024) BigAlignedStruct {
struct alignas(64) BigAlignedStruct {
int i;
};
ASSERT_EQ(alignof(BigAlignedStruct), 1024u);
ASSERT_EQ(alignof(BigAlignedStruct), 64u);
AlignedVector<BigAlignedStruct> big_aligned_vector;
big_aligned_vector.push_back(BigAlignedStruct());