name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_des3_crypt_cbc | int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
testb $0x7, %r12b
je 0x5577
pushq $-0x32
popq %rax
jmp 0x5604
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbp
cmpl $0x1, %esi
jne 0x55c7
testq %r12, %r12
je 0x5602
xorl %eax, %eax
cmpq $0x8, %rax
je 0x55a5
movb (%... | /project-everest[P]mbedtls/library/des.c |
mbedtls_des_self_test | int mbedtls_des_self_test( int verbose )
{
int i, j, u, v, ret = 0;
mbedtls_des_context ctx;
mbedtls_des3_context ctx3;
unsigned char buf[8];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[8];
unsigned char iv[8];
#endif
mbedtls_des_init( &ctx );
mbedtls_des3_init( &ctx3 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %edi, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x50(%rbx)
mov... | /project-everest[P]mbedtls/library/des.c |
main | int main()
{
diy::MemoryBuffer bb;
std::cout << "Position: " << bb.position << std::endl;
{
std::vector<Point> points;
Point p; p[0] = p[1] = p[2] = 5;
points.push_back(p);
p[0] = 1;
points.push_back(p);
p[2] = 1;
points.push_back(p);
save(bb, points);
}
std::cout << "Posi... | subq $0x1d8, %rsp # imm = 0x1D8
movl $0x0, 0x1d4(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x188(%rsp), %rdi
callq 0x2a30
movq 0x10cde(%rip), %rdi # 0x12fd8
leaq 0xad47(%rip), %rsi # 0xd048
callq 0x20d0
movq %rax, 0xd8(%rsp)
jmp 0x2310
movq 0xd8(%rsp), %rdi
movq 0x190(%rsp), %rsi
callq 0x2040
movq ... | /diatomic[P]diy/examples/serialization/test-serialization.cpp |
PropTestSlowFunction::check(std::vector<int, std::allocator<int>> const&) const | bool check(const std::vector<int>& v) const override {
if (shrinking) {
std::cout << "Sleeping..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
if (v.size() >= 4 && (v[3] % 5) == 1) {
shrinking = true;
return false;
}
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x26070
testb $0x1, %al
jne 0x1e857
jmp 0x1e89a
movq 0x1675a(%rip), %rdi # 0x34fb8
leaq 0xdbb0(%rip), %rsi # 0x2c415
callq 0x1d210
movq %rax, %rdi
movq 0x16734(%rip), %rsi # 0x34fa... | /philipp-classen[P]CppQuickCheck/examples/src/TestSlowShrinking.cpp |
roaring_bitmap_maximum | uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *bm) {
if (bm->high_low_container.size > 0) {
container_t *container =
bm->high_low_container.containers[bm->high_low_container.size - 1];
uint8_t typecode =
bm->high_low_container.typecodes[bm->high_low_container.size - ... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x14e8a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx... | /RoaringBitmap[P]CRoaring/src/roaring.c |
roaring_bitmap_remove | void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t val) {
const uint16_t hb = val >> 16;
const int i = ra_get_index(&r->high_low_container, hb);
uint8_t typecode;
if (i >= 0) {
ra_unshare_container_at_index(&r->high_low_container, (uint16_t)i);
container_t *container = ra_get_conta... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
shrl $0x10, %eax
movw %ax, 0x2a(%rsp)
movq 0x30(%rsp), %rdi
movzwl 0x2a(%rsp), %esi
callq 0x226e0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x15712
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movzwl %ax, %esi
callq 0x14080
movq 0x30... | /RoaringBitmap[P]CRoaring/src/roaring.c |
container_nonzero_cardinality | static inline bool container_nonzero_cardinality(const container_t *c,
uint8_t typecode) {
c = container_unwrap_shared(c, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE:
return bitset_container_const_nonzero_cardinality(
... | subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x1cc50
movq %rax, 0x8(%rsp)
movzbl 0x7(%rsp), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x1585f
jmp 0x15853
movl (%rsp), %eax
subl $0x2, %eax
je 0x15871
jmp 0x1585d
jmp 0x15883
movq 0x8(%rsp), %rdi
... | /RoaringBitmap[P]CRoaring/include/roaring/containers/containers.h |
roaring_bitmap_andnot_inplace | void roaring_bitmap_andnot_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2) {
assert(x1 != x2);
uint8_t result_type = 0;
int length1 = x1->high_low_container.size;
const int length2 = x2->high_low_container.size;
int intersection_size = 0;
if (0 == l... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
xorl %eax, %eax
cmpl 0x3c(%rsp), %eax
jne 0x19efe
jmp 0x1a1cb
xorl %eax, %eax
cmpl 0x40(%rs... | /RoaringBitmap[P]CRoaring/src/roaring.c |
container_add_offset | static inline void container_add_offset(const container_t *c, uint8_t type,
container_t **lo, container_t **hi,
uint16_t offset) {
assert(offset != 0);
assert(container_nonzero_cardinality(c, type));
assert(lo != NULL || hi != N... | subq $0x28, %rsp
movw %r8w, %ax
movq %rdi, 0x20(%rsp)
movb %sil, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movw %ax, 0x6(%rsp)
movzbl 0x1f(%rsp), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x1ccdc
jmp 0x1ccd0
movl (%rsp), %eax
subl $0x2, %eax
je 0x1ccf7
jmp 0x1ccda
jmp 0x1cd12
movq 0x20(%rsp), %rdi
movq 0x10... | /RoaringBitmap[P]CRoaring/include/roaring/containers/containers.h |
container_get_index | static inline int container_get_index(const container_t *c, uint8_t type,
uint16_t x) {
c = container_unwrap_shared(c, &type);
switch (type) {
case BITSET_CONTAINER_TYPE:
return bitset_container_get_index(const_CAST_bitset(c), x);
case ARRAY_CONT... | subq $0x18, %rsp
movw %dx, %ax
movb %sil, %cl
movq %rdi, 0x8(%rsp)
movb %cl, 0x7(%rsp)
movw %ax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x1cc50
movq %rax, 0x8(%rsp)
movzbl 0x7(%rsp), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x1de97
jmp 0x1de8b
movl (%rsp), %eax
subl $0x2, %eax
je 0x1deac
jmp 0x1de95... | /RoaringBitmap[P]CRoaring/include/roaring/containers/containers.h |
ra_append_copy | void ra_append_copy(roaring_array_t *ra, const roaring_array_t *sa,
uint16_t index, bool copy_on_write) {
extend_array(ra, 1);
const int32_t pos = ra->size;
// old contents is junk that does not need freeing
ra->keys[pos] = sa->keys[index];
// the shared container will be in two... | subq $0x18, %rsp
movb %cl, %al
movw %dx, %cx
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movw %cx, 0x6(%rsp)
andb $0x1, %al
movb %al, 0x5(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x22f50
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzwl 0x6(%rsp), %ecx
m... | /RoaringBitmap[P]CRoaring/src/roaring_array.c |
store_unique_xor | static inline int store_unique_xor(__m128i old, __m128i newval,
uint16_t *output) {
__m128i vecTmp1 = _mm_alignr_epi8(newval, old, 16 - 4);
__m128i vecTmp2 = _mm_alignr_epi8(newval, old, 16 - 2);
__m128i equalleft = _mm_cmpeq_epi16(vecTmp2, vecTmp1);
__m128i equalright... | subq $0x128, %rsp # imm = 0x128
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa %xmm1, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovdqa 0x20(%rsp), %xmm1
vpalignr $0xc, %xmm1, %xmm0, %xmm0 # xmm0 = xmm1[12,13,14,15],xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovd... | /RoaringBitmap[P]CRoaring/src/array_util.c |
memequals | bool memequals(const void *s1, const void *s2, size_t n) {
if (n == 0) {
return true;
}
#if CROARING_IS_X64
int support = croaring_hardware_support();
#if CROARING_COMPILER_SUPPORTS_AVX512
if (support & ROARING_SUPPORTS_AVX512) {
return _avx512_memequals(s1, s2, n);
} else
#endif //... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2af22
movb $0x1, 0x27(%rsp)
jmp 0x2af9b
callq 0x7d800
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2af53
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0... | /RoaringBitmap[P]CRoaring/src/array_util.c |
array_container_validate | bool array_container_validate(const array_container_t *v, const char **reason) {
if (v->capacity < 0) {
*reason = "negative capacity";
return false;
}
if (v->cardinality < 0) {
*reason = "negative cardinality";
return false;
}
if (v->cardinality > v->capacity) {
... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x31dee
movq -0x18(%rsp), %rax
leaq 0x56270(%rip), %rcx # 0x88051
movq %rcx, (%rax)
movb $0x0, -0x1(%rsp)
jmp 0x31f29
movq -0x10(%rsp), %rax
cmpl $0x0, (%rax)
jge 0x31e11
movq -0x18(%rsp), %rax
leaq 0x5625f(%rip), %rcx ... | /RoaringBitmap[P]CRoaring/src/containers/array.c |
array_container_is_subset | bool array_container_is_subset(const array_container_t *container1,
const array_container_t *container2) {
if (container1->cardinality > container2->cardinality) {
return false;
}
int i1 = 0, i2 = 0;
while (i1 < container1->cardinality && i2 < container2->cardinali... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jle 0x32044
movb $0x0, -0x1(%rsp)
jmp 0x32122
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x10(%rsp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x21(%rsp... | /RoaringBitmap[P]CRoaring/src/containers/array.c |
bitset_container_create | bitset_container_t *bitset_container_create(void) {
bitset_container_t *bitset =
(bitset_container_t *)roaring_malloc(sizeof(bitset_container_t));
if (!bitset) {
return NULL;
}
size_t align_size = 32;
#if CROARING_IS_X64
int support = croaring_hardware_support();
if (support & ... | subq $0x28, %rsp
movl $0x10, %edi
callq 0x12e00
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x32739
movq $0x0, 0x20(%rsp)
jmp 0x327bb
movq $0x20, 0x10(%rsp)
callq 0x7d800
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x32762
movq $0x40, 0x10(%rsp)
jmp 0x3276b
movq $0x20, 0x10(%rsp)
mo... | /RoaringBitmap[P]CRoaring/src/containers/bitset.c |
bitset_container_intersect | bool bitset_container_intersect(const bitset_container_t *src_1,
const bitset_container_t *src_2) {
// could vectorize, but this is probably already quite fast in practice
const uint64_t *__restrict__ words_1 = src_1->words;
const uint64_t *__restrict__ words_2 = src_2->words... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpl $0x400, -0x2c(%rsp) # imm = 0x400
jge 0x33090
movq -0x20(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movq (%rax,%rc... | /RoaringBitmap[P]CRoaring/src/containers/bitset.c |
container_mutable_unwrap_shared | static inline container_t *container_mutable_unwrap_shared(container_t *c,
uint8_t *type) {
if (*type == SHARED_CONTAINER_TYPE) { // the passed in container is shared
*type = CAST_shared(c)->typecode;
assert(*type != SHARED_CONTAINER_TYPE);... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x4, %eax
jne 0x6e8e5
movq -0x10(%rsp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x6e8ef
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
... | /RoaringBitmap[P]CRoaring/include/roaring/containers/containers.h |
array_container_try_add | static inline int array_container_try_add(array_container_t *arr,
uint16_t value,
int32_t max_cardinality) {
const int32_t cardinality = arr->cardinality;
// best case, we can append.
if ((array_container_empty(arr) || arr-... | subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x726c0
testb $0x1, %al
jne 0x724ee
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
m... | /RoaringBitmap[P]CRoaring/include/roaring/containers/array.h |
run_container_cardinality | int run_container_cardinality(const run_container_t *run) {
#if CROARING_COMPILER_SUPPORTS_AVX512
if (croaring_hardware_support() & ROARING_SUPPORTS_AVX512) {
return _avx512_run_container_cardinality(run);
} else
#endif
if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) {
return _a... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
callq 0x7d800
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7b666
movq 0x8(%rsp), %rdi
callq 0x7cf50
movl %eax, 0x14(%rsp)
jmp 0x7b691
callq 0x7d800
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7b683
movq 0x8(%rsp), %rdi
callq 0x7d310
movl %eax, 0x14(%rsp)
jmp 0x7b691
movq 0x8(%rsp), %rdi
callq 0x7... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_iterate | bool run_container_iterate(const run_container_t *cont, uint32_t base,
roaring_iterator iterator, void *ptr) {
for (int i = 0; i < cont->n_runs; ++i) {
uint32_t run_start = base + cont->runs[i].value;
uint16_t le = cont->runs[i].length;
for (int j = 0; j <= le; ++... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x7c174
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movzwl (%rcx,%rdx,4), %ecx
addl %... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_get_index | int run_container_get_index(const run_container_t *container, uint16_t x) {
if (run_container_contains(container, x)) {
int sum = 0;
uint32_t x32 = x;
for (int i = 0; i < container->n_runs; i++) {
uint32_t startpoint = container->runs[i].value;
uint32_t length = conta... | subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq 0x28(%rsp), %rdi
movzwl 0x26(%rsp), %esi
callq 0x79760
testb $0x1, %al
jne 0x7c729
jmp 0x7c7e6
movl $0x0, 0x20(%rsp)
movzwl 0x26(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx),... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
add_symbol_value | static void add_symbol_value(ListNode * const symbol_map_head,
const char * const symbol_names[],
const size_t number_of_symbol_names,
const void* value, const int refcount) {
const char* symbol_name;
ListNode *target_node;
... | subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xa5e2(%rip), %rsi # 0x88cc9
leaq 0x9fe6(%rip), %rdx # 0x886d4
movl $0x2ee, %ecx # imm = 0x2EE
callq 0x... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
check_in_range | static int check_in_range(const LargestIntegralType value,
const LargestIntegralType check_value_data) {
CheckIntegerRange * const check_integer_range =
cast_largest_integral_type_to_pointer(CheckIntegerRange*,
check_value_data);
as... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x9f18(%rip), %rsi # 0x88cea
leaq 0x98fb(%rip), %rdx # 0x886d4
movl $0x5a5, %ecx # imm = 0x5A5
callq 0x7e610
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rsi
movq (... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
expect_memory_setup | static void expect_memory_setup(
const char* const function, const char* const parameter,
const char* const file, const int line,
const void * const memory, const size_t size,
const CheckParameterValue check_function, const int count) {
CheckMemoryData * const check_data =
(C... | subq $0x58, %rsp
movl 0x68(%rsp), %eax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
callq 0x22f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x18(... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
cmprintf_group_finish | static void cmprintf_group_finish(const char *group_name,
size_t total_executed,
size_t total_passed,
size_t total_failed,
size_t total_errors,
size_t... | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x808b0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x81c53
movq (%rsp), %rax
leaq 0x6... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
free_allocated_blocks | static void free_allocated_blocks(const ListNode * const check_point) {
const ListNode * const head = get_allocated_blocks_list();
const ListNode *node;
assert_non_null(check_point);
node = check_point->next;
assert_non_null(node);
while (node != head) {
const MallocBlockInfo block_inf... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x803f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x5055(%rip), %rsi # 0x89184
leaq 0x459e(%rip), %rdx # 0x886d4
movl $0x86b, %ecx # imm = 0x86B
callq 0x7e610
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
remove_always_return_values_from_list | static void remove_always_return_values_from_list(ListNode * const map_head)
{
ListNode * current = NULL;
ListNode * next = NULL;
assert_non_null(map_head);
for (current = map_head->next, next = current->next;
current != map_head;
current = next, next = current->next) {
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rdi
leaq 0x47ca(%rip), %rsi # 0x88cd0
leaq 0x41c7(%rip), %rdx # 0x886d4
movl $0x34c, %ecx # imm = 0x34C
callq 0x7e610
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax... | /RoaringBitmap[P]CRoaring/build_O0/_deps/cmocka-src/src/cmocka.c |
MapWrapper::freeAllItems() | void freeAllItems() {
for (auto& entry : map) {
delete entry.second;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2c42
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x2c38
movq %r14, %rdi
callq 0x2c4a
movq %r14, %rdi
callq 0x2200
jmp 0x2c1f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /greensky00[P]latency-collector/src/latency_collector.h |
MapWrapper::addItem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | LatencyItem* addItem(const std::string& bin_name) {
LatencyItem* item = new LatencyItem(bin_name);
map.insert( std::make_pair(bin_name, item) );
return item;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x2220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x398e
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %rbx, 0x20(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a0c
mov... | /greensky00[P]latency-collector/src/latency_collector.h |
main | int main(int argc, const char* argv[]) {
if (argc < 3) {
Usage(argv);
return EXIT_FAILURE;
}
const std::string input_path = argv[1];
const std::string output_path = argv[2];
libwebm::VpxPes2Ts converter(input_path, output_path);
return converter.ConvertToFile() == true ? EXIT_SUCCESS : EXIT_FAILUR... | pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0xba44
movq (%rbx), %rsi
leaq 0x115ce(%rip), %rdi # 0x1d004
xorl %eax, %eax
callq 0xb050
movl $0x1, %eax
jmp 0xbabc
movq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xb0c0
movq 0x10(%rbx), %rsi
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx... | /webmproject[P]libwebm/m2ts/vpxpes2ts_main.cc |
libwebm::Webm2Pes::~Webm2Pes() | ~Webm2Pes() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0xbcd3
callq 0xb180
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xbce1
callq 0xb190
movq $0x0, 0x68(%rbx)
leaq 0x48(%rbx), %rdi
callq 0x1cb34
leaq 0x40(%rbx), %rdi
callq 0xbd22
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xbd0d
callq ... | /webmproject[P]libwebm/m2ts/webm2pes.h |
libwebm::Webm2Pes::Webm2Pes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, libwebm::PacketReceiverInterface*) | Webm2Pes(const std::string& input_file, PacketReceiverInterface* packet_sink)
: input_file_name_(input_file), packet_sink_(packet_sink) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xbc00
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
leaq ... | /webmproject[P]libwebm/m2ts/webm2pes.h |
libwebm::VpxPesParser::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool VpxPesParser::Open(const std::string& pes_file) {
pes_file_size_ = static_cast<size_t>(libwebm::GetFileSize(pes_file));
if (pes_file_size_ <= 0)
return false;
pes_file_data_.reserve(static_cast<size_t>(pes_file_size_));
libwebm::FilePtr file = libwebm::FilePtr(std::fopen(pes_file.c_str(), "rb"),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xe63a
movq %rax, 0x38(%r14)
testq %rax, %rax
je 0xc78e
leaq 0x58(%r14), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xc5c8
movq (%rbx), %rdi
leaq 0x10b52(%rip), %rsi # 0x1d24c
callq 0xb1f0
m... | /webmproject[P]libwebm/m2ts/vpxpes_parser.cc |
libwebm::VpxPesParser::ParsePesHeader(libwebm::VpxPesParser::PesHeader*) | bool VpxPesParser::ParsePesHeader(PesHeader* header) {
if (!header || parse_state_ != kParsePesHeader)
return false;
if (!VerifyPacketStartCode())
return false;
std::size_t pos = read_pos_;
for (auto& a : header->start_code) {
a = pes_file_data_[pos++];
}
// PES Video stream IDs start at E0.
... | testq %rsi, %rsi
je 0xc8a8
cmpl $0x1, 0x78(%rdi)
jne 0xc8a8
movq 0x70(%rdi), %rax
leaq 0x2(%rax), %rcx
movq 0x58(%rdi), %rdx
movq 0x60(%rdi), %r8
subq %rdx, %r8
cmpq %r8, %rcx
ja 0xc8a8
cmpb $0x0, (%rdx,%rax)
jne 0xc8a8
cmpb $0x0, 0x1(%rdx,%rax)
jne 0xc8a8
cmpb $0x1, (%rdx,%rcx)
jne 0xc8a8
xorl %ecx, %ecx
movq 0x58(%rd... | /webmproject[P]libwebm/m2ts/vpxpes_parser.cc |
libwebm::VpxPesParser::FindStartCode(unsigned long, unsigned long*) const | bool VpxPesParser::FindStartCode(std::size_t origin,
std::size_t* offset) const {
if (read_pos_ + 2 >= pes_file_size_)
return false;
const std::size_t length = pes_file_size_ - origin;
if (length < 3)
return false;
const uint8_t* const data = &pes_file_data_[origin];
... | movq 0x38(%rdi), %rcx
movq 0x70(%rdi), %rax
addq $0x2, %rax
cmpq %rcx, %rax
jae 0xccec
movq %rcx, %rax
subq %rsi, %rax
cmpq $0x3, %rax
jb 0xccec
addq $-0x3, %rax
setne %al
je 0xccee
movq 0x58(%rdi), %rax
addq $-0x3, %rcx
cmpb $0x0, (%rax,%rsi)
jne 0xcce4
cmpb $0x0, 0x1(%rax,%rsi)
jne 0xcce4
cmpb $0x1, 0x2(%rax,%rsi)
je... | /webmproject[P]libwebm/m2ts/vpxpes_parser.cc |
libwebm::VpxPesParser::ParseNextPacket(libwebm::VpxPesParser::PesHeader*, libwebm::VideoFrame*) | bool VpxPesParser::ParseNextPacket(PesHeader* header, VideoFrame* frame) {
if (!header || !frame || parse_state_ != kFindStartCode ||
BytesAvailable() == 0) {
return false;
}
std::size_t packet_start_pos = read_pos_;
if (!FindStartCode(read_pos_, &packet_start_pos)) {
return false;
}
parse_st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0xcea9
movq %rdi, %rbx
cmpl $0x0, 0x78(%rdi)
je 0xceba
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq... | /webmproject[P]libwebm/m2ts/vpxpes_parser.cc |
libwebm::PesOptionalHeader::SetPtsBits(long) | void PesOptionalHeader::SetPtsBits(std::int64_t pts_90khz) {
// PTS is broken up and stored in 40 bits as shown:
//
// PES PTS Only flag
// / Marker Marker Marker
// | / / /
// | | ... | movl %esi, %eax
shrl $0x6, %eax
andl $0xfffe00, %eax # imm = 0xFFFE00
movl %esi, %ecx
shll $0x19, %ecx
movl %esi, %edx
shll $0x9, %edx
andl $0xff0000, %edx # imm = 0xFF0000
orl %ecx, %edx
orl %eax, %edx
movl %esi, %eax
shrl $0x16, %eax
movzbl %al, %eax
orl %edx, %eax
shlq $0x8, %rax
shrq $0x1d, %rsi
and... | /webmproject[P]libwebm/m2ts/webm2pes.cc |
libwebm::PesOptionalHeader::Write(bool, std::vector<unsigned char, std::allocator<unsigned char>>*) const | bool PesOptionalHeader::Write(bool write_pts, PacketDataBuffer* buffer) const {
if (buffer == nullptr) {
std::fprintf(stderr, "Webm2Pes: nullptr in opt header writer.\n");
return false;
}
const int kHeaderSize = 9;
std::uint8_t header[kHeaderSize] = {0};
std::uint8_t* byte = header;
if (marker.Che... | pushq %rbx
subq $0x10, %rsp
testq %rdx, %rdx
je 0xd4b7
movb $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movl 0x8(%rdi), %eax
decl %eax
cmpl $0x3f, %eax
ja 0xd474
movl 0x10(%rdi), %ecx
cmpl $0x3f, %ecx
ja 0xd474
movl 0x20(%rdi), %eax
decl %eax
cmpl $0x3f, %eax
ja 0xd474
cmpl $0x3f, 0x28(%rdi)
ja 0xd474
movl 0x38(%rdi), %eax
decl ... | /webmproject[P]libwebm/m2ts/webm2pes.cc |
libwebm::CopyAndEscapeStartCodes(unsigned char const*, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>>*) | bool CopyAndEscapeStartCodes(const std::uint8_t* raw_input,
std::size_t raw_input_length,
PacketDataBuffer* packet_buffer) {
if (raw_input == nullptr || raw_input_length < 1 || packet_buffer == nullptr)
return false;
int num_zeros = 0;
for (std::size_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0xd566
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movb (%r15,%r13), %al... | /webmproject[P]libwebm/m2ts/webm2pes.cc |
libwebm::BCMVHeader::Write(std::vector<unsigned char, std::allocator<unsigned char>>*) const | bool BCMVHeader::Write(PacketDataBuffer* buffer) const {
if (buffer == nullptr) {
std::fprintf(stderr, "Webm2Pes: nullptr for buffer in BCMV Write.\n");
return false;
}
const int kBcmvSize = 4;
for (int i = 0; i < kBcmvSize; ++i)
buffer->push_back(bcmv[i]);
// Note: The 4 byte length field must i... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0xd5f7
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xd5a7
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0xd5af
movq %rbx, %rdi
callq 0xd122
incq %r15
cmpq $0x4, %r15
jn... | /webmproject[P]libwebm/m2ts/webm2pes.cc |
libwebm::TempFileDeleter::TempFileDeleter() | TempFileDeleter::TempFileDeleter() { file_name_ = GetTempFileName(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rdi
callq 0xe478
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb210
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe79f
callq 0xb180
ad... | /webmproject[P]libwebm/common/file_util.cc |
mkvparser::ReadUInt(mkvparser::IMkvReader*, long long, long&) | long long ReadUInt(IMkvReader* pReader, long long pos, long& len) {
if (!pReader || pos < 0)
return E_FILE_FORMAT_INVALID;
len = 1;
unsigned char b;
int status = pReader->Read(pos, 1, &b);
if (status < 0) // error or underflow
return status;
if (status > 0) // interpreted as "underflow"
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sets %cl
orb %al, %cl
movq $-0x2, %r12
jne 0xe92d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x1, (%rdx)
movq (%rdi), %rax
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq *(%rax)
testl %eax, %ea... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::ParseElementHeader(mkvparser::IMkvReader*, long long&, long long, long long&, long long&) | long ParseElementHeader(IMkvReader* pReader, long long& pos, long long stop,
long long& id, long long& size) {
if (stop >= 0 && pos >= stop)
return E_FILE_FORMAT_INVALID;
long len;
id = ReadID(pReader, pos, len);
if (id < 0)
return E_FILE_FORMAT_INVALID;
pos += len; // con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rsi, %r14
testq %rdx, %rdx
setns %al
movq (%rsi), %rsi
cmpq %rdx, %rsi
setge %cl
movq $-0x2, %r15
testb %cl, %al
jne 0xef07
movq %r8, %r12
movq %rdx, %rbx
movq %rdi, %r13
movq %rsp, %rdx
callq 0xe94f
movq %rax, (%rbp)
mov... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::Match(mkvparser::IMkvReader*, long long&, unsigned long, long long&) | bool Match(IMkvReader* pReader, long long& pos, unsigned long expected_id,
long long& val) {
if (!pReader || pos < 0)
return false;
long long total = 0;
long long available = 0;
const long status = pReader->Length(&total, &available);
if (status < 0 || (total >= 0 && available > total))
r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %r12d, %r12d
testq %rdi, %rdi
je 0xf022
movq %rsi, %rbx
cmpq $0x0, (%rsi)
js 0xf022
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x18(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x8(%rsp), %rdx
movq %r12, (%rdx)
movq (%rdi), %... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::EBMLHeader::Init() | void EBMLHeader::Init() {
m_version = 1;
m_readVersion = 1;
m_maxIdLength = 4;
m_maxSizeLength = 8;
if (m_docType) {
delete[] m_docType;
m_docType = NULL;
}
m_docTypeVersion = 1;
m_docTypeReadVersion = 1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq %r14, (%rdi)
movq %r14, 0x8(%rdi)
movq $0x4, 0x10(%rdi)
movq $0x8, 0x18(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xf1fe
callq 0xb240
movq $0x0, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::Tracks::Parse() | long Tracks::Parse() {
assert(m_trackEntries == NULL);
assert(m_trackEntriesEnd == NULL);
const long long stop = m_start + m_size;
IMkvReader* const pReader = m_pSegment->m_pReader;
long long count = 0;
long long pos = m_start;
while (pos < stop) {
long long id, size;
const long status = Parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x28(%rdi)
jne 0x1046b
cmpq $0x0, 0x30(%rdi)
jne 0x1048a
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %rdx
leaq (%rdx,%rcx), %r14
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq %rcx, (%rsp)
xorl %... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::Segment::DoLoadClusterUnknownSize(long long&, long&) | long Segment::DoLoadClusterUnknownSize(long long& pos, long& len) {
if (m_pos >= 0 || m_pUnknownSize == NULL)
return E_PARSE_FAILED;
const long status = m_pUnknownSize->Parse(pos, len);
if (status < 0) // error or underflow
return status;
if (status == 0) // parsed a block
return 2; // continu... | movq $-0x1, %rax
cmpq $0x0, 0x68(%rdi)
js 0x10fe7
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x11034
movq %rsi, %r14
callq 0x1182a
testq %rax, %rax
js 0x11034
movl $0x2, %eax
je 0x11034
movq 0x70(%rbx), %rdx
movq 0x20(%rdx), %rcx
testq %rcx, %rcx
js 0x1102d
addq 0x8(... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::AudioTrack::Parse(mkvparser::Segment*, mkvparser::Track::Info const&, long long, long long, mkvparser::AudioTrack*&) | long AudioTrack::Parse(Segment* pSegment, const Info& info,
long long element_start, long long element_size,
AudioTrack*& pResult) {
if (pResult)
return -1;
if (info.type != Track::kAudio)
return -1;
IMkvReader* const pReader = pSegment->m_pReader;
const ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpq $0x0, (%r8)
movq $-0x1, %rbp
jne 0x19ded
cmpq $0x2, (%rsi)
jne 0x19ded
movq 0x68(%rsi), %rax
testq %rax, %rax
js 0x19dff
movq %rdx, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x28(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x70(%rsi), %r13
te... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::Cluster::ParseBlockGroup(long long, long long&, long&) | long Cluster::ParseBlockGroup(long long payload_size, long long& pos,
long& len) {
const long long payload_start = pos;
const long long payload_stop = pos + payload_size;
IMkvReader* const pReader = m_pSegment->m_pReader;
long long total, avail;
long status = pReader->Length(&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r15
movq (%rdi), %rax
movq (%rax), %rbp
movq (%rbp), %rax
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq *0x8(%rax)
testl %eax, %eax
js 0x1ac... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
mkvparser::Cluster::CreateSimpleBlock(long long, long long) | long Cluster::CreateSimpleBlock(long long st, long long sz) {
assert(m_entries);
assert(m_entries_size > 0);
assert(m_entries_count >= 0);
assert(m_entries_count < m_entries_size);
const long idx = m_entries_count;
BlockEntry** const ppEntry = m_entries + idx;
BlockEntry*& pEntry = *ppEntry;
pEntry =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rdi), %r12
testq %r12, %r12
je 0x1bd36
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
jle 0x1bd55
movq 0x40(%rbx), %r13
testq %r13, %r13
js 0x1bd74
cmpq %rax, %r13
jge 0x1bd93
movq %rdx, %r14
movq %rsi, %r15
movq 0xa335(%rip), %rsi # 0x25fc8... | /webmproject[P]libwebm/mkvparser/mkvparser.cc |
solver_started_cb(baryonyx::solver_parameters const&) | static void
solver_started_cb(const baryonyx::solver_parameters& params)
{
fmt::print("Solver starts\n");
fmt::print(" * Global parameters:\n"
" - limit: {}\n"
" - time-limit: {:.10g}s\n"
" - floating-point-type: {}\n"
" - print-level: {}\n"
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x447c6e(%rip), %rdi # 0x455ff6
callq 0x1e470
leaq 0xb0(%rbx), %rsi
leaq 0xd0(%rbx), %rcx
leaq 0xb8(%rbx), %r8
leaq 0xdc(%rbx), %r9
leaq 0xe4(%rbx), %rax
subq $0x8, %rsp
leaq 0x447c4a(%rip), %rdi # 0x456005
movq %rbx, %rdx
pushq %rax
callq 0x1e497
popq %rax
po... | /quesnel[P]baryonyx/app/src/main.cpp |
solver_updated_cb(int, double, long, double, long) | static void
solver_updated_cb(int remaining_constraints,
double value,
long int loop,
double duration,
long int reinit_number)
{
if (remaining_constraints > 0) {
fmt::print(
" - Constraints remaining: {} (loop: {} t: {}s rein... | subq $0x38, %rsp
movl %edi, 0x1c(%rsp)
vmovsd %xmm0, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
vmovsd %xmm1, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testl %edi, %edi
jle 0xe509
leaq 0x447f83(%rip), %rdi # 0x456471
leaq 0x1c(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x1f8a6
jmp 0xe556
testq %rs... | /quesnel[P]baryonyx/app/src/main.cpp |
solver_finished_cb(baryonyx::result const&) | static void
solver_finished_cb(const baryonyx::result& r)
{
fmt::print("Solver finished\n");
switch (r.status) {
case baryonyx::result_status::success:
if (!r.solutions.empty()) {
if (r.solutions.back().variables.empty()) {
fmt::print(
"Best solution fo... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x447fba(%rip), %rdi # 0x456524
callq 0x1f968
movl 0xa0(%rbx), %eax
cmpq $0x6, %rax
ja 0xe69d
leaq 0x445ad6(%rip), %rcx # 0x45405c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x70(%rbx), %rsi
cmpq %rsi, 0x68(%rbx)
je 0xe69d
movq -0x20(%rsi), %rax
cmp... | /quesnel[P]baryonyx/app/src/main.cpp |
void fmt::v7::print<char [35], std::basic_string_view<char, std::char_traits<char>>, char const*, 0>(_IO_FILE*, fmt::v7::text_style const&, char const (&) [35], std::basic_string_view<char, std::char_traits<char>> const&, char const* const&) | void print(std::FILE* f, const text_style& ts, const S& format_str,
const Args&... args) {
vprint(f, ts, format_str,
fmt::make_args_checked<Args...>(format_str, args...));
} | subq $0x28, %rsp
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq (%r8), %r9
movq %rsp, %r8
movq %rcx, (%r8)
movl $0xcd, %ecx
movq %rax, 0x8(%r8)
movq %r9, 0x10(%r8)
callq 0x2027a
addq $0x28, %rsp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
void fmt::v7::print<char [10], double&, double&, char>(std::basic_ostream<char, std::char_traits<char>>&, char const (&) [10], double&, double&) | void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
vprint(os, to_string_view(format_str),
fmt::make_args_checked<Args...>(format_str, args...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rbx
movq %rdx, %r14
callq 0xf277
movq (%r14), %rcx
movq (%rbx), %rsi
movq %rsp, %r8
movq %r15, %rdi
movq %rcx, (%r8)
movl $0xaa, %ecx
movq %rsi, 0x10(%r8)
movq %rax, %rsi
callq 0x1fd97
addq $0x20, %rsp
popq %rbx
popq %r14
popq... | /quesnel[P]baryonyx/external/fmt/include/fmt/ostream.h |
get_param::operator()(int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | constexpr std::optional<std::string_view> operator()(
int arg_position,
const std::string_view longp,
const std::string_view shortp) noexcept
{
std::string_view arg(argv[arg_position]);
i = arg_position;
if (starts_with(arg, longp) && arg.size() > longp.size() &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rsi), %rax
movslq %edx, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movl %edx, 0x14(%rsp)
movq (%rax,%rbx,8), %r12
movq %r12, %rdi
callq 0xb220
movq %rax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %rax, %r... | /quesnel[P]baryonyx/app/src/main.cpp |
void fmt::v7::detail::vformat_to<char>(fmt::v7::detail::buffer<char>&, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<fmt::v7::type_identity<char>::type>, fmt::v7::type_identity<char>::type>>, fmt::v7::detail::locale_ref) | void detail::vformat_to(
detail::buffer<Char>& buf, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args,
detail::locale_ref loc) {
using iterator = typename buffer_context<Char>::iterator;
auto out = buffer_appender<Char>(buf);
if (format_str.size() == 2 &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x2, %rdx
jne 0xf351
leaq 0x44a539(%rip), %rsi # 0x459864
movq %r14, %rdi
callq 0xf6d7
testb %al, %al
je 0xf351
testq %r13, %r13
js 0x... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::default_arg_formatter<fmt::v7::detail::buffer_appender<char>, char>::operator()(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::handle) | OutputIt operator()(typename basic_format_arg<context>::handle handle) {
basic_format_parse_context<Char> parse_ctx({});
basic_format_context<OutputIt, Char> format_ctx(out, args, loc);
handle.format(parse_ctx, format_ctx);
return format_ctx.out();
} | pushq %rbx
subq $0x40, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %rcx
movq %rsp, %rsi
andl $0x0, 0x10(%rsi)
leaq 0x20(%rsp), %rbx
movq %rdx, %rax
vmovaps %xmm0, (%rsi)
movq %rbx, %rdx
vmovups (%rdi), %xmm0
vmovups %xmm0, (%rbx)
vmovups 0x10(%rdi), %xmm0
movq %rcx, %rdi
vmovups %xmm0, 0x10(%rbx)
callq *%rax
movq (%rbx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, int, 0>(fmt::v7::detail::buffer_appender<char>, int) | OutputIt write(OutputIt out, T value) {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
negl %ebx
movl %esi, %r15d
movq %rdi, %r14
cmovsl %esi, %ebx
movl %ebx, %edi
callq 0xf872
movl %eax, %ebp
movl %r15d, %eax
shrl $0x1f, %eax
movslq %ebp, %r13
movq %r14, %rdi
addq %rax, %r13
movq %r13, %rsi
callq 0xf897
movq %ra... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::format_decimal_result<char*> fmt::v7::detail::format_decimal<char, unsigned int>(char*, unsigned int, int) | inline format_decimal_result<Char*> format_decimal(Char* out, UInt value,
int size) {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of tw... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl %esi, %edi
movl %edx, %ebp
movl %esi, %ebx
callq 0xf872
cmpl %ebp, %eax
jg 0xf94a
movslq %ebp, %rax
leaq -0x2(%r14,%rax), %rsi
leaq (%r14,%rax), %rcx
pushq $0x64
popq %r8
leaq 0x4474b5(%rip), %rdi # 0x456dc0
cmpl $0x64, %ebx
jb 0xf926
movl %ebx, %eax
xorl %edx, %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::assert_fail(char const*, int, char const*) | FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
// Use unchecked std::fprintf to avoid triggering another assertion when
// writing to stderr fails
std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
// Chosen instead of std::abort to satisfy Clang in CUDA mode... | pushq %rax
movq 0x62d5fd(%rip), %rax # 0x63cfd0
movq %rdx, %r8
movq %rdi, %rdx
movl %esi, %ecx
leaq 0x445814(%rip), %rsi # 0x4551f6
movq (%rax), %rdi
xorl %eax, %eax
callq 0xb170
callq 0xb6e0
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::count_digits(unsigned __int128) | inline int count_digits(uint128_t n) {
int count = 1;
for (;;) {
// Integer division is slow so do it for a group of four digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < 10) return count... | pushq %r15
pushq %r14
pushq %rbx
pushq $0x4
popq %rbx
pushq $0x63
popq %r14
movl $0x3e7, %r15d # imm = 0x3E7
cmpq $0xa, %rdi
movq %rsi, %rax
sbbq $0x0, %rax
jb 0xfdcf
cmpq %rdi, %r14
movl $0x0, %eax
sbbq %rsi, %rax
jae 0xfdd4
cmpq %rdi, %r15
movl $0x0, %eax
sbbq %rsi, %rax
jae 0xfdd9
cmpq $0x2710, %rdi ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::format_decimal_result<char*> fmt::v7::detail::format_decimal<char, unsigned __int128>(char*, unsigned __int128, int) | inline format_decimal_result<Char*> format_decimal(Char* out, UInt value,
int size) {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of tw... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xfd6f
cmpl %ebx, %eax
jg 0xfe96
movslq %ebx, %rax
leaq (%r15,%rax), %rbx
leaq -0x2(%r15,%rax), %r15
pushq $0x64
popq %r13
leaq 0x446f9d(%rip... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, unsigned __int128, 0>(fmt::v7::detail::buffer_appender<char>, unsigned __int128) | OutputIt write(OutputIt out, T value) {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xfd6f
movslq %eax, %r13
movl %eax, %ebp
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf897
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xf8b2
testq %rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, bool) | OutputIt write(OutputIt out, bool value) {
return write<Char>(out, string_view(value ? "true" : "false"));
} | pushq %rbx
leaq 0x4452b2(%rip), %rcx # 0x455212
leaq 0x4452b0(%rip), %rax # 0x455217
testl %esi, %esi
movl %esi, %edx
movq %rdi, %rbx
cmovneq %rcx, %rax
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xff86
movq %rbx, %rax
popq %rbx
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::buffer<char>::append<char>(char const*, char const*) | void buffer<T>::append(const U* begin, const U* end) {
do {
auto count = to_unsigned(end - begin);
try_reserve(size_ + count);
auto free_cap = capacity_ - size_;
if (free_cap < count) count = free_cap;
std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
size_ += count;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdi
subq %r14, %rdi
callq 0x10002
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r12
movq %rax, %r13
leaq (%rdi,%rax), %rsi
cmpq %rsi, %r12
jae 0xffc7
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x10(%r1... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, float, 0>(fmt::v7::detail::buffer_appender<char>, float) | OutputIt write(OutputIt out, T value) {
if (const_check(!is_supported_floating_point(value))) return out;
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uint = typename dragonbox::float_info<floaty>::carrier_uint;
auto bits = bit_cast<uint>(value);
auto fspecs = float_sp... | pushq %rbx
subq $0x10, %rsp
andq $0x0, (%rsp)
vmovd %xmm0, %eax
movq %rdi, %rbx
testl %eax, %eax
jns 0x10078
vpxord 0x44428c(%rip){1to4}, %xmm0, %xmm0 # 0x4542fc
movl $0x100, 0x4(%rsp) # imm = 0x100
notl %eax
testl $0x7f800000, %eax # imm = 0x7F800000
jne 0x100a9
vmovd %xmm0, %eax
xorl %esi, %esi
leaq 0x446... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_nonfinite<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, bool, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs const&) | OutputIt write_nonfinite(OutputIt out, bool isinf,
const basic_format_specs<Char>& specs,
const float_specs& fspecs) {
auto str =
isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
constexpr size_t str_size = 3;
auto sign = fspecs.sign;... | subq $0x18, %rsp
movl 0x4(%rcx), %r8d
leaq 0x4451b3(%rip), %rax # 0x455295
leaq 0x4451a8(%rip), %rcx # 0x455291
leaq 0x4451a9(%rip), %r9 # 0x455299
btl $0x10, %r8d
cmovaeq %rax, %rcx
leaq 0x44519d(%rip), %rax # 0x45529d
cmovaeq %rax, %r9
testl %esi, %esi
movq %rdx, %rsi
cmovneq %rcx, %r9
shrl $0x8, %r8d
xo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_... | OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x40(%rsp)
movb %r8b, 0xf(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, %rdi
movq %rcx, %rbp
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movl %r8d, 0x3c(%rsp)
movl (%rsi), %eax
movl %eax, 0x50(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x10b7d
movq... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_nonfinite<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, bool, fmt::v7::basic_f... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x446747(%rip), %rcx # 0x456f48
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
bool fmt::v7::detail::dragonbox::is_center_integer<float>(fmt::v7::detail::dragonbox::float_info<float>::carrier_uint, int, int) | bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
int minus_k) FMT_NOEXCEPT {
// Exponent for 5 is negative.
if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
if (exponent > float_info<T>::case_fc_upper_threshold)
return divisi... | cmpl $0x27, %esi
jle 0x10a8a
xorl %eax, %eax
retq
cmpl $0x7, %esi
jl 0x10a96
movl %edx, %esi
jmp 0x10b05
movb $0x1, %al
cmpl $-0x3, %esi
jg 0x10a89
subl %esi, %edx
incl %edx
movl %edx, %esi
jmp 0x10b39
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::dragonbox::decimal_fp<double> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(fmt::v7::d... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x44500d(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char) | OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x38(%rsp)
movb %r8b, 0xb(%rsp)
movq %rcx, %r14
shrq $0x28, %r14
movq %rcx, %r13
shrq $0x20, %r13
xorl %ebx, %ebx
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, 0x28(%rsp)
movl %r8d, 0x34(%rsp)
movq (%rsi), %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, unsigned long, 0>(fmt::v7::detail::buffer_appender<char>, unsigned long) | OutputIt write(OutputIt out, T value) {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0xfb66
movslq %eax, %r12
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf897
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xf8b2
testq %rax, %rax
je 0x13397
movq %rax, %rdi
movq %r14, %rsi
movl... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::fixed_handler::on_digit(char, unsigned long, unsigned long, unsigned long, int, bool) | digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
uint64_t error, int, bool integral) {
FMT_ASSERT(remainder < divisor, "");
buf[size++] = digit;
if (!integral && error >= remainder) return digits::error;
if (size < precision) return digits::more;
if... | pushq %rbx
cmpq %rdx, %rcx
jae 0x13b47
movq %rdi, %rbx
movslq 0x8(%rbx), %r9
movb 0x10(%rsp), %dil
movq (%rbx), %rax
cmpq %rcx, %r8
leal 0x1(%r9), %r10d
movl %r10d, 0x8(%rbx)
movb %sil, (%rax,%r9)
movl %edi, %r9d
setae %al
xorb $0x1, %r9b
pushq $0x2
popq %rsi
testb %r9b, %al
jne 0x13aad
movl 0x8(%rbx), %r9d
xorl %eax, ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::assign(unsigned long) | void assign(uint64_t n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = n & ~bigit(0);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
} | pushq %rbx
movq 0x8(%rdi), %rcx
movq %rsi, %rax
movq %rdi, %rbx
xorl %esi, %esi
movl %eax, (%rcx,%rsi,4)
incq %rsi
shrq $0x20, %rax
jne 0x13c3f
movq %rbx, %rdi
callq 0x140f0
andl $0x0, 0xa8(%rbx)
popq %rbx
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::operator<<=(int) | FMT_NOINLINE bigint& operator<<=(int shift) {
assert(shift >= 0);
exp_ += shift / bigit_bits;
shift %= bigit_bits;
if (shift == 0) return *this;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
bigit c = bigits_[i] >> (bigit_bits - shift);
bigits_[i] = (bigits_[i... | pushq %rbx
subq $0x10, %rsp
testl %esi, %esi
js 0x13cce
movl %esi, %eax
shrl $0x5, %eax
movq %rdi, %rbx
addl %eax, 0xa8(%rdi)
andl $0x1f, %esi
je 0x13cc5
andl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
pushq $0x20
popq %rdx
subl %esi, %edx
xorl %r8d, %r8d
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x13cb3
movl ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::divmod_assign(fmt::v7::detail::bigint const&) | int divmod_assign(const bigint& divisor) {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
align(divisor);
int quotient = 0;
do {
subtract_aligned(divisor);
++quotient;
} while (compar... | pushq %rbp
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0x13e57
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13e87
testl %eax, %eax
js 0x13e4e
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpl $0x0, -0x4(%rax,%rcx,4)
je 0x13e6f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14426
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::grow(unsigned long) | void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
#ifdef FMT_FUZZ
if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity) new_capacity = size;
T... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %r14
movq 0x8(%rdi), %rbx
movq %rdi, %r15
addq $0xa0, %rdi
movq %r14, %r12
shrq %r12
addq %r14, %r12
cmpq %rsi, %r12
cmovbeq %rsi, %r12
movq %r12, %rsi
callq 0x140c0
movq 0x10(%r15), %rdx
movq %rax, %r13
testq %rdx, %rdx
je 0x1408c
shlq $0x2, %rdx
... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::bigint::square() | void square() {
basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
int num_bigits = static_cast<int>(bigits_.size());
int num_result_bigits = 2 * num_bigits;
bigits_.resize(to_unsigned(num_result_bigits));
using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x142b4
movq 0x10(%rbx), %r14
leal (%r14,%r14), %edi
movl %edi, 0x4(%rsp)
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0x140f0
movl %r14d, %eax
sarl $0x1f, %eax
xorl %r15... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::remove_leading_zeros() | void remove_leading_zeros() {
int num_bigits = static_cast<int>(bigits_.size()) - 1;
while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
bigits_.resize(to_unsigned(num_bigits + 1));
} | pushq %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %ebp
movq %rdi, %rbx
movl %ebp, %r14d
cmpl $0x2, %ebp
jl 0x14305
leal -0x1(%r14), %ebp
movl %ebp, %edi
callq 0x1085f
movq 0x8(%rbx), %rcx
movl %eax, %eax
cmpl $0x0, (%rcx,%rax,4)
je 0x142e6
movl %r14d, %edi
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
popq %rbx
popq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::align(fmt::v7::detail::bigint const&) | void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
bigits_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xa8(%rdi), %r14d
subl 0xa8(%rsi), %r14d
jle 0x14498
movl 0x10(%rdi), %r15d
movq %rdi, %rbx
leal (%r14,%r15), %edi
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0x140f0
movq 0x8(%rbx), %rdi
leal -0x1(%r15,%r14), %ecx
movl %r15d, %eax
decl %eax
movslq %ecx, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::subtract_bigits(int, unsigned int, unsigned int&) | void subtract_bigits(int index, bigit other, bigit& borrow) {
auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
(*this)[index] = static_cast<bigit>(result);
borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movl %esi, %edi
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movq 0x8(%r15), %rcx
movl %eax, %eax
movl %r14d, %edi
movl (%rcx,%rax,4), %r12d
movl (%rbx), %ecx
movl %ebp, %eax
addq %rax, %rcx
subq %rcx, %r12
callq 0x1085f
movq 0x8(%... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::multiply(unsigned int) | void multiply(uint32_t value) {
const double_bigit wide_value = value;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * wide_value + carry;
bigits_[i] = static_cast<bigit>(result);
carry = static_cast<bigit>(result >> bigit_bits);
... | pushq %rax
andl $0x0, 0x4(%rsp)
movl %esi, %eax
xorl %edx, %edx
xorl %r8d, %r8d
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rsi
cmpq %r8, %rsi
je 0x14660
movl (%rcx,%r8,4), %r9d
movl %edx, %edx
imulq %rax, %r9
addq %r9, %rdx
movl %edx, (%rcx,%r8,4)
shrq $0x20, %rdx
incq %r8
movl %edx, 0x4(%rsp)
jmp 0x1463d
testl %edx, %edx
... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, ... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x442a3e(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_significand<fmt::v7::detail::buffer_appender<char>, char>(fmt::v7::detail::buffer_appender<char>, char const*, int, int, char) | inline OutputIt write_significand(OutputIt out, const char* significand,
int significand_size, int integral_size,
Char decimal_point) {
out = detail::copy_str<Char>(significand, significand + integral_size, out);
if (!decimal_point) return out;
*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq %ecx, %r15
movl %r8d, %r12d
movl %edx, %ebp
movq %rdi, %rdx
movq %rsi, %rbx
movb %r12b, 0xf(%rsp)
movq %rsi, %rdi
addq %rsi, %r15
movq %r15, %rsi
callq 0x10954
movq %rax, %r14
testb %r12b, %r12b
je 0x148a2
leaq 0xf(%rsp), %rsi
movq %r14, %rd... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, ... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x442943(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_ptr<char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, fmt::v7::basic_format_specs<char> const*) | OutputIt write_ptr(OutputIt out, UIntPtr value,
const basic_format_specs<Char>* specs) {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
auto write = [=](iterator it) {
*it++ = static... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rbx
movq %rsi, %r15
callq 0x14d0a
movl %eax, %edi
movl %eax, %ebp
callq 0x1085f
movl %eax, %edx
addq $0x2, %rdx
movq %r15, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
testq %rbx, %rbx
je 0x14ce7
leaq 0x8(%rsp), %rcx
movq %r14, ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_ptr<char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x442488(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::on_text(char const*, char const*) | void on_text(const Char* begin, const Char* end) {
auto size = to_unsigned(end - begin);
auto out = context.out();
auto&& it = reserve(out, size);
it = std::copy_n(begin, size, it);
context.advance_to(out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
subq %rsi, %rdx
movq %rdi, %r14
movq %rsi, %rbx
movq %rdx, %rdi
callq 0x10002
movq 0x20(%r14), %r12
movq %rax, %r15
movq %rax, %rsi
movq %r12, %rdi
callq 0xf897
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1090a
movq %r12, 0x20(%r14)
addq $0x8, %rsp
popq... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::parse_format_string<false, char, fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&>(fmt::v7::basic_string_view<char>, fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, ch... | FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
if (pbegin == pend) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(pbegin, pend, '}', p))
return handler_.on_text(pbegin, pend);
++p;
if (p == pend || *p != '}')
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq %rdx, %rsi
je 0x1526a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x7d
popq %rbp
leaq 0x8(%rsp), %r12
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x151c1
testb %al, %al
je 0x1525c
movq ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::id_adapter<fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&, char>&>(char const*, char const*, fmt::v7::detail::id_adapter<fmt::v7::detail::format_h... | FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0'... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x1539b
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x152b0
cmpl $0x3a, %eax
jne 0x152c5
movq %rbx, %rdi
callq 0x156b8
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::on_format_specs(int, char const*, char const*) | const Char* on_format_specs(int id, const Char* begin, const Char* end) {
auto arg = get_arg(context, id);
if (arg.type() == type::custom_type) {
advance_to(parse_context, begin);
visit_format_arg(custom_formatter<Context>(parse_context, context), arg);
return parse_context.begin();
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq 0x20(%rdi), %rbx
leaq 0x20(%rsp), %r14
movq %rdx, %r13
movl %esi, %edx
movq %rdi, %r15
movq %rcx, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1565d
movl 0x10(%r14), %eax
cmpl $0xf, %eax
jne 0x15416
addq $0x8, %r15
movq %r13, %rsi
movq %r15, %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::id_adapter<fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&, char>&>(char const*&, char const*, fmt::v7::detail::id_adapter<fmt::v7::detail::format... | FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>()... | pushq %rbx
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x15730
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x15730
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x15718
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x15712
m... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::get_id<char>(fmt::v7::basic_string_view<char>) const | int get_id(basic_string_view<Char> name) const {
if (!has_named_args()) return -1;
const auto& named_args =
(is_packed() ? values_[-1] : args_[-1].value_).named_args;
for (size_t i = 0; i < named_args.size; ++i) {
if (named_args.data[i].name == name) return named_args.data[i].id;
}
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq %rdx, (%rsp)
pushq $-0x1
popq %rax
btq $0x3e, %rcx
jae 0x1583d
movq 0x8(%rdi), %r13
xorl %ebp, %ebp
testq %rcx, %rcx
movq %rsi, %r15
setns %bpl
xorl %ebx, %ebx
xorl %r14d, %r14d
shll $0x4, %ebp
orq $-0x20, %rbp
cmpq 0x8(... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
char const* fmt::v7::detail::parse_format_specs<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_... | FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
SpecHandler&& handler) {
if (begin == end) return begin;
begin = parse_align(begin, end, handler);
if (begin == end) return begin;
// Parse sign.
switch (to_ascii(*begin)) {
case '... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x15983
movq %rbx, %rdi
movq %rdx, %r14
movq %rsi, %r15
callq 0x159a4
movq %rax, %rbx
cmpq %r15, %rax
je 0x15983
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x15907
cmpl $0x2d, %eax
je 0x158fd
cmpl $0x2b, %eax
jne 0x15912
movq %r14, %rdi
callq 0x15a74
jmp ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_align<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_checker... | FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
auto align = align::none;
auto p = begin + code_point_length(begin);
if (p >= end) p = begin;
for (;;) {
switch (to_ascii(*p)) {
case '<':
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x15a5b
movzbl (%rdi), %eax
movq %rdx, %rbx
leaq 0x43e8df(%rip), %rdx # 0x4542a0
movq %rdi, %r14
movl %eax, %ecx
shrl $0x3, %ecx
movsbq (%rcx,%rdx), %r15
movl $0x80ff0000, %edx # imm = 0x80FF0000
btl %ecx, %edx
adcq %rdi, %r15
cmpq %rsi,... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_width<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_checker... | FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
if ('0' <= *begin && *begin <= '9') {
handler.on_width(parse_nonnegative_int(begin, end, handler));
} else if (*begin == '{') {
++begin;
if... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, (%rsp)
cmpq %rsi, %rdi
je 0x15b96
movb (%rdi), %al
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x15b49
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x15d75
movq (%r14), %rcx
movl %eax, (%rc... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*&, char const*, fmt::v7::detail::specs_chec... | FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>()... | pushq %rbx
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x15dd8
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x15dd8
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x15dc0
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x15dba
m... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
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.