1 /* Unaligned memory access functionality.
2 Copyright (C) 2000-2014, 2018 Red Hat, Inc.
3 This file is part of elfutils.
4
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
7
8 * the GNU Lesser General Public License as published by the Free
9 Software Foundation; either version 3 of the License, or (at
10 your option) any later version
11
12 or
13
14 * the GNU General Public License as published by the Free
15 Software Foundation; either version 2 of the License, or (at
16 your option) any later version
17
18 or both in parallel, as here.
19
20 elfutils is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
24
25 You should have received copies of the GNU General Public License and
26 the GNU Lesser General Public License along with this program. If
27 not, see <http://www.gnu.org/licenses/>. */
28
29 #ifndef _MEMORY_ACCESS_H
30 #define _MEMORY_ACCESS_H 1
31
32 #include <limits.h>
33 #include <stdint.h>
34
35 #include <system.h>
36
37 /* Number decoding macros. See 7.6 Variable Length Data. */
38
39 #define len_leb128(var) ((8 * sizeof (var) + 6) / 7)
40
41 static inline size_t
__libdw_max_len_leb128(const size_t type_len,const unsigned char * addr,const unsigned char * end)42 __libdw_max_len_leb128 (const size_t type_len,
43 const unsigned char *addr, const unsigned char *end)
44 {
45 const size_t pointer_len = likely (addr < end) ? end - addr : 0;
46 return likely (type_len <= pointer_len) ? type_len : pointer_len;
47 }
48
49 static inline size_t
__libdw_max_len_uleb128(const unsigned char * addr,const unsigned char * end)50 __libdw_max_len_uleb128 (const unsigned char *addr, const unsigned char *end)
51 {
52 const size_t type_len = len_leb128 (uint64_t);
53 return __libdw_max_len_leb128 (type_len, addr, end);
54 }
55
56 static inline size_t
__libdw_max_len_sleb128(const unsigned char * addr,const unsigned char * end)57 __libdw_max_len_sleb128 (const unsigned char *addr, const unsigned char *end)
58 {
59 /* Subtract one step, so we don't shift into sign bit. */
60 const size_t type_len = len_leb128 (int64_t) - 1;
61 return __libdw_max_len_leb128 (type_len, addr, end);
62 }
63
64 #define get_uleb128_step(var, addr, nth) \
65 do { \
66 unsigned char __b = *(addr)++; \
67 (var) |= (typeof (var)) (__b & 0x7f) << ((nth) * 7); \
68 if (likely ((__b & 0x80) == 0)) \
69 return (var); \
70 } while (0)
71
72 static inline uint64_t
__libdw_get_uleb128(const unsigned char ** addrp,const unsigned char * end)73 __libdw_get_uleb128 (const unsigned char **addrp, const unsigned char *end)
74 {
75 uint64_t acc = 0;
76
77 /* Unroll the first step to help the compiler optimize
78 for the common single-byte case. */
79 get_uleb128_step (acc, *addrp, 0);
80
81 const size_t max = __libdw_max_len_uleb128 (*addrp - 1, end);
82 for (size_t i = 1; i < max; ++i)
83 get_uleb128_step (acc, *addrp, i);
84 /* Other implementations set VALUE to UINT_MAX in this
85 case. So we better do this as well. */
86 return UINT64_MAX;
87 }
88
89 static inline uint64_t
__libdw_get_uleb128_unchecked(const unsigned char ** addrp)90 __libdw_get_uleb128_unchecked (const unsigned char **addrp)
91 {
92 uint64_t acc = 0;
93
94 /* Unroll the first step to help the compiler optimize
95 for the common single-byte case. */
96 get_uleb128_step (acc, *addrp, 0);
97
98 const size_t max = len_leb128 (uint64_t);
99 for (size_t i = 1; i < max; ++i)
100 get_uleb128_step (acc, *addrp, i);
101 /* Other implementations set VALUE to UINT_MAX in this
102 case. So we better do this as well. */
103 return UINT64_MAX;
104 }
105
106 /* Note, addr needs to me smaller than end. */
107 #define get_uleb128(var, addr, end) ((var) = __libdw_get_uleb128 (&(addr), end))
108 #define get_uleb128_unchecked(var, addr) ((var) = __libdw_get_uleb128_unchecked (&(addr)))
109
110 /* The signed case is similar, but we sign-extend the result. */
111
112 #define get_sleb128_step(var, addr, nth) \
113 do { \
114 unsigned char __b = *(addr)++; \
115 (var) |= (typeof (var)) (__b & 0x7f) << ((nth) * 7); \
116 if (likely ((__b & 0x80) == 0)) \
117 { \
118 if ((__b & 0x40) != 0) \
119 (var) |= - ((typeof (var)) 1 << (((nth) + 1) * 7)); \
120 return (var); \
121 } \
122 } while (0)
123
124 static inline int64_t
__libdw_get_sleb128(const unsigned char ** addrp,const unsigned char * end)125 __libdw_get_sleb128 (const unsigned char **addrp, const unsigned char *end)
126 {
127 /* Do the work in an unsigned type, but use implementation-defined
128 behavior to cast to signed on return. This avoids some undefined
129 behavior when shifting. */
130 uint64_t acc = 0;
131
132 /* Unroll the first step to help the compiler optimize
133 for the common single-byte case. */
134 get_sleb128_step (acc, *addrp, 0);
135
136 const size_t max = __libdw_max_len_sleb128 (*addrp - 1, end);
137 for (size_t i = 1; i < max; ++i)
138 get_sleb128_step (acc, *addrp, i);
139 if (*addrp == end)
140 return INT64_MAX;
141
142 /* There might be one extra byte. */
143 unsigned char b = **addrp;
144 ++*addrp;
145 if (likely ((b & 0x80) == 0))
146 {
147 /* We only need the low bit of the final byte, and as it is the
148 sign bit, we don't need to do anything else here. */
149 acc |= ((typeof (acc)) b) << 7 * max;
150 return acc;
151 }
152
153 /* Other implementations set VALUE to INT_MAX in this
154 case. So we better do this as well. */
155 return INT64_MAX;
156 }
157
158 static inline int64_t
__libdw_get_sleb128_unchecked(const unsigned char ** addrp)159 __libdw_get_sleb128_unchecked (const unsigned char **addrp)
160 {
161 /* Do the work in an unsigned type, but use implementation-defined
162 behavior to cast to signed on return. This avoids some undefined
163 behavior when shifting. */
164 uint64_t acc = 0;
165
166 /* Unroll the first step to help the compiler optimize
167 for the common single-byte case. */
168 get_sleb128_step (acc, *addrp, 0);
169
170 /* Subtract one step, so we don't shift into sign bit. */
171 const size_t max = len_leb128 (int64_t) - 1;
172 for (size_t i = 1; i < max; ++i)
173 get_sleb128_step (acc, *addrp, i);
174
175 /* There might be one extra byte. */
176 unsigned char b = **addrp;
177 ++*addrp;
178 if (likely ((b & 0x80) == 0))
179 {
180 /* We only need the low bit of the final byte, and as it is the
181 sign bit, we don't need to do anything else here. */
182 acc |= ((typeof (acc)) b) << 7 * max;
183 return acc;
184 }
185
186 /* Other implementations set VALUE to INT_MAX in this
187 case. So we better do this as well. */
188 return INT64_MAX;
189 }
190
191 #define get_sleb128(var, addr, end) ((var) = __libdw_get_sleb128 (&(addr), end))
192 #define get_sleb128_unchecked(var, addr) ((var) = __libdw_get_sleb128_unchecked (&(addr)))
193
194
195 /* We use simple memory access functions in case the hardware allows it.
196 The caller has to make sure we don't have alias problems. */
197 #if ALLOW_UNALIGNED
198
199 # define read_2ubyte_unaligned(Dbg, Addr) \
200 (unlikely ((Dbg)->other_byte_order) \
201 ? bswap_16 (*((const uint16_t *) (Addr))) \
202 : *((const uint16_t *) (Addr)))
203 # define read_2sbyte_unaligned(Dbg, Addr) \
204 (unlikely ((Dbg)->other_byte_order) \
205 ? (int16_t) bswap_16 (*((const int16_t *) (Addr))) \
206 : *((const int16_t *) (Addr)))
207
208 # define read_4ubyte_unaligned_noncvt(Addr) \
209 *((const uint32_t *) (Addr))
210 # define read_4ubyte_unaligned(Dbg, Addr) \
211 (unlikely ((Dbg)->other_byte_order) \
212 ? bswap_32 (*((const uint32_t *) (Addr))) \
213 : *((const uint32_t *) (Addr)))
214 # define read_4sbyte_unaligned(Dbg, Addr) \
215 (unlikely ((Dbg)->other_byte_order) \
216 ? (int32_t) bswap_32 (*((const int32_t *) (Addr))) \
217 : *((const int32_t *) (Addr)))
218
219 # define read_8ubyte_unaligned_noncvt(Addr) \
220 *((const uint64_t *) (Addr))
221 # define read_8ubyte_unaligned(Dbg, Addr) \
222 (unlikely ((Dbg)->other_byte_order) \
223 ? bswap_64 (*((const uint64_t *) (Addr))) \
224 : *((const uint64_t *) (Addr)))
225 # define read_8sbyte_unaligned(Dbg, Addr) \
226 (unlikely ((Dbg)->other_byte_order) \
227 ? (int64_t) bswap_64 (*((const int64_t *) (Addr))) \
228 : *((const int64_t *) (Addr)))
229
230 #else
231
232 union unaligned
233 {
234 void *p;
235 uint16_t u2;
236 uint32_t u4;
237 uint64_t u8;
238 int16_t s2;
239 int32_t s4;
240 int64_t s8;
241 } attribute_packed;
242
243 # define read_2ubyte_unaligned(Dbg, Addr) \
244 read_2ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
245 # define read_2sbyte_unaligned(Dbg, Addr) \
246 read_2sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
247 # define read_4ubyte_unaligned(Dbg, Addr) \
248 read_4ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
249 # define read_4sbyte_unaligned(Dbg, Addr) \
250 read_4sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
251 # define read_8ubyte_unaligned(Dbg, Addr) \
252 read_8ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
253 # define read_8sbyte_unaligned(Dbg, Addr) \
254 read_8sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
255
256 static inline uint16_t
read_2ubyte_unaligned_1(bool other_byte_order,const void * p)257 read_2ubyte_unaligned_1 (bool other_byte_order, const void *p)
258 {
259 const union unaligned *up = p;
260 if (unlikely (other_byte_order))
261 return bswap_16 (up->u2);
262 return up->u2;
263 }
264 static inline int16_t
read_2sbyte_unaligned_1(bool other_byte_order,const void * p)265 read_2sbyte_unaligned_1 (bool other_byte_order, const void *p)
266 {
267 const union unaligned *up = p;
268 if (unlikely (other_byte_order))
269 return (int16_t) bswap_16 (up->u2);
270 return up->s2;
271 }
272
273 static inline uint32_t
read_4ubyte_unaligned_noncvt(const void * p)274 read_4ubyte_unaligned_noncvt (const void *p)
275 {
276 const union unaligned *up = p;
277 return up->u4;
278 }
279 static inline uint32_t
read_4ubyte_unaligned_1(bool other_byte_order,const void * p)280 read_4ubyte_unaligned_1 (bool other_byte_order, const void *p)
281 {
282 const union unaligned *up = p;
283 if (unlikely (other_byte_order))
284 return bswap_32 (up->u4);
285 return up->u4;
286 }
287 static inline int32_t
read_4sbyte_unaligned_1(bool other_byte_order,const void * p)288 read_4sbyte_unaligned_1 (bool other_byte_order, const void *p)
289 {
290 const union unaligned *up = p;
291 if (unlikely (other_byte_order))
292 return (int32_t) bswap_32 (up->u4);
293 return up->s4;
294 }
295
296 static inline uint64_t
read_8ubyte_unaligned_noncvt(const void * p)297 read_8ubyte_unaligned_noncvt (const void *p)
298 {
299 const union unaligned *up = p;
300 return up->u8;
301 }
302 static inline uint64_t
read_8ubyte_unaligned_1(bool other_byte_order,const void * p)303 read_8ubyte_unaligned_1 (bool other_byte_order, const void *p)
304 {
305 const union unaligned *up = p;
306 if (unlikely (other_byte_order))
307 return bswap_64 (up->u8);
308 return up->u8;
309 }
310 static inline int64_t
read_8sbyte_unaligned_1(bool other_byte_order,const void * p)311 read_8sbyte_unaligned_1 (bool other_byte_order, const void *p)
312 {
313 const union unaligned *up = p;
314 if (unlikely (other_byte_order))
315 return (int64_t) bswap_64 (up->u8);
316 return up->s8;
317 }
318
319 #endif /* allow unaligned */
320
321
322 #define read_2ubyte_unaligned_inc(Dbg, Addr) \
323 ({ uint16_t t_ = read_2ubyte_unaligned (Dbg, Addr); \
324 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2); \
325 t_; })
326 #define read_2sbyte_unaligned_inc(Dbg, Addr) \
327 ({ int16_t t_ = read_2sbyte_unaligned (Dbg, Addr); \
328 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2); \
329 t_; })
330
331 #define read_4ubyte_unaligned_inc(Dbg, Addr) \
332 ({ uint32_t t_ = read_4ubyte_unaligned (Dbg, Addr); \
333 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4); \
334 t_; })
335 #define read_4sbyte_unaligned_inc(Dbg, Addr) \
336 ({ int32_t t_ = read_4sbyte_unaligned (Dbg, Addr); \
337 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4); \
338 t_; })
339
340 #define read_8ubyte_unaligned_inc(Dbg, Addr) \
341 ({ uint64_t t_ = read_8ubyte_unaligned (Dbg, Addr); \
342 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8); \
343 t_; })
344 #define read_8sbyte_unaligned_inc(Dbg, Addr) \
345 ({ int64_t t_ = read_8sbyte_unaligned (Dbg, Addr); \
346 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8); \
347 t_; })
348
349 /* 3ubyte reads are only used for DW_FORM_addrx3 and DW_FORM_strx3.
350 And are probably very rare. They are not optimized. They are
351 handled as if reading a 4byte value with the first (for big endian)
352 or last (for little endian) byte zero. */
353
354 static inline int
file_byte_order(bool other_byte_order)355 file_byte_order (bool other_byte_order)
356 {
357 #if BYTE_ORDER == LITTLE_ENDIAN
358 return other_byte_order ? BIG_ENDIAN : LITTLE_ENDIAN;
359 #else
360 return other_byte_order ? LITTLE_ENDIAN : BIG_ENDIAN;
361 #endif
362 }
363
364 static inline uint32_t
read_3ubyte_unaligned(Dwarf * dbg,const unsigned char * p)365 read_3ubyte_unaligned (Dwarf *dbg, const unsigned char *p)
366 {
367 union
368 {
369 uint32_t u4;
370 unsigned char c[4];
371 } d;
372 bool other_byte_order = dbg->other_byte_order;
373
374 if (file_byte_order (other_byte_order) == BIG_ENDIAN)
375 {
376 d.c[0] = 0x00;
377 d.c[1] = p[0];
378 d.c[2] = p[1];
379 d.c[3] = p[2];
380 }
381 else
382 {
383 d.c[0] = p[0];
384 d.c[1] = p[1];
385 d.c[2] = p[2];
386 d.c[3] = 0x00;
387 }
388
389 if (other_byte_order)
390 return bswap_32 (d.u4);
391 else
392 return d.u4;
393 }
394
395
396 #define read_3ubyte_unaligned_inc(Dbg, Addr) \
397 ({ uint32_t t_ = read_3ubyte_unaligned (Dbg, Addr); \
398 Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 3); \
399 t_; })
400
401 #define read_addr_unaligned_inc(Nbytes, Dbg, Addr) \
402 (assert ((Nbytes) == 4 || (Nbytes) == 8), \
403 ((Nbytes) == 4 ? read_4ubyte_unaligned_inc (Dbg, Addr) \
404 : read_8ubyte_unaligned_inc (Dbg, Addr)))
405
406 #endif /* memory-access.h */
407