Skip to content

Commit

Permalink
bsc 3.2.4
Browse files Browse the repository at this point in the history
  • Loading branch information
@IlyaGrebnov
IlyaGrebnov committed Jan 18, 2022
1 parent 4997ac0 commit bfd3f1b
Show file tree
Hide file tree
Showing 8 changed files with 284 additions and 22 deletions.
3 changes: 3 additions & 0 deletions CHANGES
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,6 @@
Changes in 3.2.4 (18 January, 18 2022)
- Improved performance for AArch64 (ARM64) platform.

Changes in 3.2.3 (September, 30 2021)
- Fixed various out-of-bound memory access bugs found by LibFuzzer.
- Fixed data corruption issue found by LibFuzzer.
Expand Down
2 changes: 1 addition & 1 deletion VERSION
View file
Original file line number Diff line number Diff line change
@@ -1 +1 @@
3.2.3
3.2.4
2 changes: 1 addition & 1 deletion bsc.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -851,7 +851,7 @@ void ProcessCommandline(int argc, char * argv[])

int main(int argc, char * argv[])
{
fprintf(stdout, "This is bsc, Block Sorting Compressor. Version 3.2.3. 30 September 2021.\n");
fprintf(stdout, "This is bsc, Block Sorting Compressor. Version 3.2.4. 18 January 2022.\n");
fprintf(stdout, "Copyright (c) 2009-2021 Ilya Grebnov <[email protected]>.\n\n");

#if defined(_OPENMP) && defined(__INTEL_COMPILER)
Expand Down
61 changes: 59 additions & 2 deletions libbsc/adler32/adler32.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,7 @@ See also the bsc and libbsc web site:
--*/

#include <stdlib.h>
#include <stdint.h>
#include <memory.h>
#include <string.h>

Expand Down Expand Up @@ -78,11 +79,23 @@ See also the bsc and libbsc web site:

#if defined(ADLER32_FUNCTION_NAME)

#define make_uint32x4(d0, d1, d2, d3) vcombine_u32(vcreate_u32(((unsigned long long)(d0) << 0) + ((unsigned long long)(d1) << 32)), vcreate_u32(((unsigned long long)(d2) << 0) + ((unsigned long long)(d3) << 32)))
#define make_uint16x4(w0, w1, w2, w3) vcreate_u16(((unsigned long long)(w0) << 0) + ((unsigned long long)(w1) << 16) + ((unsigned long long)(w2) << 32) + ((unsigned long long)(w3) << 48))

unsigned int ADLER32_FUNCTION_NAME (const unsigned char * T, int n, int features)
{
unsigned int sum1 = 1;
unsigned int sum2 = 0;

#if LIBBSC_CPU_FEATURE >= LIBBSC_CPU_FEATURE_SSSE3 || LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64

while ((((uintptr_t)T & 15) != 0) && n > 0)
{
DO1(T, 0); T += 1; n -= 1;
}

#endif

while (n >= NMAX)
{
#if LIBBSC_CPU_FEATURE >= LIBBSC_CPU_FEATURE_SSSE3
Expand All @@ -97,8 +110,8 @@ unsigned int ADLER32_FUNCTION_NAME (const unsigned char * T, int n, int features

for (int i = 0; i < NMAX / 32; ++i)
{
const __m128i bytes1 = _mm_loadu_si128((__m128i *)(T));
const __m128i bytes2 = _mm_loadu_si128((__m128i *)(T + 16));
const __m128i bytes1 = _mm_load_si128((__m128i *)(T));
const __m128i bytes2 = _mm_load_si128((__m128i *)(T + 16));

v_ps = _mm_add_epi32(v_ps, v_s1);

Expand All @@ -120,6 +133,50 @@ unsigned int ADLER32_FUNCTION_NAME (const unsigned char * T, int n, int features
v_s2 = _mm_add_epi32(v_s2, _mm_shuffle_epi32(v_s2, _MM_SHUFFLE(2, 3, 0, 1)));
v_s2 = _mm_add_epi32(v_s2, _mm_shuffle_epi32(v_s2, _MM_SHUFFLE(1, 0, 3, 2)));
sum2 = _mm_cvtsi128_si32(v_s2);
#elif LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64

unsigned int sum1_n = sum1 * (NMAX / 32);

uint32x4_t v_s2 = make_uint32x4(0, 0, 0, sum1_n);
uint32x4_t v_s1 = make_uint32x4(0, 0, 0, 0);
uint16x8_t v_column_sum_1 = vdupq_n_u16(0);
uint16x8_t v_column_sum_2 = vdupq_n_u16(0);
uint16x8_t v_column_sum_3 = vdupq_n_u16(0);
uint16x8_t v_column_sum_4 = vdupq_n_u16(0);

for (int i = 0; i < NMAX / 32; ++i)
{
const uint8x16_t bytes1 = vld1q_u8((uint8_t *)(T));
const uint8x16_t bytes2 = vld1q_u8((uint8_t *)(T + 16));

v_s2 = vaddq_u32(v_s2, v_s1);
v_s1 = vpadalq_u16(v_s1, vpadalq_u8(vpaddlq_u8(bytes1), bytes2));

v_column_sum_1 = vaddw_u8(v_column_sum_1, vget_low_u8(bytes1));
v_column_sum_2 = vaddw_u8(v_column_sum_2, vget_high_u8(bytes1));
v_column_sum_3 = vaddw_u8(v_column_sum_3, vget_low_u8(bytes2));
v_column_sum_4 = vaddw_u8(v_column_sum_4, vget_high_u8(bytes2));

T += 32;
}

v_s2 = vshlq_n_u32(v_s2, 5);

v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_1), make_uint16x4(32, 31, 30, 29));
v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_1), make_uint16x4(28, 27, 26, 25));
v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_2), make_uint16x4(24, 23, 22, 21));
v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_2), make_uint16x4(20, 19, 18, 17));
v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_3), make_uint16x4(16, 15, 14, 13));
v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_3), make_uint16x4(12, 11, 10, 9));
v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_4), make_uint16x4( 8, 7, 6, 5));
v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_4), make_uint16x4( 4, 3, 2, 1));

