idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
10,100 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_destroy(unsigned long) | void
_M_destroy(size_type __size) throw()
{ _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x54a0
movq %rax, -0x18(%rbp)
jmp 0x53f3
movq -0x20(%rbp), %rdi
callq 0x5320
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
incq %rdx
callq 0x5450
jmp 0x5411
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,101 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_local_data() const | const_pointer
_M_local_data() const
{
#if __cplusplus >= 201103L
return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
#else
return const_pointer(_M_local_buf);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x5440
addq $0x10, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,102 | std::pointer_traits<char const*>::pointer_to(char const&) | static _GLIBCXX20_CONSTEXPR pointer
pointer_to(__make_not_void<element_type>& __r) noexcept
{ return std::addressof(__r); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/ptr_traits.h |
10,103 | std::allocator_traits<std::allocator<char>>::deallocate(std::allocator<char>&, char*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,104 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_get_allocator() | allocator_type&
_M_get_allocator()
{ return _M_dataplus; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,105 | test | int test(char *URL)
{
CURL *curls = NULL;
CURLM *multi = NULL;
int still_running;
int i = 0;
int res = 0;
CURLMsg *msg;
int counter = 3;
start_test_timing();
global_init(CURL_GLOBAL_ALL);
multi_init(multi);
easy_init(curls);
easy_setopt(curls, CURLOPT_URL, URL);
easy_setopt(curls, CURLOPT_HEADER, 1L);
easy_setopt(curls, CURLOPT_VERBOSE, 1L);
easy_setopt(curls, CURLOPT_USERPWD, "u:s");
multi_add_handle(multi, curls);
multi_perform(multi, &still_running);
abort_on_test_timeout();
while(still_running && counter--) {
int num;
res = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
if(res != CURLM_OK) {
printf("curl_multi_wait() returned %d\n", res);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
abort_on_test_timeout();
multi_perform(multi, &still_running);
abort_on_test_timeout();
}
msg = curl_multi_info_read(multi, &still_running);
if(msg)
/* this should now contain a result code from the easy handle,
get it */
i = msg->data.result;
test_cleanup:
/* undocumented cleanup sequence - type UA */
curl_multi_cleanup(multi);
curl_easy_cleanup(curls);
curl_global_cleanup();
if(res)
i = res;
return i; /* return the final return code */
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x3, -0x3c(%rbp)
callq 0x1c70
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq 0x30a0(%rip), %rax # 0x4358
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x12c9
jmp 0x12cb
movl $0x3, %edi
callq 0x1130
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x1330
movq 0x2cfc(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0x54(%rbp), %edi
callq 0x1050
movq -0xc0(%rbp), %rdi
movl -0xb4(%rbp), %r8d
movq %rax, %r9
leaq 0xced(%rip), %rsi # 0x2004
leaq 0xd1a(%rip), %rdx # 0x2038
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1100
movl -0x54(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1332
cmpl $0x0, -0x2c(%rbp)
je 0x1343
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a18
jmp 0x1345
jmp 0x1347
jmp 0x1349
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1383
movq 0x2c81(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd36(%rip), %rsi # 0x209f
leaq 0xcc8(%rip), %rdx # 0x2038
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7b, -0x2c(%rbp)
jmp 0x1385
cmpl $0x0, -0x2c(%rbp)
je 0x1390
jmp 0x19ef
jmp 0x1392
jmp 0x1394
jmp 0x1396
callq 0x1040
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13d0
movq 0x2c34(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd09(%rip), %rsi # 0x20bf
leaq 0xc7b(%rip), %rdx # 0x2038
movl $0x2e, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7c, -0x2c(%rbp)
jmp 0x13d2
cmpl $0x0, -0x2c(%rbp)
je 0x13dd
jmp 0x19ef
jmp 0x13df
jmp 0x13e1
jmp 0x13e3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2712, %esi # imm = 0x2712
movb $0x0, %al
callq 0x1120
movl %eax, -0x58(%rbp)
cmpl $0x0, %eax
je 0x1452
movq 0x2bda(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0x58(%rbp), %edi
callq 0x1050
movq -0xd0(%rbp), %rdi
movl -0xc4(%rbp), %r8d
movq %rax, %r9
leaq 0xca5(%rip), %rsi # 0x20de
leaq 0xbf8(%rip), %rdx # 0x2038
movl $0x30, %ecx
movb $0x0, %al
callq 0x1100
movl -0x58(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1454
cmpl $0x0, -0x2c(%rbp)
je 0x145f
jmp 0x19ef
jmp 0x1461
jmp 0x1463
jmp 0x1465
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x1120
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
je 0x14d5
movq 0x2b57(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0x5c(%rbp), %edi
callq 0x1050
movq -0xe0(%rbp), %rdi
movl -0xd4(%rbp), %r8d
movq %rax, %r9
leaq 0xc22(%rip), %rsi # 0x20de
leaq 0xb75(%rip), %rdx # 0x2038
movl $0x31, %ecx
movb $0x0, %al
callq 0x1100
movl -0x5c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x14d7
cmpl $0x0, -0x2c(%rbp)
je 0x14e2
jmp 0x19ef
jmp 0x14e4
jmp 0x14e6
jmp 0x14e8
movq -0x18(%rbp), %rdi
movl $0x29, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x1120
movl %eax, -0x60(%rbp)
cmpl $0x0, %eax
je 0x1558
movq 0x2ad4(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0xe4(%rbp)
movl -0x60(%rbp), %edi
callq 0x1050
movq -0xf0(%rbp), %rdi
movl -0xe4(%rbp), %r8d
movq %rax, %r9
leaq 0xb9f(%rip), %rsi # 0x20de
leaq 0xaf2(%rip), %rdx # 0x2038
movl $0x32, %ecx
movb $0x0, %al
callq 0x1100
movl -0x60(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x155a
cmpl $0x0, -0x2c(%rbp)
je 0x1565
jmp 0x19ef
jmp 0x1567
jmp 0x1569
jmp 0x156b
movq -0x18(%rbp), %rdi
movl $0x2715, %esi # imm = 0x2715
leaq 0xb97(%rip), %rdx # 0x2112
movb $0x0, %al
callq 0x1120
movl %eax, -0x64(%rbp)
cmpl $0x0, %eax
je 0x15dd
movq 0x2a4f(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0xf4(%rbp)
movl -0x64(%rbp), %edi
callq 0x1050
movq -0x100(%rbp), %rdi
movl -0xf4(%rbp), %r8d
movq %rax, %r9
leaq 0xb1a(%rip), %rsi # 0x20de
leaq 0xa6d(%rip), %rdx # 0x2038
movl $0x33, %ecx
movb $0x0, %al
callq 0x1100
movl -0x64(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x15df
cmpl $0x0, -0x2c(%rbp)
je 0x15ea
jmp 0x19ef
jmp 0x15ec
jmp 0x15ee
jmp 0x15f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1070
movl %eax, -0x68(%rbp)
cmpl $0x0, %eax
je 0x1658
movq 0x29d4(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0x110(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x68(%rbp), %edi
callq 0x1150
movq -0x110(%rbp), %rdi
movl -0x104(%rbp), %r8d
movq %rax, %r9
leaq 0xad7(%rip), %rsi # 0x2116
leaq 0x9f2(%rip), %rdx # 0x2038
movl $0x35, %ecx
movb $0x0, %al
callq 0x1100
movl -0x68(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x165a
cmpl $0x0, -0x2c(%rbp)
je 0x1665
jmp 0x19ef
jmp 0x1667
jmp 0x1669
jmp 0x166b
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x10d0
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x16d5
movq 0x2959(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0x120(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
movl -0x6c(%rbp), %edi
callq 0x1150
movq -0x120(%rbp), %rdi
movl -0x114(%rbp), %r8d
movq %rax, %r9
leaq 0xa95(%rip), %rsi # 0x214f
leaq 0x977(%rip), %rdx # 0x2038
movl $0x37, %ecx
movb $0x0, %al
callq 0x1100
movl -0x6c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x170c
cmpl $0x0, -0x24(%rbp)
jge 0x170a
movq 0x28fe(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movl -0x24(%rbp), %r8d
leaq 0xa95(%rip), %rsi # 0x2185
leaq 0x941(%rip), %rdx # 0x2038
movl $0x37, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7a, -0x2c(%rbp)
jmp 0x170c
jmp 0x170e
cmpl $0x0, -0x2c(%rbp)
je 0x1719
jmp 0x19ef
jmp 0x171b
jmp 0x171d
jmp 0x171f
callq 0x1c70
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq 0x2c1d(%rip), %rax # 0x4358
movq (%rax), %rdx
leaq 0x2c13(%rip), %rax # 0x4358
movq 0x8(%rax), %rcx
callq 0x1ca0
cmpq $0xea60, %rax # imm = 0xEA60
jle 0x1781
movq 0x2883(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xa75(%rip), %rsi # 0x21dc
leaq 0x8ca(%rip), %rdx # 0x2038
movl $0x39, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7d, -0x2c(%rbp)
jmp 0x1783
cmpl $0x0, -0x2c(%rbp)
je 0x178e
jmp 0x19ef
jmp 0x1790
jmp 0x1792
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x121(%rbp)
je 0x17b7
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x17c6
jmp 0x19cb
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movl $0xea60, %ecx # imm = 0xEA60
leaq -0x84(%rbp), %r8
callq 0x10e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1807
movl -0x2c(%rbp), %esi
leaq 0xa2d(%rip), %rdi # 0x2221
movb $0x0, %al
callq 0x1080
movl $0x7e, -0x2c(%rbp)
jmp 0x19ef
jmp 0x1809
jmp 0x180b
callq 0x1c70
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq 0x2b25(%rip), %rax # 0x4358
movq (%rax), %rdx
leaq 0x2b1b(%rip), %rax # 0x4358
movq 0x8(%rax), %rcx
callq 0x1ca0
cmpq $0xea60, %rax # imm = 0xEA60
jle 0x1879
movq 0x278b(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x97d(%rip), %rsi # 0x21dc
leaq 0x7d2(%rip), %rdx # 0x2038
movl $0x44, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7d, -0x2c(%rbp)
jmp 0x187b
cmpl $0x0, -0x2c(%rbp)
je 0x1886
jmp 0x19ef
jmp 0x1888
jmp 0x188a
jmp 0x188c
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x10d0
movl %eax, -0x9c(%rbp)
cmpl $0x0, %eax
je 0x1902
movq 0x2735(%rip), %rax # 0x3fe0
movq (%rax), %rax
movq %rax, -0x130(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x128(%rbp)
movl -0x9c(%rbp), %edi
callq 0x1150
movq -0x130(%rbp), %rdi
movl -0x128(%rbp), %r8d
movq %rax, %r9
leaq 0x86b(%rip), %rsi # 0x214f
leaq 0x74d(%rip), %rdx # 0x2038
movl $0x46, %ecx
movb $0x0, %al
callq 0x1100
movl -0x9c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1939
cmpl $0x0, -0x24(%rbp)
jge 0x1937
movq 0x26d1(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movl -0x24(%rbp), %r8d
leaq 0x868(%rip), %rsi # 0x2185
leaq 0x714(%rip), %rdx # 0x2038
movl $0x46, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7a, -0x2c(%rbp)
jmp 0x1939
jmp 0x193b
cmpl $0x0, -0x2c(%rbp)
je 0x1946
jmp 0x19ef
jmp 0x1948
jmp 0x194a
jmp 0x194c
callq 0x1c70
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
leaq 0x29e4(%rip), %rax # 0x4358
movq (%rax), %rdx
leaq 0x29da(%rip), %rax # 0x4358
movq 0x8(%rax), %rcx
callq 0x1ca0
cmpq $0xea60, %rax # imm = 0xEA60
jle 0x19ba
movq 0x264a(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x83c(%rip), %rsi # 0x21dc
leaq 0x691(%rip), %rdx # 0x2038
movl $0x48, %ecx
movb $0x0, %al
callq 0x1100
movl $0x7d, -0x2c(%rbp)
jmp 0x19bc
cmpl $0x0, -0x2c(%rbp)
je 0x19c4
jmp 0x19ef
jmp 0x19c6
jmp 0x1792
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x1110
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x19ed
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x19ef
movq -0x20(%rbp), %rdi
callq 0x10f0
movq -0x18(%rbp), %rdi
callq 0x10c0
callq 0x1160
cmpl $0x0, -0x2c(%rbp)
je 0x1a12
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/lib1552.c |
10,106 | select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1a65
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a80
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x10b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/first.c |
10,107 | wait_ms | void wait_ms(int ms)
{
struct timeval t;
t.tv_sec = ms/1000;
ms -= (int)t.tv_sec * 1000;
t.tv_usec = ms * 1000;
select_wrapper(0, NULL, NULL, NULL, &t);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
imull $0x3e8, %eax, %ecx # imm = 0x3E8
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
imull $0x3e8, -0x4(%rbp), %eax # imm = 0x3E8
cltq
movq %rax, -0x10(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x1a30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/first.c |
10,108 | hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
snprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x25e9(%rip), %rax # 0x40f0
movq %rax, -0x20(%rbp)
cmpq $0xc8, -0x18(%rbp)
jbe 0x1b1f
movq $0x0, -0x8(%rbp)
jmp 0x1b79
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1b6e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0x4, %esi
leaq 0x6f3(%rip), %rdx # 0x2240
movb $0x0, %al
callq 0x1060
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b27
leaq 0x257b(%rip), %rax # 0x40f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/first.c |
10,109 | main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1ba8
movl $0x6, %edi
leaq 0x627(%rip), %rsi # 0x21db
callq 0x1090
cmpl $0x2, -0x8(%rbp)
jge 0x1be0
movq 0x241a(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x676(%rip), %rsi # 0x2246
movb $0x0, %al
callq 0x1100
movl $0x1, -0x4(%rbp)
jmp 0x1c58
movl -0x8(%rbp), %eax
movl %eax, 0x2763(%rip) # 0x434c
movq -0x10(%rbp), %rax
movq %rax, 0x275c(%rip) # 0x4350
cmpl $0x2, -0x8(%rbp)
jle 0x1c09
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24d7(%rip) # 0x40e0
cmpl $0x3, -0x8(%rbp)
jle 0x1c1e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x24ca(%rip) # 0x40e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x23af(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x624(%rip), %rsi # 0x2263
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rdi
callq 0x1270
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/first.c |
10,110 | tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
** clock drifting and external source time synchronization it can jump
** forward or backward in time.
*/
struct timeval now;
(void)gettimeofday(&now, NULL);
return now;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x1140
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/testutil.c |
10,111 | tutil_tvdiff | long tutil_tvdiff(struct timeval newer, struct timeval older)
{
return (long)(newer.tv_sec-older.tv_sec)*1000+
(long)(newer.tv_usec-older.tv_usec)/1000;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
imulq $0x3e8, %rax, %rax # imm = 0x3E8
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
subq -0x18(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/testutil.c |
10,112 | tutil_tvdiff_secs | double tutil_tvdiff_secs(struct timeval newer, struct timeval older)
{
if(newer.tv_sec != older.tv_sec)
return (double)(newer.tv_sec-older.tv_sec)+
(double)(newer.tv_usec-older.tv_usec)/1000000.0;
return (double)(newer.tv_usec-older.tv_usec)/1000000.0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x1d3f
movq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
cvtsi2sd %rax, %xmm0
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm1
movsd 0x540(%rip), %xmm2 # 0x2270
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1d5d
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x51c(%rip), %xmm1 # 0x2270
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
| DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1552.asm_src.json | O0 | DarovskikhAndrei[P]curl/tests/libtest/testutil.c |
10,113 | loadable_extension_optimizer_demo_init | DUCKDB_EXTENSION_API void loadable_extension_optimizer_demo_init(duckdb::DatabaseInstance &db) {
Connection con(db);
// add a parser extension
auto &config = DBConfig::GetConfig(db);
config.optimizer_extensions.push_back(WaggleExtension());
config.AddExtensionOption("waggle_location_host", "host for remote callback", LogicalType::VARCHAR);
config.AddExtensionOption("waggle_location_port", "port for remote callback", LogicalType::INTEGER);
} | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x220(%rsp)
movq 0x220(%rsp), %rsi
leaq 0x200(%rsp), %rdi
callq 0x23f00
movq 0x220(%rsp), %rdi
callq 0x25470
movq %rax, 0x40(%rsp)
jmp 0x256f8
movq 0x40(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
addq $0x590, %rax # imm = 0x590
movq %rax, 0x38(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x23c70
jmp 0x25727
movq 0x38(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x23040
jmp 0x2573b
leaq 0x1c8(%rsp), %rdi
callq 0x24da0
movq 0x1f8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x1a7(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x24fb0
movq 0x30(%rsp), %rdx
leaq 0xc891(%rip), %rsi # 0x32004
leaq 0x1a8(%rsp), %rdi
callq 0x243d0
jmp 0x25782
leaq 0x17f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x24fb0
movq 0x20(%rsp), %rdx
leaq 0xc879(%rip), %rsi # 0x32019
leaq 0x180(%rsp), %rdi
callq 0x243d0
jmp 0x257af
leaq 0x160(%rsp), %rdi
movl $0x19, %esi
callq 0x23570
jmp 0x257c3
leaq 0x108(%rsp), %rdi
movl $0x1, %esi
callq 0x23570
jmp 0x257d7
leaq 0x120(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x23ea0
jmp 0x257ee
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r9d
leaq 0x1a8(%rsp), %rsi
leaq 0x180(%rsp), %rdx
leaq 0x160(%rsp), %rcx
leaq 0x120(%rsp), %r8
callq 0x25290
jmp 0x2581f
leaq 0x120(%rsp), %rdi
callq 0x24c30
leaq 0x108(%rsp), %rdi
callq 0x238d0
leaq 0x160(%rsp), %rdi
callq 0x238d0
leaq 0x180(%rsp), %rdi
callq 0x22f20
leaq 0x17f(%rsp), %rdi
callq 0x23c00
leaq 0x1a8(%rsp), %rdi
callq 0x22f20
leaq 0x1a7(%rsp), %rdi
callq 0x23c00
movq 0x1f8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x24fb0
movq 0x18(%rsp), %rdx
leaq 0xc78d(%rip), %rsi # 0x32032
leaq 0xe8(%rsp), %rdi
callq 0x243d0
jmp 0x258b4
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x24fb0
movq 0x8(%rsp), %rdx
leaq 0xc775(%rip), %rsi # 0x32047
leaq 0xc0(%rsp), %rdi
callq 0x243d0
jmp 0x258e1
leaq 0xa0(%rsp), %rdi
movl $0xd, %esi
callq 0x23570
jmp 0x258f5
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x23570
jmp 0x25906
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x23ea0
jmp 0x25917
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %r9d
leaq 0xe8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x60(%rsp), %r8
callq 0x25290
jmp 0x25945
leaq 0x60(%rsp), %rdi
callq 0x24c30
leaq 0x48(%rsp), %rdi
callq 0x238d0
leaq 0xa0(%rsp), %rdi
callq 0x238d0
leaq 0xc0(%rsp), %rdi
callq 0x22f20
leaq 0xbf(%rsp), %rdi
callq 0x23c00
leaq 0xe8(%rsp), %rdi
callq 0x22f20
leaq 0xe7(%rsp), %rdi
callq 0x23c00
leaq 0x200(%rsp), %rdi
callq 0x229d0
addq $0x228, %rsp # imm = 0x228
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x24da0
jmp 0x25bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25ac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25aaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25a9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25a90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25a83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x24c30
leaq 0x108(%rsp), %rdi
callq 0x238d0
leaq 0x160(%rsp), %rdi
callq 0x238d0
leaq 0x180(%rsp), %rdi
callq 0x22f20
leaq 0x17f(%rsp), %rdi
callq 0x23c00
leaq 0x1a8(%rsp), %rdi
callq 0x22f20
leaq 0x1a7(%rsp), %rdi
callq 0x23c00
jmp 0x25bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25ba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25b8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25b7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x25b68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x24c30
leaq 0x48(%rsp), %rdi
callq 0x238d0
leaq 0xa0(%rsp), %rdi
callq 0x238d0
leaq 0xc0(%rsp), %rdi
callq 0x22f20
leaq 0xbf(%rsp), %rdi
callq 0x23c00
leaq 0xe8(%rsp), %rdi
callq 0x22f20
leaq 0xe7(%rsp), %rdi
callq 0x23c00
leaq 0x200(%rsp), %rdi
callq 0x229d0
movq 0x1f0(%rsp), %rdi
callq 0x24f70
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,114 | loadable_extension_optimizer_demo_version | DUCKDB_EXTENSION_API const char *loadable_extension_optimizer_demo_version() {
return DuckDB::LibraryVersion();
} | pushq %rax
callq 0x232f0
popq %rcx
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,115 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::push_back(duckdb::OptimizerExtension&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x235f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,116 | WaggleExtension::WaggleExtension() | WaggleExtension() {
optimize_function = WaggleOptimizeFunction;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23c50
movq 0x8(%rsp), %rax
movq 0x1538c(%rip), %rcx # 0x3afc0
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,117 | WaggleExtension::~WaggleExtension() | WaggleExtension() {
optimize_function = WaggleOptimizeFunction;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24300
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,118 | WaggleExtension::WaggleOptimizeFunction(duckdb::OptimizerExtensionInput&, duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>&) | static void WaggleOptimizeFunction(OptimizerExtensionInput &input, duckdb::unique_ptr<LogicalOperator> &plan) {
if (!HasParquetScan(*plan)) {
return;
}
// rpc
auto &context = input.context;
Value host, port;
if (!context.TryGetCurrentSetting("waggle_location_host", host) ||
!context.TryGetCurrentSetting("waggle_location_port", port)) {
throw InvalidInputException("Need the parameters damnit");
}
// socket create and verification
auto sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sockfd == -1) {
throw InternalException("Failed to create socket");
}
struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
// assign IP, PORT
servaddr.sin_family = AF_INET;
auto host_string = host.ToString();
servaddr.sin_addr.s_addr = inet_addr(host_string.c_str());
servaddr.sin_port = htons(port.GetValue<int32_t>());
// connect the client socket to server socket
if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0) {
throw IOException("Failed to connect socket %s", string(strerror(errno)));
}
Allocator allocator;
MemoryStream stream(allocator);
BinarySerializer serializer(stream);
serializer.Begin();
plan->Serialize(serializer);
serializer.End();
auto data = stream.GetData();
idx_t len = stream.GetPosition();
WriteChecked(sockfd, &len, sizeof(idx_t));
WriteChecked(sockfd, data, len);
auto chunk_collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator());
idx_t n_chunks;
ReadChecked(sockfd, &n_chunks, sizeof(idx_t));
for (idx_t i = 0; i < n_chunks; i++) {
idx_t chunk_len;
ReadChecked(sockfd, &chunk_len, sizeof(idx_t));
auto buffer = malloc(chunk_len);
D_ASSERT(buffer);
ReadChecked(sockfd, buffer, chunk_len);
MemoryStream source(data_ptr_cast(buffer), chunk_len);
DataChunk chunk;
BinaryDeserializer deserializer(source);
deserializer.Begin();
chunk.Deserialize(deserializer);
deserializer.End();
chunk_collection->Initialize(chunk.GetTypes());
chunk_collection->Append(chunk);
free(buffer);
}
auto types = chunk_collection->Types();
plan = make_uniq<LogicalColumnDataGet>(0, types, std::move(chunk_collection));
len = 0;
(void)len;
WriteChecked(sockfd, &len, sizeof(idx_t));
// close the socket
close(sockfd);
} | subq $0xc18, %rsp # imm = 0xC18
movq %rdi, 0xc10(%rsp)
movq %rsi, 0xc08(%rsp)
movq 0xc08(%rsp), %rdi
callq 0x23190
movq %rax, %rdi
callq 0x22e50
testb $0x1, %al
jne 0x25cb5
jmp 0x26a03
movq 0xc10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xc00(%rsp)
leaq 0xba8(%rsp), %rdi
movq %rdi, 0xd8(%rsp)
movl $0x1, %esi
callq 0x23570
movq 0xd8(%rsp), %rsi
leaq 0xbc0(%rsp), %rdi
callq 0x23ea0
jmp 0x25cf9
leaq 0xba8(%rsp), %rdi
callq 0x238d0
leaq 0xb40(%rsp), %rdi
movl $0x1, %esi
callq 0x23570
jmp 0x25d1a
leaq 0xb58(%rsp), %rdi
leaq 0xb40(%rsp), %rsi
callq 0x23ea0
jmp 0x25d31
leaq 0xb40(%rsp), %rdi
callq 0x238d0
movq 0xc00(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0xb17(%rsp), %rdi
movq %rdi, 0xd0(%rsp)
callq 0x24fb0
movq 0xd0(%rsp), %rdx
movb $0x0, 0xaee(%rsp)
movb $0x0, 0xaed(%rsp)
leaq 0xc282(%rip), %rsi # 0x32004
leaq 0xb18(%rsp), %rdi
callq 0x243d0
jmp 0x25d91
movq 0xc8(%rsp), %rdi
leaq 0xb18(%rsp), %rsi
leaq 0xbc0(%rsp), %rdx
callq 0x22400
movb %al, 0xc7(%rsp)
jmp 0x25db7
movb 0xc7(%rsp), %al
movb %al, 0xb3f(%rsp)
leaq 0xb3f(%rsp), %rdi
callq 0x220f0
movb %al, 0xc6(%rsp)
jmp 0x25ddb
movb 0xc6(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xc5(%rsp)
jne 0x25df5
jmp 0x25ea2
movq 0xc00(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0xaef(%rsp), %rdi
movq %rdi, 0xb8(%rsp)
callq 0x24fb0
movq 0xb8(%rsp), %rdx
movb $0x1, 0xaee(%rsp)
leaq 0xc201(%rip), %rsi # 0x32032
leaq 0xaf0(%rsp), %rdi
callq 0x243d0
jmp 0x25e40
movq 0xb0(%rsp), %rdi
movb $0x1, 0xaed(%rsp)
leaq 0xaf0(%rsp), %rsi
leaq 0xb58(%rsp), %rdx
callq 0x22400
movb %al, 0xaf(%rsp)
jmp 0x25e6e
movb 0xaf(%rsp), %al
movb %al, 0xb16(%rsp)
leaq 0xb16(%rsp), %rdi
callq 0x220f0
movb %al, 0xae(%rsp)
jmp 0x25e92
movb 0xae(%rsp), %al
xorb $-0x1, %al
movb %al, 0xc5(%rsp)
movb 0xc5(%rsp), %al
movb %al, 0xad(%rsp)
testb $0x1, 0xaed(%rsp)
jne 0x25ebc
jmp 0x25ec9
leaq 0xaf0(%rsp), %rdi
callq 0x22f20
testb $0x1, 0xaee(%rsp)
jne 0x25ed5
jmp 0x25ee2
leaq 0xaef(%rsp), %rdi
callq 0x23c00
leaq 0xb18(%rsp), %rdi
callq 0x22f20
leaq 0xb17(%rsp), %rdi
callq 0x23c00
movb 0xad(%rsp), %al
testb $0x1, %al
jne 0x25f0c
jmp 0x2610d
movb $0x1, 0xac6(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x98(%rsp)
leaq 0xac7(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
callq 0x24fb0
movq 0xa0(%rsp), %rdx
leaq 0xc116(%rip), %rsi # 0x32060
leaq 0xac8(%rsp), %rdi
callq 0x243d0
jmp 0x25f59
movq 0x98(%rsp), %rdi
leaq 0xac8(%rsp), %rsi
callq 0x23c20
jmp 0x25f70
movq 0x98(%rsp), %rdi
movb $0x0, 0xac6(%rsp)
movq 0x15021(%rip), %rsi # 0x3afa8
movq 0x15022(%rip), %rdx # 0x3afb0
callq 0x24dd0
jmp 0x26a94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xba8(%rsp), %rdi
callq 0x238d0
jmp 0x26a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xb40(%rsp), %rdi
callq 0x238d0
jmp 0x26a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x2608c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26071
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
testb $0x1, 0xaed(%rsp)
jne 0x26062
jmp 0x2606f
leaq 0xaf0(%rsp), %rdi
callq 0x22f20
jmp 0x26071
testb $0x1, 0xaee(%rsp)
jne 0x2607d
jmp 0x2608a
leaq 0xaef(%rsp), %rdi
callq 0x23c00
jmp 0x2608c
leaq 0xb18(%rsp), %rdi
callq 0x22f20
leaq 0xb17(%rsp), %rdi
callq 0x23c00
jmp 0x26a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x260e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xac8(%rsp), %rdi
callq 0x22f20
leaq 0xac7(%rsp), %rdi
callq 0x23c00
testb $0x1, 0xac6(%rsp)
jne 0x260fb
jmp 0x26108
movq 0x98(%rsp), %rdi
callq 0x231d0
jmp 0x26a6d
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x22520
movl %eax, 0xac0(%rsp)
cmpl $-0x1, 0xac0(%rsp)
jne 0x26224
movb $0x1, 0xa9e(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x88(%rsp)
leaq 0xa9f(%rsp), %rdi
movq %rdi, 0x90(%rsp)
callq 0x24fb0
movq 0x90(%rsp), %rdx
leaq 0xbf07(%rip), %rsi # 0x3207b
leaq 0xaa0(%rsp), %rdi
callq 0x243d0
jmp 0x26183
movq 0x88(%rsp), %rdi
leaq 0xaa0(%rsp), %rsi
callq 0x23720
jmp 0x2619a
movq 0x88(%rsp), %rdi
movb $0x0, 0xa9e(%rsp)
movq 0x14ddf(%rip), %rsi # 0x3af90
movq 0x14dd0(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x26a94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x261f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xaa0(%rsp), %rdi
callq 0x22f20
leaq 0xa9f(%rsp), %rdi
callq 0x23c00
testb $0x1, 0xa9e(%rsp)
jne 0x26212
jmp 0x2621f
movq 0x88(%rsp), %rdi
callq 0x231d0
jmp 0x26a6d
leaq 0xa8c(%rsp), %rdi
movl $0x10, %esi
callq 0x24e60
movw $0x2, 0xa8c(%rsp)
leaq 0xa68(%rsp), %rdi
leaq 0xbc0(%rsp), %rsi
callq 0x225f0
jmp 0x26257
leaq 0xa68(%rsp), %rdi
callq 0x22900
movq %rax, %rdi
callq 0x23a30
movl %eax, 0xa90(%rsp)
leaq 0xb58(%rsp), %rdi
callq 0x23210
movl %eax, 0x84(%rsp)
jmp 0x26289
movl 0x84(%rsp), %eax
movzwl %ax, %edi
callq 0x221a0
movw %ax, 0xa8e(%rsp)
movl 0xac0(%rsp), %edi
leaq 0xa8c(%rsp), %rsi
movl $0x10, %edx
callq 0x23590
movl %eax, 0x80(%rsp)
jmp 0x262c2
movl 0x80(%rsp), %eax
cmpl $0x0, %eax
je 0x26454
movb $0x1, 0xa1e(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x70(%rsp)
leaq 0xa47(%rsp), %rdi
movq %rdi, 0x78(%rsp)
callq 0x24fb0
movq 0x78(%rsp), %rdx
leaq 0xbd8c(%rip), %rsi # 0x32093
leaq 0xa48(%rsp), %rdi
callq 0x243d0
jmp 0x26316
callq 0x22120
movl (%rax), %edi
callq 0x22780
movq %rax, 0x60(%rsp)
leaq 0xa1f(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x24fb0
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0xa20(%rsp), %rdi
callq 0x243d0
jmp 0x26352
movq 0x70(%rsp), %rdi
leaq 0xa48(%rsp), %rsi
leaq 0xa20(%rsp), %rdx
callq 0x23620
jmp 0x2636e
movq 0x70(%rsp), %rdi
movb $0x0, 0xa1e(%rsp)
movq 0x14be6(%rip), %rsi # 0x3af68
movq 0x14c4f(%rip), %rdx # 0x3afd8
callq 0x24dd0
jmp 0x26a94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x2642c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xa20(%rsp), %rdi
callq 0x22f20
leaq 0xa1f(%rsp), %rdi
callq 0x23c00
leaq 0xa48(%rsp), %rdi
callq 0x22f20
leaq 0xa47(%rsp), %rdi
callq 0x23c00
testb $0x1, 0xa1e(%rsp)
jne 0x26445
jmp 0x2644f
movq 0x70(%rsp), %rdi
callq 0x231d0
jmp 0x26a60
leaq 0x9f8(%rsp), %rdi
callq 0x22d70
jmp 0x26463
leaq 0x9c8(%rsp), %rdi
leaq 0x9f8(%rsp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x22cf0
jmp 0x2647f
xorps %xmm0, %xmm0
movaps %xmm0, 0x480(%rsp)
movaps %xmm0, 0x470(%rsp)
movaps %xmm0, 0x460(%rsp)
movq $0x0, 0x490(%rsp)
leaq 0x460(%rsp), %rdi
callq 0x229e0
jmp 0x264b5
leaq 0x498(%rsp), %rdi
leaq 0x9c8(%rsp), %rsi
leaq 0x460(%rsp), %rdx
callq 0x22200
jmp 0x264d4
leaq 0x460(%rsp), %rdi
callq 0x24b60
leaq 0x498(%rsp), %rdi
callq 0x22f80
jmp 0x264f0
movq 0xc08(%rsp), %rdi
callq 0x22470
movq %rax, 0x58(%rsp)
jmp 0x26504
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq 0x498(%rsp), %rsi
callq *%rax
jmp 0x2651c
leaq 0x498(%rsp), %rdi
callq 0x24590
jmp 0x2652b
leaq 0x9c8(%rsp), %rdi
callq 0x24fc0
movq %rax, 0x50(%rsp)
jmp 0x2653f
movq 0x50(%rsp), %rax
movq %rax, 0x458(%rsp)
leaq 0x9c8(%rsp), %rdi
callq 0x24600
movq %rax, 0x48(%rsp)
jmp 0x26560
movq 0x48(%rsp), %rax
movq %rax, 0x450(%rsp)
movl 0xac0(%rsp), %edi
leaq 0x450(%rsp), %rsi
movl $0x8, %edx
callq 0x22f10
jmp 0x26588
movl 0xac0(%rsp), %edi
movq 0x458(%rsp), %rsi
movq 0x450(%rsp), %rdx
callq 0x22f10
jmp 0x265a6
callq 0x255a0
movq %rax, 0x40(%rsp)
jmp 0x265b2
movq 0x40(%rsp), %rsi
leaq 0x448(%rsp), %rdi
callq 0x24e30
jmp 0x265c6
movl 0xac0(%rsp), %edi
leaq 0x440(%rsp), %rsi
movl $0x8, %edx
callq 0x22de0
jmp 0x265e1
movq $0x0, 0x438(%rsp)
movq 0x438(%rsp), %rax
cmpq 0x440(%rsp), %rax
jae 0x268b6
movl 0xac0(%rsp), %edi
leaq 0x430(%rsp), %rsi
movl $0x8, %edx
callq 0x22de0
jmp 0x2661e
movq 0x430(%rsp), %rdi
callq 0x24290
movq %rax, 0x428(%rsp)
movl 0xac0(%rsp), %edi
movq 0x428(%rsp), %rsi
movq 0x430(%rsp), %rdx
callq 0x22de0
jmp 0x26651
movq 0x428(%rsp), %rdi
callq 0x23420
movq %rax, 0x38(%rsp)
jmp 0x26665
movq 0x38(%rsp), %rsi
movq 0x430(%rsp), %rdx
leaq 0x3f8(%rsp), %rdi
callq 0x222b0
jmp 0x26681
leaq 0x3b8(%rsp), %rdi
callq 0x24630
jmp 0x26690
leaq 0x400(%rsp), %rsi
leaq 0x128(%rsp), %rdi
callq 0x23e10
jmp 0x266a7
leaq 0x128(%rsp), %rdi
callq 0x22110
jmp 0x266b6
leaq 0x3b8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x228d0
jmp 0x266cd
leaq 0x128(%rsp), %rdi
callq 0x24db0
jmp 0x266dc
leaq 0x448(%rsp), %rdi
callq 0x22290
movq %rax, 0x30(%rsp)
jmp 0x266f0
leaq 0x110(%rsp), %rdi
leaq 0x3b8(%rsp), %rsi
callq 0x252e0
jmp 0x26707
movq 0x30(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x230c0
jmp 0x2671b
leaq 0x110(%rsp), %rdi
callq 0x239e0
leaq 0x448(%rsp), %rdi
callq 0x22290
movq %rax, 0x28(%rsp)
jmp 0x2673c
movq 0x28(%rsp), %rdi
leaq 0x3b8(%rsp), %rsi
callq 0x24730
jmp 0x26750
movq 0x428(%rsp), %rdi
callq 0x23f80
leaq 0x128(%rsp), %rdi
callq 0x23da0
leaq 0x3b8(%rsp), %rdi
callq 0x24870
leaq 0x3f8(%rsp), %rdi
callq 0x23cd0
movq 0x438(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x438(%rsp)
jmp 0x265ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0x460(%rsp), %rdi
callq 0x24b60
jmp 0x26a46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26a2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x268a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x26897
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
jmp 0x2688a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x239e0
leaq 0x128(%rsp), %rdi
callq 0x23da0
leaq 0x3b8(%rsp), %rdi
callq 0x24870
leaq 0x3f8(%rsp), %rdi
callq 0x23cd0
jmp 0x26a2c
leaq 0x448(%rsp), %rdi
callq 0x22290
movq %rax, 0x20(%rsp)
jmp 0x268ca
movq 0x20(%rsp), %rdi
callq 0x245d0
movq %rax, 0x18(%rsp)
jmp 0x268db
movq 0x18(%rsp), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x220d0
jmp 0x268ef
movl $0x0, 0xe4(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe4(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
leaq 0x448(%rsp), %rcx
callq 0x23800
jmp 0x26921
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xe8(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x240d0
movq 0x8(%rsp), %rsi
movq 0xc08(%rsp), %rdi
callq 0x223b0
movq 0x8(%rsp), %rdi
callq 0x25070
movq 0x10(%rsp), %rdi
callq 0x254b0
movq $0x0, 0x450(%rsp)
movl 0xac0(%rsp), %edi
leaq 0x450(%rsp), %rsi
movl $0x8, %edx
callq 0x22f10
jmp 0x2698d
movl 0xac0(%rsp), %edi
callq 0x254a0
jmp 0x2699b
leaq 0xf8(%rsp), %rdi
callq 0x239e0
leaq 0x448(%rsp), %rdi
callq 0x24700
leaq 0x498(%rsp), %rdi
callq 0x22be0
leaq 0x9c8(%rsp), %rdi
callq 0x23cd0
leaq 0x9f8(%rsp), %rdi
callq 0x24160
leaq 0xa68(%rsp), %rdi
callq 0x22f20
leaq 0xb58(%rsp), %rdi
callq 0x24c30
leaq 0xbc0(%rsp), %rdi
callq 0x24c30
addq $0xc18, %rsp # imm = 0xC18
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xba0(%rsp)
movl %eax, 0xb9c(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x239e0
leaq 0x448(%rsp), %rdi
callq 0x24700
leaq 0x498(%rsp), %rdi
callq 0x22be0
leaq 0x9c8(%rsp), %rdi
callq 0x23cd0
leaq 0x9f8(%rsp), %rdi
callq 0x24160
leaq 0xa68(%rsp), %rdi
callq 0x22f20
leaq 0xb58(%rsp), %rdi
callq 0x24c30
leaq 0xbc0(%rsp), %rdi
callq 0x24c30
movq 0xba0(%rsp), %rdi
callq 0x24f70
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,119 | duckdb::shared_ptr<duckdb::OptimizerExtensionInfo, true>::shared_ptr() | shared_ptr() : internal() {
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24c00
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp |
10,120 | std::shared_ptr<duckdb::OptimizerExtensionInfo>::shared_ptr() | constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x222e0
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
10,121 | std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2>::__shared_ptr() | constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x23080
popq %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,122 | std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count() | constexpr __shared_count() noexcept : _M_pi(0)
{ } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,123 | WaggleExtension::HasParquetScan(duckdb::LogicalOperator&) | static bool HasParquetScan(LogicalOperator &op) {
if (op.type == LogicalOperatorType::LOGICAL_GET) {
auto &get = op.Cast<LogicalGet>();
return get.function.name == "parquet_scan";
}
for (auto &child : op.children) {
if (HasParquetScan(*child)) {
return true;
}
}
return false;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpb $0x19, 0x8(%rax)
jne 0x26b47
movq 0x28(%rsp), %rdi
callq 0x24b10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x70, %rdi
addq $0x8, %rdi
leaq 0xb578(%rip), %rsi # 0x320af
callq 0x25580
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x26bc7
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x23d80
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x23e80
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x23440
testb $0x1, %al
jne 0x26b88
jmp 0x26bc2
leaq 0x10(%rsp), %rdi
callq 0x22880
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x23190
movq %rax, %rdi
callq 0x22e50
testb $0x1, %al
jne 0x26bad
jmp 0x26bb4
movb $0x1, 0x37(%rsp)
jmp 0x26bc7
jmp 0x26bb6
leaq 0x10(%rsp), %rdi
callq 0x23200
jmp 0x26b73
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,124 | duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>::operator*() const | typename std::add_lvalue_reference<DATA_TYPE>::type operator*() const { // NOLINT: hiding on purpose
const auto ptr = original::get();
if (MemorySafety<SAFE>::ENABLED) {
AssertNotNull(!ptr);
}
return *ptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x22760
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x22910
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/unique_ptr.hpp |
10,125 | duckdb::SettingLookupResult::operator bool() | operator bool() { // NOLINT: allow implicit conversion to bool
return scope != SettingScope::INVALID;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x3, (%rax)
setne %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/main/settings.hpp |
10,126 | duckdb::IOException::IOException<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | explicit IOException(const string &msg, ARGS... params) : IOException(ConstructMessage(msg, params...)) {
} | subq $0x88, %rsp
movq %rdx, (%rsp)
movq %rsi, %rax
movq (%rsp), %rsi
movq %rdi, 0x80(%rsp)
movq %rax, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22a00
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x25490
jmp 0x26cc0
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x25370
jmp 0x26cd1
leaq 0x50(%rsp), %rdi
callq 0x22f20
leaq 0x30(%rsp), %rdi
callq 0x22f20
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x26d15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x22f20
leaq 0x30(%rsp), %rdi
callq 0x22f20
movq 0x28(%rsp), %rdi
callq 0x24f70
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/exception.hpp |
10,127 | duckdb::SerializationOptions::SerializationOptions() | SerializationOptions() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movb $0x0, (%rdi)
movb $0x0, 0x1(%rdi)
addq $0x8, %rdi
callq 0x23310
popq %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/serializer.hpp |
10,128 | duckdb::BinarySerializer::BinarySerializer(duckdb::WriteStream&, duckdb::SerializationOptions) | explicit BinarySerializer(WriteStream &stream, SerializationOptions options_p = SerializationOptions())
: stream(stream) {
options = std::move(options_p);
// Override the value set by the passed in SerializationOptions
options.serialize_enum_as_string = false;
} | subq $0x48, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22690
movq 0x18(%rsp), %rdi
movq 0x14205(%rip), %rax # 0x3af98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x2a8, %rdi # imm = 0x2A8
movq %rdi, 0x10(%rsp)
callq 0x22a40
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x2c0(%rdi)
addq $0x2c8, %rdi # imm = 0x2C8
callq 0x25300
jmp 0x26dca
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rdi
callq 0x234b0
movq 0x18(%rsp), %rax
movb $0x0, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x23430
movq 0x18(%rsp), %rdi
callq 0x23220
movq 0x28(%rsp), %rdi
callq 0x24f70
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp |
10,129 | duckdb::SerializationOptions::~SerializationOptions() | SerializationOptions() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x25330
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/serializer.hpp |
10,130 | duckdb::BinarySerializer::Begin() | void Begin() {
OnObjectBegin();
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x230a0
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp |
10,131 | duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>::operator->() const | typename original::pointer operator->() const { // NOLINT: hiding on purpose
const auto ptr = original::get();
if (MemorySafety<SAFE>::ENABLED) {
AssertNotNull(!ptr);
}
return ptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x22760
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x22910
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/unique_ptr.hpp |
10,132 | duckdb::BinarySerializer::End() | void End() {
OnObjectEnd();
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22b80
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp |
10,133 | WaggleExtension::WriteChecked(int, void*, unsigned long) | static void WriteChecked(int sockfd, void *data, idx_t write_size) {
auto bytes_written = write(sockfd, data, write_size);
if (bytes_written < 0) {
throw InternalException("Failed to write \"%lld\" bytes to socket: %s", write_size, strerror(errno));
}
if (idx_t(bytes_written) != write_size) {
throw InternalException("Failed to write \"%llu\" bytes from socket - wrote %llu instead", write_size,
bytes_written);
}
} | subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movl 0xa4(%rsp), %edi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x227e0
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
jge 0x26fca
movb $0x1, 0x53(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x18(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x24fb0
movq 0x20(%rsp), %rdx
leaq 0xb252(%rip), %rsi # 0x32172
leaq 0x68(%rsp), %rdi
callq 0x243d0
jmp 0x26f2c
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x22120
movl (%rax), %edi
callq 0x22780
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x68(%rsp), %rsi
callq 0x23070
jmp 0x26f5e
movq 0x18(%rsp), %rdi
movb $0x0, 0x53(%rsp)
movq 0x14021(%rip), %rsi # 0x3af90
movq 0x14012(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x270b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x26fa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x22f20
leaq 0x67(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x53(%rsp)
jne 0x26fbb
jmp 0x26fc5
movq 0x18(%rsp), %rdi
callq 0x231d0
jmp 0x270a6
movq 0x88(%rsp), %rax
cmpq 0x90(%rsp), %rax
je 0x2709e
movb $0x1, 0x2e(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x24fb0
movq 0x8(%rsp), %rdx
leaq 0xb18f(%rip), %rsi # 0x3219d
leaq 0x30(%rsp), %rdi
callq 0x243d0
jmp 0x2701a
movq (%rsp), %rdi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x30(%rsp), %rsi
callq 0x231b0
jmp 0x2703a
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0x13f46(%rip), %rsi # 0x3af90
movq 0x13f37(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x270b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x27080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x2f(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x2e(%rsp)
jne 0x27093
jmp 0x2709c
movq (%rsp), %rdi
callq 0x231d0
jmp 0x270a6
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x24f70
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,134 | WaggleExtension::ReadChecked(int, void*, unsigned long) | static void ReadChecked(int sockfd, void *data, idx_t read_size) {
auto bytes_read = read(sockfd, data, read_size);
if (bytes_read < 0) {
throw InternalException("Failed to read \"%lld\" bytes from socket: %s", read_size, strerror(errno));
}
if (idx_t(bytes_read) != read_size) {
throw InternalException("Failed to read \"%llu\" bytes from socket - read %llu instead", read_size,
bytes_read);
}
} | subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movl 0xa4(%rsp), %edi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x245a0
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
jge 0x2725a
movb $0x1, 0x53(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x18(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x24fb0
movq 0x20(%rsp), %rdx
leaq 0xb02b(%rip), %rsi # 0x321db
leaq 0x68(%rsp), %rdi
callq 0x243d0
jmp 0x271bc
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x22120
movl (%rax), %edi
callq 0x22780
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x68(%rsp), %rsi
callq 0x23070
jmp 0x271ee
movq 0x18(%rsp), %rdi
movb $0x0, 0x53(%rsp)
movq 0x13d91(%rip), %rsi # 0x3af90
movq 0x13d82(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x27340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x27238
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x22f20
leaq 0x67(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x53(%rsp)
jne 0x2724b
jmp 0x27255
movq 0x18(%rsp), %rdi
callq 0x231d0
jmp 0x27336
movq 0x88(%rsp), %rax
cmpq 0x90(%rsp), %rax
je 0x2732e
movb $0x1, 0x2e(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x24fb0
movq 0x8(%rsp), %rdx
leaq 0xaf69(%rip), %rsi # 0x32207
leaq 0x30(%rsp), %rdi
callq 0x243d0
jmp 0x272aa
movq (%rsp), %rdi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x30(%rsp), %rsi
callq 0x231b0
jmp 0x272ca
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0x13cb6(%rip), %rsi # 0x3af90
movq 0x13ca7(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x27340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x27310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x2f(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x2e(%rsp)
jne 0x27323
jmp 0x2732c
movq (%rsp), %rdi
callq 0x231d0
jmp 0x27336
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x24f70
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/test/extension/loadable_extension_optimizer_demo.cpp |
10,135 | unsigned char* duckdb::data_ptr_cast<void>(void*) | data_ptr_t data_ptr_cast(SRC *src) { // NOLINT: naming
return reinterpret_cast<data_ptr_t>(src);
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/typedefs.hpp |
10,136 | duckdb::BinaryDeserializer::BinaryDeserializer(duckdb::ReadStream&) | explicit BinaryDeserializer(ReadStream &stream) : stream(stream) {
deserialize_enum_from_string = false;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x235a0
movq (%rsp), %rax
movq 0x13c51(%rip), %rcx # 0x3afc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x278(%rax)
movq $0x0, 0x280(%rax)
movb $0x0, 0x288(%rax)
movw $0x0, 0x28a(%rax)
movb $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp |
10,137 | duckdb::BinaryDeserializer::Begin() | void Begin() {
OnObjectBegin();
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23060
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp |
10,138 | duckdb::BinaryDeserializer::End() | void End() {
OnObjectEnd();
D_ASSERT(nesting_level == 0); // make sure we are at the root level
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x254e0
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp |
10,139 | duckdb::unique_ptr<duckdb::ColumnDataCollection, std::default_delete<duckdb::ColumnDataCollection>, true>::operator->() const | typename original::pointer operator->() const { // NOLINT: hiding on purpose
const auto ptr = original::get();
if (MemorySafety<SAFE>::ENABLED) {
AssertNotNull(!ptr);
}
return ptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x23cf0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x22070
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/unique_ptr.hpp |
10,140 | duckdb::BinaryDeserializer::~BinaryDeserializer() | explicit BinaryDeserializer(ReadStream &stream) : stream(stream) {
deserialize_enum_from_string = false;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22870
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp |
10,141 | duckdb::ColumnDataCollection::Types() | vector<LogicalType> &Types() {
return types;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x10, %rax
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp |
10,142 | duckdb::BinarySerializer::~BinarySerializer() | explicit BinarySerializer(WriteStream &stream, SerializationOptions options_p = SerializationOptions())
: stream(stream) {
options = std::move(options_p);
// Override the value set by the passed in SerializationOptions
options.serialize_enum_as_string = false;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x1395e(%rip), %rax # 0x3af98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x2c8, %rdi # imm = 0x2C8
callq 0x24900
movq 0x8(%rsp), %rdi
addq $0x2a8, %rdi # imm = 0x2A8
callq 0x23430
movq 0x8(%rsp), %rdi
callq 0x23220
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp |
10,143 | duckdb::LogicalGet& duckdb::LogicalOperator::Cast<duckdb::LogicalGet>() | TARGET &Cast() {
if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
}
return reinterpret_cast<TARGET &>(*this);
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpb $0x19, 0x8(%rax)
je 0x2773b
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x24fb0
movq 0x8(%rsp), %rdx
leaq 0xaa01(%rip), %rsi # 0x320bc
leaq 0x30(%rsp), %rdi
callq 0x243d0
jmp 0x276c7
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x23720
jmp 0x276d7
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x138a9(%rip), %rsi # 0x3af90
movq 0x1389a(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x2774f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x2771d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x2f(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x1b(%rsp)
jne 0x27730
jmp 0x27739
movq (%rsp), %rdi
callq 0x231d0
jmp 0x27745
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x24f70
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/planner/logical_operator.hpp |
10,144 | bool std::operator==<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) == 0; } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x225b0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,145 | std::vector<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>, std::allocator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x24f10
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,146 | std::vector<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>, std::allocator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %rdi
callq 0x24f10
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,147 | _gnu_cxx::__normal_iterator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>*, std::vector<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>, std::allocator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
10,148 | _gnu_cxx::__normal_iterator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>*, std::vector<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>, std::allocator<duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>>>>::__normal_iterator(duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
10,149 | std::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>>::get() const | pointer
get() const noexcept
{ return _M_t._M_ptr(); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x234a0
movq %rax, 0x8(%rsp)
jmp 0x2789a
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,150 | duckdb::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>, true>::AssertNotNull(bool) | static inline void AssertNotNull(const bool null) {
#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
return;
#else
if (DUCKDB_UNLIKELY(null)) {
throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
}
#endif
} | subq $0x58, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
je 0x2797a
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x22b10
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x24fb0
movq 0x10(%rsp), %rdx
leaq 0xa80e(%rip), %rsi # 0x32105
leaq 0x30(%rsp), %rdi
callq 0x243d0
jmp 0x27903
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x23720
jmp 0x27914
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x1366b(%rip), %rsi # 0x3af90
movq 0x1365c(%rip), %rdx # 0x3af88
callq 0x24dd0
jmp 0x27989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x2795b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x2f(%rsp), %rdi
callq 0x23c00
testb $0x1, 0x1b(%rsp)
jne 0x2796e
jmp 0x27978
movq 0x8(%rsp), %rdi
callq 0x231d0
jmp 0x2797f
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x24f70
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/unique_ptr.hpp |
10,151 | std::__uniq_ptr_impl<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>>::_M_ptr() const | pointer _M_ptr() const { return std::get<0>(_M_t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24c20
movq (%rax), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,152 | std::tuple_element<0ul, std::tuple<duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>>>::type const& std::get<0ul, duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>>(std::tuple<duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>> const&) | constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22a20
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,153 | duckdb::LogicalOperator* const& std::__get_helper<0ul, duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>>(std::_Tuple_impl<0ul, duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>> const&) | constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x25350
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,154 | std::_Tuple_impl<0ul, duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>>::_M_head(std::_Tuple_impl<0ul, duckdb::LogicalOperator*, std::default_delete<duckdb::LogicalOperator>> const&) | static constexpr const _Head&
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22c90
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,155 | std::_Head_base<0ul, duckdb::LogicalOperator*, false>::_M_head(std::_Head_base<0ul, duckdb::LogicalOperator*, false> const&) | static constexpr const _Head&
_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,156 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::Exception::ConstructMessage<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | static string ConstructMessage(const string &msg, ARGS... params) {
const std::size_t num_args = sizeof...(ARGS);
if (num_args == 0) {
return msg;
}
std::vector<ExceptionFormatValue> values;
return ConstructMessageRecursive(msg, values, params...);
} | subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq $0x1, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x23410
movq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22a00
jmp 0x27a68
movq 0x18(%rsp), %rsi
movq (%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x25450
jmp 0x27a82
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x50(%rsp), %rdi
callq 0x22380
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x27acb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22f20
leaq 0x50(%rsp), %rdi
callq 0x22380
movq 0x28(%rsp), %rdi
callq 0x24f70
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/exception.hpp |
10,157 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::vector() | vector() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24320
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,158 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::Exception::ConstructMessageRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values, T param,
ARGS... params) {
values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
return ConstructMessageRecursive(msg, values, params...);
} | subq $0xb8, %rsp
movq %rcx, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rdi, 0x10(%rsp)
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x22a00
movq 0x28(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x24750
jmp 0x27b5e
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x24030
jmp 0x27b6f
leaq 0x60(%rsp), %rdi
callq 0x25280
leaq 0x40(%rsp), %rdi
callq 0x22f20
movq 0x10(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x24c60
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x27bd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x25280
leaq 0x40(%rsp), %rdi
callq 0x22f20
movq 0x38(%rsp), %rdi
callq 0x24f70
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/exception.hpp |
10,159 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0x23a60
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x222c0
jmp 0x27c2d
movq 0x8(%rsp), %rdi
callq 0x23840
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,160 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_Vector_base() | _Vector_base() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x230d0
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,161 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x22ab0
movq 0x8(%rsp), %rdi
callq 0x23a90
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,162 | std::allocator<duckdb::ExceptionFormatValue>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22af0
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
10,163 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,164 | _gnu_cxx::new_allocator<duckdb::ExceptionFormatValue>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,165 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::push_back(duckdb::ExceptionFormatValue&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x254f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,166 | void std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::emplace_back<duckdb::ExceptionFormatValue>(duckdb::ExceptionFormatValue&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x27d78
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x18(%rsp), %rdx
callq 0x22160
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
jmp 0x27d9b
movq 0x8(%rsp), %rdi
callq 0x23cc0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
callq 0x24ff0
addq $0x28, %rsp
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
10,167 | void std::allocator_traits<std::allocator<duckdb::ExceptionFormatValue>>::construct<duckdb::ExceptionFormatValue, duckdb::ExceptionFormatValue>(std::allocator<duckdb::ExceptionFormatValue>&, duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x22c00
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,168 | void std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_realloc_insert<duckdb::ExceptionFormatValue>(__gnu_cxx::__normal_iterator<duckdb::ExceptionFormatValue*, std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>>, duckdb::ExceptionFormatValue&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | subq $0x88, %rsp
movq %rsi, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x1, %esi
leaq 0xa338(%rip), %rdx # 0x32137
callq 0x23d00
movq 0x30(%rsp), %rdi
movq %rax, 0x68(%rsp)
movq (%rdi), %rax
movq %rax, 0x60(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x58(%rsp)
callq 0x22d60
movq %rax, 0x48(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x23b50
movq 0x30(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rsi
callq 0x23e70
movq 0x30(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rsi
imulq $0x38, 0x50(%rsp), %rax
addq %rax, %rsi
movq 0x70(%rsp), %rdx
callq 0x22160
movq $0x0, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x24ae0
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x23a60
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x239f0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x38(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x24ae0
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x23a60
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
callq 0x239f0
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rsi
movq 0x10(%rdi), %rax
movq 0x60(%rsp), %rcx
subq %rcx, %rax
movl $0x38, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x25570
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
imulq $0x38, 0x68(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
10,169 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %rdi
callq 0x22bb0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,170 | void __gnu_cxx::new_allocator<duckdb::ExceptionFormatValue>::construct<duckdb::ExceptionFormatValue, duckdb::ExceptionFormatValue>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x22fa0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,171 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x23fe0
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x23480
movq %rax, %rcx
movq 0x28(%rsp), %rax
subq %rcx, %rax
cmpq 0x48(%rsp), %rax
jae 0x2808d
movq 0x40(%rsp), %rdi
callq 0x22c50
movq 0x20(%rsp), %rdi
callq 0x23480
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x23480
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x24370
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq (%rcx), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x23480
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x2810c
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x23fe0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2811c
movq 0x20(%rsp), %rdi
callq 0x23fe0
movq %rax, (%rsp)
jmp 0x28125
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x58, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,172 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x22bb0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,173 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x281e6
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x253d0
movq %rax, 0x8(%rsp)
jmp 0x281ef
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x281ef
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,174 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_S_relocate(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x23bf0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,175 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,176 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_deallocate(duckdb::ExceptionFormatValue*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x28299
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x24640
addq $0x28, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,177 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22b70
movq %rax, %rdi
callq 0x23280
popq %rcx
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,178 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x38, %ecx
cqto
idivq %rcx
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,179 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_S_max_size(std::allocator<duckdb::ExceptionFormatValue> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movabsq $0x249249249249249, %rax # imm = 0x249249249249249
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x22ae0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x232e0
movq %rax, 0x8(%rsp)
jmp 0x2835d
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,180 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,181 | std::allocator_traits<std::allocator<duckdb::ExceptionFormatValue>>::max_size(std::allocator<duckdb::ExceptionFormatValue> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22740
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,182 | _gnu_cxx::new_allocator<duckdb::ExceptionFormatValue>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23400
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,183 | _gnu_cxx::__normal_iterator<duckdb::ExceptionFormatValue*, std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>>::__normal_iterator(duckdb::ExceptionFormatValue* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
10,184 | std::allocator_traits<std::allocator<duckdb::ExceptionFormatValue>>::allocate(std::allocator<duckdb::ExceptionFormatValue>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x233f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,185 | _gnu_cxx::new_allocator<duckdb::ExceptionFormatValue>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x23400
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2849f
movabsq $0x492492492492492, %rax # imm = 0x492492492492492
cmpq %rax, 0x18(%rsp)
jbe 0x2849a
callq 0x233a0
callq 0x22820
imulq $0x38, 0x18(%rsp), %rdi
callq 0x23a00
addq $0x28, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,186 | std::vector<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_S_do_relocate(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x234d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,187 | duckdb::ExceptionFormatValue* std::__relocate_a<duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x248b0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x248b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x248b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
callq 0x24bf0
addq $0x38, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,188 | duckdb::ExceptionFormatValue* std::__relocate_a_1<duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&) | inline _ForwardIterator
__relocate_a_1(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
std::addressof(*__first),
__alloc)))
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
static_assert(std::is_same<_ValueType, _ValueType2>::value,
"relocation is only possible for values of the same type");
_ForwardIterator __cur = __result;
for (; __first != __last; ++__first, (void)++__cur)
std::__relocate_object_a(std::__addressof(*__cur),
std::__addressof(*__first), __alloc);
return __cur;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x285ac
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x25310
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
jmp 0x28571
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,189 | void std::__relocate_object_a<duckdb::ExceptionFormatValue, duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&) | inline void
__relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
_Allocator& __alloc)
noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
__dest, std::move(*__orig)))
&& noexcept(std::allocator_traits<_Allocator>::destroy(
__alloc, std::__addressof(*__orig))))
{
typedef std::allocator_traits<_Allocator> __traits;
__traits::construct(__alloc, __dest, std::move(*__orig));
__traits::destroy(__alloc, std::__addressof(*__orig));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x22160
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x24dc0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,190 | void std::allocator_traits<std::allocator<duckdb::ExceptionFormatValue>>::destroy<duckdb::ExceptionFormatValue>(std::allocator<duckdb::ExceptionFormatValue>&, duckdb::ExceptionFormatValue*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x23270
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,191 | void __gnu_cxx::new_allocator<duckdb::ExceptionFormatValue>::destroy<duckdb::ExceptionFormatValue>(duckdb::ExceptionFormatValue*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x25280
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,192 | std::allocator_traits<std::allocator<duckdb::ExceptionFormatValue>>::deallocate(std::allocator<duckdb::ExceptionFormatValue>&, duckdb::ExceptionFormatValue*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x24bc0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,193 | void std::_Destroy<duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*, std::allocator<duckdb::ExceptionFormatValue>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x22ad0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,194 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
callq 0x25570
jmp 0x28726
movq 0x8(%rsp), %rdi
callq 0x241a0
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,195 | void std::_Destroy<duckdb::ExceptionFormatValue*>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x24c70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,196 | void std::_Destroy_aux<false>::__destroy<duckdb::ExceptionFormatValue*>(duckdb::ExceptionFormatValue*, duckdb::ExceptionFormatValue*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x287a4
movq 0x10(%rsp), %rdi
callq 0x23e00
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x10(%rsp)
jmp 0x2877e
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,197 | void std::_Destroy<duckdb::ExceptionFormatValue>(duckdb::ExceptionFormatValue*) | _GLIBCXX14_CONSTEXPR inline void
_Destroy(_Tp* __pointer)
{
#if __cplusplus > 201703L
std::destroy_at(__pointer);
#else
__pointer->~_Tp();
#endif
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x25280
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,198 | std::_Vector_base<duckdb::ExceptionFormatValue, std::allocator<duckdb::ExceptionFormatValue>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23c40
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,199 | std::allocator<duckdb::ExceptionFormatValue>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23090
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.