OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/memory/aligned_memory.h" | 5 #include "base/memory/aligned_memory.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "build/build_config.h" | 9 #include "build/build_config.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
11 | 11 |
12 #define EXPECT_ALIGNED(ptr, align) \ | 12 #define EXPECT_ALIGNED(ptr, align) \ |
13 EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1)) | 13 EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1)) |
14 | 14 |
15 namespace { | 15 namespace { |
16 | 16 |
17 using base::AlignedMemory; | 17 using base::AlignedMemory; |
18 | 18 |
19 TEST(AlignedMemoryTest, StaticAlignment) { | 19 TEST(AlignedMemoryTest, StaticAlignment) { |
20 static AlignedMemory<8, 8> raw8; | 20 static AlignedMemory<8, 8> raw8; |
21 static AlignedMemory<8, 16> raw16; | 21 static AlignedMemory<8, 16> raw16; |
22 // GCC doesn't like alignment >64 on ARM. | |
danakj
2017/02/08 21:29:47
Same Q. Should we test 64 instead?
dcheng
2017/02/09 00:01:24
Done.
| |
23 #if !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) | |
22 static AlignedMemory<8, 256> raw256; | 24 static AlignedMemory<8, 256> raw256; |
23 static AlignedMemory<8, 4096> raw4096; | 25 static AlignedMemory<8, 4096> raw4096; |
26 #endif | |
24 | 27 |
25 EXPECT_EQ(8u, ALIGNOF(raw8)); | 28 EXPECT_EQ(8u, alignof(decltype(raw8))); |
26 EXPECT_EQ(16u, ALIGNOF(raw16)); | 29 EXPECT_EQ(16u, alignof(decltype(raw16))); |
27 EXPECT_EQ(256u, ALIGNOF(raw256)); | |
28 EXPECT_EQ(4096u, ALIGNOF(raw4096)); | |
29 | 30 |
30 EXPECT_ALIGNED(raw8.void_data(), 8); | 31 EXPECT_ALIGNED(raw8.void_data(), 8); |
31 EXPECT_ALIGNED(raw16.void_data(), 16); | 32 EXPECT_ALIGNED(raw16.void_data(), 16); |
33 | |
34 // GCC doesn't like alignment >64 on ARM. | |
35 #if !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) | |
36 EXPECT_EQ(256u, alignof(decltype(raw256))); | |
37 EXPECT_EQ(4096u, alignof(decltype(raw4096))); | |
32 EXPECT_ALIGNED(raw256.void_data(), 256); | 38 EXPECT_ALIGNED(raw256.void_data(), 256); |
33 EXPECT_ALIGNED(raw4096.void_data(), 4096); | 39 EXPECT_ALIGNED(raw4096.void_data(), 4096); |
40 #endif | |
34 } | 41 } |
35 | 42 |
36 TEST(AlignedMemoryTest, StackAlignment) { | 43 TEST(AlignedMemoryTest, StackAlignment) { |
37 AlignedMemory<8, 8> raw8; | 44 AlignedMemory<8, 8> raw8; |
38 AlignedMemory<8, 16> raw16; | 45 AlignedMemory<8, 16> raw16; |
46 // GCC doesn't like alignment >64 on ARM. | |
47 #if !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) | |
39 AlignedMemory<8, 128> raw128; | 48 AlignedMemory<8, 128> raw128; |
49 #endif | |
40 | 50 |
41 EXPECT_EQ(8u, ALIGNOF(raw8)); | 51 EXPECT_EQ(8u, alignof(decltype(raw8))); |
42 EXPECT_EQ(16u, ALIGNOF(raw16)); | 52 EXPECT_EQ(16u, alignof(decltype(raw16))); |
43 EXPECT_EQ(128u, ALIGNOF(raw128)); | 53 // GCC doesn't like alignment >64 on ARM. |
54 #if !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) | |
55 EXPECT_EQ(128u, alignof(decltype(raw128))); | |
56 #endif | |
44 | 57 |
45 EXPECT_ALIGNED(raw8.void_data(), 8); | 58 EXPECT_ALIGNED(raw8.void_data(), 8); |
46 EXPECT_ALIGNED(raw16.void_data(), 16); | 59 EXPECT_ALIGNED(raw16.void_data(), 16); |
47 | 60 |
48 // TODO(ios): __attribute__((aligned(X))) with X >= 128 does not works on | 61 // GCC doesn't like alignment >64 on ARM. |
49 // the stack when building for arm64 on iOS, http://crbug.com/349003 | 62 #if !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) |
50 #if !(defined(OS_IOS) && defined(ARCH_CPU_ARM64)) | |
51 EXPECT_ALIGNED(raw128.void_data(), 128); | 63 EXPECT_ALIGNED(raw128.void_data(), 128); |
52 | 64 |
53 // NaCl x86-64 compiler emits non-validating instructions for >128 | 65 // NaCl x86-64 compiler emits non-validating instructions for >128 |
54 // bytes alignment. | 66 // bytes alignment. |
55 // http://www.chromium.org/nativeclient/design-documents/nacl-sfi-model-on-x86 -64-systems | 67 // http://www.chromium.org/nativeclient/design-documents/nacl-sfi-model-on-x86 -64-systems |
56 // TODO(hamaji): Ideally, NaCl compiler for x86-64 should workaround | 68 // TODO(hamaji): Ideally, NaCl compiler for x86-64 should workaround |
57 // this limitation and this #if should be removed. | 69 // this limitation and this #if should be removed. |
58 // https://code.google.com/p/nativeclient/issues/detail?id=3463 | 70 // https://code.google.com/p/nativeclient/issues/detail?id=3463 |
59 #if !(defined(OS_NACL) && defined(ARCH_CPU_X86_64)) | 71 #if !(defined(OS_NACL) && defined(ARCH_CPU_X86_64)) |
60 AlignedMemory<8, 256> raw256; | 72 AlignedMemory<8, 256> raw256; |
61 EXPECT_EQ(256u, ALIGNOF(raw256)); | 73 EXPECT_EQ(256u, alignof(decltype(raw256))); |
62 EXPECT_ALIGNED(raw256.void_data(), 256); | 74 EXPECT_ALIGNED(raw256.void_data(), 256); |
63 | 75 |
64 // TODO(ios): This test hits an armv7 bug in clang. crbug.com/138066 | |
65 #if !(defined(OS_IOS) && defined(ARCH_CPU_ARM_FAMILY)) | |
66 AlignedMemory<8, 4096> raw4096; | 76 AlignedMemory<8, 4096> raw4096; |
67 EXPECT_EQ(4096u, ALIGNOF(raw4096)); | 77 EXPECT_EQ(4096u, alignof(decltype(raw4096))); |
68 EXPECT_ALIGNED(raw4096.void_data(), 4096); | 78 EXPECT_ALIGNED(raw4096.void_data(), 4096); |
69 #endif // !(defined(OS_IOS) && defined(ARCH_CPU_ARM_FAMILY)) | |
70 #endif // !(defined(OS_NACL) && defined(ARCH_CPU_X86_64)) | 79 #endif // !(defined(OS_NACL) && defined(ARCH_CPU_X86_64)) |
71 #endif // !(defined(OS_IOS) && defined(ARCH_CPU_ARM64)) | 80 #endif // !defined(ARCH_CPU_ARM_FAMILY) || defined(__clang__) |
72 } | 81 } |
73 | 82 |
74 TEST(AlignedMemoryTest, DynamicAllocation) { | 83 TEST(AlignedMemoryTest, DynamicAllocation) { |
75 void* p = base::AlignedAlloc(8, 8); | 84 void* p = base::AlignedAlloc(8, 8); |
76 EXPECT_TRUE(p); | 85 EXPECT_TRUE(p); |
77 EXPECT_ALIGNED(p, 8); | 86 EXPECT_ALIGNED(p, 8); |
78 base::AlignedFree(p); | 87 base::AlignedFree(p); |
79 | 88 |
80 p = base::AlignedAlloc(8, 16); | 89 p = base::AlignedAlloc(8, 16); |
81 EXPECT_TRUE(p); | 90 EXPECT_TRUE(p); |
(...skipping 12 matching lines...) Expand all Loading... | |
94 } | 103 } |
95 | 104 |
96 TEST(AlignedMemoryTest, ScopedDynamicAllocation) { | 105 TEST(AlignedMemoryTest, ScopedDynamicAllocation) { |
97 std::unique_ptr<float, base::AlignedFreeDeleter> p( | 106 std::unique_ptr<float, base::AlignedFreeDeleter> p( |
98 static_cast<float*>(base::AlignedAlloc(8, 8))); | 107 static_cast<float*>(base::AlignedAlloc(8, 8))); |
99 EXPECT_TRUE(p.get()); | 108 EXPECT_TRUE(p.get()); |
100 EXPECT_ALIGNED(p.get(), 8); | 109 EXPECT_ALIGNED(p.get(), 8); |
101 } | 110 } |
102 | 111 |
103 } // namespace | 112 } // namespace |
OLD | NEW |