Coverage Report

Created: 2024-11-21 07:03

/src/mbedtls/library/alignment.h
Line
Count
Source (jump to first uncovered line)
1
/**
2
 * \file alignment.h
3
 *
4
 * \brief Utility code for dealing with unaligned memory accesses
5
 */
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
52
typedef uint16_t __packed mbedtls_uint16_unaligned_t;
53
typedef uint32_t __packed mbedtls_uint32_unaligned_t;
54
typedef 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
86
typedef struct {
87
    uint16_t x;
88
} __attribute__((packed)) mbedtls_uint16_unaligned_t;
89
typedef struct {
90
    uint32_t x;
91
} __attribute__((packed)) mbedtls_uint32_unaligned_t;
92
typedef 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
103
/**
104
 * Read the unsigned 16 bits integer from the given address, which need not
105
 * be aligned.
106
 *
107
 * \param   p pointer to 2 bytes of data
108
 * \return  Data at the given address
109
 */
110
#if defined(__IAR_SYSTEMS_ICC__)
111
#pragma inline = forced
112
#elif defined(__GNUC__)
113
__attribute__((always_inline))
114
#endif
115
static inline uint16_t mbedtls_get_unaligned_uint16(const void *p)
116
0
{
117
0
    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
0
    memcpy(&r, p, sizeof(r));
126
0
#endif
127
0
    return r;
128
0
}
Unexecuted instantiation: platform.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_client.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_its_file.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: psa_util.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ripemd160.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: rsa.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: sha1.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: sha256.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: sha3.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: sha512.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: asn1parse.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: asn1write.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: bignum.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: bignum_core.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ccm.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: chachapoly.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: cipher.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: cipher_wrap.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: cmac.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: constant_time.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ctr_drbg.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: des.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ecdh.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ecdsa.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ecjpake.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ecp.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: ecp_curves.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: entropy.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: entropy_poll.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: gcm.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: hmac_drbg.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: md.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: md5.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: nist_kw.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: oid.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: platform_util.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: poly1305.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: aes.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: aesni.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: aria.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: camellia.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: chacha20.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: hkdf.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: pkcs12.c:mbedtls_get_unaligned_uint16
Unexecuted instantiation: pkcs5.c:mbedtls_get_unaligned_uint16
129
130
/**
131
 * Write the unsigned 16 bits integer to the given address, which need not
132
 * be aligned.
133
 *
134
 * \param   p pointer to 2 bytes of data
135
 * \param   x data to write
136
 */
137
#if defined(__IAR_SYSTEMS_ICC__)
138
#pragma inline = forced
139
#elif defined(__GNUC__)
140
__attribute__((always_inline))
141
#endif
142
static inline void mbedtls_put_unaligned_uint16(void *p, uint16_t x)
143
0
{
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
0
    memcpy(p, &x, sizeof(x));
152
0
#endif
153
0
}
Unexecuted instantiation: platform.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_client.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_its_file.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: psa_util.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ripemd160.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: rsa.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: sha1.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: sha256.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: sha3.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: sha512.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: asn1parse.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: asn1write.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: bignum.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: bignum_core.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ccm.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: chachapoly.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: cipher.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: cipher_wrap.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: cmac.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: constant_time.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ctr_drbg.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: des.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ecdh.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ecdsa.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ecjpake.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ecp.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: ecp_curves.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: entropy.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: entropy_poll.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: gcm.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: hmac_drbg.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: md.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: md5.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: nist_kw.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: oid.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: platform_util.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: poly1305.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: aes.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: aesni.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: aria.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: camellia.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: chacha20.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: hkdf.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: pkcs12.c:mbedtls_put_unaligned_uint16
Unexecuted instantiation: pkcs5.c:mbedtls_put_unaligned_uint16
154
155
/**
156
 * Read the unsigned 32 bits integer from the given address, which need not
157
 * be aligned.
158
 *
159
 * \param   p pointer to 4 bytes of data
160
 * \return  Data at the given address
161
 */
