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