helper/types.h: Add missing #includes
[openocd.git] / src / helper / types.h
1 /***************************************************************************
2 * Copyright (C) 2004, 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
20 ***************************************************************************/
21
22 #ifndef OPENOCD_HELPER_TYPES_H
23 #define OPENOCD_HELPER_TYPES_H
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <stddef.h>
30 #include <assert.h>
31 #ifdef HAVE_SYS_TYPES_H
32 #include <sys/types.h>
33 #endif
34 #ifdef HAVE_STDINT_H
35 #include <stdint.h>
36 #endif
37 #ifdef HAVE_INTTYPES_H
38 #include <inttypes.h>
39 #endif
40
41 #ifdef HAVE_STDBOOL_H
42 #include <stdbool.h>
43 #else /* HAVE_STDBOOL_H */
44 #define __bool_true_false_are_defined 1
45
46 #ifndef HAVE__BOOL
47 #ifndef __cplusplus
48
49 #define false 0
50 #define true 1
51
52 typedef int _Bool;
53 #else
54 typedef bool _Bool;
55 #endif /* __cplusplus */
56 #endif /* HAVE__BOOL */
57
58 #define bool _Bool
59
60 #endif /* HAVE_STDBOOL_H */
61
62 /// turns a macro argument into a string constant
63 #define stringify(s) __stringify(s)
64 #define __stringify(s) #s
65
66
67 /**
68 * Compute the number of elements of a variable length array.
69 * <code>
70 * const char *strs[] = { "a", "b", "c" };
71 * unsigned num_strs = ARRAY_SIZE(strs);
72 * </code>
73 */
74 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
75
76
77 /**
78 * Cast a member of a structure out to the containing structure.
79 * @param ptr The pointer to the member.
80 * @param type The type of the container struct this is embedded in.
81 * @param member The name of the member within the struct.
82 *
83 * This is a mechanism which is used throughout the Linux kernel.
84 */
85 #define container_of(ptr, type, member) ({ \
86 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
87 (type *)( (void *) ( (char *)__mptr - offsetof(type,member) ) );})
88
89
90 /**
91 * Rounds @c m up to the nearest multiple of @c n using division.
92 * @param m The value to round up to @c n.
93 * @param n Round @c m up to a multiple of this number.
94 * @returns The rounded integer value.
95 */
96 #define DIV_ROUND_UP(m, n) (((m) + (n) - 1) / (n))
97
98
99 /* DANGER!!!! here be dragons!
100 *
101 * Leave these fn's as byte accesses because it is safe
102 * across architectures. Clever usage of 32 bit access
103 * will create problems on some hosts.
104 *
105 * Note that the "buf" pointer in memory is probably unaligned.
106 *
107 * Were these functions to be re-written to take a 32 bit wide or 16 bit wide
108 * memory access shortcut, then on some CPU's, i.e. ARM7, the 2 lsbytes of the address are
109 * ignored for 32 bit access, whereas on other CPU's a 32 bit wide unaligned memory access
110 * will cause an exception, and lastly on x86, an unaligned "greater than bytewide"
111 * memory access works as if aligned. So what follows below will work for all
112 * platforms and gives the compiler leeway to do its own platform specific optimizations.
113 *
114 * Again, note that the "buf" pointer in memory is probably unaligned.
115 */
116
117 static inline uint64_t le_to_h_u64(const uint8_t *buf)
118 {
119 return (uint64_t)((uint64_t)buf[0] |
120 (uint64_t)buf[1] << 8 |
121 (uint64_t)buf[2] << 16 |
122 (uint64_t)buf[3] << 24 |
123 (uint64_t)buf[4] << 32 |
124 (uint64_t)buf[5] << 40 |
125 (uint64_t)buf[6] << 48 |
126 (uint64_t)buf[7] << 56);
127 }
128
129 static inline uint32_t le_to_h_u32(const uint8_t* buf)
130 {
131 return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24);
132 }
133
134 static inline uint32_t le_to_h_u24(const uint8_t* buf)
135 {
136 return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16);
137 }
138
139 static inline uint16_t le_to_h_u16(const uint8_t* buf)
140 {
141 return (uint16_t)(buf[0] | buf[1] << 8);
142 }
143
144 static inline uint64_t be_to_h_u64(const uint8_t *buf)
145 {
146 return (uint64_t)((uint64_t)buf[7] |
147 (uint64_t)buf[6] << 8 |
148 (uint64_t)buf[5] << 16 |
149 (uint64_t)buf[4] << 24 |
150 (uint64_t)buf[3] << 32 |
151 (uint64_t)buf[2] << 40 |
152 (uint64_t)buf[1] << 48 |
153 (uint64_t)buf[0] << 56);
154 }
155
156 static inline uint32_t be_to_h_u32(const uint8_t* buf)
157 {
158 return (uint32_t)(buf[3] | buf[2] << 8 | buf[1] << 16 | buf[0] << 24);
159 }
160
161 static inline uint32_t be_to_h_u24(const uint8_t* buf)
162 {
163 return (uint32_t)(buf[2] | buf[1] << 8 | buf[0] << 16);
164 }
165
166 static inline uint16_t be_to_h_u16(const uint8_t* buf)
167 {
168 return (uint16_t)(buf[1] | buf[0] << 8);
169 }
170
171 static inline void h_u64_to_le(uint8_t *buf, int64_t val)
172 {
173 buf[7] = (uint8_t) (val >> 56);
174 buf[6] = (uint8_t) (val >> 48);
175 buf[5] = (uint8_t) (val >> 40);
176 buf[4] = (uint8_t) (val >> 32);
177 buf[3] = (uint8_t) (val >> 24);
178 buf[2] = (uint8_t) (val >> 16);
179 buf[1] = (uint8_t) (val >> 8);
180 buf[0] = (uint8_t) (val >> 0);
181 }
182
183 static inline void h_u64_to_be(uint8_t *buf, int64_t val)
184 {
185 buf[0] = (uint8_t) (val >> 56);
186 buf[1] = (uint8_t) (val >> 48);
187 buf[2] = (uint8_t) (val >> 40);
188 buf[3] = (uint8_t) (val >> 32);
189 buf[4] = (uint8_t) (val >> 24);
190 buf[5] = (uint8_t) (val >> 16);
191 buf[6] = (uint8_t) (val >> 8);
192 buf[7] = (uint8_t) (val >> 0);
193 }
194
195 static inline void h_u32_to_le(uint8_t* buf, int val)
196 {
197 buf[3] = (uint8_t) (val >> 24);
198 buf[2] = (uint8_t) (val >> 16);
199 buf[1] = (uint8_t) (val >> 8);
200 buf[0] = (uint8_t) (val >> 0);
201 }
202
203 static inline void h_u32_to_be(uint8_t* buf, int val)
204 {
205 buf[0] = (uint8_t) (val >> 24);
206 buf[1] = (uint8_t) (val >> 16);
207 buf[2] = (uint8_t) (val >> 8);
208 buf[3] = (uint8_t) (val >> 0);
209 }
210
211 static inline void h_u24_to_le(uint8_t* buf, int val)
212 {
213 buf[2] = (uint8_t) (val >> 16);
214 buf[1] = (uint8_t) (val >> 8);
215 buf[0] = (uint8_t) (val >> 0);
216 }
217
218 static inline void h_u24_to_be(uint8_t* buf, int val)
219 {
220 buf[0] = (uint8_t) (val >> 16);
221 buf[1] = (uint8_t) (val >> 8);
222 buf[2] = (uint8_t) (val >> 0);
223 }
224
225 static inline void h_u16_to_le(uint8_t* buf, int val)
226 {
227 buf[1] = (uint8_t) (val >> 8);
228 buf[0] = (uint8_t) (val >> 0);
229 }
230
231 static inline void h_u16_to_be(uint8_t* buf, int val)
232 {
233 buf[0] = (uint8_t) (val >> 8);
234 buf[1] = (uint8_t) (val >> 0);
235 }
236
237 /**
238 * Byte-swap buffer 16-bit.
239 *
240 * Len must be even, dst and src must be either the same or non-overlapping.
241 *
242 * @param dst Destination buffer.
243 * @param src Source buffer.
244 * @param len Length of source (and destination) buffer, in bytes.
245 */
246 static inline void buf_bswap16(uint8_t *dst, const uint8_t *src, size_t len)
247 {
248 assert(len % 2 == 0);
249 assert(dst == src || dst + len <= src || src + len <= dst);
250
251 for (size_t n = 0; n < len; n += 2) {
252 uint16_t x = be_to_h_u16(src + n);
253 h_u16_to_le(dst + n, x);
254 }
255 }
256
257 /**
258 * Byte-swap buffer 32-bit.
259 *
260 * Len must be divisible by four, dst and src must be either the same or non-overlapping.
261 *
262 * @param dst Destination buffer.
263 * @param src Source buffer.
264 * @param len Length of source (and destination) buffer, in bytes.
265 */
266 static inline void buf_bswap32(uint8_t *dst, const uint8_t *src, size_t len)
267 {
268 assert(len % 4 == 0);
269 assert(dst == src || dst + len <= src || src + len <= dst);
270
271 for (size_t n = 0; n < len; n += 4) {
272 uint32_t x = be_to_h_u32(src + n);
273 h_u32_to_le(dst + n, x);
274 }
275 }
276
277 /**
278 * Calculate the (even) parity of a 32-bit datum.
279 * @param x The datum.
280 * @return 1 if the number of set bits in x is odd, 0 if it is even.
281 */
282 static inline int parity_u32(uint32_t x)
283 {
284 #ifdef __GNUC__
285 return __builtin_parityl(x);
286 #else
287 x ^= x >> 16;
288 x ^= x >> 8;
289 x ^= x >> 4;
290 x ^= x >> 2;
291 x ^= x >> 1;
292 return x & 1;
293 #endif
294 }
295
296 #if defined(__ECOS)
297
298 /* eCos plain lacks these definition... A series of upstream patches
299 * could probably repair it, but it seems like too much work to be
300 * worth it.
301 */
302
303 #if !defined(_STDINT_H)
304 #define PRId32 "d"
305 #define PRIi32 "i"
306 #define PRIo32 "o"
307 #define PRIu32 "u"
308 #define PRIx32 "x"
309 #define PRIX32 "X"
310 #define SCNx32 "x"
311 #define PRId8 PRId32
312 #define SCNx64 "llx"
313 #define PRId64 "lld"
314 #define PRIi64 "lli"
315 #define PRIo64 "llo"
316 #define PRIu64 "llu"
317 #define PRIx64 "llx"
318 #define PRIX64 "llX"
319
320 typedef CYG_ADDRWORD intptr_t;
321 typedef int64_t intmax_t;
322 typedef uint64_t uintmax_t;
323 #define INT8_MAX 0x7f
324 #define INT8_MIN (-INT8_MAX - 1)
325 # define UINT8_MAX (255)
326 #define INT16_MAX 0x7fff
327 #define INT16_MIN (-INT16_MAX - 1)
328 # define UINT16_MAX (65535)
329 #define INT32_MAX 0x7fffffffL
330 #define INT32_MIN (-INT32_MAX - 1L)
331 # define UINT32_MAX (4294967295U)
332 #define INT64_MAX 0x7fffffffffffffffLL
333 #define INT64_MIN (-INT64_MAX - 1LL)
334 #define UINT64_MAX (__CONCAT(INT64_MAX, U) * 2ULL + 1ULL)
335 #endif
336
337 #ifndef LLONG_MAX
338 #define ULLONG_MAX UINT64_C(0xFFFFFFFFFFFFFFFF)
339 #define LLONG_MAX INT64_C(0x7FFFFFFFFFFFFFFF)
340 #define LLONG_MIN ULLONG_MAX
341 #endif
342
343
344 #define ULLONG_MAX 18446744073709551615
345
346 /* C99, eCos is C90 compliant (with bits of C99) */
347 #define isblank(c) ((c) == ' ' || (c) == '\t')
348
349
350 #endif
351
352 #if BUILD_TARGET64
353 typedef uint64_t target_addr_t;
354 #define TARGET_ADDR_MAX UINT64_MAX
355 #define TARGET_PRIdADDR PRId64
356 #define TARGET_PRIuADDR PRIu64
357 #define TARGET_PRIoADDR PRIo64
358 #define TARGET_PRIxADDR PRIx64
359 #define TARGET_PRIXADDR PRIX64
360 #else
361 typedef uint32_t target_addr_t;
362 #define TARGET_ADDR_MAX UINT32_MAX
363 #define TARGET_PRIdADDR PRId32
364 #define TARGET_PRIuADDR PRIu32
365 #define TARGET_PRIoADDR PRIo32
366 #define TARGET_PRIxADDR PRIx32
367 #define TARGET_PRIXADDR PRIX32
368 #endif
369 #define TARGET_ADDR_FMT "0x%8.8" TARGET_PRIxADDR
370
371 #endif /* OPENOCD_HELPER_TYPES_H */

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)