162
#if defined(__IAR_SYSTEMS_ICC__)
163
#pragma inline = forced
164
#elif defined(__GNUC__)
165
__attribute__((always_inline))
166
#endif
167
static inline uint32_t mbedtls_get_unaligned_uint32(const void *p)
168
46.4M
{
169
46.4M
    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
46.4M
    memcpy(&r, p, sizeof(r));
178
46.4M
#endif
179
46.4M
    return r;
180
46.4M
}
Unexecuted instantiation: platform.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_client.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_its_file.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: psa_util.c:mbedtls_get_unaligned_uint32
ripemd160.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
12.5M
{
169
12.5M
    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
12.5M
    memcpy(&r, p, sizeof(r));
178
12.5M
#endif
179
12.5M
    return r;
180
12.5M
}
Unexecuted instantiation: rsa.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_get_unaligned_uint32
sha1.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
13.3M
{
169
13.3M
    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
13.3M
    memcpy(&r, p, sizeof(r));
178
13.3M
#endif
179
13.3M
    return r;
180
13.3M
}
sha256.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
13.8M
{
169
13.8M
    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
13.8M
    memcpy(&r, p, sizeof(r));
178
13.8M
#endif
179
13.8M
    return r;
180
13.8M
}
Unexecuted instantiation: sha3.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: sha512.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: asn1parse.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: asn1write.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: bignum.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: bignum_core.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: ccm.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: chachapoly.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: cipher.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: cipher_wrap.c:mbedtls_get_unaligned_uint32
cmac.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
16
{
169
16
    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
16
    memcpy(&r, p, sizeof(r));
178
16
#endif
179
16
    return r;
180
16
}
Unexecuted instantiation: constant_time.c:mbedtls_get_unaligned_uint32
ctr_drbg.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
30
{
169
30
    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
30
    memcpy(&r, p, sizeof(r));
178
30
#endif
179
30
    return r;
180
30
}
des.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
172
{
169
172
    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
172
    memcpy(&r, p, sizeof(r));
178
172
#endif
179
172
    return r;
180
172
}
Unexecuted instantiation: ecdh.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: ecdsa.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: ecjpake.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: ecp.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: ecp_curves.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: entropy.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: entropy_poll.c:mbedtls_get_unaligned_uint32
gcm.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
4.60k
{
169
4.60k
    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
4.60k
    memcpy(&r, p, sizeof(r));
178
4.60k
#endif
179
4.60k
    return r;
180
4.60k
}
Unexecuted instantiation: hmac_drbg.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: md.c:mbedtls_get_unaligned_uint32
md5.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
6.57M
{
169
6.57M
    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
6.57M
    memcpy(&r, p, sizeof(r));
178
6.57M
#endif
179
6.57M
    return r;
180
6.57M
}
Unexecuted instantiation: nist_kw.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: oid.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: platform_util.c:mbedtls_get_unaligned_uint32
poly1305.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
924
{
169
924
    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
924
    memcpy(&r, p, sizeof(r));
178
924
#endif
179
924
    return r;
180
924
}
Unexecuted instantiation: aes.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: aesni.c:mbedtls_get_unaligned_uint32
aria.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
7.68k
{
169
7.68k
    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
7.68k
    memcpy(&r, p, sizeof(r));
178
7.68k
#endif
179
7.68k
    return r;
180
7.68k
}
camellia.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
2.31k
{
169
2.31k
    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
2.31k
    memcpy(&r, p, sizeof(r));
178
2.31k
#endif
179
2.31k
    return r;
180
2.31k
}
chacha20.c:mbedtls_get_unaligned_uint32
Line
Count
Source
168
700
{
169
700
    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
700
    memcpy(&r, p, sizeof(r));
178
700
#endif
179
700
    return r;
180
700
}
Unexecuted instantiation: hkdf.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: pkcs12.c:mbedtls_get_unaligned_uint32
Unexecuted instantiation: pkcs5.c:mbedtls_get_unaligned_uint32
181
182
/**
183
 * Write the unsigned 32 bits integer to the given address, which need not
184
 * be aligned.
185
 *
186
 * \param   p pointer to 4 bytes of data
187
 * \param   x data to write
188
 */
