1 /******************************************************************************
2 *  Filename:       sw_ecrypt-portable.h
3 *  Revised:        2016-10-05 12:42:03 +0200 (Wed, 05 Oct 2016)
4 *  Revision:       47308
5 ******************************************************************************/
6 /* ecrypt-portable.h */
7 
8 /*
9  * WARNING: the conversions defined below are implemented as macros,
10  * and should be used carefully. They should NOT be used with
11  * parameters which perform some action. E.g., the following two lines
12  * are not equivalent:
13  *
14  *  1) ++x; y = ROTL32(x, n);
15  *  2) y = ROTL32(++x, n);
16  */
17 
18 /*
19  * *** Please do not edit this file. ***
20  *
21  * The default macros can be overridden for specific architectures by
22  * editing 'ecrypt-machine.h'.
23  */
24 
25 #ifndef ECRYPT_PORTABLE
26 #define ECRYPT_PORTABLE
27 
28 #include "sw_ecrypt-config.h"
29 
30 /* ------------------------------------------------------------------------- */
31 
32 /*
33  * The following types are defined (if available):
34  *
35  * u8:  unsigned integer type, at least 8 bits
36  * u16: unsigned integer type, at least 16 bits
37  * u32: unsigned integer type, at least 32 bits
38  * u64: unsigned integer type, at least 64 bits
39  *
40  * s8, s16, s32, s64 -> signed counterparts of u8, u16, u32, u64
41  *
42  * The selection of minimum-width integer types is taken care of by
43  * 'ecrypt-config.h'. Note: to enable 64-bit types on 32-bit
44  * compilers, it might be necessary to switch from ISO C90 mode to ISO
45  * C99 mode (e.g., gcc -std=c99).
46  */
47 
48 #ifdef I8T
49 typedef signed I8T s8;
50 typedef unsigned I8T u8;
51 #endif
52 
53 #ifdef I16T
54 typedef signed I16T s16;
55 typedef unsigned I16T u16;
56 #endif
57 
58 #ifdef I32T
59 typedef signed I32T s32;
60 typedef unsigned I32T u32;
61 #endif
62 
63 #ifdef I64T
64 typedef signed I64T s64;
65 typedef unsigned I64T u64;
66 #endif
67 
68 /*
69  * The following macros are used to obtain exact-width results.
70  */
71 
72 #define U8V(v) ((u8)(v) & U8C(0xFF))
73 #define U16V(v) ((u16)(v) & U16C(0xFFFF))
74 #define U32V(v) ((u32)(v) & U32C(0xFFFFFFFF))
75 #define U64V(v) ((u64)(v) & U64C(0xFFFFFFFFFFFFFFFF))
76 
77 /* ------------------------------------------------------------------------- */
78 
79 /*
80  * The following macros return words with their bits rotated over n
81  * positions to the left/right.
82  */
83 
84 #define ECRYPT_DEFAULT_ROT
85 
86 #define ROTL8(v, n) \
87    (U8V((v) << (n)) | ((v) >> (8 - (n))))
88 
89 #define ROTL16(v, n) \
90    (U16V((v) << (n)) | ((v) >> (16 - (n))))
91 
92 #define ROTL32(v, n) \
93    (U32V((v) << (n)) | ((v) >> (32 - (n))))
94 
95 #define ROTL64(v, n) \
96    (U64V((v) << (n)) | ((v) >> (64 - (n))))
97 
98 #define ROTR8(v, n) ROTL8(v, 8 - (n))
99 #define ROTR16(v, n) ROTL16(v, 16 - (n))
100 #define ROTR32(v, n) ROTL32(v, 32 - (n))
101 #define ROTR64(v, n) ROTL64(v, 64 - (n))
102 
103 #include "sw_ecrypt-machine.h"
104 
105 /* ------------------------------------------------------------------------- */
106 
107 /*
108  * The following macros return a word with bytes in reverse order.
109  */
110 
111 #define ECRYPT_DEFAULT_SWAP
112 
113 #define SWAP16(v) \
114    ROTL16(v, 8)
115 
116 #define SWAP32(v) \
117    ((ROTL32(v,  8) & U32C(0x00FF00FF)) | \
118     (ROTL32(v, 24) & U32C(0xFF00FF00)))
119 
120 #ifdef ECRYPT_NATIVE64
121 #define SWAP64(v) \
122    ((ROTL64(v,  8) & U64C(0x000000FF000000FF)) | \
123     (ROTL64(v, 24) & U64C(0x0000FF000000FF00)) | \
124     (ROTL64(v, 40) & U64C(0x00FF000000FF0000)) | \
125     (ROTL64(v, 56) & U64C(0xFF000000FF000000)))
126 #else
127 #define SWAP64(v) \
128    (((u64)SWAP32(U32V(v)) << 32) | (u64)SWAP32(U32V(v >> 32)))
129 #endif
130 
131 #include "sw_ecrypt-machine.h"
132 
133 #define ECRYPT_DEFAULT_WTOW
134 
135 #ifdef ECRYPT_LITTLE_ENDIAN
136 #define U16TO16_LITTLE(v) (v)
137 #define U32TO32_LITTLE(v) (v)
138 #define U64TO64_LITTLE(v) (v)
139 
140 #define U16TO16_BIG(v) SWAP16(v)
141 #define U32TO32_BIG(v) SWAP32(v)
142 #define U64TO64_BIG(v) SWAP64(v)
143 #endif
144 
145 #ifdef ECRYPT_BIG_ENDIAN
146 #define U16TO16_LITTLE(v) SWAP16(v)
147 #define U32TO32_LITTLE(v) SWAP32(v)
148 #define U64TO64_LITTLE(v) SWAP64(v)
149 
150 #define U16TO16_BIG(v) (v)
151 #define U32TO32_BIG(v) (v)
152 #define U64TO64_BIG(v) (v)
153 #endif
154 
155 #include "sw_ecrypt-machine.h"
156 
157 /*
158  * The following macros load words from an array of bytes with
159  * different types of endianness, and vice versa.
160  */
161 
162 #define ECRYPT_DEFAULT_BTOW
163 
164 #if (!defined(ECRYPT_UNKNOWN) && defined(ECRYPT_I8T_IS_BYTE))
165 
166 #define U8TO16_LITTLE(p) U16TO16_LITTLE(((u16*)(p))[0])
167 #define U8TO32_LITTLE(p) U32TO32_LITTLE(((u32*)(p))[0])
168 #define U8TO64_LITTLE(p) U64TO64_LITTLE(((u64*)(p))[0])
169 
170 #define U8TO16_BIG(p) U16TO16_BIG(((u16*)(p))[0])
171 #define U8TO32_BIG(p) U32TO32_BIG(((u32*)(p))[0])
172 #define U8TO64_BIG(p) U64TO64_BIG(((u64*)(p))[0])
173 
174 #define U16TO8_LITTLE(p, v) (((u16*)(p))[0] = U16TO16_LITTLE(v))
175 #define U32TO8_LITTLE(p, v) (((u32*)(p))[0] = U32TO32_LITTLE(v))
176 #define U64TO8_LITTLE(p, v) (((u64*)(p))[0] = U64TO64_LITTLE(v))
177 
178 #define U16TO8_BIG(p, v) (((u16*)(p))[0] = U16TO16_BIG(v))
179 #define U32TO8_BIG(p, v) (((u32*)(p))[0] = U32TO32_BIG(v))
180 #define U64TO8_BIG(p, v) (((u64*)(p))[0] = U64TO64_BIG(v))
181 
182 #else
183 
184 #define U8TO16_LITTLE(p) \
185    (((u16)((p)[0])      ) | \
186     ((u16)((p)[1]) <<  8))
187 
188 #define U8TO32_LITTLE(p) \
189    (((u32)((p)[0])      ) | \
190     ((u32)((p)[1]) <<  8) | \
191     ((u32)((p)[2]) << 16) | \
192     ((u32)((p)[3]) << 24))
193 
194 #ifdef ECRYPT_NATIVE64
195 #define U8TO64_LITTLE(p) \
196    (((u64)((p)[0])      ) | \
197     ((u64)((p)[1]) <<  8) | \
198     ((u64)((p)[2]) << 16) | \
199     ((u64)((p)[3]) << 24) | \
200     ((u64)((p)[4]) << 32) | \
201     ((u64)((p)[5]) << 40) | \
202     ((u64)((p)[6]) << 48) | \
203     ((u64)((p)[7]) << 56))
204 #else
205 #define U8TO64_LITTLE(p) \
206    ((u64)U8TO32_LITTLE(p) | ((u64)U8TO32_LITTLE((p) + 4) << 32))
207 #endif
208 
209 #define U8TO16_BIG(p) \
210    (((u16)((p)[0]) <<  8) | \
211     ((u16)((p)[1])      ))
212 
213 #define U8TO32_BIG(p) \
214    (((u32)((p)[0]) << 24) | \
215     ((u32)((p)[1]) << 16) | \
216     ((u32)((p)[2]) <<  8) | \
217     ((u32)((p)[3])      ))
218 
219 #ifdef ECRYPT_NATIVE64
220 #define U8TO64_BIG(p) \
221    (((u64)((p)[0]) << 56) | \
222     ((u64)((p)[1]) << 48) | \
223     ((u64)((p)[2]) << 40) | \
224     ((u64)((p)[3]) << 32) | \
225     ((u64)((p)[4]) << 24) | \
226     ((u64)((p)[5]) << 16) | \
227     ((u64)((p)[6]) <<  8) | \
228     ((u64)((p)[7])      ))
229 #else
230 #define U8TO64_BIG(p) \
231    (((u64)U8TO32_BIG(p) << 32) | (u64)U8TO32_BIG((p) + 4))
232 #endif
233 
234 #define U16TO8_LITTLE(p, v) \
235    do { \
236       (p)[0] = U8V((v)      ); \
237       (p)[1] = U8V((v) >>  8); \
238    } while (0)
239 
240 #define U32TO8_LITTLE(p, v) \
241    do { \
242       (p)[0] = U8V((v)      ); \
243       (p)[1] = U8V((v) >>  8); \
244       (p)[2] = U8V((v) >> 16); \
245       (p)[3] = U8V((v) >> 24); \
246    } while (0)
247 
248 #ifdef ECRYPT_NATIVE64
249 #define U64TO8_LITTLE(p, v) \
250    do { \
251       (p)[0] = U8V((v)      ); \
252       (p)[1] = U8V((v) >>  8); \
253       (p)[2] = U8V((v) >> 16); \
254       (p)[3] = U8V((v) >> 24); \
255       (p)[4] = U8V((v) >> 32); \
256       (p)[5] = U8V((v) >> 40); \
257       (p)[6] = U8V((v) >> 48); \
258       (p)[7] = U8V((v) >> 56); \
259    } while (0)
260 #else
261 #define U64TO8_LITTLE(p, v) \
262    do { \
263       U32TO8_LITTLE((p),     U32V((v)      )); \
264       U32TO8_LITTLE((p) + 4, U32V((v) >> 32)); \
265    } while (0)
266 #endif
267 
268 #define U16TO8_BIG(p, v) \
269    do { \
270       (p)[0] = U8V((v)      ); \
271       (p)[1] = U8V((v) >>  8); \
272    } while (0)
273 
274 #define U32TO8_BIG(p, v) \
275    do { \
276       (p)[0] = U8V((v) >> 24); \
277       (p)[1] = U8V((v) >> 16); \
278       (p)[2] = U8V((v) >>  8); \
279       (p)[3] = U8V((v)      ); \
280    } while (0)
281 
282 #ifdef ECRYPT_NATIVE64
283 #define U64TO8_BIG(p, v) \
284    do { \
285       (p)[0] = U8V((v) >> 56); \
286       (p)[1] = U8V((v) >> 48); \
287       (p)[2] = U8V((v) >> 40); \
288       (p)[3] = U8V((v) >> 32); \
289       (p)[4] = U8V((v) >> 24); \
290       (p)[5] = U8V((v) >> 16); \
291       (p)[6] = U8V((v) >>  8); \
292       (p)[7] = U8V((v)      ); \
293    } while (0)
294 #else
295 #define U64TO8_BIG(p, v) \
296    do { \
297       U32TO8_BIG((p),     U32V((v) >> 32)); \
298       U32TO8_BIG((p) + 4, U32V((v)      )); \
299    } while (0)
300 #endif
301 
302 #endif
303 
304 #include "sw_ecrypt-machine.h"
305 
306 /* ------------------------------------------------------------------------- */
307 
308 #endif
309