1// Copyright (c) 2020 Gilad Naaman, Ralf Jung
2//
3// Permission is hereby granted, free of charge, to any person obtaining a copy
4// of this software and associated documentation files (the "Software"), to deal
5// in the Software without restriction, including without limitation the rights
6// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7// copies of the Software, and to permit persons to whom the Software is
8// furnished to do so, subject to the following conditions:
9//
10// The above copyright notice and this permission notice shall be included in all
11// copies or substantial portions of the Software.
12//
13// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19// SOFTWARE.
20
21/// `addr_of!`, or just ref-then-cast when that is not available.
22#[cfg(raw_ref_macros)]
23#[macro_export]
24#[doc(hidden)]
25macro_rules! _memoffset__addr_of {
26 ($path:expr) => {{
27 $crate::__priv::ptr::addr_of!($path)
28 }};
29}
30#[cfg(not(raw_ref_macros))]
31#[macro_export]
32#[doc(hidden)]
33macro_rules! _memoffset__addr_of {
34 ($path:expr) => {{
35 // This is UB because we create an intermediate reference to uninitialized memory.
36 // Nothing we can do about that without `addr_of!` though.
37 &$path as *const _
38 }};
39}
40
41/// Deref-coercion protection macro.
42///
43/// Prevents compilation if the specified field name is not a part of the
44/// struct definition.
45///
46/// ```compile_fail
47/// use memoffset::_memoffset__field_check;
48///
49/// struct Foo {
50/// foo: i32,
51/// }
52///
53/// type BoxedFoo = Box<Foo>;
54///
55/// _memoffset__field_check!(BoxedFoo, foo);
56/// ```
57#[cfg(allow_clippy)]
58#[macro_export]
59#[doc(hidden)]
60macro_rules! _memoffset__field_check {
61 ($type:path, $field:tt) => {
62 // Make sure the field actually exists. This line ensures that a
63 // compile-time error is generated if $field is accessed through a
64 // Deref impl.
65 #[allow(clippy::unneeded_field_pattern)]
66 let $type { $field: _, .. };
67 };
68}
69#[cfg(not(allow_clippy))]
70#[macro_export]
71#[doc(hidden)]
72macro_rules! _memoffset__field_check {
73 ($type:path, $field:tt) => {
74 // Make sure the field actually exists. This line ensures that a
75 // compile-time error is generated if $field is accessed through a
76 // Deref impl.
77 let $type { $field: _, .. };
78 };
79}
80
81/// Deref-coercion protection macro.
82///
83/// Prevents compilation if the specified type is not a tuple.
84///
85/// ```compile_fail
86/// use memoffset::_memoffset__field_check_tuple;
87///
88/// _memoffset__field_check_tuple!(i32, 0);
89/// ```
90#[cfg(allow_clippy)]
91#[macro_export]
92#[doc(hidden)]
93macro_rules! _memoffset__field_check_tuple {
94 ($type:ty, $field:tt) => {
95 // Make sure the type argument is a tuple
96 #[allow(clippy::unneeded_wildcard_pattern)]
97 let (_, ..): $type;
98 };
99}
100#[cfg(not(allow_clippy))]
101#[macro_export]
102#[doc(hidden)]
103macro_rules! _memoffset__field_check_tuple {
104 ($type:ty, $field:tt) => {
105 // Make sure the type argument is a tuple
106 let (_, ..): $type;
107 };
108}
109
110/// Deref-coercion protection macro for unions.
111/// Unfortunately accepts single-field structs as well, which is not ideal,
112/// but ultimately pretty harmless.
113///
114/// ```compile_fail
115/// use memoffset::_memoffset__field_check_union;
116///
117/// union Foo {
118/// variant_a: i32,
119/// }
120///
121/// type BoxedFoo = Box<Foo>;
122///
123/// _memoffset__field_check_union!(BoxedFoo, variant_a);
124/// ```
125#[cfg(allow_clippy)]
126#[macro_export]
127#[doc(hidden)]
128macro_rules! _memoffset__field_check_union {
129 ($type:path, $field:tt) => {
130 // Make sure the field actually exists. This line ensures that a
131 // compile-time error is generated if $field is accessed through a
132 // Deref impl.
133 #[allow(clippy::unneeded_wildcard_pattern)]
134 // rustc1.19 requires unsafe here for the pattern; not needed in newer versions
135 #[allow(unused_unsafe)]
136 unsafe {
137 let $type { $field: _ };
138 }
139 };
140}
141#[cfg(not(allow_clippy))]
142#[macro_export]
143#[doc(hidden)]
144macro_rules! _memoffset__field_check_union {
145 ($type:path, $field:tt) => {
146 // Make sure the field actually exists. This line ensures that a
147 // compile-time error is generated if $field is accessed through a
148 // Deref impl.
149 // rustc1.19 requires unsafe here for the pattern; not needed in newer versions
150 #[allow(unused_unsafe)]
151 unsafe {
152 let $type { $field: _ };
153 }
154 };
155}
156
157/// Computes a const raw pointer to the given field of the given base pointer
158/// to the given parent type.
159///
160/// The `base` pointer *must not* be dangling, but it *may* point to
161/// uninitialized memory.
162#[macro_export(local_inner_macros)]
163macro_rules! raw_field {
164 ($base:expr, $parent:path, $field:tt) => {{
165 _memoffset__field_check!($parent, $field);
166 let base = $base; // evaluate $base outside the `unsafe` block
167
168 // Get the field address.
169 // Crucially, we know that this will not trigger a deref coercion because
170 // of the field check we did above.
171 #[allow(unused_unsafe)] // for when the macro is used in an unsafe block
172 unsafe {
173 _memoffset__addr_of!((*(base as *const $parent)).$field)
174 }
175 }};
176}
177
178/// Computes a const raw pointer to the given field of the given base pointer
179/// to the given parent tuple type.
180///
181/// The `base` pointer *must not* be dangling, but it *may* point to
182/// uninitialized memory.
183#[cfg(tuple_ty)]
184#[macro_export(local_inner_macros)]
185macro_rules! raw_field_tuple {
186 ($base:expr, $parent:ty, $field:tt) => {{
187 _memoffset__field_check_tuple!($parent, $field);
188 let base = $base; // evaluate $base outside the `unsafe` block
189
190 // Get the field address.
191 // Crucially, we know that this will not trigger a deref coercion because
192 // of the field check we did above.
193 #[allow(unused_unsafe)] // for when the macro is used in an unsafe block
194 unsafe {
195 _memoffset__addr_of!((*(base as *const $parent)).$field)
196 }
197 }};
198}
199
200/// Computes a const raw pointer to the given field of the given base pointer
201/// to the given parent tuple type.
202///
203/// The `base` pointer *must not* be dangling, but it *may* point to
204/// uninitialized memory.
205///
206/// ## Note
207/// This macro is the same as `raw_field`, except for a different Deref-coercion check that
208/// supports unions.
209/// Due to `macro_rules!` limitations, this check will accept structs with a single field as well as unions.
210/// This is not a stable guarantee, and future versions of this crate might fail
211/// on any use of this macro with a struct, without a semver bump.
212#[macro_export(local_inner_macros)]
213macro_rules! raw_field_union {
214 ($base:expr, $parent:path, $field:tt) => {{
215 _memoffset__field_check_union!($parent, $field);
216 let base = $base; // evaluate $base outside the `unsafe` block
217
218 // Get the field address.
219 // Crucially, we know that this will not trigger a deref coercion because
220 // of the field check we did above.
221 #[allow(unused_unsafe)] // for when the macro is used in an unsafe block
222 unsafe {
223 _memoffset__addr_of!((*(base as *const $parent)).$field)
224 }
225 }};
226}
227