189
#if defined(__IAR_SYSTEMS_ICC__)
190
#pragma inline = forced
191
#elif defined(__GNUC__)
192
__attribute__((always_inline))
193
#endif
194
static inline void mbedtls_put_unaligned_uint32(void *p, uint32_t x)
195
485k
{
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
485k
    memcpy(p, &x, sizeof(x));
204
485k
#endif
205
485k
}
Unexecuted instantiation: platform.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_client.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_its_file.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: psa_util.c:mbedtls_put_unaligned_uint32
ripemd160.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
89.6k
{
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
89.6k
    memcpy(p, &x, sizeof(x));
204
89.6k
#endif
205
89.6k
}
Unexecuted instantiation: rsa.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_put_unaligned_uint32
sha1.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
127k
{
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
127k
    memcpy(p, &x, sizeof(x));
204
127k
#endif
205
127k
}
sha256.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
188k
{
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
188k
    memcpy(p, &x, sizeof(x));
204
188k
#endif
205
188k
}
Unexecuted instantiation: sha3.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: sha512.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: asn1parse.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: asn1write.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: bignum.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: bignum_core.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: ccm.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: chachapoly.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: cipher.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: cipher_wrap.c:mbedtls_put_unaligned_uint32
cmac.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
16
{
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
16
    memcpy(p, &x, sizeof(x));
204
16
#endif
205
16
}
Unexecuted instantiation: constant_time.c:mbedtls_put_unaligned_uint32
ctr_drbg.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
40
{
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
40
    memcpy(p, &x, sizeof(x));
204
40
#endif
205
40
}
des.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
24
{
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
24
    memcpy(p, &x, sizeof(x));
204
24
#endif
205
24
}
Unexecuted instantiation: ecdh.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: ecdsa.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: ecjpake.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: ecp.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: ecp_curves.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: entropy.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: entropy_poll.c:mbedtls_put_unaligned_uint32
gcm.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
4.67k
{
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
4.67k
    memcpy(p, &x, sizeof(x));
204
4.67k
#endif
205
4.67k
}
Unexecuted instantiation: hmac_drbg.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: md.c:mbedtls_put_unaligned_uint32
md5.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
65.6k
{
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
65.6k
    memcpy(p, &x, sizeof(x));
204
65.6k
#endif
205
65.6k
}
Unexecuted instantiation: nist_kw.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: oid.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: platform_util.c:mbedtls_put_unaligned_uint32
poly1305.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
144
{
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
144
    memcpy(p, &x, sizeof(x));
204
144
#endif
205
144
}
Unexecuted instantiation: aes.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: aesni.c:mbedtls_put_unaligned_uint32
aria.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
7.27k
{
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
7.27k
    memcpy(p, &x, sizeof(x));
204
7.27k
#endif
205
7.27k
}
camellia.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
276
{
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
276
    memcpy(p, &x, sizeof(x));
204
276
#endif
205
276
}
chacha20.c:mbedtls_put_unaligned_uint32
Line
Count
Source
195
1.40k
{
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
1.40k
    memcpy(p, &x, sizeof(x));
204
1.40k
#endif
205
1.40k
}
Unexecuted instantiation: hkdf.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: pkcs12.c:mbedtls_put_unaligned_uint32
Unexecuted instantiation: pkcs5.c:mbedtls_put_unaligned_uint32
206
207
/**
208
 * Read the unsigned 64 bits integer from the given address, which need not
209
 * be aligned.
210
 *
211
 * \param   p pointer to 8 bytes of data
212
 * \return  Data at the given address
213
 */
