1 // Copyright (c) 2017 Gilad Naaman
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 /// Reexport for `local_inner_macros`; see
22 /// <https://doc.rust-lang.org/edition-guide/rust-2018/macros/macro-changes.html#macros-using-local_inner_macros>.
23 #[doc(hidden)]
24 #[macro_export]
25 macro_rules! _memoffset__compile_error {
26     ($($inner:tt)*) => {
27         compile_error! { $($inner)* }
28     }
29 }
30 
31 /// Produces a range instance representing the sub-slice containing the specified member.
32 ///
33 /// This macro provides 2 forms of differing functionalities.
34 ///
35 /// The first form is identical to the appearance of the `offset_of!` macro.
36 ///
37 /// ```ignore
38 /// span_of!(Struct, member)
39 /// ```
40 ///
41 /// The second form of `span_of!` returns a sub-slice which starts at one field, and ends at another.
42 /// The general pattern of this form is:
43 ///
44 /// ```ignore
45 /// // Exclusive
46 /// span_of!(Struct, member_a .. member_b)
47 /// // Inclusive
48 /// span_of!(Struct, member_a ..= member_b)
49 ///
50 /// // Open-ended ranges
51 /// span_of!(Struct, .. end)
52 /// span_of!(Struct, start ..)
53 /// ```
54 ///
55 /// ### Note
56 /// This macro uses recursion in order to resolve the range expressions, so there is a limit to
57 /// the complexity of the expression.
58 /// In order to raise the limit, the compiler's recursion limit should be lifted.
59 ///
60 /// ### Safety
61 /// The inter-field form mentioned above assumes that the first field is positioned before the
62 /// second.
63 /// This is only guarenteed for `repr(C)` structs.
64 /// Usage with `repr(Rust)` structs may yield unexpected results, like downward-going ranges,
65 /// spans that include unexpected fields, empty spans, or spans that include *unexpected* padding bytes.
66 ///
67 /// ## Examples
68 /// ```
69 /// use memoffset::span_of;
70 ///
71 /// #[repr(C)]
72 /// struct Florp {
73 ///     a: u32
74 /// }
75 ///
76 /// #[repr(C)]
77 /// struct Blarg {
78 ///     x: [u32; 2],
79 ///     y: [u8; 56],
80 ///     z: Florp,
81 ///     egg: [[u8; 4]; 4]
82 /// }
83 ///
84 /// fn main() {
85 ///     assert_eq!(0..84,  span_of!(Blarg, ..));
86 ///     assert_eq!(0..8,   span_of!(Blarg, .. y));
87 ///     assert_eq!(0..64,  span_of!(Blarg, ..= y));
88 ///     assert_eq!(0..8,   span_of!(Blarg, x));
89 ///     assert_eq!(8..84,  span_of!(Blarg, y ..));
90 ///     assert_eq!(0..8,   span_of!(Blarg, x .. y));
91 ///     assert_eq!(0..64,  span_of!(Blarg, x ..= y));
92 /// }
93 /// ```
94 #[macro_export(local_inner_macros)]
95 macro_rules! span_of {
96     (@helper  $root:ident, [] ..=) => {
97         _memoffset__compile_error!("Expected a range, found '..='")
98     };
99     (@helper $root:ident, [] ..) => {
100         _memoffset__compile_error!("Expected a range, found '..'")
101     };
102     // No explicit begin for range.
103     (@helper $root:ident, $parent:path, [] ..) => {{
104         ($root as usize,
105          $root as usize + $crate::__priv::size_of_pointee($root))
106     }};
107     (@helper $root:ident, $parent:path, [] ..= $end:tt) => {{
108         let end = raw_field!($root, $parent, $end);
109         ($root as usize, end as usize + $crate::__priv::size_of_pointee(end))
110     }};
111     (@helper $root:ident, $parent:path, [] .. $end:tt) => {{
112         ($root as usize, raw_field!($root, $parent, $end) as usize)
113     }};
114     // Explicit begin and end for range.
115     (@helper $root:ident, $parent:path, # $begin:tt [] ..= $end:tt) => {{
116         let begin = raw_field!($root, $parent, $begin);
117         let end = raw_field!($root, $parent, $end);
118         (begin as usize, end as usize + $crate::__priv::size_of_pointee(end))
119     }};
120     (@helper $root:ident, $parent:path, # $begin:tt [] .. $end:tt) => {{
121         (raw_field!($root, $parent, $begin) as usize,
122          raw_field!($root, $parent, $end) as usize)
123     }};
124     // No explicit end for range.
125     (@helper $root:ident, $parent:path, # $begin:tt [] ..) => {{
126         (raw_field!($root, $parent, $begin) as usize,
127          $root as usize + $crate::__priv::size_of_pointee($root))
128     }};
129     (@helper $root:ident, $parent:path, # $begin:tt [] ..=) => {{
130         _memoffset__compile_error!(
131             "Found inclusive range to the end of a struct. Did you mean '..' instead of '..='?")
132     }};
133     // Just one field.
134     (@helper $root:ident, $parent:path, # $field:tt []) => {{
135         let field = raw_field!($root, $parent, $field);
136         (field as usize, field as usize + $crate::__priv::size_of_pointee(field))
137     }};
138     // Parsing.
139     (@helper $root:ident, $parent:path, $(# $begin:tt)+ [] $tt:tt $($rest:tt)*) => {{
140         span_of!(@helper $root, $parent, $(#$begin)* #$tt [] $($rest)*)
141     }};
142     (@helper $root:ident, $parent:path, [] $tt:tt $($rest:tt)*) => {{
143         span_of!(@helper $root, $parent, #$tt [] $($rest)*)
144     }};
145 
146     // Entry point.
147     ($sty:path, $($exp:tt)+) => ({
148         // Get a base pointer.
149         _memoffset__let_base_ptr!(root, $sty);
150         let base = root as usize;
151         let (begin, end) = span_of!(@helper root, $sty, [] $($exp)*);
152         begin-base..end-base
153     });
154 }
155 
156 #[cfg(test)]
157 mod tests {
158     use core::mem;
159 
160     #[test]
span_simple()161     fn span_simple() {
162         #[repr(C)]
163         struct Foo {
164             a: u32,
165             b: [u8; 2],
166             c: i64,
167         }
168 
169         assert_eq!(span_of!(Foo, a), 0..4);
170         assert_eq!(span_of!(Foo, b), 4..6);
171         assert_eq!(span_of!(Foo, c), 8..8 + 8);
172     }
173 
174     #[test]
175     #[cfg_attr(miri, ignore)] // this creates unaligned references
span_simple_packed()176     fn span_simple_packed() {
177         #[repr(C, packed)]
178         struct Foo {
179             a: u32,
180             b: [u8; 2],
181             c: i64,
182         }
183 
184         assert_eq!(span_of!(Foo, a), 0..4);
185         assert_eq!(span_of!(Foo, b), 4..6);
186         assert_eq!(span_of!(Foo, c), 6..6 + 8);
187     }
188 
189     #[test]
span_forms()190     fn span_forms() {
191         #[repr(C)]
192         struct Florp {
193             a: u32,
194         }
195 
196         #[repr(C)]
197         struct Blarg {
198             x: u64,
199             y: [u8; 56],
200             z: Florp,
201             egg: [[u8; 4]; 5],
202         }
203 
204         // Love me some brute force
205         assert_eq!(0..8, span_of!(Blarg, x));
206         assert_eq!(64..68, span_of!(Blarg, z));
207         assert_eq!(68..mem::size_of::<Blarg>(), span_of!(Blarg, egg));
208 
209         assert_eq!(8..64, span_of!(Blarg, y..z));
210         assert_eq!(0..64, span_of!(Blarg, x..=y));
211     }
212 
213     #[test]
ig_test()214     fn ig_test() {
215         #[repr(C)]
216         struct Member {
217             foo: u32,
218         }
219 
220         #[repr(C)]
221         struct Test {
222             x: u64,
223             y: [u8; 56],
224             z: Member,
225             egg: [[u8; 4]; 4],
226         }
227 
228         assert_eq!(span_of!(Test, ..x), 0..0);
229         assert_eq!(span_of!(Test, ..=x), 0..8);
230         assert_eq!(span_of!(Test, ..y), 0..8);
231         assert_eq!(span_of!(Test, ..=y), 0..64);
232         assert_eq!(span_of!(Test, ..z), 0..64);
233         assert_eq!(span_of!(Test, ..=z), 0..68);
234         assert_eq!(span_of!(Test, ..egg), 0..68);
235         assert_eq!(span_of!(Test, ..=egg), 0..84);
236         assert_eq!(span_of!(Test, ..), 0..mem::size_of::<Test>());
237         assert_eq!(
238             span_of!(Test, x..),
239             offset_of!(Test, x)..mem::size_of::<Test>()
240         );
241         assert_eq!(
242             span_of!(Test, y..),
243             offset_of!(Test, y)..mem::size_of::<Test>()
244         );
245 
246         assert_eq!(
247             span_of!(Test, z..),
248             offset_of!(Test, z)..mem::size_of::<Test>()
249         );
250         assert_eq!(
251             span_of!(Test, egg..),
252             offset_of!(Test, egg)..mem::size_of::<Test>()
253         );
254         assert_eq!(
255             span_of!(Test, x..y),
256             offset_of!(Test, x)..offset_of!(Test, y)
257         );
258         assert_eq!(
259             span_of!(Test, x..=y),
260             offset_of!(Test, x)..offset_of!(Test, y) + mem::size_of::<[u8; 56]>()
261         );
262     }
263 }
264