uint32x2_t v_sum1 = vpadd_u32(vget_low_u32(v_s1), vget_high_u32(v_s1));
uint32x2_t v_sum2 = vpadd_u32(vget_low_u32(v_s2), vget_high_u32(v_s2));
uint32x2_t v_s1s2 = vpadd_u32(v_sum1, v_sum2);

sum1 += vget_lane_u32(v_s1s2, 0);
sum2 += vget_lane_u32(v_s1s2, 1);

#else
for (int i = 0; i < NMAX / 16; ++i)
Expand Down
181 changes: 181 additions & 0 deletions libbsc/coder/qlfc/qlfc.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -254,6 +254,145 @@ unsigned char * QLFC_TRANSFORM_FUNCTION_NAME (const unsigned char * RESTRICT inp
return buffer + j;
}

#elif LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64

INLINE ptrdiff_t QLFC_TRANSFORM_SCAN_FUNCTION_NAME (const unsigned char * RESTRICT input, ptrdiff_t i, unsigned long long currentChar)
{
unsigned long long v = currentChar; v |= (v << 8); v |= (v << 16); v |= (v << 32);

while (i >= 8)
{
i -= 8; unsigned long long m = (*(unsigned long long const *)(input + i)) ^ v;
if (m != 0) { return i + (bsc_bit_scan_reverse64(m) / 8); }
}

do {} while ((--i >= 0) && (input[i] == currentChar)); return i;
}

unsigned char * QLFC_TRANSFORM_FUNCTION_NAME (const unsigned char * RESTRICT input, unsigned char * RESTRICT buffer, int n, unsigned char * RESTRICT MTFTable)
{
signed char ALIGNED(64) ranks[ALPHABET_SIZE];
signed char ALIGNED(64) flags[ALPHABET_SIZE];

for (ptrdiff_t i = 0; i < ALPHABET_SIZE; ++i) { ranks[i] = (signed char)(i - 128); }
for (ptrdiff_t i = 0; i < ALPHABET_SIZE; ++i) { flags[i] = 0; }

ptrdiff_t i = (ptrdiff_t)n - 1, j = n; signed char nSymbols = 0;

for (; i >= 0;)
{
unsigned char currentChar1 = input[i]; i = QLFC_TRANSFORM_SCAN_FUNCTION_NAME(input, i, currentChar1); if (i < 0) { i = 0; break; }
unsigned char currentChar2 = input[i]; i = QLFC_TRANSFORM_SCAN_FUNCTION_NAME(input, i, currentChar2);

signed char rank1 = ranks[currentChar1], rank2 = ranks[currentChar2]; rank2 += rank1 > rank2;

buffer[--j] = rank1 + 128; if (flags[currentChar1] == 0) { flags[currentChar1] = 1; buffer[j] = nSymbols++; }
buffer[--j] = rank2 + 128; if (flags[currentChar2] == 0) { flags[currentChar2] = 1; buffer[j] = nSymbols++; }

int8x16_t r1 = vdupq_n_s8(rank1), r2 = vdupq_n_s8(rank2), x, y;

x = vld1q_s8((int8_t const *)(ranks + 16 * 0)); y = vld1q_s8((int8_t const *)(ranks + 16 * 1));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 0), x); vst1q_s8((int8_t *)(ranks + 16 * 1), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 2)); y = vld1q_s8((int8_t const *)(ranks + 16 * 3));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 2), x); vst1q_s8((int8_t *)(ranks + 16 * 3), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 4)); y = vld1q_s8((int8_t const *)(ranks + 16 * 5));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 4), x); vst1q_s8((int8_t *)(ranks + 16 * 5), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 6)); y = vld1q_s8((int8_t const *)(ranks + 16 * 7));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 6), x); vst1q_s8((int8_t *)(ranks + 16 * 7), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 8)); y = vld1q_s8((int8_t const *)(ranks + 16 * 9));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 8), x); vst1q_s8((int8_t *)(ranks + 16 * 9), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 10)); y = vld1q_s8((int8_t const *)(ranks + 16 * 11));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 10), x); vst1q_s8((int8_t *)(ranks + 16 * 11), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 12)); y = vld1q_s8((int8_t const *)(ranks + 16 * 13));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 12), x); vst1q_s8((int8_t *)(ranks + 16 * 13), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 14)); y = vld1q_s8((int8_t const *)(ranks + 16 * 15));
x = vsubq_s8(vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r1, x))), vreinterpretq_s8_u8(vcgtq_s8(r2, x)));
y = vsubq_s8(vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r1, y))), vreinterpretq_s8_u8(vcgtq_s8(r2, y)));
vst1q_s8((int8_t *)(ranks + 16 * 14), x); vst1q_s8((int8_t *)(ranks + 16 * 15), y);