214
#if defined(__IAR_SYSTEMS_ICC__)
215
#pragma inline = forced
216
#elif defined(__GNUC__)
217
__attribute__((always_inline))
218
#endif
219
static inline uint64_t mbedtls_get_unaligned_uint64(const void *p)
220
145M
{
221
145M
    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
145M
    memcpy(&r, p, sizeof(r));
230
145M
#endif
231
145M
    return r;
232
145M
}
Unexecuted instantiation: platform.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_client.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_its_file.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: psa_util.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: ripemd160.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: rsa.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: sha1.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: sha256.c:mbedtls_get_unaligned_uint64
sha3.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
2.25M
{
221
2.25M
    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
2.25M
    memcpy(&r, p, sizeof(r));
230
2.25M
#endif
231
2.25M
    return r;
232
2.25M
}
sha512.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
10.5M
{
221
10.5M
    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
10.5M
    memcpy(&r, p, sizeof(r));
230
10.5M
#endif
231
10.5M
    return r;
232
10.5M
}
Unexecuted instantiation: asn1parse.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: asn1write.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: bignum.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: bignum_core.c:mbedtls_get_unaligned_uint64
ccm.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
148
{
221
148
    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
148
    memcpy(&r, p, sizeof(r));
230
148
#endif
231
148
    return r;
232
148
}
Unexecuted instantiation: chachapoly.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: cipher.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: cipher_wrap.c:mbedtls_get_unaligned_uint64
cmac.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
640
{
221
640
    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
640
    memcpy(&r, p, sizeof(r));
230
640
#endif
231
640
    return r;
232
640
}
constant_time.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
132M
{
221
132M
    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
132M
    memcpy(&r, p, sizeof(r));
230
132M
#endif
231
132M
    return r;
232
132M
}
ctr_drbg.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
720
{
221
720
    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
720
    memcpy(&r, p, sizeof(r));
230
720
#endif
231
720
    return r;
232
720
}
des.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
16
{
221
16
    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
16
    memcpy(&r, p, sizeof(r));
230
16
#endif
231
16
    return r;
232
16
}
Unexecuted instantiation: ecdh.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: ecdsa.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: ecjpake.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: ecp.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: ecp_curves.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: entropy.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: entropy_poll.c:mbedtls_get_unaligned_uint64
gcm.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
53.7k
{
221
53.7k
    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
53.7k
    memcpy(&r, p, sizeof(r));
230
53.7k
#endif
231
53.7k
    return r;
232
53.7k
}
Unexecuted instantiation: hmac_drbg.c:mbedtls_get_unaligned_uint64
md.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
422k
{
221
422k
    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
422k
    memcpy(&r, p, sizeof(r));
230
422k
#endif
231
422k
    return r;
232
422k
}
Unexecuted instantiation: md5.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: nist_kw.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: oid.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: platform_util.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: poly1305.c:mbedtls_get_unaligned_uint64
aes.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
8
{
221
8
    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
8
    memcpy(&r, p, sizeof(r));
230
8
#endif
231
8
    return r;
232
8
}
Unexecuted instantiation: aesni.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: aria.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: camellia.c:mbedtls_get_unaligned_uint64
chacha20.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
1.05k
{
221
1.05k
    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
1.05k
    memcpy(&r, p, sizeof(r));
230
1.05k
#endif
231
1.05k
    return r;
232
1.05k
}
Unexecuted instantiation: hkdf.c:mbedtls_get_unaligned_uint64
Unexecuted instantiation: pkcs12.c:mbedtls_get_unaligned_uint64
pkcs5.c:mbedtls_get_unaligned_uint64
Line
Count
Source
220
63.7k
{
221
63.7k
    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
63.7k
    memcpy(&r, p, sizeof(r));
230
63.7k
#endif
231
63.7k
    return r;
232
63.7k
}
233
234
/**
235
 * Write the unsigned 64 bits integer to the given address, which need not
236
 * be aligned.
237
 *
238
 * \param   p pointer to 8 bytes of data
239
 * \param   x data to write
240
 */
