• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <byteswap.h>
33 #include <endian.h>
34 #include <limits.h>
35 #include <stdint.h>
36 
37 
38 /* Number decoding macros.  See 7.6 Variable Length Data.  */
39 
40 #define len_leb128(var) ((8 * sizeof (var) + 6) / 7)
41 
42 static inline size_t
__libdw_max_len_leb128(const size_t type_len,const unsigned char * addr,const unsigned char * end)43 __libdw_max_len_leb128 (const size_t type_len,
44 			const unsigned char *addr, const unsigned char *end)
45 {
46   const size_t pointer_len = likely (addr < end) ? end - addr : 0;
47   return likely (type_len <= pointer_len) ? type_len : pointer_len;
48 }
49 
50 static inline size_t
__libdw_max_len_uleb128(const unsigned char * addr,const unsigned char * end)51 __libdw_max_len_uleb128 (const unsigned char *addr, const unsigned char *end)
52 {
53   const size_t type_len = len_leb128 (uint64_t);
54   return __libdw_max_len_leb128 (type_len, addr, end);
55 }
56 
57 static inline size_t
__libdw_max_len_sleb128(const unsigned char * addr,const unsigned char * end)58 __libdw_max_len_sleb128 (const unsigned char *addr, const unsigned char *end)
59 {
60   /* Subtract one step, so we don't shift into sign bit.  */
61   const size_t type_len = len_leb128 (int64_t) - 1;
62   return __libdw_max_len_leb128 (type_len, addr, end);
63 }
64 
65 #define get_uleb128_step(var, addr, nth)				      \
66   do {									      \
67     unsigned char __b = *(addr)++;					      \
68     (var) |= (typeof (var)) (__b & 0x7f) << ((nth) * 7);		      \
69     if (likely ((__b & 0x80) == 0))					      \
70       return (var);							      \
71   } while (0)
72 
73 static inline uint64_t
__libdw_get_uleb128(const unsigned char ** addrp,const unsigned char * end)74 __libdw_get_uleb128 (const unsigned char **addrp, const unsigned char *end)
75 {
76   uint64_t acc = 0;
77 
78   /* Unroll the first step to help the compiler optimize
79      for the common single-byte case.  */
80   get_uleb128_step (acc, *addrp, 0);
81 
82   const size_t max = __libdw_max_len_uleb128 (*addrp - 1, end);
83   for (size_t i = 1; i < max; ++i)
84     get_uleb128_step (acc, *addrp, i);
85   /* Other implementations set VALUE to UINT_MAX in this
86      case.  So we better do this as well.  */
87   return UINT64_MAX;
88 }
89 
90 static inline uint64_t
__libdw_get_uleb128_unchecked(const unsigned char ** addrp)91 __libdw_get_uleb128_unchecked (const unsigned char **addrp)
92 {
93   uint64_t acc = 0;
94 
95   /* Unroll the first step to help the compiler optimize
96      for the common single-byte case.  */
97   get_uleb128_step (acc, *addrp, 0);
98 
99   const size_t max = len_leb128 (uint64_t);
100   for (size_t i = 1; i < max; ++i)
101     get_uleb128_step (acc, *addrp, i);
102   /* Other implementations set VALUE to UINT_MAX in this
103      case.  So we better do this as well.  */
104   return UINT64_MAX;
105 }
106 
107 /* Note, addr needs to me smaller than end. */
108 #define get_uleb128(var, addr, end) ((var) = __libdw_get_uleb128 (&(addr), end))
109 #define get_uleb128_unchecked(var, addr) ((var) = __libdw_get_uleb128_unchecked (&(addr)))
110 
111 /* The signed case is similar, but we sign-extend the result.  */
112 
113 #define get_sleb128_step(var, addr, nth)				      \
114   do {									      \
115     unsigned char __b = *(addr)++;					      \
116     if (likely ((__b & 0x80) == 0))					      \
117       {									      \
118 	struct { signed int i:7; } __s = { .i = __b };			      \
119 	(var) |= (typeof (var)) __s.i * ((typeof (var)) 1 << ((nth) * 7));    \
120 	return (var);							      \
121       }									      \
122     (var) |= (typeof (var)) (__b & 0x7f) << ((nth) * 7);		      \
123   } while (0)
124 
125 static inline int64_t
__libdw_get_sleb128(const unsigned char ** addrp,const unsigned char * end)126 __libdw_get_sleb128 (const unsigned char **addrp, const unsigned char *end)
127 {
128   int64_t acc = 0;
129 
130   /* Unroll the first step to help the compiler optimize
131      for the common single-byte case.  */
132   get_sleb128_step (acc, *addrp, 0);
133 
134   const size_t max = __libdw_max_len_sleb128 (*addrp - 1, end);
135   for (size_t i = 1; i < max; ++i)
136     get_sleb128_step (acc, *addrp, i);
137   /* Other implementations set VALUE to INT_MAX in this
138      case.  So we better do this as well.  */
139   return INT64_MAX;
140 }
141 
142 static inline int64_t
__libdw_get_sleb128_unchecked(const unsigned char ** addrp)143 __libdw_get_sleb128_unchecked (const unsigned char **addrp)
144 {
145   int64_t acc = 0;
146 
147   /* Unroll the first step to help the compiler optimize
148      for the common single-byte case.  */
149   get_sleb128_step (acc, *addrp, 0);
150 
151   /* Subtract one step, so we don't shift into sign bit.  */
152   const size_t max = len_leb128 (int64_t) - 1;
153   for (size_t i = 1; i < max; ++i)
154     get_sleb128_step (acc, *addrp, i);
155   /* Other implementations set VALUE to INT_MAX in this
156      case.  So we better do this as well.  */
157   return INT64_MAX;
158 }
159 
160 #define get_sleb128(var, addr, end) ((var) = __libdw_get_sleb128 (&(addr), end))
161 #define get_sleb128_unchecked(var, addr) ((var) = __libdw_get_sleb128_unchecked (&(addr)))
162 
163 
164 /* We use simple memory access functions in case the hardware allows it.
165    The caller has to make sure we don't have alias problems.  */
166 #if ALLOW_UNALIGNED
167 
168 # define read_2ubyte_unaligned(Dbg, Addr) \
169   (unlikely ((Dbg)->other_byte_order)					      \
170    ? bswap_16 (*((const uint16_t *) (Addr)))				      \
171    : *((const uint16_t *) (Addr)))
172 # define read_2sbyte_unaligned(Dbg, Addr) \
173   (unlikely ((Dbg)->other_byte_order)					      \
174    ? (int16_t) bswap_16 (*((const int16_t *) (Addr)))			      \
175    : *((const int16_t *) (Addr)))
176 
177 # define read_4ubyte_unaligned_noncvt(Addr) \
178    *((const uint32_t *) (Addr))
179 # define read_4ubyte_unaligned(Dbg, Addr) \
180   (unlikely ((Dbg)->other_byte_order)					      \
181    ? bswap_32 (*((const uint32_t *) (Addr)))				      \
182    : *((const uint32_t *) (Addr)))
183 # define read_4sbyte_unaligned(Dbg, Addr) \
184   (unlikely ((Dbg)->other_byte_order)					      \
185    ? (int32_t) bswap_32 (*((const int32_t *) (Addr)))			      \
186    : *((const int32_t *) (Addr)))
187 
188 # define read_8ubyte_unaligned_noncvt(Addr) \
189    *((const uint64_t *) (Addr))
190 # define read_8ubyte_unaligned(Dbg, Addr) \
191   (unlikely ((Dbg)->other_byte_order)					      \
192    ? bswap_64 (*((const uint64_t *) (Addr)))				      \
193    : *((const uint64_t *) (Addr)))
194 # define read_8sbyte_unaligned(Dbg, Addr) \
195   (unlikely ((Dbg)->other_byte_order)					      \
196    ? (int64_t) bswap_64 (*((const int64_t *) (Addr)))			      \
197    : *((const int64_t *) (Addr)))
198 
199 #else
200 
201 union unaligned
202   {
203     void *p;
204     uint16_t u2;
205     uint32_t u4;
206     uint64_t u8;
207     int16_t s2;
208     int32_t s4;
209     int64_t s8;
210   } attribute_packed;
211 
212 # define read_2ubyte_unaligned(Dbg, Addr) \
213   read_2ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
214 # define read_2sbyte_unaligned(Dbg, Addr) \
215   read_2sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
216 # define read_4ubyte_unaligned(Dbg, Addr) \
217   read_4ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
218 # define read_4sbyte_unaligned(Dbg, Addr) \
219   read_4sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
220 # define read_8ubyte_unaligned(Dbg, Addr) \
221   read_8ubyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
222 # define read_8sbyte_unaligned(Dbg, Addr) \
223   read_8sbyte_unaligned_1 ((Dbg)->other_byte_order, (Addr))
224 
225 static inline uint16_t
read_2ubyte_unaligned_1(bool other_byte_order,const void * p)226 read_2ubyte_unaligned_1 (bool other_byte_order, const void *p)
227 {
228   const union unaligned *up = p;
229   if (unlikely (other_byte_order))
230     return bswap_16 (up->u2);
231   return up->u2;
232 }
233 static inline int16_t
read_2sbyte_unaligned_1(bool other_byte_order,const void * p)234 read_2sbyte_unaligned_1 (bool other_byte_order, const void *p)
235 {
236   const union unaligned *up = p;
237   if (unlikely (other_byte_order))
238     return (int16_t) bswap_16 (up->u2);
239   return up->s2;
240 }
241 
242 static inline uint32_t
read_4ubyte_unaligned_noncvt(const void * p)243 read_4ubyte_unaligned_noncvt (const void *p)
244 {
245   const union unaligned *up = p;
246   return up->u4;
247 }
248 static inline uint32_t
read_4ubyte_unaligned_1(bool other_byte_order,const void * p)249 read_4ubyte_unaligned_1 (bool other_byte_order, const void *p)
250 {
251   const union unaligned *up = p;
252   if (unlikely (other_byte_order))
253     return bswap_32 (up->u4);
254   return up->u4;
255 }
256 static inline int32_t
read_4sbyte_unaligned_1(bool other_byte_order,const void * p)257 read_4sbyte_unaligned_1 (bool other_byte_order, const void *p)
258 {
259   const union unaligned *up = p;
260   if (unlikely (other_byte_order))
261     return (int32_t) bswap_32 (up->u4);
262   return up->s4;
263 }
264 
265 static inline uint64_t
read_8ubyte_unaligned_noncvt(const void * p)266 read_8ubyte_unaligned_noncvt (const void *p)
267 {
268   const union unaligned *up = p;
269   return up->u8;
270 }
271 static inline uint64_t
read_8ubyte_unaligned_1(bool other_byte_order,const void * p)272 read_8ubyte_unaligned_1 (bool other_byte_order, const void *p)
273 {
274   const union unaligned *up = p;
275   if (unlikely (other_byte_order))
276     return bswap_64 (up->u8);
277   return up->u8;
278 }
279 static inline int64_t
read_8sbyte_unaligned_1(bool other_byte_order,const void * p)280 read_8sbyte_unaligned_1 (bool other_byte_order, const void *p)
281 {
282   const union unaligned *up = p;
283   if (unlikely (other_byte_order))
284     return (int64_t) bswap_64 (up->u8);
285   return up->s8;
286 }
287 
288 #endif	/* allow unaligned */
289 
290 
291 #define read_2ubyte_unaligned_inc(Dbg, Addr) \
292   ({ uint16_t t_ = read_2ubyte_unaligned (Dbg, Addr);			      \
293      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2);		      \
294      t_; })
295 #define read_2sbyte_unaligned_inc(Dbg, Addr) \
296   ({ int16_t t_ = read_2sbyte_unaligned (Dbg, Addr);			      \
297      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2);		      \
298      t_; })
299 
300 #define read_4ubyte_unaligned_inc(Dbg, Addr) \
301   ({ uint32_t t_ = read_4ubyte_unaligned (Dbg, Addr);			      \
302      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4);		      \
303      t_; })
304 #define read_4sbyte_unaligned_inc(Dbg, Addr) \
305   ({ int32_t t_ = read_4sbyte_unaligned (Dbg, Addr);			      \
306      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4);		      \
307      t_; })
308 
309 #define read_8ubyte_unaligned_inc(Dbg, Addr) \
310   ({ uint64_t t_ = read_8ubyte_unaligned (Dbg, Addr);			      \
311      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8);		      \
312      t_; })
313 #define read_8sbyte_unaligned_inc(Dbg, Addr) \
314   ({ int64_t t_ = read_8sbyte_unaligned (Dbg, Addr);			      \
315      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8);		      \
316      t_; })
317 
318 /* 3ubyte reads are only used for DW_FORM_addrx3 and DW_FORM_strx3.
319    And are probably very rare.  They are not optimized.  They are
320    handled as if reading a 4byte value with the first (for big endian)
321    or last (for little endian) byte zero.  */
322 
323 static inline int
file_byte_order(bool other_byte_order)324 file_byte_order (bool other_byte_order)
325 {
326 #if __BYTE_ORDER == __LITTLE_ENDIAN
327   return other_byte_order ? __BIG_ENDIAN : __LITTLE_ENDIAN;
328 #else
329   return other_byte_order ? __LITTLE_ENDIAN : __BIG_ENDIAN;
330 #endif
331 }
332 
333 static inline uint32_t
read_3ubyte_unaligned(Dwarf * dbg,const unsigned char * p)334 read_3ubyte_unaligned (Dwarf *dbg, const unsigned char *p)
335 {
336   union
337   {
338     uint32_t u4;
339     unsigned char c[4];
340   } d;
341   bool other_byte_order = dbg->other_byte_order;
342 
343   if (file_byte_order (other_byte_order) == __BIG_ENDIAN)
344     {
345       d.c[0] = 0x00;
346       d.c[1] = p[0];
347       d.c[2] = p[1];
348       d.c[3] = p[2];
349     }
350   else
351     {
352       d.c[0] = p[0];
353       d.c[1] = p[1];
354       d.c[2] = p[2];
355       d.c[3] = 0x00;
356     }
357 
358   if (other_byte_order)
359     return bswap_32 (d.u4);
360   else
361     return d.u4;
362 }
363 
364 
365 #define read_3ubyte_unaligned_inc(Dbg, Addr) \
366   ({ uint32_t t_ = read_2ubyte_unaligned (Dbg, Addr);			      \
367      Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 3);		      \
368      t_; })
369 
370 #define read_addr_unaligned_inc(Nbytes, Dbg, Addr)			\
371   (assert ((Nbytes) == 4 || (Nbytes) == 8),				\
372     ((Nbytes) == 4 ? read_4ubyte_unaligned_inc (Dbg, Addr)		\
373      : read_8ubyte_unaligned_inc (Dbg, Addr)))
374 
375 #endif	/* memory-access.h */
376