name string | code string | asm string | file string |
|---|---|---|---|
secp256k1_xonly_pubkey_cmp | int secp256k1_xonly_pubkey_cmp(const secp256k1_context* ctx, const secp256k1_xonly_pubkey* pk0, const secp256k1_xonly_pubkey* pk1) {
unsigned char out[2][32];
const secp256k1_xonly_pubkey* pk[2];
int i;
VERIFY_CHECK(ctx != NULL);
pk[0] = pk0; pk[1] = pk1;
for (i = 0; i < 2; i++) {
/* If... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %r15
movb $0x1, %bpl
leaq 0x20(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e0f5
testl %eax, %eax
jne 0x1e289
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
secp256k1_keypair_sec | int secp256k1_keypair_sec(const secp256k1_context* ctx, unsigned char *seckey, const secp256k1_keypair *keypair) {
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(seckey != NULL);
memset(seckey, 0, 32);
ARG_CHECK(keypair != NULL);
memcpy(seckey, &keypair->data[0], 32);
return 1;
} | pushq %rax
testq %rsi, %rsi
je 0x1e767
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
testq %rdx, %rdx
je 0x1e76e
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movl $0x1, %eax
popq %rcx
retq
callq 0x4dad
jmp 0x1e773
callq 0x4d96
xorl %eax, %eax
jmp 0x1e765... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
nonce_function_bip340 | static int nonce_function_bip340(unsigned char *nonce32, const unsigned char *msg, size_t msglen, const unsigned char *key32, const unsigned char *xonly_pk32, const unsigned char *algo, size_t algolen, void *data) {
secp256k1_sha256 sha;
unsigned char masked_key[32];
int i;
if (algo == NULL) {
... | testq %r9, %r9
je 0x1ecdc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
testq %rsi, %rsi
je 0x1ecdf
movaps 0x5041a(%rip), %xmm0 # 0x6f080
movq... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/schnorrsig/main_impl.h |
ecdsa_signature_parse_der_lax | int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
size_t rpos, rlen, spos, slen;
size_t pos = 0;
size_t lenbyte;
unsigned char tmpsig[64] = {0};
int overflow = 0;
/* Hack to initialize sig with a correc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r12, %rdx
callq 0x14bcb
xorl %... | /bitcoin[P]bitcoin/src/secp256k1/src/../contrib/lax_der_parsing.c |
ec_privkey_import_der | int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
const unsigned char *end = privkey + privkeylen;
int lenb = 0;
int len = 0;
memset(out32, 0, 32);
/* sequence header */
if (end < privkey+1 || *privkey != 0x30) {
... | xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
xorl %eax, %eax
testq %rcx, %rcx
jle 0x2607d
cmpb $0x30, (%rdx)
jne 0x2607d
cmpq $0x1, %rcx
je 0x2607d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl 0x1(%rdx), %esi
testb %sil, %sil
jns 0x26076
movq %rdi, %r14
andl $0x7f, %esi
leal -0x3(%rsi), %... | /bitcoin[P]bitcoin/src/secp256k1/src/../contrib/lax_der_privatekey_parsing.c |
run_ellswift_tests | void run_ellswift_tests(void) {
int i = 0;
/* Test vectors. */
for (i = 0; (unsigned)i < sizeof(ellswift_xswiftec_inv_tests) / sizeof(ellswift_xswiftec_inv_tests[0]); ++i) {
const struct ellswift_xswiftec_inv_test *testcase = &ellswift_xswiftec_inv_tests[i];
int c;
for (c = 0; c < 8;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb78, %rsp # imm = 0xB78
leaq 0x57bf4(%rip), %r13 # 0x7dda8
xorl %ebx, %ebx
imulq $0x198, %rbx, %rax # imm = 0x198
leaq 0x57b8c(%rip), %rcx # 0x7dd50
leaq (%rcx,%rax), %r15
leaq (%rax,%rcx), %rdx
addq $0x30, %rdx
movq %rdx,... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/ellswift/tests_impl.h |
testutil_random_ge_test | static void testutil_random_ge_test(secp256k1_ge *ge) {
secp256k1_fe fe;
do {
testutil_random_fe_test(&fe);
if (secp256k1_ge_set_xo_var(ge, &fe, testrand_bits(1))) {
secp256k1_fe_normalize(&ge->y);
break;
}
} while(1);
ge->infinity = 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5f5b1
movq 0x198d36(%rip), %rax # 0x1c0110
movq 0x198d47(%rip), %rcx # 0x1c0128
leaq (%rcx,%rax), %rdx
rolq $0x17, %rdx
addq %rax, %rdx
movq 0x198d25(%rip), %rsi # 0x1c0118
movq %rsi, %rdi
shlq $0x11, %rdi
movq 0x198... | /bitcoin[P]bitcoin/src/secp256k1/src/testutil.h |
secp256k1_ge_eq_var | static int secp256k1_ge_eq_var(const secp256k1_ge *a, const secp256k1_ge *b) {
secp256k1_fe tmp;
SECP256K1_GE_VERIFY(a);
SECP256K1_GE_VERIFY(b);
if (a->infinity != b->infinity) return 0;
if (a->infinity) return 1;
tmp = a->x;
secp256k1_fe_normalize_weak(&tmp);
if (!secp256k1_fe_equal(&... | movl 0x50(%rdi), %ecx
xorl %eax, %eax
cmpl 0x50(%rsi), %ecx
jne 0x274dc
movl $0x1, %eax
testl %ecx, %ecx
je 0x274dd
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x3fffffffffffc, %r15 # imm = 0x3FFFFFFFFFFFC
movabsq $0xffffffffffff, %r12 # imm =... | /bitcoin[P]bitcoin/src/secp256k1/src/group_impl.h |
testutil_random_scalar_order_test | static void testutil_random_scalar_order_test(secp256k1_scalar *num) {
do {
unsigned char b32[32];
int overflow = 0;
testrand256_test(b32);
secp256k1_scalar_set_b32(num, b32, &overflow);
if (overflow || secp256k1_scalar_is_zero(num)) {
continue;
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movl $0x0, 0xc(%rsp)
movl $0x20, %esi
movq %r14, %rdi
callq 0x5f624
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x14c7d
cmpl $0x0, 0xc(%rsp)
jne 0x2768d
movdqu (%rbx), %xmm0
movdqu 0x10(%rbx), %xmm1
po... | /bitcoin[P]bitcoin/src/secp256k1/src/testutil.h |
testutil_random_scalar_order | static void testutil_random_scalar_order(secp256k1_scalar *num) {
do {
unsigned char b32[32];
int overflow = 0;
testrand256(b32);
secp256k1_scalar_set_b32(num, b32, &overflow);
if (overflow || secp256k1_scalar_is_zero(num)) {
continue;
}
break;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movl $0x0, 0xc(%rsp)
movq %r14, %rdi
callq 0x2745b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x14c7d
cmpl $0x0, 0xc(%rsp)
jne 0x27708
movdqu (%rbx), %xmm0
movdqu 0x10(%rbx), %xmm1
por %xmm0, %xmm1
pc... | /bitcoin[P]bitcoin/src/secp256k1/src/testutil.h |
testrand_flip | static void testrand_flip(unsigned char *b, size_t len) {
b[testrand_int(len)] ^= (1 << testrand_bits(3));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1989af(%rip), %rax # 0x1c0110
movq 0x1989c0(%rip), %rdx # 0x1c0128
leaq (%rdx,%rax), %rcx
rolq $0x17, %rcx
addq %rax, %rcx
movq 0x19899e(%rip), %rdi # 0x1c0118
movq %rdi, %r8
shlq $0x11, %r8
movq 0x198998(%rip), %r9 # 0x1c0120
xorq %rax, %r9
xorq %rdi... | /bitcoin[P]bitcoin/src/secp256k1/src/testrand_impl.h |
run_eckey_edge_case_test | static void run_eckey_edge_case_test(void) {
const unsigned char orderc[32] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
};
co... | pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp # imm = 0x230
movaps 0x5d827(%rip), %xmm0 # 0x9b2f0
leaq 0x190(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movdqa 0x5d803(%rip), %xmm0 # 0x9b2e0
movdqa %xmm0, (%rsi)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x180(%rsp)
movdqa %xmm0, 0x170(%rsp)
movdqa %xmm0, 0x160(%rs... | /bitcoin[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_scalar_inverse_var | static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
secp256k1_modinv64_signed62 s;
#ifdef VERIFY
int zero_in = secp256k1_scalar_is_zero(x);
#endif
SECP256K1_SCALAR_VERIFY(x);
secp256k1_scalar_to_signed62(&s, x);
secp256k1_modinv64_var(&s, &secp256k1_const_modi... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq %rsi, %rdi
shldq $0x6, %rdx, %rdi
shldq $0x4, %rcx, %rdx
shldq $0x2, %rax, %rcx
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
andq %r8, %rax
movq %rsp, %r14
movq %... | /bitcoin[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_rfc6979_hmac_sha256_initialize | static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256 *rng, const unsigned char *key, size_t keylen) {
secp256k1_hmac_sha256 hmac;
static const unsigned char zero[1] = {0x00};
static const unsigned char one[1] = {0x01};
memset(rng->v, 0x01, 32); /* RFC6979 3.2.b. */
mem... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movaps 0x252c3(%rip), %xmm0 # 0x6f1a0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rsp, %r14
movl $... | /bitcoin[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_scalar_inverse | static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
secp256k1_modinv64_signed62 s;
#ifdef VERIFY
int zero_in = secp256k1_scalar_is_zero(x);
#endif
SECP256K1_SCALAR_VERIFY(x);
secp256k1_scalar_to_signed62(&s, x);
secp256k1_modinv64(&s, &secp256k1_const_modinfo_scal... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq %rsi, %rdi
shldq $0x6, %rdx, %rdi
shldq $0x4, %rcx, %rdx
shldq $0x2, %rax, %rcx
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
andq %r8, %rax
movq %rsp, %r14
movq %... | /bitcoin[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_gej_rescale | static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *s) {
/* Operations: 4 mul, 1 sqr */
secp256k1_fe zz;
SECP256K1_GEJ_VERIFY(r);
SECP256K1_FE_VERIFY(s);
VERIFY_CHECK(!secp256k1_fe_normalizes_to_zero_var(s));
secp256k1_fe_sqr(&zz, s);
secp256k1_fe_mul(&r->x, &r->x, &zz);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rsi), %rcx
movq 0x8(%rsi), %r10
movq %r10, 0x20(%rsp)
movq 0x18(%rsi), %r14
movq %rsi, %r8
leaq (%rcx,%rcx), %rdx
movq %rdx, 0x60(%rsp)
movq %r14, %rax
movq %r14, 0x38(%rsp)
mulq %rdx
movq %rax, %r9
movq %rdx, %rsi
movq 0x10(%r8),... | /bitcoin[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_impl_normalize_weak | static void secp256k1_fe_impl_normalize_weak(secp256k1_fe *r) {
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
/* The first pass ens... | movq 0x20(%rdi), %rcx
movabsq $0xffffffffffff, %rax # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
movq %rcx, %rdx
shrq $0x30, %rdx
movabsq $0x1000003d1, %rcx # imm = 0x1000003D1
imulq %rdx, %rcx
addq (%rdi), %rcx
movq %rcx, %rdx
shrq $0x34, %rdx
addq 0x8(%rdi), %rdx
movabsq $0xfffffffffffff, %rsi # imm = 0xFFFFFFFFFFF... | /bitcoin[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ecmult_wnaf | static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_scalar *a, int w) {
secp256k1_scalar s;
int last_set_bit = -1;
int bit = 0;
int sign = 1;
int carry = 0;
VERIFY_CHECK(wnaf != NULL);
VERIFY_CHECK(0 <= len && len <= 256);
VERIFY_CHECK(a != NULL);
VERIFY_CHECK(2 <= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
jle 0x53c89
movl %ebp, %edx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rs... | /bitcoin[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_fe_impl_is_square_var | static int secp256k1_fe_impl_is_square_var(const secp256k1_fe *x) {
secp256k1_fe tmp;
secp256k1_modinv64_signed62 s;
int jac, ret;
tmp = *x;
secp256k1_fe_normalize_var(&tmp);
/* secp256k1_jacobi64_maybe_var cannot deal with input 0. */
if (secp256k1_fe_is_zero(&tmp)) return 1;
secp256k1... | pushq %rbx
subq $0x80, %rsp
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1e522
movq (%rbx), %rsi
movq 0x8(%rbx), %r8
movq %r8, %rcx
orq %rsi, %rcx
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %ra... | /bitcoin[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
testrand_int | static uint32_t testrand_int(uint32_t range) {
uint32_t mask = 0;
uint32_t range_copy;
/* Reduce range by 1, changing its meaning to "maximum value". */
VERIFY_CHECK(range != 0);
range -= 1;
/* Count the number of bits in range. */
range_copy = range;
while (range_copy) {
mask = ... | xorl %ecx, %ecx
decl %edi
je 0x5f801
movl %edi, %edx
movl %edi, %eax
leal 0x1(,%rcx,2), %ecx
shrl %eax
cmpl $0x2, %edx
movl %eax, %edx
jae 0x5f7f1
movq 0x160908(%rip), %r9 # 0x1c0110
movq 0x160919(%rip), %r8 # 0x1c0128
movq 0x160902(%rip), %rsi # 0x1c0118
movq 0x160903(%rip), %rdx # 0x1c0120
leaq (%r8,%r9... | /bitcoin[P]bitcoin/src/secp256k1/src/testrand_impl.h |
secp256k1_scratch_destroy | static void secp256k1_scratch_destroy(const secp256k1_callback* error_callback, secp256k1_scratch* scratch) {
if (scratch != NULL) {
if (secp256k1_memcmp_var(scratch->magic, "scratch", 8) != 0) {
secp256k1_callback_call(error_callback, "invalid scratch space");
return;
}
... | testq %rsi, %rsi
je 0x5faf4
xorl %eax, %eax
leaq 0x111a4(%rip), %rcx # 0x70c7f
movb (%rsi,%rax), %dl
cmpb (%rax,%rcx), %dl
jne 0x5faf5
incq %rax
cmpq $0x8, %rax
jne 0x5fadb
movq %rsi, %rdi
jmp 0x1040
retq
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
leaq 0x11184(%rip), %rdi # 0x70c87
jmpq *%rax
| /bitcoin[P]bitcoin/src/secp256k1/src/scratch_impl.h |
test_pre_g_table | static void test_pre_g_table(const secp256k1_ge_storage * pre_g, size_t n) {
/* Tests the pre_g / pre_g_128 tables for consistency.
* For independent verification we take a "geometric" approach to verification.
* We check that every entry is on-curve.
* We check that for consecutive entries p and q, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp # imm = 0x378
movq %rdi, %rsi
leaq 0x1c8(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x1b8(%rsp)
callq 0x48578
movq %rbx, %rdi
callq 0x47703
testl %eax, %eax
je 0x6924b
movl 0x218(%rsp), %eax
movl %eax, 0x298(%rsp)
movups 0x1c8(%r... | /bitcoin[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_ecmult_multi_simple_var | static int secp256k1_ecmult_multi_simple_var(secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points) {
size_t point_idx;
secp256k1_gej tmpj;
secp256k1_gej_set_infinity(r);
secp256k1_gej_set_infinity(&tmpj);
/* r = inp_g_sc*G */
secp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9c8, %rsp # imm = 0x9C8
movq %r8, %r14
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r9
movq %rdi, %r13
movl $0x1, %ebx
movl %ebx, 0x78(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20... | /bitcoin[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_pippenger_batch | static int secp256k1_ecmult_pippenger_batch(const secp256k1_callback* error_callback, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points, size_t cb_offset) {
const size_t scratch_checkpoint = secp256k1_scratch_checkpoint(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, 0x8(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x140(%rsp), %rbx
xorl %eax, %eax
leaq 0x6acc(%rip), %rcx # 0x70c7f
movb (%r13,%rax), %dl
cmpb (... | /bitcoin[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
test_scalar_split | static void test_scalar_split(const secp256k1_scalar* full) {
secp256k1_scalar s, s1, slam;
const unsigned char zero[32] = {0};
unsigned char tmp[32];
secp256k1_scalar_split_lambda(&s1, &slam, full);
/* check slam*lambda + s1 == full */
secp256k1_scalar_mul(&s, &secp256k1_const_lambda, &slam);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x538da
leaq 0x1525b(%rip), %rsi # 0x81288
leaq 0x88(%rsp), %r12
movq %r12, %r... | /bitcoin[P]bitcoin/src/secp256k1/src/tests.c |
void ModulusHelper<unsigned short, char, 1>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned short const&, char const&, unsigned short&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//trap corner case
if (mod_corner_case<U, std::numeric_limits< U >::is_signed >::is_undefined(u))
{
result = 0;
... | movq %rdx, %rcx
movzbl (%rsi), %eax
cmpl $0xff, %eax
je 0xa1b5
testl %eax, %eax
je 0xa1bb
movsbl %al, %esi
movzwl (%rdi), %eax
xorl %edx, %edx
idivl %esi
jmp 0xa1b7
xorl %edx, %edx
movw %dx, (%rcx)
retq
pushq %rax
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<unsigned long, char, 3>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned long const&, char const&, unsigned long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
// u could be negative - if so, need to convert to positive
if(u < 0)
result = (T)(t % AbsValueHelper< U, GetAbsMethod< U >::method... | pushq %r14
pushq %rbx
pushq %rax
movzbl (%rsi), %ecx
testq %rcx, %rcx
je 0xa3bb
movq %rdx, %rbx
movq (%rdi), %r14
testb %cl, %cl
jns 0xa3a8
movsbl %cl, %edi
callq 0x574a
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<char, safeint_exception_handlers::SafeInt_InvalidParameter> operator%<char, long long, safeint_exception_handlers::SafeInt_InvalidParameter>(long long, SafeInt<char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator %( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Value of return depends on sign of lhs
// This one may not be safe - bounds check in constructor
// if lhs is negative and rhs is unsigned, this will throw an exception.
// Fast-track the simple case
... | pushq %rbx
subq $0x10, %rsp
leaq 0x7(%rsp), %rbx
movb $0x0, (%rbx)
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movsbl %sil, %esi
movq %rax, %rdi
callq 0xa3f4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x932a
movb (%rbx), %al
addq $0x10, %rsp
popq %rbx
retq
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<unsigned long long, char, 3>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned long long const&, char const&, unsigned long long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
// u could be negative - if so, need to convert to positive
if(u < 0)
result = (T)(t % AbsValueHelper< U, GetAbsMethod< U >::method... | pushq %r14
pushq %rbx
pushq %rax
movzbl (%rsi), %ecx
testq %rcx, %rcx
je 0xa4c9
movq %rdx, %rbx
movq (%rdi), %r14
testb %cl, %cl
jns 0xa4b6
movsbl %cl, %edi
callq 0x574a
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter> operator+<unsigned char, char, safeint_exception_handlers::SafeInt_InvalidParameter>(char, SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// 16-bit or less - one or both are signed
std::int32_t tmp = lhs + rhs;
if( tmp <= (std::int32_t)std::numeric_limits<T>::max() && tmp >= (std::int32_t)std::numeric_limits<T>::min() )
... | movzbl %sil, %eax
addl %edi, %eax
cmpl $0x100, %eax # imm = 0x100
jae 0xcf58
retq
pushq %rax
callq 0x40b2
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<unsigned char, unsigned char, 0>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned char const&, unsigned char const&, unsigned char&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//trap corner case
if (mod_corner_case<U, std::numeric_limits< U >::is_signed >::is_undefined(u))
{
result = 0;
... | movb (%rsi), %cl
testb %cl, %cl
je 0xd411
movzbl (%rdi), %eax
divb %cl
movzbl %ah, %eax
movb %al, (%rdx)
retq
pushq %rax
callq 0x4876
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void DivisionHelper<unsigned char, unsigned char, 0>::DivideThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned char const&, unsigned char const&, unsigned char&) | SAFEINT_CONSTEXPR14 static void DivideThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if( u == 0 )
E::SafeIntOnDivZero();
if( t == 0 )
{
result = 0;
return;
}
result = (T)( t/u );
} | movb (%rsi), %cl
testb %cl, %cl
je 0xd430
movb (%rdi), %al
testb %al, %al
je 0xd42b
movzbl %al, %eax
divb %cl
jmp 0xd42d
xorl %eax, %eax
movb %al, (%rdx)
retq
pushq %rax
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void AdditionHelper<unsigned char, char, 5>::AdditionThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned char const&, char const&, unsigned char&) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// 16-bit or less - one or both are signed
std::int32_t tmp = lhs + rhs;
if( tmp <= (std::int32_t)std::numeric_limits<T>::max() && tmp >= (std::int32_t)std::numeric_limits<T>::min() )
... | movzbl (%rdi), %ecx
movsbl (%rsi), %eax
addl %ecx, %eax
cmpl $0xff, %eax
ja 0xd448
movb %al, (%rdx)
retq
pushq %rax
callq 0x40b2
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter> operator/<unsigned char, signed char, safeint_exception_handlers::SafeInt_InvalidParameter>(signed char, SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator /( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Corner case - has to be handled seperately
SafeInt< T, E > result;
if( DivisionCornerCaseHelper< T, U, E, (int)DivisionMethod< U, T >::method == (int)DivisionState_UnsignedSigned >::DivisionCornerCase1( lhs, ... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x6(%rsp), %rax
movb %dil, (%rax)
leaq 0x5(%rsp), %rbx
movb $0x0, (%rbx)
leaq 0x4(%rsp), %rcx
movb %sil, (%rcx)
movq %rax, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
callq 0xdbf0
leaq 0x7(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd486
movb (%r14), %al
addq $0x8, %rsp
popq %rbx
... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter> operator+<unsigned char, signed char, safeint_exception_handlers::SafeInt_InvalidParameter>(signed char, SafeInt<unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// 16-bit or less - one or both are signed
std::int32_t tmp = lhs + rhs;
if( tmp <= (std::int32_t)std::numeric_limits<T>::max() && tmp >= (std::int32_t)std::numeric_limits<T>::min() )
... | movzbl %sil, %eax
addl %edi, %eax
cmpl $0x100, %eax # imm = 0x100
jae 0xd6da
retq
pushq %rax
callq 0x40b2
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<unsigned long, unsigned long long, 0>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned long const&, unsigned long long const&, unsigned long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//trap corner case
if (mod_corner_case<U, std::numeric_limits< U >::is_signed >::is_undefined(u))
{
result = 0;
... | movq (%rsi), %rsi
testq %rsi, %rsi
je 0x3d7f1
movq %rdx, %rcx
movq (%rdi), %rax
xorl %edx, %edx
divq %rsi
movq %rdx, (%rcx)
retq
pushq %rax
callq 0x4876
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void DivisionHelper<unsigned long long, unsigned long, 0>::DivideThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned long long const&, unsigned long const&, unsigned long long&) | SAFEINT_CONSTEXPR14 static void DivideThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if( u == 0 )
E::SafeIntOnDivZero();
if( t == 0 )
{
result = 0;
return;
}
result = (T)( t/u );
} | movq (%rsi), %rsi
testq %rsi, %rsi
je 0x3d83e
movq %rdx, %rcx
movq (%rdi), %rax
testq %rax, %rax
je 0x3d838
xorl %edx, %edx
divq %rsi
jmp 0x3d83a
xorl %eax, %eax
movq %rax, (%rcx)
retq
pushq %rax
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<unsigned long, safeint_exception_handlers::SafeInt_InvalidParameter> operator%<unsigned long, char, safeint_exception_handlers::SafeInt_InvalidParameter>(char, SafeInt<unsigned long, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator %( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Value of return depends on sign of lhs
// This one may not be safe - bounds check in constructor
// if lhs is negative and rhs is unsigned, this will throw an exception.
// Fast-track the simple case
... | pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x7(%rsp), %rax
movb %dil, (%rax)
movq %rax, %rdi
callq 0x83c6
movsbl %al, %edi
movq %rbx, %rsi
callq 0xa4ce
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<long, unsigned long, 4>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, unsigned long const&, long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//t could be negative - if so, need to convert to positive
if(t < 0)
result = (T)( ~( AbsValueHelper< T, GetAbsMethod< T >::method ... | pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x3d9da
movq %rdx, %rbx
movq (%rdi), %rax
testq %rax, %rax
js 0x3d9bc
xorl %edx, %edx
divq %rcx
jmp 0x3d9cf
movq %rsi, %r14
movq %rax, %rdi
callq 0x10338
xorl %edx, %edx
divq (%r14)
negq %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
ret... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<unsigned long, safeint_exception_handlers::SafeInt_InvalidParameter> operator%<unsigned long, long long, safeint_exception_handlers::SafeInt_InvalidParameter>(long long, SafeInt<unsigned long, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator %( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Value of return depends on sign of lhs
// This one may not be safe - bounds check in constructor
// if lhs is negative and rhs is unsigned, this will throw an exception.
// Fast-track the simple case
... | pushq %rax
movq %rsp, %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x3da12
testq %rax, %rax
js 0x3da0c
popq %rcx
retq
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<long long, unsigned long, 4>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long long const&, unsigned long const&, long long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//t could be negative - if so, need to convert to positive
if(t < 0)
result = (T)( ~( AbsValueHelper< T, GetAbsMethod< T >::method ... | pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x3da76
movq %rdx, %rbx
movq (%rdi), %rax
testq %rax, %rax
js 0x3da58
xorl %edx, %edx
divq %rcx
jmp 0x3da6b
movq %rsi, %r14
movq %rax, %rdi
callq 0x111da
xorl %edx, %edx
divq (%r14)
negq %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
ret... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void ModulusHelper<unsigned long long, unsigned long, 0>::ModulusThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned long long const&, unsigned long const&, unsigned long long&) | SAFEINT_CONSTEXPR14 static void ModulusThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
E::SafeIntOnDivZero();
//trap corner case
if (mod_corner_case<U, std::numeric_limits< U >::is_signed >::is_undefined(u))
{
result = 0;
... | movq (%rsi), %rsi
testq %rsi, %rsi
je 0x3dad1
movq %rdx, %rcx
movq (%rdi), %rax
xorl %edx, %edx
divq %rsi
movq %rdx, (%rcx)
retq
pushq %rax
callq 0x4876
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void CompiledMixedType<long, int>() | void CompiledMixedType()
{
// Mixed constructors
U u = 0;
T t = 0;
bool b = false;
SafeInt<T> st(u);
SafeInt<U> su(u);
SafeInt<T> st2(su);
// Shut up the compiler
b = !b;
// Assignment
st = t;
st = u;
st = su;
st = st2;
// Casting
U u2 = (U)st;
// Multiplication
t = st * u;
t = st * st2;
t = u *... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x34e00
movq %rbx, %rdi
xorl %esi, %esi
callq 0x415d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3f3ce
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x415ef
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41618
movq %rbx, %rdi... | /dcleblanc[P]SafeInt/Test/CompileTest.cpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter> operator/<long, char, safeint_exception_handlers::SafeInt_InvalidParameter>(char, SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator /( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Corner case - has to be handled seperately
SafeInt< T, E > result;
if( DivisionCornerCaseHelper< T, U, E, (int)DivisionMethod< U, T >::method == (int)DivisionState_UnsignedSigned >::DivisionCornerCase1( lhs, ... | pushq %rbx
subq $0x10, %rsp
movb %dil, 0x6(%rsp)
cmpb $-0x80, %dil
sete %cl
cmpq $-0x1, %rsi
sete %dl
movl $0x80, %eax
testb %dl, %cl
jne 0x3f54f
leaq 0x7(%rsp), %rbx
movb $0x0, (%rbx)
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x6(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x8038
movsbq (%rbx), %rax
addq $0x10... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>& SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>::operator<<=<char>(SafeInt<char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E >& operator <<=( SafeInt< U, E > bits ) SAFEINT_NOTHROW
{
ShiftAssert( !std::numeric_limits< U >::is_signed || (U)bits >= 0 );
ShiftAssert( (U)bits < (int)safeint_internal::int_traits< T >::bitCount );
m_int <<= (U)bits;
return *this;
} | pushq %rax
testb %sil, %sil
js 0x3f8a0
cmpb $0x40, %sil
jae 0x3f8bf
movl %esi, %ecx
shlq %cl, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x33869(%rip), %rdi # 0x73110
leaq 0x33788(%rip), %rsi # 0x73036
leaq 0x54fda(%rip), %rcx # 0x9488f
movl $0x178b, %edx # imm = 0x178B
callq 0x1050
leaq 0x3390b(%... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>& SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>::operator>>=<char>(SafeInt<char, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E >& operator >>=( SafeInt< U, E > bits ) SAFEINT_NOTHROW
{
ShiftAssert( !std::numeric_limits< U >::is_signed || (U)bits >= 0 );
ShiftAssert( (U)bits < (int)safeint_internal::int_traits< T >::bitCount );
m_int >>= (U)bits;
return *this;
} | pushq %rax
testb %sil, %sil
js 0x3fa44
cmpb $0x40, %sil
jae 0x3fa63
movl %esi, %ecx
sarq %cl, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x336c5(%rip), %rdi # 0x73110
leaq 0x335e4(%rip), %rsi # 0x73036
leaq 0x550c0(%rip), %rcx # 0x94b19
movl $0x17b3, %edx # imm = 0x17B3
callq 0x1050
leaq 0x33767(%... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void LargeIntRegMultiply<long, int>::RegMultiplyThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long, int, long*) | SAFEINT_CONSTEXPR14_MULTIPLY static void RegMultiplyThrow( std::int64_t a, std::int32_t b, std::int64_t* pRet ) SAFEINT_CPP_THROW
{
#if SAFEINT_USE_INTRINSICS || SAFEINT_HAS_INT128
if( !MultiplyInt64( a, (std::int64_t)b, pRet ) )
E::SafeIntOnOverflow();
#else
bool aNegative = false;
... | pushq %rax
movslq %esi, %rsi
callq 0x7fd0
testb %al, %al
je 0x3fab9
popq %rax
retq
callq 0x40b2
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void LargeIntRegMultiply<long, long>::RegMultiplyThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, long const&, long*) | SAFEINT_CONSTEXPR14_MULTIPLY static void RegMultiplyThrow( const std::int64_t& a, const std::int64_t& b, std::int64_t* pRet ) SAFEINT_CPP_THROW
{
#if SAFEINT_USE_INTRINSICS || SAFEINT_HAS_INT128
if( !MultiplyInt64( a, b, pRet ) )
E::SafeIntOnOverflow();
#else
bool aNegative = false;
... | pushq %rax
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x7fd0
testb %al, %al
je 0x3fb0e
popq %rax
retq
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void DivisionHelper<long, long, 5>::DivideThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, long const&, long&) | SAFEINT_CONSTEXPR14 static void DivideThrow( const T& t, const U& u, T& result ) SAFEINT_CPP_THROW
{
if(u == 0)
{
E::SafeIntOnDivZero();
}
if( t == 0 )
{
result = 0;
return;
}
// Must test for corner case
if( t == ... | pushq %rax
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x3fb71
movq %rdx, %rcx
movq (%rdi), %rax
testq %rax, %rax
je 0x3fb6a
movq %rax, %rdx
btcq $0x3f, %rdx
movq %rsi, %rdi
notq %rdi
orq %rdx, %rdi
je 0x3fb76
cqto
idivq %rsi
jmp 0x3fb6c
xorl %eax, %eax
movq %rax, (%rcx)
popq %rax
retq
callq 0x4876
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void SubtractionHelper<long, char, 7>::SubtractThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, char const&, long&) | SAFEINT_CONSTEXPR14 static void SubtractThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is an std::int64_t, rhs signed (up to 64-bit)
// we have essentially 4 cases:
//
// 1) lhs positive, rhs positive - overflow not possible
// 2) lhs positive, rhs ... | movq (%rdi), %rcx
movb (%rsi), %sil
movsbq %sil, %rdi
movq %rcx, %rax
subq %rdi, %rax
testq %rcx, %rcx
setns %r8b
testb %dil, %dil
sets %dil
cmpq %rcx, %rax
setl %r9b
andb %dil, %r9b
testb %r8b, %r9b
jne 0x3fc04
testb %sil, %sil
setns %sil
cmpq %rcx, %rax
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
je 0x3fc04
movq %rax, (%r... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void SubtractionHelper<char, long, 18>::SubtractThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(char const&, long const&, long&) | SAFEINT_CONSTEXPR14 static void SubtractThrow( const U& lhs, const T& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is any signed int32 or smaller, rhs is int64
std::int64_t tmp = (std::int64_t)lhs - rhs;
if( ( lhs >= 0 && rhs < 0 && tmp < lhs ) ||
( rhs > 0 && tmp > lhs ) )
... | movsbq (%rdi), %rcx
movq (%rsi), %rsi
movq %rcx, %rax
subq %rsi, %rax
jo 0x3fc8c
testb %cl, %cl
setns %dil
testq %rsi, %rsi
sets %r8b
cmpq %rcx, %rax
setl %r9b
andb %r8b, %r9b
testb %dil, %r9b
jne 0x3fc86
testq %rsi, %rsi
setg %sil
cmpq %rcx, %rax
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
je 0x3fc86
movq %rax, (%rdx)
retq... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>& SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>::operator<<=<signed char>(signed char) | SAFEINT_CONSTEXPR14 SafeInt< T, E >& operator <<=( U bits ) SAFEINT_NOTHROW
{
ShiftAssert( !std::numeric_limits< U >::is_signed || bits >= 0 );
ShiftAssert( bits < (int)safeint_internal::int_traits< T >::bitCount );
m_int <<= bits;
return *this;
} | pushq %rax
testb %sil, %sil
js 0x40066
cmpb $0x40, %sil
jae 0x40085
movl %esi, %ecx
shlq %cl, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x32f97(%rip), %rdi # 0x73004
leaq 0x32fc2(%rip), %rsi # 0x73036
leaq 0x54cc1(%rip), %rcx # 0x94d3c
movl $0x1781, %edx # imm = 0x1781
callq 0x1050
leaq 0x33148(%... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>& SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>::operator>>=<signed char>(signed char) | SAFEINT_CONSTEXPR14 SafeInt< T, E >& operator >>=( U bits ) SAFEINT_NOTHROW
{
ShiftAssert( !std::numeric_limits< U >::is_signed || bits >= 0 );
ShiftAssert( bits < (int)safeint_internal::int_traits< T >::bitCount );
m_int >>= bits;
return *this;
} | pushq %rax
testb %sil, %sil
js 0x4020a
cmpb $0x40, %sil
jae 0x40229
movl %esi, %ecx
sarq %cl, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x32df3(%rip), %rdi # 0x73004
leaq 0x32e1e(%rip), %rsi # 0x73036
leaq 0x54dca(%rip), %rcx # 0x94fe9
movl $0x17a9, %edx # imm = 0x17A9
callq 0x1050
leaq 0x32fa4(%... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void AdditionHelper<long, signed char, 10>::AdditionThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, signed char const&, long&) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is std::int64_t, rhs signed
std::int64_t tmp = (std::int64_t)((std::uint64_t)lhs + (std::uint64_t)rhs);
if( lhs >= 0 )
{
// mixed sign cannot overflow
... | pushq %rax
movq (%rdi), %rcx
movsbq (%rsi), %rsi
movq %rsi, %rax
addq %rcx, %rax
testq %rcx, %rcx
js 0x402e6
testb %sil, %sil
setns %sil
cmpq %rcx, %rax
setl %cl
jmp 0x402f3
testb %sil, %sil
sets %sil
cmpq %rcx, %rax
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
je 0x40300
movq %rax, (%rdx)
popq %rax
retq
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter> operator+<long, unsigned char, safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned char, SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is std::int64_t, rhs unsigned < 64-bit
// Some compilers get optimization-happy, let's thwart them
std::uint64_t tmp = (std::uint64_t)lhs + (std::uint64_t)rhs;
if( (std... | movl %edi, %eax
addq %rsi, %rax
cmpq %rsi, %rax
jl 0x40587
retq
pushq %rax
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void SubtractionHelper<long, unsigned char, 9>::SubtractThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, unsigned char const&, long&) | SAFEINT_CONSTEXPR14 static void SubtractThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is a 64-bit int, rhs unsigned int32 or smaller
// perform test as unsigned to prevent unwanted optimizations
std::uint64_t tmp = (std::uint64_t)lhs - (std::uint64_t)rhs;
... | movq (%rdi), %rcx
movzbl (%rsi), %esi
movq %rcx, %rax
subq %rsi, %rax
cmpq %rcx, %rax
jg 0x40905
movq %rax, (%rdx)
retq
pushq %rax
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>& SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>::operator<<=<short>(short) | SAFEINT_CONSTEXPR14 SafeInt< T, E >& operator <<=( U bits ) SAFEINT_NOTHROW
{
ShiftAssert( !std::numeric_limits< U >::is_signed || bits >= 0 );
ShiftAssert( bits < (int)safeint_internal::int_traits< T >::bitCount );
m_int <<= bits;
return *this;
} | pushq %rax
testw %si, %si
js 0x40d10
cmpw $0x40, %si
jae 0x40d2f
movl %esi, %ecx
shlq %cl, (%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x322ed(%rip), %rdi # 0x73004
leaq 0x32318(%rip), %rsi # 0x73036
leaq 0x54acd(%rip), %rcx # 0x957f2
movl $0x1781, %edx # imm = 0x1781
callq 0x1050
leaq 0x3249e(%rip... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void AdditionHelper<long, short, 10>::AdditionThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, short const&, long&) | SAFEINT_CONSTEXPR14 static void AdditionThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is std::int64_t, rhs signed
std::int64_t tmp = (std::int64_t)((std::uint64_t)lhs + (std::uint64_t)rhs);
if( lhs >= 0 )
{
// mixed sign cannot overflow
... | pushq %rax
movq (%rdi), %rcx
movswq (%rsi), %rsi
movq %rsi, %rax
addq %rcx, %rax
testq %rcx, %rcx
js 0x40f90
testw %si, %si
setns %sil
cmpq %rcx, %rax
setl %cl
jmp 0x40f9d
testw %si, %si
sets %sil
cmpq %rcx, %rax
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
je 0x40faa
movq %rax, (%rdx)
popq %rax
retq
callq 0x40b2
nop
| /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void SubtractionHelper<long, short, 7>::SubtractThrow<safeint_exception_handlers::SafeInt_InvalidParameter>(long const&, short const&, long&) | SAFEINT_CONSTEXPR14 static void SubtractThrow( const T& lhs, const U& rhs, T& result ) SAFEINT_CPP_THROW
{
// lhs is an std::int64_t, rhs signed (up to 64-bit)
// we have essentially 4 cases:
//
// 1) lhs positive, rhs positive - overflow not possible
// 2) lhs positive, rhs ... | movq (%rdi), %rcx
movzwl (%rsi), %esi
movswq %si, %rdi
movq %rcx, %rax
subq %rdi, %rax
testq %rcx, %rcx
setns %r8b
testw %di, %di
sets %dil
cmpq %rcx, %rax
setl %r9b
andb %dil, %r9b
testb %r8b, %r9b
jne 0x40ff6
testw %si, %si
setns %sil
cmpq %rcx, %rax
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
je 0x40ff6
movq %rax, (%rdx)... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter> operator/<long, unsigned short, safeint_exception_handlers::SafeInt_InvalidParameter>(unsigned short, SafeInt<long, safeint_exception_handlers::SafeInt_InvalidParameter>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator /( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Corner case - has to be handled seperately
SafeInt< T, E > result;
if( DivisionCornerCaseHelper< T, U, E, (int)DivisionMethod< U, T >::method == (int)DivisionState_UnsignedSigned >::DivisionCornerCase1( lhs, ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movw %di, 0x4(%rsp)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x4153e
testb %al, %al
je 0x4118a
movq 0x8(%rsp), %rax
jmp 0x411ad
leaq 0x6(%rsp), %r14
andw $0x0, (%r14)
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x4(%rsp), %rdi
movq %r14, %rdx
callq 0x1fcda
mov... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp |
void TestConstExpr::ComparisonTestTU<unsigned char, long>() | void ComparisonTestTU()
{
static bool b1 = LessThanTest<T, U>();
static bool b2 = LessThanEqualTest<T, U>();
static bool b3 = GreaterThanTest<T, U>();
static bool b4 = GreaterThanEqualTest<T, U>();
static bool b5 = EqualTest<T, U>();
static bool b6 = NotEqualTest<T, U>();
} | pushq %rax
movb 0x82765(%rip), %al # 0xdbda8
testb %al, %al
je 0x5968b
movb 0x8276b(%rip), %al # 0xdbdb8
testb %al, %al
je 0x596b4
movb 0x82771(%rip), %al # 0xdbdc8
testb %al, %al
je 0x596e0
movb 0x82773(%rip), %al # 0xdbdd8
testb %al, %al
je 0x59710
movb 0x82775(%rip), %al # 0xdbde8
testb %al,... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
void TestConstExpr::ComparisonTestTU<unsigned char, long long>() | void ComparisonTestTU()
{
static bool b1 = LessThanTest<T, U>();
static bool b2 = LessThanEqualTest<T, U>();
static bool b3 = GreaterThanTest<T, U>();
static bool b4 = GreaterThanEqualTest<T, U>();
static bool b5 = EqualTest<T, U>();
static bool b6 = NotEqualTest<T, U>();
} | pushq %rax
movb 0x82565(%rip), %al # 0xdbe68
testb %al, %al
je 0x5994b
movb 0x8256b(%rip), %al # 0xdbe78
testb %al, %al
je 0x59974
movb 0x82571(%rip), %al # 0xdbe88
testb %al, %al
je 0x599a0
movb 0x82573(%rip), %al # 0xdbe98
testb %al, %al
je 0x599d0
movb 0x82575(%rip), %al # 0xdbea8
testb %al,... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
void TestConstExpr::ComparisonTestTU<unsigned char, unsigned long long>() | void ComparisonTestTU()
{
static bool b1 = LessThanTest<T, U>();
static bool b2 = LessThanEqualTest<T, U>();
static bool b3 = GreaterThanTest<T, U>();
static bool b4 = GreaterThanEqualTest<T, U>();
static bool b5 = EqualTest<T, U>();
static bool b6 = NotEqualTest<T, U>();
} | pushq %rax
movb 0x82465(%rip), %al # 0xdbec8
testb %al, %al
je 0x59aab
movb 0x8246b(%rip), %al # 0xdbed8
testb %al, %al
je 0x59ad4
movb 0x82471(%rip), %al # 0xdbee8
testb %al, %al
je 0x59b00
movb 0x82473(%rip), %al # 0xdbef8
testb %al, %al
je 0x59b30
movb 0x82475(%rip), %al # 0xdbf08
testb %al,... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, char>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x7(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x59c3b
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x59c3b
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<unsigned char, char>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x7(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jb 0x59cc4
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
ja 0x59cc4
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned char, char>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jne 0x59e9a
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jne 0x59e9a
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<unsigned char, signed char>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x7(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jb 0x5a06c
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
ja 0x5a06c
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, short>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x5(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x5a71b
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x5a71b
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::NotEqualTest<unsigned char, short>() | SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xd(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
je 0x5aa1d
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
je 0x5aa1d
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
lea... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned char, unsigned short>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xd(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jne 0x5ad18
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jne 0x5ad18
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned char, int>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %rbx
subq $0x20, %rsp
leaq 0x1c(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xb(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jne 0x5b012
leaq 0x18(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xa(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jne 0x5b012
leaq 0x14(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x9(%rs... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, unsigned int>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x5b134
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x5b134
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanTest<unsigned char, unsigned int>() | SAFEINT_CONSTEXPR11 bool GreaterThanTest()
{
return
(U)2 > SafeInt<T>(3) &&
SafeInt<T>(4) > (U)5 &&
SafeInt<T>(6) > SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x1, (%rbx)
ja 0x5b240
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x6, (%rbx)
jb 0x5b240
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned char, unsigned int>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xb(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jne 0x5b387
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xa(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jne 0x5b387
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x5b4ad
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x5b4ad
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x1(%rsp), %... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, long long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x5bb1b
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x5bb1b
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x1(%rsp), %... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<unsigned char, long long>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jb 0x5bb82
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
ja 0x5bb82
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x1(%rsp), %... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanEqualTest<unsigned char, long long>() | SAFEINT_CONSTEXPR11 bool GreaterThanEqualTest()
{
return
(U)2 >= SafeInt<T>(3) &&
SafeInt<T>(4) >= (U)5 &&
SafeInt<T>(6) >= SafeInt<U>(7);
} | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x3(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
ja 0x5bc50
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x2(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jb 0x5bc50
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x1(%rsp), %... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned char, unsigned long long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x1c(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x3, (%rbx)
jb 0x5be10
leaq 0x18(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x4, (%rbx)
ja 0x5be10
leaq 0x14(%rsp), %rsi
movl $0x6, (%rsi)
lea... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanTest<unsigned char, unsigned long long>() | SAFEINT_CONSTEXPR11 bool GreaterThanTest()
{
return
(U)2 > SafeInt<T>(3) &&
SafeInt<T>(4) > (U)5 &&
SafeInt<T>(6) > SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x1c(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x1, (%rbx)
ja 0x5bf1c
leaq 0x18(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x6, (%rbx)
jb 0x5bf1c
leaq 0x14(%rsp), %rsi
movl $0x6, (%rsi)
lea... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned char, unsigned long long>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x1c(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x7(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x2, (%rbx)
jne 0x5c063
leaq 0x18(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x563e
cmpb $0x5, (%rbx)
jne 0x5c063
leaq 0x14(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<short, char>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jl 0x5d73f
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jg 0x5d73f
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanEqualTest<short, char>() | SAFEINT_CONSTEXPR11 bool GreaterThanEqualTest()
{
return
(U)2 >= SafeInt<T>(3) &&
SafeInt<T>(4) >= (U)5 &&
SafeInt<T>(6) >= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jg 0x5d851
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jl 0x5d851
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<short, char>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jne 0x5d917
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jne 0x5d917
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<short, signed char>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jl 0x5daeb
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jg 0x5daeb
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanTest<short, signed char>() | SAFEINT_CONSTEXPR11 bool GreaterThanTest()
{
return
(U)2 > SafeInt<T>(3) &&
SafeInt<T>(4) > (U)5 &&
SafeInt<T>(6) > SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x1, (%rbx)
jg 0x5db74
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x6, (%rbx)
jl 0x5db74
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanEqualTest<short, signed char>() | SAFEINT_CONSTEXPR11 bool GreaterThanEqualTest()
{
return
(U)2 >= SafeInt<T>(3) &&
SafeInt<T>(4) >= (U)5 &&
SafeInt<T>(6) >= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jg 0x5dbfd
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jl 0x5dbfd
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<short, signed char>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jne 0x5dcc3
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jne 0x5dcc3
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::NotEqualTest<short, signed char>() | SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
je 0x5dd67
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
je 0x5dd67
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
lea... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<short, unsigned char>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x3, (%rbx)
jl 0x5de10
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x4, (%rbx)
jg 0x5de10
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanEqualTest<short, unsigned char>() | SAFEINT_CONSTEXPR11 bool LessThanEqualTest()
{
return
(U)2 <= SafeInt<T>(3) &&
SafeInt<T>(4) <= (U)5 &&
SafeInt<T>(6) <= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jl 0x5de9b
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jg 0x5de9b
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanTest<short, unsigned char>() | SAFEINT_CONSTEXPR11 bool GreaterThanTest()
{
return
(U)2 > SafeInt<T>(3) &&
SafeInt<T>(4) > (U)5 &&
SafeInt<T>(6) > SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x1, (%rbx)
jg 0x5df26
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x6, (%rbx)
jl 0x5df26
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::NotEqualTest<short, unsigned char>() | SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x24(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0xe(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
je 0x5e11f
leaq 0x20(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
je 0x5e11f
leaq 0x1c(%rsp), %rsi
movl $0x6, (%rsi)
lea... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::GreaterThanEqualTest<short, unsigned short>() | SAFEINT_CONSTEXPR11 bool GreaterThanEqualTest()
{
return
(U)2 >= SafeInt<T>(3) &&
SafeInt<T>(4) >= (U)5 &&
SafeInt<T>(6) >= SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x2, (%rbx)
jg 0x5e705
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x5eea
cmpw $0x5, (%rbx)
jl 0x5e705
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned long long, unsigned int>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x1c(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x3, (%rbx)
jb 0x71dc2
leaq 0x18(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x4, (%rbx)
ja 0x71dc2
leaq 0x14(%rsp), %rsi
movl $0x6, (%rsi)
l... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned long long, long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %rbx
subq $0x30, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x3, (%rbx)
jb 0x7214c
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x4, (%rbx)
ja 0x7214c
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x18(%rs... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::NotEqualTest<unsigned long long, long>() | SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
} | pushq %rbx
subq $0x40, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x2, (%rbx)
je 0x723b2
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x5, (%rbx)
je 0x723b2
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x28(%rs... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned long long, unsigned long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x3, (%rbx)
jb 0x72456
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x4, (%rbx)
ja 0x72456
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
le... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::EqualTest<unsigned long long, long long>() | SAFEINT_CONSTEXPR11 bool EqualTest()
{
return
(U)2 == SafeInt<T>(3) &&
SafeInt<T>(4) == (U)5 &&
SafeInt<T>(6) == SafeInt<U>(7) &&
true == SafeInt<T>(1) &&
false == SafeInt<T>(0);
} | pushq %rbx
subq $0x40, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x2, (%rbx)
jne 0x729bd
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x5, (%rbx)
jne 0x729bd
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
leaq 0x28(%... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
bool TestConstExpr::LessThanTest<unsigned long long, unsigned long long>() | SAFEINT_CONSTEXPR11 bool LessThanTest()
{
return
(U)2 < SafeInt<T>(3) &&
SafeInt<T>(4) < (U)5 &&
SafeInt<T>(6) < SafeInt<U>(7);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x14(%rsp), %rsi
movl $0x3, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x3, (%rbx)
jb 0x72ae6
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x9bf4
cmpq $0x4, (%rbx)
ja 0x72ae6
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
le... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.