241
#if defined(__IAR_SYSTEMS_ICC__)
242
#pragma inline = forced
243
#elif defined(__GNUC__)
244
__attribute__((always_inline))
245
#endif
246
static inline void mbedtls_put_unaligned_uint64(void *p, uint64_t x)
247
66.6M
{
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
66.6M
    memcpy(p, &x, sizeof(x));
256
66.6M
#endif
257
66.6M
}
Unexecuted instantiation: platform.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_aead.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_cipher.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_client.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_driver_wrappers_no_static.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_ecp.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_ffdh.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_hash.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_mac.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_pake.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_rsa.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_slot_management.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_crypto_storage.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_its_file.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: psa_util.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: ripemd160.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: rsa.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: rsa_alt_helpers.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: sha1.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: sha256.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: sha3.c:mbedtls_put_unaligned_uint64
sha512.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
232k
{
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
232k
    memcpy(p, &x, sizeof(x));
256
232k
#endif
257
232k
}
Unexecuted instantiation: asn1parse.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: asn1write.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: bignum.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: bignum_core.c:mbedtls_put_unaligned_uint64
ccm.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
74
{
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
74
    memcpy(p, &x, sizeof(x));
256
74
#endif
257
74
}
chachapoly.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
72
{
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
72
    memcpy(p, &x, sizeof(x));
256
72
#endif
257
72
}
Unexecuted instantiation: cipher.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: cipher_wrap.c:mbedtls_put_unaligned_uint64
cmac.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
320
{
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
320
    memcpy(p, &x, sizeof(x));
256
320
#endif
257
320
}
constant_time.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
66.1M
{
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
66.1M
    memcpy(p, &x, sizeof(x));
256
66.1M
#endif
257
66.1M
}
ctr_drbg.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
360
{
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
360
    memcpy(p, &x, sizeof(x));
256
360
#endif
257
360
}
des.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
8
{
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
8
    memcpy(p, &x, sizeof(x));
256
8
#endif
257
8
}
Unexecuted instantiation: ecdh.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: ecdsa.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: ecjpake.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: ecp.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: ecp_curves.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: entropy.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: entropy_poll.c:mbedtls_put_unaligned_uint64
gcm.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
26.9k
{
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
26.9k
    memcpy(p, &x, sizeof(x));
256
26.9k
#endif
257
26.9k
}
Unexecuted instantiation: hmac_drbg.c:mbedtls_put_unaligned_uint64
md.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
211k
{
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
211k
    memcpy(p, &x, sizeof(x));
256
211k
#endif
257
211k
}
Unexecuted instantiation: md5.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: nist_kw.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: oid.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: platform_util.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: poly1305.c:mbedtls_put_unaligned_uint64
aes.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
4
{
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
4
    memcpy(p, &x, sizeof(x));
256
4
#endif
257
4
}
Unexecuted instantiation: aesni.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: aria.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: camellia.c:mbedtls_put_unaligned_uint64
chacha20.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
527
{
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
527
    memcpy(p, &x, sizeof(x));
256
527
#endif
257
527
}
Unexecuted instantiation: hkdf.c:mbedtls_put_unaligned_uint64
Unexecuted instantiation: pkcs12.c:mbedtls_put_unaligned_uint64
pkcs5.c:mbedtls_put_unaligned_uint64
Line
Count
Source
247
31.8k
{
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
31.8k
    memcpy(p, &x, sizeof(x));
256
31.8k
#endif
257
31.8k
}
258
259
#if defined(MBEDTLS_POP_IAR_LANGUAGE_PRAGMA)
260
#pragma language=restore
261
#endif
262
263
/** Byte Reading Macros
264
 *
265
 * Given a multi-byte integer \p x, MBEDTLS_BYTE_n retrieves the n-th
266
 * byte from x, where byte 0 is the least significant byte.
267
 */
268
91.0k
#define MBEDTLS_BYTE_0(x) ((uint8_t) ((x)         & 0xff))
269
90.9k
#define MBEDTLS_BYTE_1(x) ((uint8_t) (((x) >>  8) & 0xff))
270
88.5k
#define MBEDTLS_BYTE_2(x) ((uint8_t) (((x) >> 16) & 0xff))
271
88.5k
#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
0
#define MBEDTLS_BSWAP16 __builtin_bswap16
296
#endif /* __has_builtin(__builtin_bswap16) */
297
#if __has_builtin(__builtin_bswap32) && !defined(MBEDTLS_BSWAP32)
298
27.6M
#define MBEDTLS_BSWAP32 __builtin_bswap32
299
#endif /* __has_builtin(__builtin_bswap32) */
300
#if __has_builtin(__builtin_bswap64) && !defined(MBEDTLS_BSWAP64)
301
10.8M
#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)
344
static 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)
354
static 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)
366
static 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
389
static 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
57.7M
#define MBEDTLS_IS_BIG_ENDIAN 0
399
#endif
400
401
#endif /* !defined(__BYTE_ORDER__) */
402
403
/**
404
 * Get the unsigned 32 bits integer corresponding to four bytes in
405
 * big-endian order (MSB first).
406
 *
407
 * \param   data    Base address of the memory to get the four bytes from.
408
 * \param   offset  Offset from \p data of the first and most significant
409
 *                  byte of the four bytes to build the 32 bits unsigned
410
 *                  integer from.
411
 */