ranks[currentChar1] = -127; ranks[currentChar2] = -128;
}

if (i >= 0)
{
unsigned char currentChar = input[0]; signed char rank = ranks[currentChar];

buffer[--j] = rank + 128; if (flags[currentChar] == 0) { flags[currentChar] = 1; buffer[j] = nSymbols++; }

int8x16_t r = vdupq_n_s8(rank), x, y;

x = vld1q_s8((int8_t const *)(ranks + 16 * 0)); y = vld1q_s8((int8_t const *)(ranks + 16 * 1));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 0), x); vst1q_s8((int8_t *)(ranks + 16 * 1), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 2)); y = vld1q_s8((int8_t const *)(ranks + 16 * 3));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 2), x); vst1q_s8((int8_t *)(ranks + 16 * 3), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 4)); y = vld1q_s8((int8_t const *)(ranks + 16 * 5));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 4), x); vst1q_s8((int8_t *)(ranks + 16 * 5), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 6)); y = vld1q_s8((int8_t const *)(ranks + 16 * 7));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 6), x); vst1q_s8((int8_t *)(ranks + 16 * 7), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 8)); y = vld1q_s8((int8_t const *)(ranks + 16 * 9));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 8), x); vst1q_s8((int8_t *)(ranks + 16 * 9), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 10)); y = vld1q_s8((int8_t const *)(ranks + 16 * 11));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 10), x); vst1q_s8((int8_t *)(ranks + 16 * 11), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 12)); y = vld1q_s8((int8_t const *)(ranks + 16 * 13));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 12), x); vst1q_s8((int8_t *)(ranks + 16 * 13), y);

x = vld1q_s8((int8_t const *)(ranks + 16 * 14)); y = vld1q_s8((int8_t const *)(ranks + 16 * 15));
x = vsubq_s8(x, vreinterpretq_s8_u8(vcgtq_s8(r, x)));
y = vsubq_s8(y, vreinterpretq_s8_u8(vcgtq_s8(r, y)));
vst1q_s8((int8_t *)(ranks + 16 * 14), x); vst1q_s8((int8_t *)(ranks + 16 * 15), y);

ranks[currentChar] = -128;
}

buffer[n - 1] = 1;

for (ptrdiff_t i = 0; i < ALPHABET_SIZE; ++i) { MTFTable[ranks[i] + 128] = (unsigned char)i; }
for (ptrdiff_t i = 1; i < ALPHABET_SIZE; ++i) { if (flags[MTFTable[i]] == 0) { MTFTable[i] = MTFTable[i - 1]; break; } }

return buffer + j;
}

#else

unsigned char * QLFC_TRANSFORM_FUNCTION_NAME (const unsigned char * RESTRICT input, unsigned char * RESTRICT buffer, int n, unsigned char * RESTRICT MTFTable)
Expand Down Expand Up @@ -419,6 +558,20 @@ int QLFC_ADAPTIVE_ENCODE_FUNCTION_NAME (const unsigned char * input, unsigned ch

input += 16;
}
#elif LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64
unsigned long long v = currentChar; v |= (v << 8); v |= (v << 16); v |= (v << 32);

