diff --git a/kotlin-native/common/build.gradle.kts b/kotlin-native/common/build.gradle.kts index 9914d2ea6ba..9ca081c4846 100644 --- a/kotlin-native/common/build.gradle.kts +++ b/kotlin-native/common/build.gradle.kts @@ -8,9 +8,6 @@ plugins { } bitcode { - create("hash") { - dependsOn(":kotlin-native:dependencies:update") - } create("files"){ dependsOn(":kotlin-native:dependencies:update") } @@ -19,7 +16,6 @@ bitcode { val hostName: String by project val build by tasks.registering { - dependsOn("${hostName}Hash") dependsOn("${hostName}Files") } diff --git a/kotlin-native/common/src/hash/cpp/Base64.cpp b/kotlin-native/common/src/hash/cpp/Base64.cpp deleted file mode 100644 index 031b4dc071e..00000000000 --- a/kotlin-native/common/src/hash/cpp/Base64.cpp +++ /dev/null @@ -1,184 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include -#include - -#include "Base64.h" - -namespace { - -// From https://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64 -// with minor tweaks. - -#define WHITESPACE 64 -#define EQUALS 65 -#define INVALID 66 - -const char kAlphabet[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -static const unsigned char kDecode[] = { - 66,66,66,66,66,66,66,66,66,66,64,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,62,66,66,66,63,52,53, - 54,55,56,57,58,59,60,61,66,66,66,65,66,66,66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,66,66,66,66,66,66,26,27,28, - 29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, - 66,66,66,66,66,66 -}; - -} // namespace - -#ifdef __cplusplus -extern "C" { -#endif - -int EncodeBase64( - const void* dataBuf, uint32_t dataLength, void* resultBuf, uint32_t resultSize) { - char *result = reinterpret_cast(resultBuf); - const uint8_t *data = reinterpret_cast(dataBuf); - size_t resultIndex = 0; - size_t x; - uint32_t n = 0; - int padCount = dataLength % 3; - uint8_t n0, n1, n2, n3; - - /* increment over the length of the string, three characters at a time */ - for (x = 0; x < dataLength; x += 3) { - /* these three 8-bit (ASCII) characters become one 24-bit number */ - n = ((uint32_t)data[x]) << 16; - - if ((x+1) < dataLength) - n += ((uint32_t)data[x+1]) << 8; - - if ((x+2) < dataLength) - n += data[x+2]; - - /* this 24-bit number gets separated into four 6-bit numbers */ - n0 = (uint8_t)(n >> 18) & 63; - n1 = (uint8_t)(n >> 12) & 63; - n2 = (uint8_t)(n >> 6) & 63; - n3 = (uint8_t)n & 63; - - /* - * if we have one byte available, then its encoding is spread - * out over two characters - */ - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - result[resultIndex++] = kAlphabet[n0]; - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - result[resultIndex++] = kAlphabet[n1]; - - /* - * if we have only two bytes available, then their encoding is - * spread out over three chars - */ - if ((x+1) < dataLength) { - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - result[resultIndex++] = kAlphabet[n2]; - } - - /* - * if we have all three bytes available, then their encoding is spread - * out over four characters - */ - if ((x+2) < dataLength) { - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - result[resultIndex++] = kAlphabet[n3]; - } - } - - /* - * create and add padding that is required if we did not have a multiple of 3 - * number of characters available - */ - if (padCount > 0) { - for (; padCount < 3; padCount++) { - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - result[resultIndex++] = '='; - } - } - if (resultIndex >= resultSize) - return 1; /* indicate failure: buffer too small */ - - result[resultIndex] = 0; - - return 0; /* indicate success */ -} - -int DecodeBase64( - const char *in, uint32_t inLen, void* outBuf, uint32_t* outLen) { - uint8_t* out = reinterpret_cast(outBuf); - const char* end = in + inLen; - char iter = 0; - size_t buf = 0, len = 0; - - while (in < end) { - // char may be a signed type. Explicitly convert it to an unsigned byte, - // so that indexing into kDecode array is safe. The latter has exactly - // 256 elements, so any unsigned byte value is valid. - uint8_t index = *in++; - unsigned char c = kDecode[index]; - - switch (c) { - case WHITESPACE: continue; /* skip whitespace */ - case INVALID: return 1; /* invalid input, return error */ - case EQUALS: /* pad character, end of data */ - in = end; - continue; - default: - buf = buf << 6 | c; - iter++; // increment the number of iteration - /* If the buffer is full, split it into bytes */ - if (iter == 4) { - if ((len += 3) > *outLen) - return 1; /* buffer overflow */ - *(out++) = (buf >> 16) & 255; - *(out++) = (buf >> 8) & 255; - *(out++) = buf & 255; - buf = 0; iter = 0; - } - } - } - - if (iter == 3) { - if ((len += 2) > *outLen) - return 1; /* buffer overflow */ - *(out++) = (buf >> 10) & 255; - *(out++) = (buf >> 2) & 255; - } - else if (iter == 2) { - if (++len > *outLen) - return 1; /* buffer overflow */ - *(out++) = (buf >> 4) & 255; - } - - *outLen = len; /* modify to reflect the actual output size */ - return 0; -} - -#ifdef __cplusplus -} -#endif diff --git a/kotlin-native/common/src/hash/cpp/City.cpp b/kotlin-native/common/src/hash/cpp/City.cpp deleted file mode 100644 index 68470aa774f..00000000000 --- a/kotlin-native/common/src/hash/cpp/City.cpp +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "City.h" - -#include - -#include - -namespace { - -// Some primes between 2^63 and 2^64 for various uses. -static const uint64_t k0 = 0xc3a5c85c97cb3127ULL; -static const uint64_t k1 = 0xb492b66fbe98f273ULL; -static const uint64_t k2 = 0x9ae16a3b2f90404fULL; - -uint64_t UNALIGNED_LOAD64(const char *p) { - uint64_t result; - memcpy(&result, p, sizeof(result)); - return result; -} - -uint32_t UNALIGNED_LOAD32(const char *p) { - uint32_t result; - memcpy(&result, p, sizeof(result)); - return result; -} - -#define bswap32(x) __builtin_bswap32(x) -#define bswap64(x) __builtin_bswap64(x) - -#ifdef WORDS_BIGENDIAN -#define uint32_in_expected_order(x) (bswap32(x)) -#define uint64_in_expected_order(x) (bswap64(x)) -#else -#define uint32_in_expected_order(x) (x) -#define uint64_in_expected_order(x) (x) -#endif - -uint64_t Fetch64(const char *p) { - return uint64_in_expected_order(UNALIGNED_LOAD64(p)); -} - -uint32_t Fetch32(const char *p) { - return uint32_in_expected_order(UNALIGNED_LOAD32(p)); -} - -// Bitwise right rotate. Normally this will compile to a single -// instruction, especially if the shift is a manifest constant. -uint64_t Rotate(uint64_t val, int shift) { - // Avoid shifting by 64: doing so yields an undefined result. - return shift == 0 ? val : ((val >> shift) | (val << (64 - shift))); -} - -uint64_t ShiftMix(uint64_t val) { - return val ^ (val >> 47); -} - -uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) { - // Murmur-inspired hashing. - uint64_t a = (u ^ v) * mul; - a ^= (a >> 47); - uint64_t b = (v ^ a) * mul; - b ^= (b >> 47); - b *= mul; - return b; -} - -typedef std::pair uint128_t; - -uint64_t Hash128to64(const uint128_t& x) { - // Murmur-inspired hashing. - const uint64_t kMul = 0x9ddfea08eb382d69ULL; - uint64_t a = (x.first ^ x.second) * kMul; - a ^= (a >> 47); - uint64_t b = (x.second ^ a) * kMul; - b ^= (b >> 47); - b *= kMul; - return b; -} - -uint64_t HashLen16(uint64_t u, uint64_t v) { - return Hash128to64(uint128_t(u, v)); -} - -uint64_t HashLen0to16(const char *s, size_t len) { - if (len >= 8) { - uint64_t mul = k2 + len * 2; - uint64_t a = Fetch64(s) + k2; - uint64_t b = Fetch64(s + len - 8); - uint64_t c = Rotate(b, 37) * mul + a; - uint64_t d = (Rotate(a, 25) + b) * mul; - return HashLen16(c, d, mul); - } - if (len >= 4) { - uint64_t mul = k2 + len * 2; - uint64_t a = Fetch32(s); - return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul); - } - if (len > 0) { - uint8_t a = s[0]; - uint8_t b = s[len >> 1]; - uint8_t c = s[len - 1]; - uint32_t y = static_cast(a) + (static_cast(b) << 8); - uint32_t z = len + (static_cast(c) << 2); - return ShiftMix(y * k2 ^ z * k0) * k2; - } - return k2; -} - -// This probably works well for 16-byte strings as well, but it may be overkill -// in that case. -static uint64_t HashLen17to32(const char *s, size_t len) { - uint64_t mul = k2 + len * 2; - uint64_t a = Fetch64(s) * k1; - uint64_t b = Fetch64(s + 8); - uint64_t c = Fetch64(s + len - 8) * mul; - uint64_t d = Fetch64(s + len - 16) * k2; - return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, - a + Rotate(b + k2, 18) + c, mul); -} - -// Return a 16-byte hash for 48 bytes. Quick and dirty. -// Callers do best to use "random-looking" values for a and b. -std::pair WeakHashLen32WithSeeds( - uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) { - a += w; - b = Rotate(b + a + z, 21); - uint64_t c = a; - a += x; - a += y; - b += Rotate(a, 44); - return std::make_pair(a + z, b + c); -} - -// Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. -std::pair WeakHashLen32WithSeeds( - const char* s, uint64_t a, uint64_t b) { - return WeakHashLen32WithSeeds(Fetch64(s), - Fetch64(s + 8), - Fetch64(s + 16), - Fetch64(s + 24), - a, - b); -} - -// Return an 8-byte hash for 33 to 64 bytes. -uint64_t HashLen33to64(const char *s, size_t len) { - uint64_t mul = k2 + len * 2; - uint64_t a = Fetch64(s) * k2; - uint64_t b = Fetch64(s + 8); - uint64_t c = Fetch64(s + len - 24); - uint64_t d = Fetch64(s + len - 32); - uint64_t e = Fetch64(s + 16) * k2; - uint64_t f = Fetch64(s + 24) * 9; - uint64_t g = Fetch64(s + len - 8); - uint64_t h = Fetch64(s + len - 16) * mul; - uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; - uint64_t v = ((a + g) ^ d) + f + 1; - uint64_t w = bswap64((u + v) * mul) + h; - uint64_t x = Rotate(e + f, 42) + c; - uint64_t y = (bswap64((v + w) * mul) + g) * mul; - uint64_t z = e + f + c; - a = bswap64((x + z) * mul + y) + b; - b = ShiftMix((z + a) * mul + d + h) * mul; - return b + x; -} - -} // namespace - -extern "C" { - -uint64_t CityHash64(const void* data, size_t len) { - const char* s = reinterpret_cast(data); - if (len <= 32) { - if (len <= 16) { - return HashLen0to16(s, len); - } else { - return HashLen17to32(s, len); - } - } else if (len <= 64) { - return HashLen33to64(s, len); - } - - // For strings over 64 bytes we hash the end first, and then as we - // loop we keep 56 bytes of state: v, w, x, y, and z. - uint64_t x = Fetch64(s + len - 40); - uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56); - uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24)); - std::pair v = WeakHashLen32WithSeeds(s + len - 64, len, z); - std::pair w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x); - x = x * k1 + Fetch64(s); - - // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. - len = (len - 1) & ~static_cast(63); - do { - x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1; - y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1; - x ^= w.second; - y += v.first + Fetch64(s + 40); - z = Rotate(z + w.first, 33) * k1; - v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first); - w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); - std::swap(z, x); - s += 64; - len -= 64; - } while (len != 0); - return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z, - HashLen16(v.second, w.second) + x); -} - -} // extern "C" diff --git a/kotlin-native/common/src/hash/cpp/Names.cpp b/kotlin-native/common/src/hash/cpp/Names.cpp deleted file mode 100644 index 3c19b37d476..00000000000 --- a/kotlin-native/common/src/hash/cpp/Names.cpp +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include - -#include "Names.h" - -#include "Base64.h" -#include "City.h" -#include "Sha1.h" - -namespace { - -constexpr uint32_t PrintableBase64Size(uint32_t input_length) { - return ((input_length + 2) / 3 * 4) + 1; -} - -void PrintableBase64(const uint8_t* data, uint32_t data_length, char* base64) { - int rv = EncodeBase64(data, data_length, base64, PrintableBase64Size(data_length)); - assert(rv == 0); -} - -} // namespace - -extern "C" { - -// Make local hash out of arbitrary data. -void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash) { - *hash = CityHash64(data, size); -} - -// Make global hash out of arbitrary data. -void MakeGlobalHash(const void* data, uint32_t size, GlobalHash* hash) { - SHA1_CTX ctx; - SHA1Init(&ctx); - SHA1Update(&ctx, reinterpret_cast(data), size); - SHA1Final(&hash->bits[0], &ctx); -} - -// Make printable C string out of local hash. -void PrintableLocalHash(const LocalHash* hash, char* buffer, uint32_t size) { - if (size < PrintableBase64Size(sizeof(*hash))) { - assert(false); - return; - } - PrintableBase64(reinterpret_cast(&hash), sizeof(*hash), buffer); -} - -// Make printable C string out of global hash. -void PrintableGlobalHash(const GlobalHash* hash, char* buffer, uint32_t size) { - if (size < PrintableBase64Size(sizeof(*hash))) { - assert(false); - return; - } - PrintableBase64(hash->bits, sizeof(*hash), buffer); -} - -} // extern "C" diff --git a/kotlin-native/common/src/hash/cpp/Sha1.cpp b/kotlin-native/common/src/hash/cpp/Sha1.cpp deleted file mode 100644 index 73db0b3ac3a..00000000000 --- a/kotlin-native/common/src/hash/cpp/Sha1.cpp +++ /dev/null @@ -1,190 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -/* -SHA-1 in C -By Steve Reid -100% Public Domain - -Test Vectors (from FIPS PUB 180-1) -"abc" - A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D -"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" - 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 -A million repetitions of "a" - 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F -*/ - -/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */ -/* #define SHA1HANDSOFF * Copies data before messing with it. */ - -#define SHA1HANDSOFF - -#include -#include -#include - -#include "Sha1.h" - -#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) - -/* blk0() and blk() perform the initial expand. */ -/* I got the idea of expanding during the round function from SSLeay */ -#if BYTE_ORDER == LITTLE_ENDIAN -#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ - |(rol(block->l[i],8)&0x00FF00FF)) -#elif BYTE_ORDER == BIG_ENDIAN -#define blk0(i) block->l[i] -#else -#error "Endianness not defined!" -#endif -#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ - ^block->l[(i+2)&15]^block->l[i&15],1)) - -/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ -#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); -#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); -#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); -#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); -#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); - -/* Hash a single 512-bit block. This is the core of the algorithm. */ -static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) -{ - uint32_t a, b, c, d, e; - typedef union { - unsigned char c[64]; - uint32_t l[16]; - } CHAR64LONG16; -#ifdef SHA1HANDSOFF - CHAR64LONG16 block[1]; /* use array to appear as a pointer */ - memcpy(block, buffer, 64); -#else - /* The following had better never be used because it causes the - * pointer-to-const buffer to be cast into a pointer to non-const. - * And the result is written through. I threw a "const" in, hoping - * this will cause a diagnostic. - */ - CHAR64LONG16* block = (const CHAR64LONG16*)buffer; -#endif - /* Copy context->state[] to working vars */ - a = state[0]; - b = state[1]; - c = state[2]; - d = state[3]; - e = state[4]; - /* 4 rounds of 20 operations each. Loop unrolled. */ - R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); - R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); - R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); - R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); - R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); - R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); - R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); - R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); - R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); - R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); - R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); - R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); - R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); - R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); - R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); - R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); - R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); - R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); - R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); - R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); - /* Add the working vars back into context.state[] */ - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - state[4] += e; - /* Wipe variables */ - a = b = c = d = e = 0; -#ifdef SHA1HANDSOFF - memset(block, '\0', sizeof(block)); -#endif -} - -#ifdef __cplusplus -extern "C" { -#endif - -/* SHA1Init - Initialize new context */ -void SHA1Init(SHA1_CTX* context) -{ - /* SHA1 initialization constants */ - context->state[0] = 0x67452301; - context->state[1] = 0xEFCDAB89; - context->state[2] = 0x98BADCFE; - context->state[3] = 0x10325476; - context->state[4] = 0xC3D2E1F0; - context->count[0] = context->count[1] = 0; -} - - -/* Run your data through this. */ -void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len) -{ - uint32_t i, j; - - j = context->count[0]; - if ((context->count[0] += len << 3) < j) - context->count[1]++; - context->count[1] += (len>>29); - j = (j >> 3) & 63; - if ((j + len) > 63) { - memcpy(&context->buffer[j], data, (i = 64-j)); - SHA1Transform(context->state, context->buffer); - for ( ; i + 63 < len; i += 64) { - SHA1Transform(context->state, &data[i]); - } - j = 0; - } - else i = 0; - memcpy(&context->buffer[j], &data[i], len - i); -} - -/* Add padding and return the message digest. */ -void SHA1Final(unsigned char digest[20], SHA1_CTX* context) -{ - unsigned i; - unsigned char finalcount[8]; - unsigned char c; - - for (i = 0; i < 8; i++) { - finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] - >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ - } - c = 0200; - SHA1Update(context, &c, 1); - while ((context->count[0] & 504) != 448) { - c = 0000; - SHA1Update(context, &c, 1); - } - SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ - for (i = 0; i < 20; i++) { - digest[i] = (unsigned char) - ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); - } - /* Wipe variables */ - memset(context, '\0', sizeof(*context)); - memset(&finalcount, '\0', sizeof(finalcount)); -} - -#ifdef __cplusplus -} -#endif diff --git a/kotlin-native/common/src/hash/headers/Base64.h b/kotlin-native/common/src/hash/headers/Base64.h deleted file mode 100644 index 1efcf118416..00000000000 --- a/kotlin-native/common/src/hash/headers/Base64.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef COMMON_BASE64_H -#define COMMON_BASE64_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -int EncodeBase64( - const void* input, uint32_t inputLen, void* output, uint32_t outputLen); - -int DecodeBase64( - const char* input, uint32_t inputLen, void* output, uint32_t* outputLen); - -#ifdef __cplusplus -} -#endif - -#endif // COMMON_BASE64_H diff --git a/kotlin-native/common/src/hash/headers/City.h b/kotlin-native/common/src/hash/headers/City.h deleted file mode 100644 index 4adf2cc3f8f..00000000000 --- a/kotlin-native/common/src/hash/headers/City.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef COMMON_CITY_H -#define COMMON_CITY_H - -// CityHash, by Geoff Pike and Jyrki Alakuijala. - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -// Hash function for a byte array. -uint64_t CityHash64(const void* buf, size_t len); - -#ifdef __cplusplus -} -#endif - -#endif // COMMON_CITY_H diff --git a/kotlin-native/common/src/hash/headers/Names.h b/kotlin-native/common/src/hash/headers/Names.h deleted file mode 100644 index bb3823907a1..00000000000 --- a/kotlin-native/common/src/hash/headers/Names.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef COMMON_NAMES_H -#define COMMON_NAMES_H - -#include - -// All names in system are stored as hashes (or maybe, for debug builds, -// as pointers to uniqued C strings containing names?). -// There are two types of hashes: -// - local hash, must be unique per class/scope (CityHash64 is being used) -// - global hash, must be unique globally (SHA1 is being used) -// Generic guideline is that global hash is being used in global persistent -// context, while local hashes are more local in scope. -// Local hash. -typedef int64_t LocalHash; -// Hash of field name. -typedef LocalHash FieldNameHash; -// Hash of open method name. -typedef LocalHash MethodNameHash; -// Global hash. -typedef struct { - uint8_t bits[20]; -} GlobalHash; -// Hash of function name. -typedef GlobalHash FunctionNameHash; -// Hash of class name. -typedef GlobalHash ClassNameHash; - -#ifdef __cplusplus -extern "C" { -#endif -// Make local hash out of arbitrary data. -void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash); -// Make global hash out of arbitrary data. -void MakeGlobalHash(const void* data, uint32_t size, GlobalHash* hash); -// Make printable C string out of local hash. -void PrintableLocalHash(const LocalHash* hash, char* buffer, uint32_t size); -// Make printable C string out of global hash. -void PrintableGlobalHash(const GlobalHash* hash, char* buffer, uint32_t size); -#ifdef __cplusplus -} // extern "C" -#endif - -#endif // COMMON_NAMES_H diff --git a/kotlin-native/common/src/hash/headers/Sha1.h b/kotlin-native/common/src/hash/headers/Sha1.h deleted file mode 100644 index 07158174d94..00000000000 --- a/kotlin-native/common/src/hash/headers/Sha1.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef COMMON_SHA1_H -#define COMMON_SHA1_H - -#include - -/* -SHA-1 in C -By Steve Reid -100% Public Domain -*/ - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct SHA1_CTX { - uint32_t state[5]; - uint32_t count[2]; - unsigned char buffer[64]; -} SHA1_CTX; - -void SHA1Init(SHA1_CTX* context); -void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len); -void SHA1Final(unsigned char digest[20], SHA1_CTX* context); - -#ifdef __cplusplus -} -#endif - -#endif // COMMON_SHA1_H