412
#define MBEDTLS_GET_UINT32_BE(data, offset)                                \
413
27.2M
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
414
27.2M
        ? mbedtls_get_unaligned_uint32((data) + (offset))                  \
415
27.2M
        : MBEDTLS_BSWAP32(mbedtls_get_unaligned_uint32((data) + (offset))) \
416
27.2M
    )
417
418
/**
419
 * Put in memory a 32 bits unsigned integer in big-endian order.
420
 *
421
 * \param   n       32 bits unsigned integer to put in memory.
422
 * \param   data    Base address of the memory where to put the 32
423
 *                  bits unsigned integer in.
424
 * \param   offset  Offset from \p data where to put the most significant
425
 *                  byte of the 32 bits unsigned integer \p n.
426
 */
427
#define MBEDTLS_PUT_UINT32_BE(n, data, offset)                                   \
428
320k
    {                                                                            \
429
320k
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
430
320k
        {                                                                        \
431
0
            mbedtls_put_unaligned_uint32((data) + (offset), (uint32_t) (n));     \
432
0
        }                                                                        \
433
320k
        else                                                                     \
434
320k
        {                                                                        \
435
320k
            mbedtls_put_unaligned_uint32((data) + (offset), MBEDTLS_BSWAP32((uint32_t) (n))); \
436
320k
        }                                                                        \
437
320k
    }
438
439
/**
440
 * Get the unsigned 32 bits integer corresponding to four bytes in
441
 * little-endian order (LSB first).
442
 *
443
 * \param   data    Base address of the memory to get the four bytes from.
444
 * \param   offset  Offset from \p data of the first and least significant
445
 *                  byte of the four bytes to build the 32 bits unsigned
446
 *                  integer from.
447
 */
448
#define MBEDTLS_GET_UINT32_LE(data, offset)                                \
449
19.1M
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
450
19.1M
        ? MBEDTLS_BSWAP32(mbedtls_get_unaligned_uint32((data) + (offset))) \
451
19.1M
        : mbedtls_get_unaligned_uint32((data) + (offset))                  \
452
19.1M
    )
453
454
455
/**
456
 * Put in memory a 32 bits unsigned integer in little-endian order.
457
 *
458
 * \param   n       32 bits unsigned integer to put in memory.
459
 * \param   data    Base address of the memory where to put the 32
460
 *                  bits unsigned integer in.
461
 * \param   offset  Offset from \p data where to put the least significant
462
 *                  byte of the 32 bits unsigned integer \p n.
463
 */
464
#define MBEDTLS_PUT_UINT32_LE(n, data, offset)                                   \
465
164k
    {                                                                            \
466
164k
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
467
164k
        {                                                                        \
468
0
            mbedtls_put_unaligned_uint32((data) + (offset), MBEDTLS_BSWAP32((uint32_t) (n))); \
469
0
        }                                                                        \
470
164k
        else                                                                     \
471
164k
        {                                                                        \
472
164k
            mbedtls_put_unaligned_uint32((data) + (offset), ((uint32_t) (n)));   \
473
164k
        }                                                                        \
474
164k
    }
475
476
/**
477
 * Get the unsigned 16 bits integer corresponding to two bytes in
478
 * little-endian order (LSB first).
479
 *
480
 * \param   data    Base address of the memory to get the two bytes from.
481
 * \param   offset  Offset from \p data of the first and least significant
482
 *                  byte of the two bytes to build the 16 bits unsigned
483
 *                  integer from.
484
 */
