1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___MEMORY_ARRAY_COOKIE_H
#define _LIBCPP___MEMORY_ARRAY_COOKIE_H
#include <__config>
#include <__configuration/abi.h>
#include <__cstddef/size_t.h>
#include <__memory/addressof.h>
#include <__type_traits/integral_constant.h>
#include <__type_traits/is_trivially_destructible.h>
#include <__type_traits/negation.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
// Trait representing whether a type requires an array cookie at the start of its allocation when
// allocated as `new T[n]` and deallocated as `delete[] array`.
//
// Under the Itanium C++ ABI [1] and the ARM ABI which derives from it, we know that an array cookie is available
// unless `T` is trivially destructible and the call to `operator delete[]` is not a sized operator delete. Under
// other ABIs, we assume there are no array cookies.
//
// [1]: https://itanium-cxx-abi.github.io/cxx-abi/abi.html#array-cookies
#if defined(_LIBCPP_ABI_ITANIUM) || defined(_LIBCPP_ABI_ITANIUM_WITH_ARM_DIFFERENCES)
// TODO: Use a builtin instead
// TODO: We should factor in the choice of the usual deallocation function in this determination:
// a cookie may be available in more cases but we ignore those for now.
template <class _Tp>
struct __has_array_cookie : _Not<is_trivially_destructible<_Tp> > {};
#else
template <class _Tp>
struct __has_array_cookie : false_type {};
#endif
struct __itanium_array_cookie {
size_t __element_count;
};
template <class _Tp>
struct [[__gnu__::__aligned__(_LIBCPP_ALIGNOF(_Tp))]] __arm_array_cookie {
size_t __element_size;
size_t __element_count;
};
// Return the element count in the array cookie located before the given pointer.
//
// In the Itanium ABI [1]
// ----------------------
// The element count is stored immediately before the first element of the array. If the preferred alignment
// of array elements (which is different from the ABI alignment) is more than that of size_t, additional
// padding bytes exist before the array cookie. Assuming array elements of size and alignment 16 bytes, that
// gives us the following layout:
//
// |ooooooooxxxxxxxxaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd|
// ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// | ^^^^^^^^ |
// | | array elements
// padding |
// element count
//
//
// In the Itanium ABI with ARM differences [2]
// -------------------------------------------
// The array cookie is stored at the very start of the allocation and it has the following form:
//
// struct array_cookie {
// std::size_t element_size; // element_size != 0
// std::size_t element_count;
// };
//
// Assuming elements of size and alignment 32 bytes, this gives us the following layout:
//
// |xxxxxxxxXXXXXXXXooooooooooooooooaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb|
// ^^^^^^^^ ^^^^^^^^^^^^^^^^
// | ^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// element size | padding |
// element count array elements
//
// We must be careful to take into account the alignment of the array cookie, which may result in padding
// bytes between the element count and the first element of the array. Note that for ARM, the compiler
// aligns the array cookie using the ABI alignment, not the preferred alignment of array elements.
//
// [1]: https://itanium-cxx-abi.github.io/cxx-abi/abi.html#array-cookies
// [2]: https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms#Handle-C++-differences
template <class _Tp>
// Avoid failures when -fsanitize-address-poison-custom-array-cookie is enabled
_LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") size_t __get_array_cookie([[__maybe_unused__]] _Tp const* __ptr) {
static_assert(
__has_array_cookie<_Tp>::value, "Trying to access the array cookie of a type that is not guaranteed to have one");
#if defined(_LIBCPP_ABI_ITANIUM)
using _ArrayCookie = __itanium_array_cookie;
#elif defined(_LIBCPP_ABI_ITANIUM_WITH_ARM_DIFFERENCES)
using _ArrayCookie = __arm_array_cookie<_Tp>;
#else
static_assert(false, "The array cookie layout is unknown on this ABI");
struct _ArrayCookie { // dummy definition required to make the function parse
size_t element_count;
};
#endif
char const* __array_cookie_start = reinterpret_cast<char const*>(__ptr) - sizeof(_ArrayCookie);
_ArrayCookie __cookie;
// This is necessary to avoid violating strict aliasing. It's valid because _ArrayCookie is an
// implicit lifetime type.
__builtin_memcpy(std::addressof(__cookie), __array_cookie_start, sizeof(_ArrayCookie));
return __cookie.__element_count;
}
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_ARRAY_COOKIE_H
|
