Work around Travis "virtual memory exhausted" error
[openssl.git] / crypto / blake2 / blake2_impl.h
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * Derived from the BLAKE2 reference implementation written by Samuel Neves.
12  * Copyright 2012, Samuel Neves <sneves@dei.uc.pt>
13  * More information about the BLAKE2 hash function and its implementations
14  * can be found at https://blake2.net.
15  */
16
17 #include <string.h>
18 #include "e_os.h"
19
20 static ossl_inline uint32_t load32(const uint8_t *src)
21 {
22     const union {
23         long one;
24         char little;
25     } is_endian = { 1 };
26
27     if (is_endian.little) {
28         uint32_t w;
29         memcpy(&w, src, sizeof(w));
30         return w;
31     } else {
32         uint32_t w = ((uint32_t)src[0])
33                    | ((uint32_t)src[1] <<  8)
34                    | ((uint32_t)src[2] << 16)
35                    | ((uint32_t)src[3] << 24);
36         return w;
37     }
38 }
39
40 static ossl_inline uint64_t load64(const uint8_t *src)
41 {
42     const union {
43         long one;
44         char little;
45     } is_endian = { 1 };
46
47     if (is_endian.little) {
48         uint64_t w;
49         memcpy(&w, src, sizeof(w));
50         return w;
51     } else {
52         uint64_t w = ((uint64_t)src[0])
53                    | ((uint64_t)src[1] <<  8)
54                    | ((uint64_t)src[2] << 16)
55                    | ((uint64_t)src[3] << 24)
56                    | ((uint64_t)src[4] << 32)
57                    | ((uint64_t)src[5] << 40)
58                    | ((uint64_t)src[6] << 48)
59                    | ((uint64_t)src[7] << 56);
60         return w;
61     }
62 }
63
64 static ossl_inline void store32(uint8_t *dst, uint32_t w)
65 {
66     const union {
67         long one;
68         char little;
69     } is_endian = { 1 };
70
71     if (is_endian.little) {
72         memcpy(dst, &w, sizeof(w));
73     } else {
74         uint8_t *p = (uint8_t *)dst;
75         int i;
76
77         for (i = 0; i < 4; i++)
78             p[i] = (uint8_t)(w >> (8 * i));
79     }
80 }
81
82 static ossl_inline void store64(uint8_t *dst, uint64_t w)
83 {
84     const union {
85         long one;
86         char little;
87     } is_endian = { 1 };
88
89     if (is_endian.little) {
90         memcpy(dst, &w, sizeof(w));
91     } else {
92         uint8_t *p = (uint8_t *)dst;
93         int i;
94
95         for (i = 0; i < 8; i++)
96             p[i] = (uint8_t)(w >> (8 * i));
97     }
98 }
99
100 static ossl_inline uint64_t load48(const uint8_t *src)
101 {
102     uint64_t w = ((uint64_t)src[0])
103                | ((uint64_t)src[1] <<  8)
104                | ((uint64_t)src[2] << 16)
105                | ((uint64_t)src[3] << 24)
106                | ((uint64_t)src[4] << 32)
107                | ((uint64_t)src[5] << 40);
108     return w;
109 }
110
111 static ossl_inline void store48(uint8_t *dst, uint64_t w)
112 {
113     uint8_t *p = (uint8_t *)dst;
114     p[0] = (uint8_t)w;
115     p[1] = (uint8_t)(w>>8);
116     p[2] = (uint8_t)(w>>16);
117     p[3] = (uint8_t)(w>>24);
118     p[4] = (uint8_t)(w>>32);
119     p[5] = (uint8_t)(w>>40);
120 }
121
122 static ossl_inline uint32_t rotr32(const uint32_t w, const unsigned int c)
123 {
124     return (w >> c) | (w << (32 - c));
125 }
126
127 static ossl_inline uint64_t rotr64(const uint64_t w, const unsigned int c)
128 {
129     return (w >> c) | (w << (64 - c));
130 }