485
#define MBEDTLS_GET_UINT16_LE(data, offset)                                \
486
0
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
487
0
        ? MBEDTLS_BSWAP16(mbedtls_get_unaligned_uint16((data) + (offset))) \
488
0
        : mbedtls_get_unaligned_uint16((data) + (offset))                  \
489
0
    )
490
491
/**
492
 * Put in memory a 16 bits unsigned integer in little-endian order.
493
 *
494
 * \param   n       16 bits unsigned integer to put in memory.
495
 * \param   data    Base address of the memory where to put the 16
496
 *                  bits unsigned integer in.
497
 * \param   offset  Offset from \p data where to put the least significant
498
 *                  byte of the 16 bits unsigned integer \p n.
499
 */
500
#define MBEDTLS_PUT_UINT16_LE(n, data, offset)                                   \
501
0
    {                                                                            \
502
0
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
503
0
        {                                                                        \
504
0
            mbedtls_put_unaligned_uint16((data) + (offset), MBEDTLS_BSWAP16((uint16_t) (n))); \
505
0
        }                                                                        \
506
0
        else                                                                     \
507
0
        {                                                                        \
508
0
            mbedtls_put_unaligned_uint16((data) + (offset), (uint16_t) (n));     \
509
0
        }                                                                        \
510
0
    }
511
512
/**
513
 * Get the unsigned 16 bits integer corresponding to two bytes in
514
 * big-endian order (MSB first).
515
 *
516
 * \param   data    Base address of the memory to get the two bytes from.
517
 * \param   offset  Offset from \p data of the first and most significant
518
 *                  byte of the two bytes to build the 16 bits unsigned
519
 *                  integer from.
520
 */
521
#define MBEDTLS_GET_UINT16_BE(data, offset)                                \
522
0
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
523
0
        ? mbedtls_get_unaligned_uint16((data) + (offset))                  \
524
0
        : MBEDTLS_BSWAP16(mbedtls_get_unaligned_uint16((data) + (offset))) \
525
0
    )
526
527
/**
528
 * Put in memory a 16 bits unsigned integer in big-endian order.
529
 *
530
 * \param   n       16 bits unsigned integer to put in memory.
531
 * \param   data    Base address of the memory where to put the 16
532
 *                  bits unsigned integer in.
533
 * \param   offset  Offset from \p data where to put the most significant
534
 *                  byte of the 16 bits unsigned integer \p n.
535
 */
536
#define MBEDTLS_PUT_UINT16_BE(n, data, offset)                                   \
537
0
    {                                                                            \
538
0
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
539
0
        {                                                                        \
540
0
            mbedtls_put_unaligned_uint16((data) + (offset), (uint16_t) (n));     \
541
0
        }                                                                        \
542
0
        else                                                                     \
543
0
        {                                                                        \
544
0
            mbedtls_put_unaligned_uint16((data) + (offset), MBEDTLS_BSWAP16((uint16_t) (n))); \
545
0
        }                                                                        \
546
0
    }
547
548
/**
549
 * Get the unsigned 24 bits integer corresponding to three bytes in
550
 * big-endian order (MSB first).
551
 *
552
 * \param   data    Base address of the memory to get the three bytes from.
553
 * \param   offset  Offset from \p data of the first and most significant
554
 *                  byte of the three bytes to build the 24 bits unsigned
555
 *                  integer from.
556
 */
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
564
/**
565
 * Put in memory a 24 bits unsigned integer in big-endian order.
566
 *
567
 * \param   n       24 bits unsigned integer to put in memory.
568
 * \param   data    Base address of the memory where to put the 24
569
 *                  bits unsigned integer in.
570
 * \param   offset  Offset from \p data where to put the most significant
571
 *                  byte of the 24 bits unsigned integer \p n.
572
 */
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
580
/**
581
 * Get the unsigned 24 bits integer corresponding to three bytes in
582
 * little-endian order (LSB first).
583
 *
584
 * \param   data    Base address of the memory to get the three bytes from.
585
 * \param   offset  Offset from \p data of the first and least significant
586
 *                  byte of the three bytes to build the 24 bits unsigned
587
 *                  integer from.
588
 */
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
596
/**
597
 * Put in memory a 24 bits unsigned integer in little-endian order.
598
 *
599
 * \param   n       24 bits unsigned integer to put in memory.
600
 * \param   data    Base address of the memory where to put the 24
601
 *                  bits unsigned integer in.
602
 * \param   offset  Offset from \p data where to put the least significant
603
 *                  byte of the 24 bits unsigned integer \p n.
604
 */
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
612
/**
613
 * Get the unsigned 64 bits integer corresponding to eight bytes in
614
 * big-endian order (MSB first).
615
 *
616
 * \param   data    Base address of the memory to get the eight bytes from.
617
 * \param   offset  Offset from \p data of the first and most significant
618
 *                  byte of the eight bytes to build the 64 bits unsigned
619
 *                  integer from.
620
 */
