Use likely()/unlikely() macros and a few bugfixes for integers
This commit is contained in:
parent
683b0f5141
commit
a201939a81
@ -73,8 +73,8 @@ static bool promote(env_t *env, ast_t *ast, CORD *code, type_t *actual, type_t *
|
||||
// Automatic optional checking for nums:
|
||||
if (needed->tag == NumType && actual->tag == OptionalType && Match(actual, OptionalType)->type->tag == NumType) {
|
||||
*code = CORD_all("({ ", compile_declaration(actual, "opt"), " = ", *code, "; ",
|
||||
"if (__builtin_expect(", check_none(actual, "opt"), ", 0))\n",
|
||||
CORD_asprintf("fail_source(%r, %ld, %ld, \"This value was expected to be non-NONE, but it's NONE!\");\n",
|
||||
"if unlikely (", check_none(actual, "opt"), ")\n",
|
||||
CORD_asprintf("fail_source(%r, %ld, %ld, \"This was expected to be a value, but it's NONE\");\n",
|
||||
CORD_quoted(ast->file->filename),
|
||||
(long)(ast->start - ast->file->text),
|
||||
(long)(ast->end - ast->file->text)),
|
||||
@ -2121,8 +2121,8 @@ CORD compile(env_t *env, ast_t *ast)
|
||||
type_t *t = get_type(env, value);
|
||||
CORD value_code = compile(env, value);
|
||||
return CORD_all("({ ", compile_declaration(t, "opt"), " = ", value_code, "; ",
|
||||
"if (__builtin_expect(", check_none(t, "opt"), ", 0))\n",
|
||||
CORD_asprintf("fail_source(%r, %ld, %ld, \"This value was expected to be non-NONE, but it's NONE!\");\n",
|
||||
"if unlikely (", check_none(t, "opt"), ")\n",
|
||||
CORD_asprintf("fail_source(%r, %ld, %ld, \"This was expected to be a value, but it's NONE\");\n",
|
||||
CORD_quoted(ast->file->filename),
|
||||
(long)(value->start - value->file->text),
|
||||
(long)(value->end - value->file->text)),
|
||||
|
||||
@ -430,7 +430,7 @@ public Array_t Array$by(Array_t array, Int_t int_stride, int64_t padded_item_siz
|
||||
int64_t stride = Int_to_Int64(int_stride, false);
|
||||
// In the unlikely event that the stride value would be too large to fit in
|
||||
// a 15-bit integer, fall back to creating a copy of the array:
|
||||
if (__builtin_expect(array.stride*stride < ARRAY_MIN_STRIDE || array.stride*stride > ARRAY_MAX_STRIDE, 0)) {
|
||||
if (unlikely(array.stride*stride < ARRAY_MIN_STRIDE || array.stride*stride > ARRAY_MAX_STRIDE)) {
|
||||
void *copy = NULL;
|
||||
int64_t len = (stride < 0 ? array.length / -stride : array.length / stride) + ((array.length % stride) != 0);
|
||||
if (len > 0) {
|
||||
@ -465,7 +465,7 @@ public Array_t Array$reversed(Array_t array, int64_t padded_item_size)
|
||||
// 15-bit integer, fall back to Array$by()'s more general method of copying
|
||||
// the array. This should only happen if array.stride is MIN_STRIDE to
|
||||
// begin with (very unlikely).
|
||||
if (__builtin_expect(-array.stride < ARRAY_MIN_STRIDE || -array.stride > ARRAY_MAX_STRIDE, 0))
|
||||
if (unlikely(-array.stride < ARRAY_MIN_STRIDE || -array.stride > ARRAY_MAX_STRIDE))
|
||||
return Array$by(array, I(-1), padded_item_size);
|
||||
|
||||
Array_t reversed = array;
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
#define Array_get(item_type, arr_expr, index_expr, start, end) *({ \
|
||||
const Array_t arr = arr_expr; int64_t index = index_expr; \
|
||||
int64_t off = index + (index < 0) * (arr.length + 1) - 1; \
|
||||
if (__builtin_expect(off < 0 || off >= arr.length, 0)) \
|
||||
if (unlikely(off < 0 || off >= arr.length)) \
|
||||
fail_source(__SOURCE_FILE__, start, end, "Invalid array index: %s (array has length %ld)\n", Text$as_c_string(Int64$as_text(&index, no, NULL)), arr.length); \
|
||||
(item_type*)(arr.data + arr.stride * off);})
|
||||
#define Array_get_unchecked(type, x, i) *({ const Array_t arr = x; int64_t index = i; \
|
||||
@ -22,7 +22,7 @@
|
||||
#define Array_lvalue(item_type, arr_expr, index_expr, padded_item_size, start, end) *({ \
|
||||
Array_t *arr = arr_expr; int64_t index = index_expr; \
|
||||
int64_t off = index + (index < 0) * (arr->length + 1) - 1; \
|
||||
if (__builtin_expect(off < 0 || off >= arr->length, 0)) \
|
||||
if (unlikely(off < 0 || off >= arr->length)) \
|
||||
fail_source(__SOURCE_FILE__, start, end, "Invalid array index: %s (array has length %ld)\n", Text$as_c_string(Int64$as_text(&index, no, NULL)), arr->length); \
|
||||
if (arr->data_refcount > 0) \
|
||||
Array$compact(arr, padded_item_size); \
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
#include "types.h"
|
||||
|
||||
public Text_t Int$value_as_text(Int_t i) {
|
||||
if (__builtin_expect(i.small & 1, 1)) {
|
||||
if (likely(i.small & 1)) {
|
||||
return Text$format("%ld", (i.small)>>2);
|
||||
} else {
|
||||
char *str = mpz_get_str(NULL, 10, *i.big);
|
||||
@ -32,33 +32,35 @@ public Text_t Int$as_text(const void *i, bool colorize, const TypeInfo_t*) {
|
||||
return text;
|
||||
}
|
||||
|
||||
public PUREFUNC int32_t Int$compare(const void *vx, const void *vy, const TypeInfo_t*) {
|
||||
Int_t *x = (Int_t*)vx;
|
||||
Int_t *y = (Int_t*)vy;
|
||||
if (__builtin_expect(((x->small | y->small) & 1) == 0, 0))
|
||||
return x->big == y->big ? 0 : mpz_cmp(*x->big, *y->big);
|
||||
return (x->small > y->small) - (x->small < y->small);
|
||||
}
|
||||
|
||||
public PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y) {
|
||||
if (__builtin_expect(((x.small | y.small) & 1) == 0, 0))
|
||||
if (likely(x.small & y.small & 1))
|
||||
return (x.small > y.small) - (x.small < y.small);
|
||||
else if (x.small & 1)
|
||||
return -mpz_cmp_si(*y.big, x.small);
|
||||
else if (y.small & 1)
|
||||
return mpz_cmp_si(*x.big, y.small);
|
||||
else
|
||||
return x.big == y.big ? 0 : mpz_cmp(*x.big, *y.big);
|
||||
return (x.small > y.small) - (x.small < y.small);
|
||||
}
|
||||
|
||||
public PUREFUNC bool Int$equal(const void *vx, const void *vy, const TypeInfo_t*) {
|
||||
Int_t *x = (Int_t*)vx;
|
||||
Int_t *y = (Int_t*)vy;
|
||||
return x->small == y->small || (__builtin_expect(((x->small | y->small) & 1) == 0, 0) && mpz_cmp(*x->big, *y->big) == 0);
|
||||
public PUREFUNC int32_t Int$compare(const void *x, const void *y, const TypeInfo_t*) {
|
||||
return Int$compare_value(*(Int_t*)x, *(Int_t*)y);
|
||||
}
|
||||
|
||||
public PUREFUNC bool Int$equal_value(const Int_t x, const Int_t y) {
|
||||
return x.small == y.small || (__builtin_expect(((x.small | y.small) & 1) == 0, 0) && mpz_cmp(*x.big, *y.big) == 0);
|
||||
if (likely((x.small | y.small) & 1))
|
||||
return x.small == y.small;
|
||||
else
|
||||
return x.big == y.big ? 0 : (mpz_cmp(*x.big, *y.big) == 0);
|
||||
}
|
||||
|
||||
public PUREFUNC bool Int$equal(const void *x, const void *y, const TypeInfo_t*) {
|
||||
return Int$equal_value(*(Int_t*)x, *(Int_t*)y);
|
||||
}
|
||||
|
||||
public PUREFUNC uint64_t Int$hash(const void *vx, const TypeInfo_t*) {
|
||||
Int_t *x = (Int_t*)vx;
|
||||
if (__builtin_expect(x->small & 1, 1)) {
|
||||
if (likely(x->small & 1)) {
|
||||
return siphash24((void*)x, sizeof(Int_t));
|
||||
} else {
|
||||
char *str = mpz_get_str(NULL, 16, *x->big);
|
||||
@ -68,7 +70,7 @@ public PUREFUNC uint64_t Int$hash(const void *vx, const TypeInfo_t*) {
|
||||
|
||||
public Text_t Int$format(Int_t i, Int_t digits_int) {
|
||||
int64_t digits = Int_to_Int64(digits_int, false);
|
||||
if (__builtin_expect(i.small & 1, 1)) {
|
||||
if (likely(i.small & 1)) {
|
||||
return Text$format("%0.*ld", digits, (i.small)>>2);
|
||||
} else {
|
||||
char *str = mpz_get_str(NULL, 10, *i.big);
|
||||
@ -91,7 +93,7 @@ public Text_t Int$hex(Int_t i, Int_t digits_int, bool uppercase, bool prefix) {
|
||||
return Text$concat(Text("-"), Int$hex(Int$negative(i), digits_int, uppercase, prefix));
|
||||
|
||||
int64_t digits = Int_to_Int64(digits_int, false);
|
||||
if (__builtin_expect(i.small & 1, 1)) {
|
||||
if (likely(i.small & 1)) {
|
||||
const char *hex_fmt = uppercase ? (prefix ? "0x%0.*lX" : "%0.*lX") : (prefix ? "0x%0.*lx" : "%0.*lx");
|
||||
return Text$format(hex_fmt, digits, (i.small)>>2);
|
||||
} else {
|
||||
@ -118,7 +120,7 @@ public Text_t Int$octal(Int_t i, Int_t digits_int, bool prefix) {
|
||||
return Text$concat(Text("-"), Int$octal(Int$negative(i), digits_int, prefix));
|
||||
|
||||
int64_t digits = Int_to_Int64(digits_int, false);
|
||||
if (__builtin_expect(i.small & 1, 1)) {
|
||||
if (likely(i.small & 1)) {
|
||||
const char *octal_fmt = prefix ? "0o%0.*lo" : "%0.*lo";
|
||||
return Text$format(octal_fmt, digits, (i.small)>>2);
|
||||
} else {
|
||||
@ -181,7 +183,7 @@ public Int_t Int$slow_divided_by(Int_t dividend, Int_t divisor) {
|
||||
mpz_init_set_int(remainder, divisor);
|
||||
mpz_tdiv_qr(quotient, remainder, quotient, remainder);
|
||||
if (mpz_sgn(remainder) < 0) {
|
||||
bool d_positive = __builtin_expect(divisor.small & 1, 1) ? divisor.small > 0x1 : mpz_sgn(*divisor.big) > 0;
|
||||
bool d_positive = likely(divisor.small & 1) ? divisor.small > 0x1 : mpz_sgn(*divisor.big) > 0;
|
||||
if (d_positive)
|
||||
mpz_sub_ui(quotient, quotient, 1);
|
||||
else
|
||||
@ -271,7 +273,7 @@ public Int_t Int$slow_negated(Int_t x)
|
||||
|
||||
public Int_t Int$slow_negative(Int_t x)
|
||||
{
|
||||
if (__builtin_expect((x.small & 1), 1))
|
||||
if (likely(x.small & 1))
|
||||
return (Int_t){.small=4*-((x.small)>>2) + 1};
|
||||
|
||||
mpz_t result;
|
||||
@ -282,7 +284,7 @@ public Int_t Int$slow_negative(Int_t x)
|
||||
|
||||
public Int_t Int$abs(Int_t x)
|
||||
{
|
||||
if (__builtin_expect((x.small & 1), 1))
|
||||
if (likely(x.small & 1))
|
||||
return (Int_t){.small=4*labs((x.small)>>2) + 1};
|
||||
|
||||
mpz_t result;
|
||||
@ -294,7 +296,7 @@ public Int_t Int$abs(Int_t x)
|
||||
public Int_t Int$power(Int_t base, Int_t exponent)
|
||||
{
|
||||
int64_t exp = Int_to_Int64(exponent, false);
|
||||
if (__builtin_expect(exp < 0, 0))
|
||||
if (unlikely(exp < 0))
|
||||
fail("Cannot take a negative power of an integer!");
|
||||
mpz_t result;
|
||||
mpz_init_set_int(result, base);
|
||||
@ -341,7 +343,7 @@ public bool Int$is_prime(Int_t x, Int_t reps)
|
||||
{
|
||||
mpz_t p;
|
||||
mpz_init_set_int(p, x);
|
||||
if (Int$compare_value(reps, I(9999)) > 0)
|
||||
if (unlikely(Int$compare_value(reps, I(9999)) > 0))
|
||||
fail("Number of prime-test repetitions should not be above 9999");
|
||||
int reps_int = Int_to_Int32(reps, false);
|
||||
return (mpz_probab_prime_p(p, reps_int) != 0);
|
||||
@ -359,7 +361,7 @@ public Int_t Int$prev_prime(Int_t x)
|
||||
{
|
||||
mpz_t p;
|
||||
mpz_init_set_int(p, x);
|
||||
if (mpz_prevprime(p, p) == 0)
|
||||
if (unlikely(mpz_prevprime(p, p) == 0))
|
||||
fail("There is no prime number before %k", (Text_t[1]){Int$as_text(&x, false, &Int$info)});
|
||||
return Int$from_mpz(p);
|
||||
}
|
||||
@ -372,7 +374,7 @@ static bool Int$is_none(const void *i, const TypeInfo_t*)
|
||||
static void Int$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t*)
|
||||
{
|
||||
Int_t i = *(Int_t*)obj;
|
||||
if (__builtin_expect((i.small & 1), 1)) {
|
||||
if (likely(i.small & 1)) {
|
||||
fputc(0, out);
|
||||
int64_t i64 = i.small >> 2;
|
||||
Int64$serialize(&i64, out, pointers, &Int64$info);
|
||||
|
||||
@ -117,7 +117,7 @@ OptionalInt_t Int$sqrt(Int_t i);
|
||||
))
|
||||
|
||||
#define mpz_init_set_int(mpz, i) do { \
|
||||
if (__builtin_expect((i).small & 1, 1)) mpz_init_set_si(mpz, (i).small >> 2); \
|
||||
if likely ((i).small & 1) mpz_init_set_si(mpz, (i).small >> 2); \
|
||||
else mpz_init_set(mpz, *(i).big); \
|
||||
} while (0)
|
||||
|
||||
@ -153,42 +153,42 @@ MACROLIKE PUREFUNC Int_t Int$clamped(Int_t x, Int_t low, Int_t high) {
|
||||
|
||||
MACROLIKE Int_t Int$plus(Int_t x, Int_t y) {
|
||||
const int64_t z = (int64_t)((uint64_t)x.small + (uint64_t)y.small);
|
||||
if (__builtin_expect(((z|2) == (int32_t)z), 1))
|
||||
if likely ((z|2) == (int32_t)z)
|
||||
return (Int_t){.small=(z-1)};
|
||||
return Int$slow_plus(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$minus(Int_t x, Int_t y) {
|
||||
const int64_t z = (int64_t)(((uint64_t)x.small ^ 3) - (uint64_t)y.small);
|
||||
if (__builtin_expect(((z & ~2) == (int32_t)z), 1))
|
||||
if likely ((z & ~2) == (int32_t)z)
|
||||
return (Int_t){.small=z};
|
||||
return Int$slow_minus(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$times(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely ((x.small & y.small) & 1) {
|
||||
const int64_t z = (x.small>>1) * (y.small>>1);
|
||||
if (__builtin_expect(z == (int32_t)z, 1))
|
||||
if likely (z == (int32_t)z)
|
||||
return (Int_t){.small=z+1};
|
||||
}
|
||||
return Int$slow_times(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$divided_by(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely (x.small & y.small & 1) {
|
||||
// Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
|
||||
const int64_t D = (x.small>>2);
|
||||
const int64_t d = (y.small>>2);
|
||||
int64_t q = D/d, r = D%d;
|
||||
q -= (r < 0) * (2*(d > 0) - 1);
|
||||
if (__builtin_expect(q == (int32_t)q, 1))
|
||||
if likely (q == (int32_t)q)
|
||||
return (Int_t){.small=(q<<2)|1};
|
||||
}
|
||||
return Int$slow_divided_by(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$modulo(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely (x.small & y.small & 1) {
|
||||
// Euclidean modulus, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
|
||||
const int64_t D = (x.small>>2);
|
||||
const int64_t d = (y.small>>2);
|
||||
@ -200,7 +200,7 @@ MACROLIKE Int_t Int$modulo(Int_t x, Int_t y) {
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$modulo1(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely (x.small & y.small & 1) {
|
||||
// Euclidean modulus, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
|
||||
const int64_t D = (x.small>>2)-1;
|
||||
const int64_t d = (y.small>>2);
|
||||
@ -212,18 +212,18 @@ MACROLIKE Int_t Int$modulo1(Int_t x, Int_t y) {
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$left_shifted(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely (x.small & y.small & 1) {
|
||||
const int64_t z = ((x.small>>2) << (y.small>>2))<<2;
|
||||
if (__builtin_expect(z == (int32_t)z, 1))
|
||||
if likely (z == (int32_t)z)
|
||||
return (Int_t){.small=z+1};
|
||||
}
|
||||
return Int$slow_left_shifted(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$right_shifted(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) != 0, 1)) {
|
||||
if likely (x.small & y.small & 1) {
|
||||
const int64_t z = ((x.small>>2) >> (y.small>>2))<<2;
|
||||
if (__builtin_expect(z == (int32_t)z, 1))
|
||||
if likely (z == (int32_t)z)
|
||||
return (Int_t){.small=z+1};
|
||||
}
|
||||
return Int$slow_right_shifted(x, y);
|
||||
@ -231,37 +231,37 @@ MACROLIKE Int_t Int$right_shifted(Int_t x, Int_t y) {
|
||||
|
||||
MACROLIKE Int_t Int$bit_and(Int_t x, Int_t y) {
|
||||
const int64_t z = x.small & y.small;
|
||||
if (__builtin_expect((z & 1) == 1, 1))
|
||||
if likely (z & 1)
|
||||
return (Int_t){.small=z};
|
||||
return Int$slow_bit_and(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$bit_or(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) == 1, 1))
|
||||
if likely (x.small & y.small & 1)
|
||||
return (Int_t){.small=(x.small | y.small)};
|
||||
return Int$slow_bit_or(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$bit_xor(Int_t x, Int_t y) {
|
||||
if (__builtin_expect(((x.small & y.small) & 1) == 1, 1))
|
||||
if likely (x.small & y.small & 1)
|
||||
return (Int_t){.small=(x.small ^ y.small) | 1};
|
||||
return Int$slow_bit_xor(x, y);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$negated(Int_t x) {
|
||||
if (__builtin_expect((x.small & 1), 1))
|
||||
if likely (x.small & 1)
|
||||
return (Int_t){.small=(~x.small) ^ 3};
|
||||
return Int$slow_negated(x);
|
||||
}
|
||||
|
||||
MACROLIKE Int_t Int$negative(Int_t x) {
|
||||
if (__builtin_expect((x.small & 1), 1))
|
||||
if likely (x.small & 1)
|
||||
return (Int_t){.small=((-((x.small)>>2))<<2) | 1};
|
||||
return Int$slow_negative(x);
|
||||
}
|
||||
|
||||
MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) {
|
||||
if (__builtin_expect((x.small & 1), 1))
|
||||
if likely (x.small & 1)
|
||||
return x.small < 0;
|
||||
return Int$compare_value(x, I_small(0)) < 0;
|
||||
}
|
||||
@ -271,7 +271,7 @@ MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) {
|
||||
MACROLIKE Int_t Int64_to_Int(int64_t i)
|
||||
{
|
||||
int64_t z = i<<2;
|
||||
if (__builtin_expect(z == (int32_t)z, 1))
|
||||
if likely (z == (int32_t)z)
|
||||
return (Int_t){.small=z+1};
|
||||
mpz_t result;
|
||||
mpz_init_set_si(result, i);
|
||||
@ -289,9 +289,9 @@ MACROLIKE Int_t Int64_to_Int(int64_t i)
|
||||
#define Int8_to_Int16(i, ...) (Int16_t)(i)
|
||||
|
||||
MACROLIKE PUREFUNC Int64_t Int_to_Int64(Int_t i, bool truncate) {
|
||||
if (__builtin_expect(i.small & 1, 1))
|
||||
if likely (i.small & 1)
|
||||
return (int64_t)(i.small >> 2);
|
||||
if (__builtin_expect(!truncate && !mpz_fits_slong_p(*i.big), 0))
|
||||
if (!truncate && unlikely(!mpz_fits_slong_p(*i.big)))
|
||||
fail("Integer is too big to fit in a 64-bit integer!");
|
||||
return mpz_get_si(*i.big);
|
||||
}
|
||||
@ -299,7 +299,7 @@ MACROLIKE PUREFUNC Int64_t Int_to_Int64(Int_t i, bool truncate) {
|
||||
MACROLIKE PUREFUNC Int32_t Int_to_Int32(Int_t i, bool truncate) {
|
||||
int64_t i64 = Int_to_Int64(i, truncate);
|
||||
int32_t i32 = (int32_t)i64;
|
||||
if (__builtin_expect(i64 != i32 && !truncate, 0))
|
||||
if (!truncate && unlikely(i64 != i32))
|
||||
fail("Integer is too big to fit in a 32-bit integer!");
|
||||
return i32;
|
||||
}
|
||||
@ -307,7 +307,7 @@ MACROLIKE PUREFUNC Int32_t Int_to_Int32(Int_t i, bool truncate) {
|
||||
MACROLIKE PUREFUNC Int16_t Int_to_Int16(Int_t i, bool truncate) {
|
||||
int64_t i64 = Int_to_Int64(i, truncate);
|
||||
int16_t i16 = (int16_t)i64;
|
||||
if (__builtin_expect(i64 != i16 && !truncate, 0))
|
||||
if (!truncate && unlikely(i64 != i16))
|
||||
fail("Integer is too big to fit in a 16-bit integer!");
|
||||
return i16;
|
||||
}
|
||||
@ -315,7 +315,7 @@ MACROLIKE PUREFUNC Int16_t Int_to_Int16(Int_t i, bool truncate) {
|
||||
MACROLIKE PUREFUNC Int8_t Int_to_Int8(Int_t i, bool truncate) {
|
||||
int64_t i64 = Int_to_Int64(i, truncate);
|
||||
int8_t i8 = (int8_t)i64;
|
||||
if (__builtin_expect(i64 != i8 && !truncate, 0))
|
||||
if (!truncate && unlikely(i64 != i8))
|
||||
fail("Integer is too big to fit in an 8-bit integer!");
|
||||
return i8;
|
||||
}
|
||||
@ -329,7 +329,7 @@ MACROLIKE PUREFUNC Int_t Num_to_Int(double n)
|
||||
|
||||
MACROLIKE PUREFUNC double Int_to_Num(Int_t i)
|
||||
{
|
||||
if (__builtin_expect(i.small & 1, 1))
|
||||
if likely (i.small & 1)
|
||||
return (double)(i.small >> 2);
|
||||
|
||||
return mpz_get_d(*i.big);
|
||||
@ -339,7 +339,7 @@ MACROLIKE PUREFUNC double Int_to_Num(Int_t i)
|
||||
|
||||
#define CONVERSION_FUNC(hi, lo) \
|
||||
MACROLIKE PUREFUNC int##lo##_t Int##hi##_to_Int##lo(int##hi##_t i, bool truncate) { \
|
||||
if (__builtin_expect(!truncate && (i != (int##lo##_t)i), 0)) \
|
||||
if (!truncate && unlikely(i != (int##lo##_t)i)) \
|
||||
fail("Cannot truncate the Int" #hi " %ld to an Int" #lo, (int64_t)i); \
|
||||
return (int##lo##_t)i; \
|
||||
}
|
||||
@ -357,7 +357,7 @@ CONVERSION_FUNC(16, 8)
|
||||
#define CONVERSION_FUNC(num, int_type) \
|
||||
MACROLIKE PUREFUNC int_type##_t num##_to_##int_type(num##_t n, bool truncate) { \
|
||||
num##_t rounded = (num##_t)round((double)n); \
|
||||
if (__builtin_expect(!truncate && (num##_t)(int_type##_t)rounded != rounded, 0)) \
|
||||
if (!truncate && unlikely((num##_t)(int_type##_t)rounded != rounded)) \
|
||||
fail("Cannot truncate the " #num " %g to an " #int_type, (double)rounded); \
|
||||
return (int_type##_t)rounded; \
|
||||
} \
|
||||
|
||||
@ -101,7 +101,7 @@ public Bool_t RNG$bool(RNG_t rng, Num_t p)
|
||||
|
||||
public Int_t RNG$int(RNG_t rng, Int_t min, Int_t max)
|
||||
{
|
||||
if (__builtin_expect(((min.small & max.small) & 1) != 0, 1)) {
|
||||
if (likely(((min.small & max.small) & 1) != 0)) {
|
||||
int32_t r = RNG$int32(rng, (int32_t)(min.small >> 2), (int32_t)(max.small >> 2));
|
||||
return I_small(r);
|
||||
}
|
||||
|
||||
@ -200,7 +200,7 @@ static void Table$set_bucket(Table_t *t, const void *entry, int32_t index, const
|
||||
|
||||
static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const TypeInfo_t *type)
|
||||
{
|
||||
if (__builtin_expect(new_capacity > TABLE_MAX_BUCKETS, 0))
|
||||
if (unlikely(new_capacity > TABLE_MAX_BUCKETS))
|
||||
fail("Table has exceeded the maximum table size (2^31) and cannot grow further!");
|
||||
hdebug("About to resize from %u to %u\n", t->bucket_info ? t->bucket_info->count : 0, new_capacity);
|
||||
hshow(t);
|
||||
@ -252,7 +252,7 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const
|
||||
// Resize buckets if necessary
|
||||
if (t->entries.length >= (int64_t)t->bucket_info->count) {
|
||||
uint32_t newsize = (uint32_t)t->bucket_info->count + MIN((uint32_t)t->bucket_info->count, 64);
|
||||
if (__builtin_expect(newsize > TABLE_MAX_BUCKETS, 0))
|
||||
if (unlikely(newsize > TABLE_MAX_BUCKETS))
|
||||
newsize = t->entries.length + 1;
|
||||
hashmap_resize_buckets(t, newsize, type);
|
||||
}
|
||||
|
||||
@ -187,10 +187,10 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le
|
||||
// that begin with *prefix* modifiers, so we gotta check for that case:
|
||||
synthetic_graphemes[-grapheme_id-1].main_codepoint = length_prefixed[1];
|
||||
for (ucs4_t i = 0; i < utf32_len; i++) {
|
||||
if (!__builtin_expect(uc_is_property_prepended_concatenation_mark(length_prefixed[1+i]), 0)) {
|
||||
synthetic_graphemes[-grapheme_id-1].main_codepoint = length_prefixed[1+i];
|
||||
break;
|
||||
}
|
||||
if (unlikely(uc_is_property_prepended_concatenation_mark(length_prefixed[1+i])))
|
||||
continue;
|
||||
synthetic_graphemes[-grapheme_id-1].main_codepoint = length_prefixed[1+i];
|
||||
break;
|
||||
}
|
||||
|
||||
// Cleanup from unicode API:
|
||||
@ -367,7 +367,7 @@ static Text_t concat2(Text_t a, Text_t b)
|
||||
if (a.length == 0) return b;
|
||||
if (b.length == 0) return a;
|
||||
|
||||
if (__builtin_expect(is_concat_stable(a, b), 1))
|
||||
if (likely(is_concat_stable(a, b)))
|
||||
return concat2_assuming_safe(a, b);
|
||||
|
||||
// Do full normalization of the last/first characters
|
||||
@ -419,7 +419,7 @@ public Text_t Text$_concat(int n, Text_t items[n])
|
||||
if (items[i].length == 0)
|
||||
continue;
|
||||
|
||||
if (i > 0 && !__builtin_expect(is_concat_stable(items[i-1], items[i]), 1)) {
|
||||
if (i > 0 && unlikely(!is_concat_stable(items[i-1], items[i]))) {
|
||||
// Oops, guess this wasn't stable for concatenation, let's break it
|
||||
// up into subtasks:
|
||||
return concat2(ret, Text$_concat(n-i, &items[i]));
|
||||
|
||||
@ -39,6 +39,14 @@
|
||||
#define INLINE inline __attribute__ ((always_inline))
|
||||
#endif
|
||||
|
||||
#ifndef likely
|
||||
#define likely(x) (__builtin_expect(!!(x), 1))
|
||||
#endif
|
||||
|
||||
#ifndef unlikely
|
||||
#define unlikely(x) (__builtin_expect(!!(x), 0))
|
||||
#endif
|
||||
|
||||
// GCC lets you define macro-like functions which are always inlined and never
|
||||
// compiled using this combination of flags. See: https://gcc.gnu.org/onlinedocs/gcc/Inline.html
|
||||
#ifndef MACROLIKE
|
||||
|
||||
Loading…
Reference in New Issue
Block a user