XenevaOS
Loading...
Searching...
No Matches
alignment.h
Go to the documentation of this file.
1
6/*
7 * Copyright The Mbed TLS Contributors
8 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
9 */
10
11#ifndef MBEDTLS_LIBRARY_ALIGNMENT_H
12#define MBEDTLS_LIBRARY_ALIGNMENT_H
13
14#include <stdint.h>
15#include <string.h>
16#include <stdlib.h>
17
18/*
19 * Define MBEDTLS_EFFICIENT_UNALIGNED_ACCESS for architectures where unaligned memory
20 * accesses are known to be efficient.
21 *
22 * All functions defined here will behave correctly regardless, but might be less
23 * efficient when this is not defined.
24 */
25#if defined(__ARM_FEATURE_UNALIGNED) \
26 || defined(MBEDTLS_ARCH_IS_X86) || defined(MBEDTLS_ARCH_IS_X64) \
27 || defined(MBEDTLS_PLATFORM_IS_WINDOWS_ON_ARM64)
28/*
29 * __ARM_FEATURE_UNALIGNED is defined where appropriate by armcc, gcc 7, clang 9
30 * (and later versions) for Arm v7 and later; all x86 platforms should have
31 * efficient unaligned access.
32 *
33 * https://learn.microsoft.com/en-us/cpp/build/arm64-windows-abi-conventions?view=msvc-170#alignment
34 * specifies that on Windows-on-Arm64, unaligned access is safe (except for uncached
35 * device memory).
36 */
37#define MBEDTLS_EFFICIENT_UNALIGNED_ACCESS
38#endif
39
40#if defined(__IAR_SYSTEMS_ICC__) && \
41 (defined(MBEDTLS_ARCH_IS_ARM64) || defined(MBEDTLS_ARCH_IS_ARM32) \
42 || defined(__ICCRX__) || defined(__ICCRL78__) || defined(__ICCRISCV__))
43#pragma language=save
44#pragma language=extended
45#define MBEDTLS_POP_IAR_LANGUAGE_PRAGMA
46/* IAR recommend this technique for accessing unaligned data in
47 * https://www.iar.com/knowledge/support/technical-notes/compiler/accessing-unaligned-data
48 * This results in a single load / store instruction (if unaligned access is supported).
49 * According to that document, this is only supported on certain architectures.
50 */
51 #define UINT_UNALIGNED
52typedef uint16_t __packed mbedtls_uint16_unaligned_t;
53typedef uint32_t __packed mbedtls_uint32_unaligned_t;
54typedef uint64_t __packed mbedtls_uint64_unaligned_t;
55#elif defined(MBEDTLS_COMPILER_IS_GCC) && (MBEDTLS_GCC_VERSION >= 40504) && \
56 ((MBEDTLS_GCC_VERSION < 60300) || (!defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS)))
57/*
58 * gcc may generate a branch to memcpy for calls like `memcpy(dest, src, 4)` rather than
59 * generating some LDR or LDRB instructions (similar for stores).
60 *
61 * This is architecture dependent: x86-64 seems fine even with old gcc; 32-bit Arm
62 * is affected. To keep it simple, we enable for all architectures.
63 *
64 * For versions of gcc < 5.4.0 this issue always happens.
65 * For gcc < 6.3.0, this issue happens at -O0
66 * For all versions, this issue happens iff unaligned access is not supported.
67 *
68 * For gcc 4.x, this implementation will generate byte-by-byte loads even if unaligned access is
69 * supported, which is correct but not optimal.
70 *
71 * For performance (and code size, in some cases), we want to avoid the branch and just generate
72 * some inline load/store instructions since the access is small and constant-size.
73 *
74 * The manual states:
75 * "The packed attribute specifies that a variable or structure field should have the smallest
76 * possible alignment—one byte for a variable"
77 * https://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/Variable-Attributes.html
78 *
79 * Previous implementations used __attribute__((__aligned__(1)), but had issues with a gcc bug:
80 * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94662
81 *
82 * Tested with several versions of GCC from 4.5.0 up to 13.2.0
83 * We don't enable for older than 4.5.0 as this has not been tested.
84 */
85 #define UINT_UNALIGNED_STRUCT
86typedef struct {
87 uint16_t x;
88} __attribute__((packed)) mbedtls_uint16_unaligned_t;
89typedef struct {
90 uint32_t x;
91} __attribute__((packed)) mbedtls_uint32_unaligned_t;
92typedef struct {
93 uint64_t x;
94} __attribute__((packed)) mbedtls_uint64_unaligned_t;
95 #endif
96
97/*
98 * We try to force mbedtls_(get|put)_unaligned_uintXX to be always inline, because this results
99 * in code that is both smaller and faster. IAR and gcc both benefit from this when optimising
100 * for size.
101 */
102
110#if defined(__IAR_SYSTEMS_ICC__)
111#pragma inline = forced
112#elif defined(__GNUC__)
113__attribute__((always_inline))
114#endif
115static inline uint16_t mbedtls_get_unaligned_uint16(const void *p)
116{
117 uint16_t r;
118#if defined(UINT_UNALIGNED)
119 mbedtls_uint16_unaligned_t *p16 = (mbedtls_uint16_unaligned_t *) p;
120 r = *p16;
121#elif defined(UINT_UNALIGNED_STRUCT)
122 mbedtls_uint16_unaligned_t *p16 = (mbedtls_uint16_unaligned_t *) p;
123 r = p16->x;
124#else
125 memcpy(&r, p, sizeof(r));
126#endif
127 return r;
128}
129
137#if defined(__IAR_SYSTEMS_ICC__)
138#pragma inline = forced
139#elif defined(__GNUC__)
140__attribute__((always_inline))
141#endif
142static inline void mbedtls_put_unaligned_uint16(void *p, uint16_t x)
143{
144#if defined(UINT_UNALIGNED)
145 mbedtls_uint16_unaligned_t *p16 = (mbedtls_uint16_unaligned_t *) p;
146 *p16 = x;
147#elif defined(UINT_UNALIGNED_STRUCT)
148 mbedtls_uint16_unaligned_t *p16 = (mbedtls_uint16_unaligned_t *) p;
149 p16->x = x;
150#else
151 memcpy(p, &x, sizeof(x));
152#endif
153}
154
162#if defined(__IAR_SYSTEMS_ICC__)
163#pragma inline = forced
164#elif defined(__GNUC__)
165__attribute__((always_inline))
166#endif
167static inline uint32_t mbedtls_get_unaligned_uint32(const void *p)
168{
169 uint32_t r;
170#if defined(UINT_UNALIGNED)
171 mbedtls_uint32_unaligned_t *p32 = (mbedtls_uint32_unaligned_t *) p;
172 r = *p32;
173#elif defined(UINT_UNALIGNED_STRUCT)
174 mbedtls_uint32_unaligned_t *p32 = (mbedtls_uint32_unaligned_t *) p;
175 r = p32->x;
176#else
177 memcpy(&r, p, sizeof(r));
178#endif
179 return r;
180}
181
189#if defined(__IAR_SYSTEMS_ICC__)
190#pragma inline = forced
191#elif defined(__GNUC__)
192__attribute__((always_inline))
193#endif
194static inline void mbedtls_put_unaligned_uint32(void *p, uint32_t x)
195{
196#if defined(UINT_UNALIGNED)
197 mbedtls_uint32_unaligned_t *p32 = (mbedtls_uint32_unaligned_t *) p;
198 *p32 = x;
199#elif defined(UINT_UNALIGNED_STRUCT)
200 mbedtls_uint32_unaligned_t *p32 = (mbedtls_uint32_unaligned_t *) p;
201 p32->x = x;
202#else
203 memcpy(p, &x, sizeof(x));
204#endif
205}
206
214#if defined(__IAR_SYSTEMS_ICC__)
215#pragma inline = forced
216#elif defined(__GNUC__)
217__attribute__((always_inline))
218#endif
219static inline uint64_t mbedtls_get_unaligned_uint64(const void *p)
220{
221 uint64_t r;
222#if defined(UINT_UNALIGNED)
223 mbedtls_uint64_unaligned_t *p64 = (mbedtls_uint64_unaligned_t *) p;
224 r = *p64;
225#elif defined(UINT_UNALIGNED_STRUCT)
226 mbedtls_uint64_unaligned_t *p64 = (mbedtls_uint64_unaligned_t *) p;
227 r = p64->x;
228#else
229 memcpy(&r, p, sizeof(r));
230#endif
231 return r;
232}
233
241#if defined(__IAR_SYSTEMS_ICC__)
242#pragma inline = forced
243#elif defined(__GNUC__)
244__attribute__((always_inline))
245#endif
246static inline void mbedtls_put_unaligned_uint64(void *p, uint64_t x)
247{
248#if defined(UINT_UNALIGNED)
249 mbedtls_uint64_unaligned_t *p64 = (mbedtls_uint64_unaligned_t *) p;
250 *p64 = x;
251#elif defined(UINT_UNALIGNED_STRUCT)
252 mbedtls_uint64_unaligned_t *p64 = (mbedtls_uint64_unaligned_t *) p;
253 p64->x = x;
254#else
255 memcpy(p, &x, sizeof(x));
256#endif
257}
258
259#if defined(MBEDTLS_POP_IAR_LANGUAGE_PRAGMA)
260#pragma language=restore
261#endif
262
268#define MBEDTLS_BYTE_0(x) ((uint8_t) ((x) & 0xff))
269#define MBEDTLS_BYTE_1(x) ((uint8_t) (((x) >> 8) & 0xff))
270#define MBEDTLS_BYTE_2(x) ((uint8_t) (((x) >> 16) & 0xff))
271#define MBEDTLS_BYTE_3(x) ((uint8_t) (((x) >> 24) & 0xff))
272#define MBEDTLS_BYTE_4(x) ((uint8_t) (((x) >> 32) & 0xff))
273#define MBEDTLS_BYTE_5(x) ((uint8_t) (((x) >> 40) & 0xff))
274#define MBEDTLS_BYTE_6(x) ((uint8_t) (((x) >> 48) & 0xff))
275#define MBEDTLS_BYTE_7(x) ((uint8_t) (((x) >> 56) & 0xff))
276
277/*
278 * Detect GCC built-in byteswap routines
279 */
280#if defined(__GNUC__) && defined(__GNUC_PREREQ)
281#if __GNUC_PREREQ(4, 8)
282#define MBEDTLS_BSWAP16 __builtin_bswap16
283#endif /* __GNUC_PREREQ(4,8) */
284#if __GNUC_PREREQ(4, 3)
285#define MBEDTLS_BSWAP32 __builtin_bswap32
286#define MBEDTLS_BSWAP64 __builtin_bswap64
287#endif /* __GNUC_PREREQ(4,3) */
288#endif /* defined(__GNUC__) && defined(__GNUC_PREREQ) */
289
290/*
291 * Detect Clang built-in byteswap routines
292 */
293#if defined(__clang__) && defined(__has_builtin)
294#if __has_builtin(__builtin_bswap16) && !defined(MBEDTLS_BSWAP16)
295#define MBEDTLS_BSWAP16 __builtin_bswap16
296#endif /* __has_builtin(__builtin_bswap16) */
297#if __has_builtin(__builtin_bswap32) && !defined(MBEDTLS_BSWAP32)
298#define MBEDTLS_BSWAP32 __builtin_bswap32
299#endif /* __has_builtin(__builtin_bswap32) */
300#if __has_builtin(__builtin_bswap64) && !defined(MBEDTLS_BSWAP64)
301#define MBEDTLS_BSWAP64 __builtin_bswap64
302#endif /* __has_builtin(__builtin_bswap64) */
303#endif /* defined(__clang__) && defined(__has_builtin) */
304
305/*
306 * Detect MSVC built-in byteswap routines
307 */
308#if defined(_MSC_VER)
309#if !defined(MBEDTLS_BSWAP16)
310#define MBEDTLS_BSWAP16 _byteswap_ushort
311#endif
312#if !defined(MBEDTLS_BSWAP32)
313#define MBEDTLS_BSWAP32 _byteswap_ulong
314#endif
315#if !defined(MBEDTLS_BSWAP64)
316#define MBEDTLS_BSWAP64 _byteswap_uint64
317#endif
318#endif /* defined(_MSC_VER) */
319
320/* Detect armcc built-in byteswap routine */
321#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 410000) && !defined(MBEDTLS_BSWAP32)
322#if defined(__ARM_ACLE) /* ARM Compiler 6 - earlier versions don't need a header */
323#include <arm_acle.h>
324#endif
325#define MBEDTLS_BSWAP32 __rev
326#endif
327
328/* Detect IAR built-in byteswap routine */
329#if defined(__IAR_SYSTEMS_ICC__)
330#if defined(__ARM_ACLE)
331#include <arm_acle.h>
332#define MBEDTLS_BSWAP16(x) ((uint16_t) __rev16((uint32_t) (x)))
333#define MBEDTLS_BSWAP32 __rev
334#define MBEDTLS_BSWAP64 __revll
335#endif
336#endif
337
338/*
339 * Where compiler built-ins are not present, fall back to C code that the
340 * compiler may be able to detect and transform into the relevant bswap or
341 * similar instruction.
342 */
343#if !defined(MBEDTLS_BSWAP16)
344static inline uint16_t mbedtls_bswap16(uint16_t x)
345{
346 return
347 (x & 0x00ff) << 8 |
348 (x & 0xff00) >> 8;
349}
350#define MBEDTLS_BSWAP16 mbedtls_bswap16
351#endif /* !defined(MBEDTLS_BSWAP16) */
352
353#if !defined(MBEDTLS_BSWAP32)
354static inline uint32_t mbedtls_bswap32(uint32_t x)
355{
356 return
357 (x & 0x000000ff) << 24 |
358 (x & 0x0000ff00) << 8 |
359 (x & 0x00ff0000) >> 8 |
360 (x & 0xff000000) >> 24;
361}
362#define MBEDTLS_BSWAP32 mbedtls_bswap32
363#endif /* !defined(MBEDTLS_BSWAP32) */
364
365#if !defined(MBEDTLS_BSWAP64)
366static inline uint64_t mbedtls_bswap64(uint64_t x)
367{
368 return
369 (x & 0x00000000000000ffULL) << 56 |
370 (x & 0x000000000000ff00ULL) << 40 |
371 (x & 0x0000000000ff0000ULL) << 24 |
372 (x & 0x00000000ff000000ULL) << 8 |
373 (x & 0x000000ff00000000ULL) >> 8 |
374 (x & 0x0000ff0000000000ULL) >> 24 |
375 (x & 0x00ff000000000000ULL) >> 40 |
376 (x & 0xff00000000000000ULL) >> 56;
377}
378#define MBEDTLS_BSWAP64 mbedtls_bswap64
379#endif /* !defined(MBEDTLS_BSWAP64) */
380
381#if !defined(__BYTE_ORDER__)
382
383#if defined(__LITTLE_ENDIAN__)
384/* IAR defines __xxx_ENDIAN__, but not __BYTE_ORDER__ */
385#define MBEDTLS_IS_BIG_ENDIAN 0
386#elif defined(__BIG_ENDIAN__)
387#define MBEDTLS_IS_BIG_ENDIAN 1
388#else
389static const uint16_t mbedtls_byte_order_detector = { 0x100 };
390#define MBEDTLS_IS_BIG_ENDIAN (*((unsigned char *) (&mbedtls_byte_order_detector)) == 0x01)
391#endif
392
393#else
394
395#if (__BYTE_ORDER__) == (__ORDER_BIG_ENDIAN__)
396#define MBEDTLS_IS_BIG_ENDIAN 1
397#else
398#define MBEDTLS_IS_BIG_ENDIAN 0
399#endif
400
401#endif /* !defined(__BYTE_ORDER__) */
402
412#define MBEDTLS_GET_UINT32_BE(data, offset) \
413 ((MBEDTLS_IS_BIG_ENDIAN) \
414 ? mbedtls_get_unaligned_uint32((data) + (offset)) \
415 : MBEDTLS_BSWAP32(mbedtls_get_unaligned_uint32((data) + (offset))) \
416 )
417
427#define MBEDTLS_PUT_UINT32_BE(n, data, offset) \
428 { \
429 if (MBEDTLS_IS_BIG_ENDIAN) \
430 { \
431 mbedtls_put_unaligned_uint32((data) + (offset), (uint32_t) (n)); \
432 } \
433 else \
434 { \
435 mbedtls_put_unaligned_uint32((data) + (offset), MBEDTLS_BSWAP32((uint32_t) (n))); \
436 } \
437 }
438
448#define MBEDTLS_GET_UINT32_LE(data, offset) \
449 ((MBEDTLS_IS_BIG_ENDIAN) \
450 ? MBEDTLS_BSWAP32(mbedtls_get_unaligned_uint32((data) + (offset))) \
451 : mbedtls_get_unaligned_uint32((data) + (offset)) \
452 )
453
454
464#define MBEDTLS_PUT_UINT32_LE(n, data, offset) \
465 { \
466 if (MBEDTLS_IS_BIG_ENDIAN) \
467 { \
468 mbedtls_put_unaligned_uint32((data) + (offset), MBEDTLS_BSWAP32((uint32_t) (n))); \
469 } \
470 else \
471 { \
472 mbedtls_put_unaligned_uint32((data) + (offset), ((uint32_t) (n))); \
473 } \
474 }
475
485#define MBEDTLS_GET_UINT16_LE(data, offset) \
486 ((MBEDTLS_IS_BIG_ENDIAN) \
487 ? MBEDTLS_BSWAP16(mbedtls_get_unaligned_uint16((data) + (offset))) \
488 : mbedtls_get_unaligned_uint16((data) + (offset)) \
489 )
490
500#define MBEDTLS_PUT_UINT16_LE(n, data, offset) \
501 { \
502 if (MBEDTLS_IS_BIG_ENDIAN) \
503 { \
504 mbedtls_put_unaligned_uint16((data) + (offset), MBEDTLS_BSWAP16((uint16_t) (n))); \
505 } \
506 else \
507 { \
508 mbedtls_put_unaligned_uint16((data) + (offset), (uint16_t) (n)); \
509 } \
510 }
511
521#define MBEDTLS_GET_UINT16_BE(data, offset) \
522 ((MBEDTLS_IS_BIG_ENDIAN) \
523 ? mbedtls_get_unaligned_uint16((data) + (offset)) \
524 : MBEDTLS_BSWAP16(mbedtls_get_unaligned_uint16((data) + (offset))) \
525 )
526
536#define MBEDTLS_PUT_UINT16_BE(n, data, offset) \
537 { \
538 if (MBEDTLS_IS_BIG_ENDIAN) \
539 { \
540 mbedtls_put_unaligned_uint16((data) + (offset), (uint16_t) (n)); \
541 } \
542 else \
543 { \
544 mbedtls_put_unaligned_uint16((data) + (offset), MBEDTLS_BSWAP16((uint16_t) (n))); \
545 } \
546 }
547
557#define MBEDTLS_GET_UINT24_BE(data, offset) \
558 ( \
559 ((uint32_t) (data)[(offset)] << 16) \
560 | ((uint32_t) (data)[(offset) + 1] << 8) \
561 | ((uint32_t) (data)[(offset) + 2]) \
562 )
563
573#define MBEDTLS_PUT_UINT24_BE(n, data, offset) \
574 { \
575 (data)[(offset)] = MBEDTLS_BYTE_2(n); \
576 (data)[(offset) + 1] = MBEDTLS_BYTE_1(n); \
577 (data)[(offset) + 2] = MBEDTLS_BYTE_0(n); \
578 }
579
589#define MBEDTLS_GET_UINT24_LE(data, offset) \
590 ( \
591 ((uint32_t) (data)[(offset)]) \
592 | ((uint32_t) (data)[(offset) + 1] << 8) \
593 | ((uint32_t) (data)[(offset) + 2] << 16) \
594 )
595
605#define MBEDTLS_PUT_UINT24_LE(n, data, offset) \
606 { \
607 (data)[(offset)] = MBEDTLS_BYTE_0(n); \
608 (data)[(offset) + 1] = MBEDTLS_BYTE_1(n); \
609 (data)[(offset) + 2] = MBEDTLS_BYTE_2(n); \
610 }
611
621#define MBEDTLS_GET_UINT64_BE(data, offset) \
622 ((MBEDTLS_IS_BIG_ENDIAN) \
623 ? mbedtls_get_unaligned_uint64((data) + (offset)) \
624 : MBEDTLS_BSWAP64(mbedtls_get_unaligned_uint64((data) + (offset))) \
625 )
626
636#define MBEDTLS_PUT_UINT64_BE(n, data, offset) \
637 { \
638 if (MBEDTLS_IS_BIG_ENDIAN) \
639 { \
640 mbedtls_put_unaligned_uint64((data) + (offset), (uint64_t) (n)); \
641 } \
642 else \
643 { \
644 mbedtls_put_unaligned_uint64((data) + (offset), MBEDTLS_BSWAP64((uint64_t) (n))); \
645 } \
646 }
647
657#define MBEDTLS_GET_UINT64_LE(data, offset) \
658 ((MBEDTLS_IS_BIG_ENDIAN) \
659 ? MBEDTLS_BSWAP64(mbedtls_get_unaligned_uint64((data) + (offset))) \
660 : mbedtls_get_unaligned_uint64((data) + (offset)) \
661 )
662
672#define MBEDTLS_PUT_UINT64_LE(n, data, offset) \
673 { \
674 if (MBEDTLS_IS_BIG_ENDIAN) \
675 { \
676 mbedtls_put_unaligned_uint64((data) + (offset), MBEDTLS_BSWAP64((uint64_t) (n))); \
677 } \
678 else \
679 { \
680 mbedtls_put_unaligned_uint64((data) + (offset), (uint64_t) (n)); \
681 } \
682 }
683
684#endif /* MBEDTLS_LIBRARY_ALIGNMENT_H */
__attribute__
typedef __attribute__
Definition list_sort.h:12
uint32_t
unsigned int uint32_t
Definition acefiex.h:163
uint64_t
COMPILER_DEPENDENT_UINT64 uint64_t
Definition acefiex.h:165
uint16_t
unsigned short int uint16_t
Definition acefiex.h:162
__packed
#define __packed
Definition compiler_attributes.h:300
memcpy
void memcpy(void)
x
int x
Definition layout.c:118
Generated by doxygen 1.9.8