621
#define MBEDTLS_GET_UINT64_BE(data, offset)                                \
622
10.5M
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
623
10.5M
        ? mbedtls_get_unaligned_uint64((data) + (offset))                  \
624
10.5M
        : MBEDTLS_BSWAP64(mbedtls_get_unaligned_uint64((data) + (offset))) \
625
10.5M
    )
626
627
/**
628
 * Put in memory a 64 bits unsigned integer in big-endian order.
629
 *
630
 * \param   n       64 bits unsigned integer to put in memory.
631
 * \param   data    Base address of the memory where to put the 64
632
 *                  bits unsigned integer in.
633
 * \param   offset  Offset from \p data where to put the most significant
634
 *                  byte of the 64 bits unsigned integer \p n.
635
 */
636
#define MBEDTLS_PUT_UINT64_BE(n, data, offset)                                   \
637
232k
    {                                                                            \
638
232k
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
639
232k
        {                                                                        \
640
0
            mbedtls_put_unaligned_uint64((data) + (offset), (uint64_t) (n));     \
641
0
        }                                                                        \
642
232k
        else                                                                     \
643
232k
        {                                                                        \
644
232k
            mbedtls_put_unaligned_uint64((data) + (offset), MBEDTLS_BSWAP64((uint64_t) (n))); \
645
232k
        }                                                                        \
646
232k
    }
647
648
/**
649
 * Get the unsigned 64 bits integer corresponding to eight bytes in
650
 * little-endian order (LSB first).
651
 *
652
 * \param   data    Base address of the memory to get the eight bytes from.
653
 * \param   offset  Offset from \p data of the first and least significant
654
 *                  byte of the eight bytes to build the 64 bits unsigned
655
 *                  integer from.
656
 */
657
#define MBEDTLS_GET_UINT64_LE(data, offset)                                \
658
0
    ((MBEDTLS_IS_BIG_ENDIAN)                                               \
659
0
        ? MBEDTLS_BSWAP64(mbedtls_get_unaligned_uint64((data) + (offset))) \
660
0
        : mbedtls_get_unaligned_uint64((data) + (offset))                  \
661
0
    )
662
663
/**
664
 * Put in memory a 64 bits unsigned integer in little-endian order.
665
 *
666
 * \param   n       64 bits unsigned integer to put in memory.
667
 * \param   data    Base address of the memory where to put the 64
668
 *                  bits unsigned integer in.
669
 * \param   offset  Offset from \p data where to put the least significant
670
 *                  byte of the 64 bits unsigned integer \p n.
671
 */
672
#define MBEDTLS_PUT_UINT64_LE(n, data, offset)                                   \
673
72
    {                                                                            \
674
72
        if (MBEDTLS_IS_BIG_ENDIAN)                                               \
675
72
        {                                                                        \
676
0
            mbedtls_put_unaligned_uint64((data) + (offset), MBEDTLS_BSWAP64((uint64_t) (n))); \
677
0
        }                                                                        \
678
72
        else                                                                     \
679
72
        {                                                                        \
680
72
            mbedtls_put_unaligned_uint64((data) + (offset), (uint64_t) (n));     \
681
72
        }                                                                        \
682
72
    }
683
684
#endif /* MBEDTLS_LIBRARY_ALIGNMENT_H */