while (true)
{
unsigned long long m = (*(unsigned long long const *)input) ^ v;
if (m != 0)
{
input += bsc_bit_scan_forward64(m) / 8;
break;
}

input += 8;
}
#else
while (*input == currentChar) { input++; }
#endif
Expand Down Expand Up @@ -771,6 +924,20 @@ int QLFC_STATIC_ENCODE_FUNCTION_NAME (const unsigned char * input, unsigned char

input += 16;
}
#elif LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64
unsigned long long v = currentChar; v |= (v << 8); v |= (v << 16); v |= (v << 32);

while (true)
{
unsigned long long m = (*(unsigned long long const *)input) ^ v;
if (m != 0)
{
input += bsc_bit_scan_forward64(m) / 8;
break;
}

input += 8;
}
#else
while (*input == currentChar) { input++; }
#endif
Expand Down Expand Up @@ -1049,6 +1216,20 @@ int QLFC_FAST_ENCODE_FUNCTION_NAME (const unsigned char * RESTRICT input, unsign

input += 16;
}
#elif LIBBSC_CPU_FEATURE == LIBBSC_CPU_FEATURE_A64
unsigned long long v = currentChar; v |= (v << 8); v |= (v << 16); v |= (v << 32);

while (true)
{
unsigned long long m = (*(unsigned long long const *)input) ^ v;
if (m != 0)
{
input += bsc_bit_scan_forward64(m) / 8;
break;
}

input += 8;
}
#else
while (*input == currentChar) { input++; }
#endif
Expand Down
6 changes: 3 additions & 3 deletions libbsc/lzp/lzp.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@ static INLINE int bsc_lzp_num_blocks(int n)
return 8;
}

#if defined (LIBBSC_ALLOW_UNALIGNED_ACCESS) && defined (__x86_64__)
#if defined(LIBBSC_ALLOW_UNALIGNED_ACCESS) && (defined(__x86_64__) || defined(__aarch64__))

template<class T> int bsc_lzp_encode_small(const unsigned char * RESTRICT input, const unsigned char * inputEnd, unsigned char * RESTRICT output, unsigned char * outputEnd, int * RESTRICT lookup, int mask)
{
Expand Down Expand Up @@ -540,7 +540,7 @@ int bsc_lzp_encode_block(const unsigned char * input, const unsigned char * inpu
int result = LIBBSC_NOT_ENOUGH_MEMORY;
if (int * lookup = (int *)bsc_zero_malloc((int)(1 << hashSize) * sizeof(int)))
{
#if defined (LIBBSC_ALLOW_UNALIGNED_ACCESS) && defined (__x86_64__)
#if defined(LIBBSC_ALLOW_UNALIGNED_ACCESS) && (defined(__x86_64__) || defined(__aarch64__))
result = (minLen == 1 * (int)sizeof(unsigned int ) && result == LIBBSC_NOT_ENOUGH_MEMORY) ? bsc_lzp_encode_small <unsigned int >(input, inputEnd, output, outputEnd, lookup, (int)(1 << hashSize) - 1) : result;
result = (minLen == 1 * (int)sizeof(unsigned long long) && result == LIBBSC_NOT_ENOUGH_MEMORY) ? bsc_lzp_encode_small <unsigned long long>(input, inputEnd, output, outputEnd, lookup, (int)(1 << hashSize) - 1) : result;
result = (minLen == 2 * (int)sizeof(unsigned long long) && result == LIBBSC_NOT_ENOUGH_MEMORY) ? bsc_lzp_encode_small2x<unsigned long long>(input, inputEnd, output, outputEnd, lookup, (int)(1 << hashSize) - 1) : result;
Expand Down Expand Up @@ -572,7 +572,7 @@ int bsc_lzp_decode_block(const unsigned char * RESTRICT input, const unsigned ch

for (int i = 0; i < 4; ++i) { *output++ = *input++; }

#if defined (LIBBSC_ALLOW_UNALIGNED_ACCESS) && defined (__x86_64__)
#if defined(LIBBSC_ALLOW_UNALIGNED_ACCESS) && (defined(__x86_64__) || defined(__aarch64__))
if (hashSize <= 17)
{
unsigned int prev4 = *(unsigned int *)(output - 4);
Expand Down
2 changes: 1 addition & 1 deletion libbsc/platform/platform.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ See also the bsc and libbsc web site:
SIZE_T g_LargePageSize = 0;
#endif

#if (LIBBSC_CPU_FEATURE != LIBBSC_CPU_FEATURE_NONE)
#if (LIBBSC_CPU_FEATURE >= LIBBSC_CPU_FEATURE_SSE2)

#if defined(_MSC_VER)
#include <intrin.h>
Expand Down
Loading

0 comments on commit bfd3f1b

Please sign in to comment.