Add SNAPPY_ prefix to PREDICT_{TRUE,FALSE} macros.
diff --git a/snappy-internal.h b/snappy-internal.h
index 26be0cc..c12637d 100644
--- a/snappy-internal.h
+++ b/snappy-internal.h
@@ -95,7 +95,7 @@
// uncommon code paths that determine, without extra effort, whether the match
// length is less than 8. In short, we are hoping to avoid a conditional
// branch, and perhaps get better code layout from the C++ compiler.
- if (PREDICT_TRUE(s2 <= s2_limit - 8)) {
+ if (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 8)) {
uint64 a1 = UNALIGNED_LOAD64(s1);
uint64 a2 = UNALIGNED_LOAD64(s2);
if (a1 != a2) {
@@ -111,7 +111,7 @@
// time until we find a 64-bit block that doesn't match; then we find
// the first non-matching bit and use that to calculate the total
// length of the match.
- while (PREDICT_TRUE(s2 <= s2_limit - 8)) {
+ while (SNAPPY_PREDICT_TRUE(s2 <= s2_limit - 8)) {
if (UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched)) {
s2 += 8;
matched += 8;
@@ -123,7 +123,7 @@
return std::pair<size_t, bool>(matched, false);
}
}
- while (PREDICT_TRUE(s2 < s2_limit)) {
+ while (SNAPPY_PREDICT_TRUE(s2 < s2_limit)) {
if (s1[matched] == *s2) {
++s2;
++matched;
diff --git a/snappy-stubs-internal.h b/snappy-stubs-internal.h
index 0dcd270..881f7ad 100644
--- a/snappy-stubs-internal.h
+++ b/snappy-stubs-internal.h
@@ -73,11 +73,11 @@
// Static prediction hints.
#ifdef HAVE_BUILTIN_EXPECT
-#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#define SNAPPY_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#define SNAPPY_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
#else
-#define PREDICT_FALSE(x) x
-#define PREDICT_TRUE(x) x
+#define SNAPPY_PREDICT_FALSE(x) x
+#define SNAPPY_PREDICT_TRUE(x) x
#endif
// This is only used for recomputing the tag byte table used during
diff --git a/snappy-test.h b/snappy-test.h
index 04454df..078f321 100644
--- a/snappy-test.h
+++ b/snappy-test.h
@@ -524,7 +524,7 @@
// and ones that are always active.
#define CRASH_UNLESS(condition) \
- PREDICT_TRUE(condition) ? (void)0 : \
+ SNAPPY_PREDICT_TRUE(condition) ? (void)0 : \
snappy::LogMessageVoidify() & snappy::LogMessageCrash()
#ifdef _MSC_VER
diff --git a/snappy.cc b/snappy.cc
index 1ba247b..23f948f 100644
--- a/snappy.cc
+++ b/snappy.cc
@@ -175,7 +175,7 @@
// copying 2x 8 bytes at a time.
// Handle the uncommon case where pattern is less than 8 bytes.
- if (PREDICT_FALSE(pattern_size < 8)) {
+ if (SNAPPY_PREDICT_FALSE(pattern_size < 8)) {
// Expand pattern to at least 8 bytes. The worse case scenario in terms of
// buffer usage is when the pattern is size 3. ^ is the original position
// of op. x are irrelevant bytes copied by the last UnalignedCopy64.
@@ -185,13 +185,13 @@
// abcabcabcabcxxxxx
// ^
// The last x is 14 bytes after ^.
- if (PREDICT_TRUE(op <= buf_limit - 14)) {
+ if (SNAPPY_PREDICT_TRUE(op <= buf_limit - 14)) {
while (pattern_size < 8) {
UnalignedCopy64(src, op);
op += pattern_size;
pattern_size *= 2;
}
- if (PREDICT_TRUE(op >= op_limit)) return op_limit;
+ if (SNAPPY_PREDICT_TRUE(op >= op_limit)) return op_limit;
} else {
return IncrementalCopySlow(src, op, op_limit);
}
@@ -207,11 +207,11 @@
UnalignedCopy64(src + 8, op + 8);
src += 16;
op += 16;
- if (PREDICT_TRUE(op >= op_limit)) return op_limit;
+ if (SNAPPY_PREDICT_TRUE(op >= op_limit)) return op_limit;
}
// We only take this branch if we didn't have enough slop and we can do a
// single 8 byte copy.
- if (PREDICT_FALSE(op <= buf_limit - 8)) {
+ if (SNAPPY_PREDICT_FALSE(op <= buf_limit - 8)) {
UnalignedCopy64(src, op);
src += 8;
op += 8;
@@ -273,7 +273,7 @@
assert(offset < 65536);
assert(len_less_than_12 == (len < 12));
- if (len_less_than_12 && PREDICT_TRUE(offset < 2048)) {
+ if (len_less_than_12 && SNAPPY_PREDICT_TRUE(offset < 2048)) {
// offset fits in 11 bits. The 3 highest go in the top of the first byte,
// and the rest go in the second byte.
*op++ = COPY_1_BYTE_OFFSET + ((len - 4) << 2) + ((offset >> 3) & 0xe0);
@@ -298,7 +298,7 @@
// it's in the noise.
// Emit 64 byte copies but make sure to keep at least four bytes reserved.
- while (PREDICT_FALSE(len >= 68)) {
+ while (SNAPPY_PREDICT_FALSE(len >= 68)) {
op = EmitCopyAtMost64(op, offset, 64, false);
len -= 64;
}
@@ -427,7 +427,7 @@
const char* next_emit = ip;
const size_t kInputMarginBytes = 15;
- if (PREDICT_TRUE(input_size >= kInputMarginBytes)) {
+ if (SNAPPY_PREDICT_TRUE(input_size >= kInputMarginBytes)) {
const char* ip_limit = input + input_size - kInputMarginBytes;
for (uint32 next_hash = Hash(++ip, shift); ; ) {
@@ -468,7 +468,7 @@
uint32 bytes_between_hash_lookups = skip >> 5;
skip += bytes_between_hash_lookups;
next_ip = ip + bytes_between_hash_lookups;
- if (PREDICT_FALSE(next_ip > ip_limit)) {
+ if (SNAPPY_PREDICT_FALSE(next_ip > ip_limit)) {
goto emit_remainder;
}
next_hash = Hash(next_ip, shift);
@@ -477,8 +477,8 @@
assert(candidate < ip);
table[hash] = ip - base_ip;
- } while (PREDICT_TRUE(UNALIGNED_LOAD32(ip) !=
- UNALIGNED_LOAD32(candidate)));
+ } while (SNAPPY_PREDICT_TRUE(UNALIGNED_LOAD32(ip) !=
+ UNALIGNED_LOAD32(candidate)));
// Step 2: A 4-byte match has been found. We'll later see if more
// than 4 bytes match. But, prior to the match, input
@@ -509,7 +509,7 @@
assert(0 == memcmp(base, candidate, matched));
op = EmitCopy(op, offset, matched, p.second);
next_emit = ip;
- if (PREDICT_FALSE(ip >= ip_limit)) {
+ if (SNAPPY_PREDICT_FALSE(ip >= ip_limit)) {
goto emit_remainder;
}
// We are now looking for a 4-byte match again. We read
@@ -700,7 +700,7 @@
// txt[1-4] 25% 75%
// pb 24% 76%
// bin 24% 76%
- if (PREDICT_FALSE((c & 0x3) == LITERAL)) {
+ if (SNAPPY_PREDICT_FALSE((c & 0x3) == LITERAL)) {
size_t literal_length = (c >> 2) + 1u;
if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length)) {
assert(literal_length < 61);
@@ -710,7 +710,7 @@
// bytes in addition to the literal.
continue;
}
- if (PREDICT_FALSE(literal_length >= 61)) {
+ if (SNAPPY_PREDICT_FALSE(literal_length >= 61)) {
// Long literal.
const size_t literal_length_length = literal_length - 60;
literal_length =
@@ -1354,7 +1354,8 @@
char* const op_end = op_ptr_ + len;
// See SnappyArrayWriter::AppendFromSelf for an explanation of
// the "offset - 1u" trick.
- if (PREDICT_TRUE(offset - 1u < op_ptr_ - op_base_ && op_end <= op_limit_)) {
+ if (SNAPPY_PREDICT_TRUE(offset - 1u < op_ptr_ - op_base_ &&
+ op_end <= op_limit_)) {
// Fast path: src and dst in current block.
op_ptr_ = IncrementalCopy(op_ptr_ - offset, op_ptr_, op_end, op_limit_);
return true;
