name string | code string | asm string | file string |
|---|---|---|---|
qpdf_oh_get_array_item | qpdf_oh
qpdf_oh_get_array_item(qpdf_data qpdf, qpdf_oh oh, int n)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, n](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_array_item");
return new_object(qpdf, o.getArrayItem(n));
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x3577(%rip), %rcx # 0x154f20
movq %rcx, 0x18(%rax)
leaq 0x3574(%rip), %rcx # 0x154f28
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdi, (%rcx)
movl %edx, 0x8(%rcx)
leaq 0x6530(%rip)... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_begin_dict_key_iter | void
qpdf_oh_begin_dict_key_iter(qpdf_data qpdf, qpdf_oh oh)
{
qpdf->cur_iter_dict_keys = do_with_oh<std::set<std::string>>(
qpdf,
oh,
[]() { return std::set<std::string>(); },
[](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_begin_dict_key_iter");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x690b(%rip), %rax # 0x15839a
movq %rax, 0x18(%rsi)
leaq 0x6920(%rip), %rax # 0x1583ba
movq %rax, 0x10(%rsi)
mov... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_has_key | QPDF_BOOL
qpdf_oh_has_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_has_key");
return o.hasKey(key);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x447d(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0x8d61(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0x8d58(%rip), %rcx # 0x15ae9c
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_key | qpdf_oh
qpdf_oh_get_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_key");
return new_object(qpdf, o.getKey(key));
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x2d11(%rip), %rcx # 0x154f20
movq %rcx, 0x18(%rax)
leaq 0x2d0e(%rip), %rcx # 0x154f28
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x626b(%rip), %rdx # 0x15849a
movq %rdx, 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_key_if_dict | qpdf_oh
qpdf_oh_get_key_if_dict(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_key_if_dict");
return new_object(qpdf, o.getKeyIfDict(key));
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x2c3b(%rip), %rcx # 0x154f20
movq %rcx, 0x18(%rax)
leaq 0x2c38(%rip), %rcx # 0x154f28
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x6271(%rip), %rdx # 0x158576
movq %rdx, 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_or_has_name | QPDF_BOOL
qpdf_oh_is_or_has_name(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_or_has_name");
return o.isOrHasName(key);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x4705(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0x8ad9(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0x8ad0(%rip), %rcx # 0x15ae9c
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_null | qpdf_oh
qpdf_oh_new_null(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_null");
return new_object(qpdf, QPDFObjectHandle::newNull());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc6c94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1524f4
callq 0x1dba8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_bool | qpdf_oh
qpdf_oh_new_bool(qpdf_data qpdf, QPDF_BOOL value)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_bool");
return new_object(qpdf, QPDFObjectHandle::newBool(value));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
testl %esi, %esi
setne %al
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0xc88b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152554
callq 0x1dba8
movl %ebx, %eax
addq $0x18,... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_integer | qpdf_oh
qpdf_oh_new_integer(qpdf_data qpdf, long long value)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_integer");
return new_object(qpdf, QPDFObjectHandle::newInteger(value));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc66f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1525ab
callq 0x1dba8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_real_from_string | qpdf_oh
qpdf_oh_new_real_from_string(qpdf_data qpdf, char const* value)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_real_from_string");
return new_object(qpdf, QPDFObjectHandle::newReal(value));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1f9e6
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc8910
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152616
callq 0x1dba8
leaq 0x2... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_string | qpdf_oh
qpdf_oh_new_string(qpdf_data qpdf, char const* str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_string");
return new_object(qpdf, QPDFObjectHandle::newString(str));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1f9e6
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc89ea
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1527be
callq 0x1dba8
leaq 0x2... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_unicode_string | qpdf_oh
qpdf_oh_new_unicode_string(qpdf_data qpdf, char const* utf8_str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_unicode_string");
return new_object(qpdf, QPDFObjectHandle::newUnicodeString(utf8_str));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1f9e6
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc8a12
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152864
callq 0x1dba8
leaq 0x2... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_binary_unicode_string | qpdf_oh
qpdf_oh_new_binary_unicode_string(qpdf_data qpdf, char const* utf8_str, size_t length)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_binary_unicode_string");
return new_object(qpdf, QPDFObjectHandle::newUnicodeString(std::string(utf8_str, length)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1fa24
movq %rsp, %rdi
movq %r14, %rsi
callq 0xc8a12
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x14cbfb
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi,... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_dictionary | qpdf_oh
qpdf_oh_new_dictionary(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_dictionary");
return new_object(qpdf, QPDFObjectHandle::newDictionary());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc8e76
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152a97
callq 0x1dba8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_stream | qpdf_oh
qpdf_oh_new_stream(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_stream");
return new_object(qpdf, qpdf->qpdf->newStream());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3b3f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152af1
callq 0x1dba8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax,... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_make_direct | void
qpdf_oh_make_direct(qpdf_data qpdf, qpdf_oh oh)
{
do_with_oh_void(qpdf, oh, [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_make_direct");
o.makeDirect();
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
leaq 0x5bc6(%rip), %rax # 0x1586f0
movq %rax, 0x18(%rdx)
leaq 0x5bc5(%rip), %rax # 0x1586fa
movq %rax, 0x10(%rdx)
callq 0x14d1eb
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x152b55
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %ed... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_make_indirect_object | qpdf_oh
qpdf_make_indirect_object(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_uninitialized(qpdf), [qpdf](QPDFObjectHandle& o) {
return new_object(qpdf, qpdf->qpdf->makeIndirectObject(o));
});
} | pushq %rbx
subq $0x40, %rsp
xorl %eax, %eax
leaq 0x20(%rsp), %rdx
movq %rax, 0x8(%rdx)
movq %rdi, (%rdx)
leaq 0x1eb3(%rip), %rcx # 0x154a54
movq %rcx, 0x18(%rdx)
leaq 0x1eb0(%rip), %rcx # 0x154a5c
movq %rcx, 0x10(%rdx)
movq %rsp, %rcx
movq %rax, 0x8(%rcx)
movq %rdi, (%rcx)
leaq 0x5b51(%rip), %rax # 0x158... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_remove_page | QPDF_ERROR_CODE
qpdf_remove_page(qpdf_data qpdf, qpdf_oh page)
{
QTC::TC("qpdf", "qpdf-c called qpdf_remove_page");
auto p = qpdf_oh_item_internal(qpdf, page);
return trap_errors(qpdf, [&p](qpdf_data q) { q->qpdf->removePage(p); });
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x153d10
leaq 0x18(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
leaq 0x539b(%rip), %rax # 0x15972c
movq %rax, 0x18(%rsi)
leaq 0x5400(%rip), %rax # 0x15979c
movq %rax, 0x10(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_update_from_json_file | QPDF_ERROR_CODE
qpdf_update_from_json_file(qpdf_data qpdf, char const* filename)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
status = trap_errors(qpdf, [filename](qpdf_data q) { q->qpdf->updateFromJSON(filename); });
return status;
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x5307(%rip), %rcx # 0x1598e8
movq %rcx, 0x18(%rax)
leaq 0x5376(%rip), %rcx # 0x159962
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x14b77e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x154611
movq %rsp, %rdi... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_data::_qpdf_data() | _qpdf_data() = default; | leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0xc0(%rdi... | /qpdf[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
TGAImage::flip_vertically() | bool TGAImage::flip_vertically() {
if (!data) return false;
unsigned long bytes_per_line = width*bytespp;
unsigned char *line = new unsigned char[bytes_per_line];
int half = height>>1;
for (int j=0; j<half; j++) {
unsigned long l1 = j*bytes_per_line;
unsigned long l2 = (height-1-j)*b... | movq (%rdi), %rax
testq %rax, %rax
je 0x61b2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rax, 0x10(%rsp)
movslq 0x8(%rdi), %rax
movslq 0x10(%rdi), %rdi
imulq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0x2030
movq %rax, (%rsp)
movl 0xc(%rbx), %r15d
sarl %r15d
xorl... | /Reynault[P]RDV_Projet_Sies_Romary/src/tgaimage.cpp |
TGAImage::flip_horizontally() | bool TGAImage::flip_horizontally() {
if (!data) return false;
int half = width>>1;
for (int i=0; i<half; i++) {
for (int j=0; j<height; j++) {
TGAColor c1 = get(i, j);
TGAColor c2 = get(width-1-i, j);
set(i, j, c2);
set(width-1-i, j, c1);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x6271
movq %rdi, %rbx
movl 0x8(%rdi), %eax
sarl %eax
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %eax
movl %eax, 0x1c(%rsp)
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
cmp... | /Reynault[P]RDV_Projet_Sies_Romary/src/tgaimage.cpp |
main | int main(){
ifstream f("input", std::ios::binary);
cerr << "detect pool sizes...\t";
const size_t bits_per_pool = 16;
const size_t pools_count = 2<<(32-bits_per_pool);
vector<uint64_t> poolsize(pools_count, 0);
while(!f.eof()) {
uint32_t x;
f.read((char*)&x, sizeof(x));
... | pushq %rbp
movq %rsp, %rbp
subq $0x6b0, %rsp # imm = 0x6B0
movl $0x0, -0x4(%rbp)
leaq 0x6c27(%rip), %rsi # 0x9010
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x21f0
movq 0xbbef(%rip), %rdi # 0xdff0
leaq 0x6c0e(%rip), %rsi # 0x9016
callq 0x20f0
jmp 0x240f
movq $0x10, -0x228(%rbp)
movq $0x2000... | /ivan2kh[P]sort-big-file-with-a-limited-memory/main.cpp |
test | int test(char *URL)
{
CURLcode res;
CURL *curl;
char *ipstr = NULL;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
fprintf(stderr, "curl_easy_init() failed\n");
curl_glo... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x3, %edi
callq 0x1170
cmpl $0x0, %eax
je 0x12f7
movq 0x2d06(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd20(%rip), %rsi # 0x2004
movb $0x0, %al
callq 0x1120
movl $0x7e, -0x4(%rbp)
jmp 0x15ef
callq 0x1070
movq %... | /macressler[P]curl/tests/libtest/lib500.c |
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... | 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 0x1715
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1730
movl -0x8(%rbp), %edi
movq -0x10(%rbp),... | /macressler[P]curl/tests/libtest/first.c |
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... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1858
movl $0x6, %edi
leaq 0x97c(%rip), %rsi # 0x21e0
callq 0x10b0
cmpl $0x2, -0x8(%rbp)
jge 0x1890
movq 0x276a(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x87f(%rip), %rsi # 0x20ff
movb... | /macressler[P]curl/tests/libtest/first.c |
libtest_debug_dump | static
void libtest_debug_dump(const char *timebuf, const char *text, FILE *stream,
const unsigned char *ptr, size_t size, int nohex)
{
size_t i;
size_t c;
unsigned int width = 0x10;
if(nohex)
/* without the hex output, we can fit more on screen */
width = 0x40;
fprintf(stre... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x10, -0x44(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1c14
movl $0x40, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rb... | /macressler[P]curl/tests/libtest/testtrace.c |
dlmalloc_stats | static void internal_malloc_stats(mstate m) {
ensure_initialization();
if (!PREACTION(m)) {
size_t maxfp = 0;
size_t fp = 0;
size_t used = 0;
check_malloc_state(m);
if (is_initialized(m)) {
msegmentptr s = &m->seg;
maxfp = m->max_footprint;
fp = m->footprint;
used = fp - ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x18066(%rip) # 0x1b1f0
jne 0x3191
callq 0x6c8c
testb $0x2, 0x183f8(%rip) # 0x1b590
je 0x31ad
pushq $0x1
popq %rbx
movl %ebx, %eax
xchgl %eax, 0x183ef(%rip) # 0x1b594
testl %eax, %eax
jne 0x32ae
movq 0x18094(%rip), %rax # 0x1b248
testq %r... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
main | int main( void )
{
#if ! defined( REGTEST ) || defined( __STDC_LIB_EXT1__ )
char s[] = "xx\0xxxxxx";
set_constraint_handler_s( test_handler );
TESTCASE( strncat_s( s, 10, abcde, 10 ) == 0 );
TESTCASE( s[2] == 'a' );
TESTCASE( s[6] == 'e' );
TESTCASE( s[7] == '\0' );
TESTCASE( s[8] == 'x' );... | pushq %rbx
subq $0x10, %rsp
movabsq $0x7878787878007878, %rax # imm = 0x7878787878007878
movq %rsp, %rbx
movq %rax, (%rbx)
movw $0x78, 0x8(%rbx)
leaq 0x54a(%rip), %rdi # 0x3a6c
callq 0x3c3c
leaq 0x6ae0(%rip), %rdx # 0xa00e
movl $0xa, %esi
movl $0xa, %ecx
movq %rbx, %rdi
callq 0x344c
testl %eax, %eax
je 0x356... | /DevSolar[P]pdclib/functions/string/strncat_s.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb 0x1(%rdi), %al
cmpb $0x25, %al
jne 0x3d8b
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jae 0x3ebb
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3eb4
movl $0x25, %edi
callq 0x4ff8
jmp ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
raise | int raise( int sig )
{
void ( *sighandler )( int );
const char * message;
switch ( sig )
{
case SIGABRT:
sighandler = _PDCLIB_sigabrt;
message = "Abnormal termination (SIGABRT)";
break;
case SIGFPE:
sighandler = _PDCLIB_sigfpe;
... | pushq %rbx
movl %edi, %ebx
leal -0x2(%rbx), %edi
cmpl $0xe, %edi
jae 0x5639
movl $0x2255, %eax # imm = 0x2255
btl %edi, %eax
jae 0x5639
movl %edi, %eax
leaq 0x876a(%rip), %rcx # 0xdd80
movq (%rcx,%rax,8), %rax
movq (%rax), %rax
cmpq $0x1, %rax
je 0x5635
testq %rax, %rax
je 0x5640
movl %ebx, %edi
xorl %es... | /DevSolar[P]pdclib/platform/example/functions/signal/raise.c |
fputs | int fputs( const char * _PDCLIB_restrict s, struct _PDCLIB_file_t * _PDCLIB_restrict stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
while ( *s != '\0' )
{
/* Unbuffered and line buffered s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rsi), %rbx
movq %rbx, %rdi
callq 0x4fbc
movq %r14, %rdi
callq 0x3cf4
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x584b
movb (%r15), %al
testb %al, %al
je 0x5835
incq %r15
movq 0x8(%r14), %rcx
movq ... | /DevSolar[P]pdclib/functions/stdio/fputs.c |
init_mparams | static int init_mparams(void) {
#ifdef NEED_GLOBAL_LOCK_INIT
if (malloc_global_mutex_status <= 0)
init_malloc_global_mutex();
#endif
ACQUIRE_MALLOC_GLOBAL_LOCK();
if (mparams.magic == 0) {
size_t magic;
size_t psize;
size_t gsize;
#ifndef WIN32
psize = malloc_getpagesize;
gsize = ((DEFAU... | pushq %rbx
movl $0x1, %ebx
movl $0x1, %eax
xchgl %eax, 0x1492b(%rip) # 0x1b5c8
testl %eax, %eax
je 0x6cc7
cmpl $0x0, 0x14920(%rip) # 0x1b5c8
jne 0x6cb9
movl $0x1, %eax
xchgl %eax, 0x14913(%rip) # 0x1b5c8
testl %eax, %eax
je 0x6cc7
testb $0x3f, %bl
jne 0x6cc3
callq 0x30b0
incl %ebx
jmp 0x6ca1
cmpq $0x0, 0x14... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
free | void dlfree(void* mem) {
/*
Consolidate freed chunks with preceeding or succeeding bordering
free chunks, if they exist, and then place in a bin. Intermixed
with special cases for top, dv, mmapped chunks, and usage errors.
*/
if (mem != 0) {
mchunkptr p = mem2chunk(mem);
#if FOOTERS
msta... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x743d
movq %rdi, %r14
leaq -0x10(%rdi), %rbx
testb $0x2, 0x1482c(%rip) # 0x1b590
je 0x6da1
movl $0x1, %ebp
movl $0x1, %eax
xchgl %eax, 0x1481e(%rip) # 0x1b594
testl %eax, %eax
jne 0x6d89
jmp 0x6da1
testb $0x3f, %bpl
jne 0x6d87
callq 0x3... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
release_unused_segments | static size_t release_unused_segments(mstate m) {
size_t released = 0;
int nsegs = 0;
msegmentptr pred = &m->seg;
msegmentptr sp = pred->next;
while (sp != 0) {
char* base = sp->base;
size_t size = sp->size;
msegmentptr next = sp->next;
++nsegs;
if (is_mmapped_segment(sp) && !is_extern_seg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x13eb6(%rip), %rdx # 0x1b5a8
testq %rdx, %rdx
je 0x7a41
leaq 0x13e96(%rip), %r9 # 0x1b598
leaq 0x13b17(%rip), %r8 # 0x1b220
movq $0x0, 0x8(%rsp)
xorl %r12d, %r12d
movq %rdx, %r15
movq 0x10(%rdx), %rdx
movl 0x18(%r15),... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
calloc | void* dlcalloc(size_t n_elements, size_t elem_size) {
void* mem;
size_t req = 0;
if (n_elements != 0) {
req = n_elements * elem_size;
if (((n_elements | elem_size) & ~(size_t)0xffff) &&
(req / n_elements != elem_size))
req = MAX_SIZE_T; /* force downstream failure on overflow */
}
mem = ... | pushq %rbx
testq %rdi, %rdi
je 0x7aaa
movq %rdi, %rax
mulq %rsi
movq %rax, %rbx
seto %al
orq %rdi, %rsi
cmpq $0x10000, %rsi # imm = 0x10000
jb 0x7aac
testb %al, %al
movq $-0x1, %rax
cmovneq %rax, %rbx
jmp 0x7aac
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x5860
testq %rax, %rax
je 0x7acd
testb $0x3, -0x8(%rax)
je 0... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlposix_memalign | int dlposix_memalign(void** pp, size_t alignment, size_t bytes) {
void* mem = 0;
if (alignment == MALLOC_ALIGNMENT)
mem = dlmalloc(bytes);
else {
size_t d = alignment / sizeof(void*);
size_t r = alignment % sizeof(void*);
if (r != 0 || d == 0 || (d & (d-SIZE_T_ONE)) != 0)
return EINVAL;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x10, %rsi
jne 0x822c
movq %rdx, %rdi
callq 0x5860
jmp 0x8273
testb $0x7, %sil
setne %al
cmpq $0x8, %rsi
setb %cl
orb %al, %cl
jne 0x8264
movq %rsi, %rax
shrq $0x3, %rax
leaq -0x1(%rax), %rcx
testq %rcx, %rax
jne 0x8264
movq $-0x80, %rax
subq %rsi, %rax
movb $0x1, ... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmalloc_trim | int dlmalloc_trim(size_t pad) {
int result = 0;
ensure_initialization();
if (!PREACTION(gm)) {
result = sys_trim(gm, pad);
POSTACTION(gm);
}
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x12b4c(%rip) # 0x1b1f0
jne 0x86ab
callq 0x6c8c
testb $0x2, 0x12ede(%rip) # 0x1b590
je 0x86ef
movl $0x1, %ebp
movl $0x1, %eax
xchgl %eax, 0x12ed0(%rip) # 0x1b594
testl %eax, %eax
je 0x86ef
cmpl $0x0, 0x12ec5(%rip) # 0x1b594
jne 0x86e0
movl $0x1... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
s3gaucnt_write | int
s3gaucnt_write(const char *fn,
vector_t ***wt_mean,
vector_t ***wt_var,
int32 pass2var,
float32 ***dnom,
uint32 n_cb,
uint32 n_feat,
uint32 n_density,
const uint32 *veclen)
{
FILE *fp;
uint32 chksum = 0;
uint32 ignore = 0;
uint32 n_elem... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq %r8, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
callq... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3gau_io.c |
s3open | FILE *
s3open(const char *file_name,
const char *mode,
uint32 *swap)
{
FILE *fp = NULL;
if (mode[0] == 'r' && mode[1] == 'b') {
/* Read a binary file */
fp = fopen(file_name, mode);
if (fp == NULL) {
E_ERROR_SYSTEM("Unable to open %s for reading",
file_name);
return NULL;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x445c
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x62, %eax
jne 0x445c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp)... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadfloat | int
areadfloat (char *file,
float **data_ref,
int *length_ref)
{
FILE *fp;
int length;
int ret, byterev;
int offset;
float *data;
int dummy_length;
/* Get the file length and whether the file needs to be byte-reversed */
i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x4c50
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x4e65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5076
movq -0x10(%rbp), %rdi
leaq 0x1a658(%ri... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
areadint | int
areadint (char *file,
int **data_ref,
int *length_ref)
{
int fd;
int length;
int size;
int offset;
char *data;
if ((fd = open (file, O_RDONLY | O_BINARY, 0644)) < 0)
{
fprintf (stderr, "areadint: %s: can't open\n", file);
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1a4, %edx # imm = 0x1A4
movb $0x0, %al
callq 0x2300
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x54d6
movq 0x20b43(%rip), %rax # 0x25ff8
movq (%r... | /cmusphinx[P]sphinxtrain/src/libs/libio/s3io.c |
ckd_free | void
ckd_free(void *ptr)
{
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if (ptr)
heap_free(0,ptr);
#else
free(ptr);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
_ckd_alloc_3d_ptr | void *
__ckd_alloc_3d_ptr(size_t d1,
size_t d2,
size_t d3,
void *store,
size_t elem_size,
char *file,
int line)
{
void **tmp1;
void ***out;
size_t i, j;
tmp1 = __ckd_calloc__(d1 * d2, sizeof(void *), file, line);
out = __ckd_calloc__(d1, sizeof(void **), file, line);... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl 0x10(%rbp), %ecx
movl $0x8, %esi
callq 0x5d80... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/ckd_alloc.c |
scalarmultiply | void
scalarmultiply(float32 ** a, float32 x, int32 n)
{
int32 i, j;
for (i = 0; i < n; ++i) {
a[i][i] *= x;
for (j = i+1; j < n; ++j) {
a[i][j] *= x;
a[j][i] *= x;
}
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xaefc
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
mulss (%rax,%rcx,4), %x... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/matrix.c |
err_logfp_cb | void
err_logfp_cb(void *user_data, err_lvl_t lvl, const char *fmt, ...)
{
va_list ap;
FILE *fp = err_get_logfp();
if (!fp)
return;
va_start(ap, fmt);
vfprintf(fp, fmt, ap);
va_end(ap);
fflush(fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xb81b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/err.c |
err_set_logfp | void
err_set_logfp(FILE *stream)
{
if (stream == NULL) {
logfp_disabled = TRUE;
logfp = NULL;
return;
}
logfp_disabled = FALSE;
logfp = stream;
return;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb9a6
movl $0x1, 0x1c507(%rip) # 0x27ea0
movq $0x0, 0x1c504(%rip) # 0x27ea8
jmp 0xb9bb
movl $0x0, 0x1c4f0(%rip) # 0x27ea0
movq -0x8(%rbp), %rax
movq %rax, 0x1c4ed(%rip) # 0x27ea8
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/err.c |
cmp | static int
cmp(Bigint *a, Bigint *b)
{
ULong *xa, *xa0, *xb, *xb0;
int i, j;
i = a->wds;
j = b->wds;
#ifdef DEBUG
if (i > 1 && !a->x[i-1])
Bug("cmp called with a->x[a->wds-1] == 0");
if (j > 1 && !b->x[j-1])
Bug("cmp called with b->x[b->wds-1] == 0");
#endif
if (i -= j)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0xe70b
... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/util/dtoa.c |
glfwPlatformTerminate | void _glfwPlatformTerminate(void)
{
if (_glfw.x11.helperWindowHandle)
{
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
_glfw.x11.helperWindowHandle)
{
_glfwPushSelectionToManagerX11();
}
XDestroyWindow(_glfw.x11.display, _glfw.x11.helpe... | pushq %rbx
leaq 0x3673f(%rip), %rbx # 0x5da30
cmpq $0x0, 0x1fee0(%rbx)
je 0x2733d
movq 0x1fec0(%rbx), %rdi
movq 0x20c08(%rbx), %rsi
callq 0x159d0
movq 0x1fee0(%rbx), %rsi
cmpq %rsi, %rax
jne 0x27326
callq 0x284f4
movq 0x1fee0(%rbx), %rsi
movq 0x1fec0(%rbx), %rdi
callq 0x15850
movq $0x0, 0x1fee0(%rbx)
movq 0x1fee8(%... | /tuket[P]gltf_viewer/libs/glfw/src/x11_init.c |
glfwPlatformCreateStandardCursor | int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
{
int native = 0;
if (shape == GLFW_ARROW_CURSOR)
native = XC_left_ptr;
else if (shape == GLFW_IBEAM_CURSOR)
native = XC_xterm;
else if (shape == GLFW_CROSSHAIR_CURSOR)
native = XC_crosshair;
else if (shap... | pushq %rbp
pushq %rbx
pushq %rax
addl $0xfffc9fff, %esi # imm = 0xFFFC9FFF
xorl %ebp, %ebp
cmpl $0x5, %esi
ja 0x2c404
movq %rdi, %rbx
movl %esi, %eax
leaq 0x26c2d(%rip), %rcx # 0x52ff8
movl (%rcx,%rax,4), %esi
leaq 0x3165b(%rip), %rax # 0x5da30
movq 0x1fec0(%rax), %rdi
callq 0x152c0
movq %rax, 0x8(%rbx)
m... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
input(_win_st*, char*, int, bool) | int input(WINDOW *win, char *str, int len, bool cont) {
int ymax, xmax;
getmaxyx(win, ymax, xmax);
int i = 0;
while(1) {
int c = wgetch(win);
if(c == KEY_ENTER || c == 10) {
if (i > 0)
break;
}
else if (c == KEY_BACKSPACE) {
if (i > 0) {
str[--i] = '\0';
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
testq %rdi, %rdi
je 0x2471
movswl 0x4(%r15), %r12d
incl %r12d
movswl 0x6(%r15), %r13d
incl %r13d
jmp 0x247d
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
m... | /rebecacalazans[P]chat/client.cpp |
init_colors() | void init_colors() {
init_pair(1,COLOR_BLUE,COLOR_BLACK);
init_pair(2,COLOR_GREEN,COLOR_BLACK);
init_pair(3,COLOR_CYAN,COLOR_BLACK);
init_pair(4,COLOR_MAGENTA,COLOR_BLACK);
init_pair(5,COLOR_YELLOW,COLOR_BLACK);
init_pair(6,COLOR_RED,COLOR_BLACK);
} | pushq %rax
movl $0x1, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x2060
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2060
movl $0x3, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2060
movl $0x4, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x2060
movl $0x5, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x2060
movl... | /rebecacalazans[P]chat/client.cpp |
send_thread(int) | void send_thread(int sockfd) {
while(1) {
wclear(typewin);
wattron(typewin, COLOR_PAIR(102));
mvwhline(typewin, 0, 0, ' ', ncolums);
mvwprintw(typewin, 0, ncolums - 10, "0/%d", MSG_LEN);
wattroff(typewin, COLOR_PAIR(102));
mutwin.lock();
mvwprintw(typewin, 1, 0, ">> ");
wrefresh(type... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x91f(%rip), %r14 # 0x300a
leaq 0x2f06(%rip), %r15 # 0x55f8
leaq 0x916(%rip), %r12 # 0x300f
leaq 0x2af0(%rip), %r13 # 0x51f0
movq 0x2ee9(%rip), %rdi # 0x55f0
callq 0x2200
movq 0x2edd(%rip), %rdi # 0x55f0
movl $0x... | /rebecacalazans[P]chat/client.cpp |
llvm::cl::ExpansionContext::ExpansionContext(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, void (*)(llvm::StringRef, llvm::StringSaver&, llvm::SmallVectorImpl<char const*>&, bool)) | ExpansionContext::ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T)
: Saver(A), Tokenizer(T), FS(vfs::getRealFileSystem().get()) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa02f
movq (%r14), %r14
testq %r14, %r14
je 0x9f081
lock
decl 0x8(%r14)
jne 0x9f081
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x... | /Support/CommandLine.cpp |
void llvm::SmallVectorImpl<char const*>::append<std::move_iterator<char const**>, void>(std::move_iterator<char const**>, std::move_iterator<char const**>) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0xa444c
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0xa6f56... | /llvm/ADT/SmallVector.h |
llvm::StringMapImpl::LookupBucketFor(llvm::StringRef, unsigned int) | unsigned StringMapImpl::LookupBucketFor(StringRef Name,
uint32_t FullHashValue) {
#ifdef EXPENSIVE_CHECKS
assert(FullHashValue == hash(Name));
#endif
// Hash table unallocated so far?
if (NumBuckets == 0)
init(16);
if (shouldReverseIterate())
FullHashValue = ~Full... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rsi, %r8
movq %rdi, %r9
cmpl $0x0, 0x8(%rdi)
jne 0xa7707
movq %r9, %rdi
movl $0x10, %esi
movq %rdx, %r14
movq %r8, %r15
movq %r9, %r12
callq 0xa760a
movq %r12, %r9
movq %r15, %r8
movq %r14, %rdx
movl 0x8(%r9), %eax
... | /Support/StringMap.cpp |
llvm::SmallVectorTemplateBase<void*, true>::push_back(void*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0xa7c97
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0xa6f56
jmp... | /llvm/ADT/SmallVector.h |
llvm::APInt::operator<<=(unsigned int) | APInt &operator<<=(unsigned ShiftAmt) {
assert(ShiftAmt <= BitWidth && "Invalid shift amount");
if (isSingleWord()) {
if (ShiftAmt == BitWidth)
U.VAL = 0;
else
U.VAL <<= ShiftAmt;
return clearUnusedBits();
}
shlSlowCase(ShiftAmt);
return *this;
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x40, %eax
ja 0xa8dcc
movq (%rbx), %rdx
movl %esi, %ecx
shlq %cl, %rdx
xorl %ecx, %ecx
cmpl %esi, %eax
cmovneq %rdx, %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xa8f4a
movq %rbx, %rdi
callq 0xcc51c
movq %rbx, %rax
popq %rbx
retq
nop
| /llvm/ADT/APInt.h |
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0xac700
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %edx
leaq 0x40f57e(%rip), %rax # 0x4bbc48
addq $0x10, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl 0x90(%rsi), %eax
movl %eax, 0x8(%rcx)
movb 0x94(%rsi), %al
movb %al, 0xc(%rcx)
leaq 0x40ead1(%rip),... | /llvm/Support/CommandLine.h |
llvm::yaml::Scanner::scanAliasOrAnchor(bool) | bool Scanner::scanAliasOrAnchor(bool IsAlias) {
StringRef::iterator Start = Current;
unsigned ColStart = Column;
skip(1);
while (Current != End) {
if ( *Current == '[' || *Current == ']'
|| *Current == '{' || *Current == '}'
|| *Current == ','
|| *Current == ':')
break;
S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %rbp
movl 0x3c(%rdi), %eax
leaq 0x1(%r15), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x8(%rsp)
incl %eax
movl %eax, 0x3c(%rdi)
cmpq %rbp, %r13
je 0xaef73
movq 0x8(%r... | /Support/YAMLParser.cpp |
llvm::yaml::ScalarNode::getPlainValue(llvm::StringRef, llvm::SmallVectorImpl<char>&) | StringRef ScalarNode::getPlainValue(StringRef RawValue,
SmallVectorImpl<char> &Storage) {
// Trim trailing whitespace ('b-char' and 's-white').
// NOTE: Alternatively we could change the scanner to not include whitespace
// here in the first place.
RawValue = RawValue.r... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x20(%rsp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
leaq 0x290688(%rip), %rsi # 0x341262
movl $0x4, %edx
movq %r15, %rdi
movq $-0x1, %rcx
callq 0xa856a
incq %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movq (%r... | /Support/YAMLParser.cpp |
llvm::formatv_object_base::format(llvm::raw_ostream&) const | void format(raw_ostream &S) const {
for (auto &R : parseFormatString(Fmt)) {
if (R.Type == ReplacementType::Empty)
continue;
if (R.Type == ReplacementType::Literal) {
S << R.Spec;
continue;
}
if (R.Index >= Adapters.size()) {
S << R.Spec;
continue;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xcf190
movl 0x8(%r15), %r12d
testq %r12, %r12
je 0xb35a9
movq 0x28(%rsp), %r13
shlq $0x6, %r12
xorl %ebp, %ebp
leaq 0x8(%... | /llvm/Support/FormatVariadic.h |
getFD(llvm::StringRef, std::error_code&, llvm::sys::fs::CreationDisposition, llvm::sys::fs::FileAccess, llvm::sys::fs::OpenFlags) | static int getFD(StringRef Filename, std::error_code &EC,
sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
sys::fs::OpenFlags Flags) {
assert((Access & sys::fs::FA_Write) &&
"Cannot make a raw_ostream from a read-only descriptor!");
// Handle "-" as stdout. ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x1, %rsi
jne 0xb3c60
leaq 0x28c392(%rip), %rsi # 0x33ffe3
movq %r12, %rdi
movq %r15, %rdx
callq 0x8b5f0
testl %eax, %eax
je 0xb3c... | /Support/raw_ostream.cpp |
llvm::errs() | raw_fd_ostream &llvm::errs() {
// Set standard error to be unbuffered.
#ifdef __MVS__
std::error_code EC = enableAutoConversion(STDERR_FILENO);
assert(!EC);
#endif
static raw_fd_ostream S(STDERR_FILENO, false, true);
return S;
} | movb 0x43a4ef(%rip), %al # 0x4ee4e0
testb %al, %al
je 0xb3ffd
leaq 0x43a484(%rip), %rax # 0x4ee480
retq
pushq %rax
callq 0x8be79
addq $0x8, %rsp
jmp 0xb3ff5
| /Support/raw_ostream.cpp |
llvm::raw_ostream::~raw_ostream() | raw_ostream::~raw_ostream() {
// raw_ostream's subclasses should take care to flush the buffer
// in their destructors.
assert(OutBufCur == OutBufStart &&
"raw_ostream destructor called with non-empty buffer!");
if (BufferMode == BufferKind::InternalBuffer)
delete [] OutBufStart;
} | leaq 0x407c89(%rip), %rax # 0x4bbd68
addq $0x10, %rax
movq %rax, (%rdi)
cmpl $0x1, 0x2c(%rdi)
jne 0xb40f9
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x8b2d0
retq
| /Support/raw_ostream.cpp |
llvm::raw_svector_ostream::reserveExtraSpace(unsigned long) | void reserveExtraSpace(uint64_t ExtraSize) override {
OS.reserve(tell() + ExtraSize);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x30(%rdi), %rbx
callq *0x50(%rax)
addq %r14, %rax
addq 0x20(%r15), %rax
subq 0x10(%r15), %rax
cmpq %rax, 0x10(%rbx)
jae 0xb41db
leaq 0x18(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp... | /llvm/Support/raw_ostream.h |
llvm::FmtAlign::format(llvm::raw_ostream&, llvm::StringRef) | void format(raw_ostream &S, StringRef Options) {
// If we don't need to align, we can format straight into the underlying
// stream. Otherwise we have to go through an intermediate stream first
// in order to calculate how long the output is so we can align it.
// TODO: Make the format method return th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xb4388
leaq 0x20(%rsp), %rcx
movq %rcx, -0x18(%rcx)
xorl %eax, %eax
movq %rax, -0x10(%rcx)
movq $0x40, -0x8(%rcx)
leaq 0x60(%rsp), %r13
movl $0x2, ... | /llvm/Support/FormatCommon.h |
freeset | static void
freeset(struct parse *p, cset *cs)
{
size_t i;
cset *top = &p->g->sets[p->g->ncsets];
size_t css = (size_t)p->g->csetsize;
for (i = 0; i < css; i++)
CHsub(cs, i);
if (cs == top-1) /* recover only the easy case */
p->g->ncsets--;
} | movq 0x38(%rdi), %rcx
movslq 0x14(%rcx), %rax
shlq $0x5, %rax
addq 0x18(%rcx), %rax
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0xb69c4
xorl %edx, %edx
xorl %r8d, %r8d
movb 0x8(%rsi), %r9b
notb %r9b
movq (%rsi), %r10
movzbl %r8b, %r11d
andb %r9b, (%r10,%r11)
addb %dl, 0x9(%rsi)
incq %r8
decb %dl
cmpq %r8, %rcx
jne 0xb6... | /Support/regcomp.c |
llvm::sys::path::root_directory(llvm::StringRef, llvm::sys::path::Style) | StringRef root_directory(StringRef path, Style style) {
const_iterator b = begin(path, style), pos = b, e = end(path);
if (b != e) {
bool has_net =
b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
bool has_drive = is_style_windows(style) && b->ends_with(":");
if ((has_net ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xba449
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movaps %xmm2, 0x20... | /Support/Path.cpp |
llvm::detail::IEEEFloat::compareAbsoluteValue(llvm::detail::IEEEFloat const&) const | IEEEFloat::cmpResult
IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const {
int compare;
assert(semantics == rhs.semantics);
assert(isFiniteNonZero());
assert(rhs.isFiniteNonZero());
compare = exponent - rhs.exponent;
/* If exponents are equal, do an unsigned bignum comparison of the
signific... | movl 0x10(%rdi), %eax
subl 0x10(%rsi), %eax
jne 0xc399e
movq (%rdi), %rax
movl 0x8(%rax), %edx
leal -0x40(%rdx), %eax
cmpl $-0x80, %eax
jae 0xc3972
movq 0x8(%rdi), %rdi
jmp 0xc3976
addq $0x8, %rdi
movq (%rsi), %rax
movl 0x8(%rax), %eax
addl $-0x40, %eax
cmpl $-0x80, %eax
jae 0xc398a
movq 0x8(%rsi), %rsi
jmp 0xc398e
add... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::convertFromString(llvm::StringRef, llvm::RoundingMode) | Expected<IEEEFloat::opStatus>
IEEEFloat::convertFromString(StringRef str, roundingMode rounding_mode) {
if (str.empty())
return createError("Invalid string length");
// Handle special cases.
if (convertFromStringSpecials(str))
return opOK;
/* Handle a leading minus sign. */
StringRef::iterator p = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rcx, %rcx
je 0xc6111
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xc5d32
testb %al, %al
je 0xc615a
andb $-0x2, 0x8(%rbx)
movl $0x0, (%rbx)
jmp 0xc61e9
... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::bitcastToAPInt() const | APInt IEEEFloat::bitcastToAPInt() const {
if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
return convertHalfAPFloatToAPInt();
if (semantics == (const llvm::fltSemantics *)&semBFloat)
return convertBFloatAPFloatToAPInt();
if (semantics == (const llvm::fltSemantics*)&semIEEEsingle)
return co... | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x27b8d8(%rip), %rcx # 0x3428a4
cmpq %rcx, %rax
je 0xc70d2
leaq 0x27b8e0(%rip), %rcx # 0x3428bc
cmpq %rcx, %rax
je 0xc70df
leaq 0x27b8e8(%rip), %rcx # 0x3428d4
cmpq %rcx, %rax
je 0xc70ec
leaq 0x27b8f0(%rip), %rcx # 0x3428ec
cmpq %rcx, %rax
je 0xc70f6
leaq 0x... | /Support/APFloat.cpp |
llvm::detail::DoubleAPFloat::addWithSpecial(llvm::detail::DoubleAPFloat const&, llvm::detail::DoubleAPFloat const&, llvm::detail::DoubleAPFloat&, llvm::RoundingMode) | APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
const DoubleAPFloat &RHS,
DoubleAPFloat &Out,
roundingMode RM) {
if (LHS.getCategory() == fcNaN) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rsi, %r12
movq 0x8(%rsi), %rax
leaq 0x8(%rax), %rsi
leaq 0x2794f4(%rip), %r15 # 0x34291c
movq 0x10(%rax), %rcx
addq $0x8, %rcx
cmpq %r15, 0x8(%rax)
cmovneq %rsi, %rcx
movb 0x14(%rcx), %cl
movl %ecx, %eax
andb $0x... | /Support/APFloat.cpp |
llvm::detail::DoubleAPFloat::convertFromAPInt(llvm::APInt const&, bool, llvm::RoundingMode) | APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
bool IsSigned,
roundingMode RM) {
assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
APFloat Tmp(semPPCDoubleDoubleLegacy);
aut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
leaq 0x27860d(%rip), %rsi # 0x342b88
movq %rbx, %rdi
callq 0xc2d26
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %ebp... | /Support/APFloat.cpp |
llvm::symbolize::(anonymous namespace)::checkFileCRC(llvm::StringRef, unsigned int) | bool checkFileCRC(StringRef Path, uint32_t CRCHash) {
ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
MemoryBuffer::getFileOrSTDIN(Path);
if (!MB)
return false;
return CRCHash == llvm::crc32(arrayRefFromStringRef(MB.get()->getBuffer()));
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
leaq 0x18(%rsp), %rax
movw $0x105, 0x20(%rax) # imm = 0x105
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rsp, %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xcf564
testb $0x1, 0x10(%r14)
j... | /DebugInfo/Symbolize/Symbolize.cpp |
llvm::pdb::PDBError::~PDBError() | PDBError(const Twine &S) : ErrorInfo(S, pdb_error_code::unspecified) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3d3ccd(%rip), %rax # 0x4bb828
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0xe7b7a
movq (%rax), %rsi
incq %rsi
callq 0x8b100
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x8b100
| /llvm/DebugInfo/PDB/GenericError.h |
llvm::pdb::PDBContext::getFunctionName[abi:cxx11](unsigned long, llvm::DINameKind) const | std::string PDBContext::getFunctionName(uint64_t Address,
DINameKind NameKind) const {
if (NameKind == DINameKind::None)
return std::string();
std::unique_ptr<PDBSymbol> FuncSymbol =
Session->findSymbolByAddress(Address, PDB_SymType::Function);
auto *Func = dyn_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %ecx, %ecx
je 0xe7e49
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x5, %ecx
callq *0x40(%rax)
movq (%r12), %r12
testq %r12, %r1... | /DebugInfo/PDB/PDBContext.cpp |
llvm::Error llvm::codeview::SymbolDeserializer::visitKnownRecordImpl<llvm::codeview::RegRelativeSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::RegRelativeSym&) | Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
Record.RecordOffset =
Delegate ? Delegate->getRecordOffset(Mapping->Reader) : 0;
if (auto EC = Mapping->Mapping.visitKnownRecord(CVR, Record))
return EC;
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xf726c
movq 0x18(%r12), %rax
leaq 0x3c659d(%rip), %rbp # 0x4bd7d8
addq $0x10, %rbp
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rcx
mo... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::visitKnownRecordImpl<llvm::codeview::ConstantSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::ConstantSym&) | Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
Record.RecordOffset =
Delegate ? Delegate->getRecordOffset(Mapping->Reader) : 0;
if (auto EC = Mapping->Mapping.visitKnownRecord(CVR, Record))
return EC;
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xf734e
movq 0x18(%r12), %rax
leaq 0x3c64bb(%rip), %rbp # 0x4bd7d8
addq $0x10, %rbp
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rcx
mo... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::visitKnownRecordImpl<llvm::codeview::ThreadLocalDataSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::ThreadLocalDataSym&) | Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
Record.RecordOffset =
Delegate ? Delegate->getRecordOffset(Mapping->Reader) : 0;
if (auto EC = Mapping->Mapping.visitKnownRecord(CVR, Record))
return EC;
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xf7512
movq 0x18(%r12), %rax
leaq 0x3c62f7(%rip), %rbp # 0x4bd7d8
addq $0x10, %rbp
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rcx
mo... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::DenseMap<std::pair<unsigned short, unsigned int>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned short, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned short, unsigned int>, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::Error llvm::BinaryStreamReader::readArray<llvm::pdb::DbiModuleDescriptor, llvm::VarStreamArrayExtractor<llvm::pdb::DbiModuleDescriptor>>(llvm::VarStreamArray<llvm::pdb::DbiModuleDescriptor, llvm::VarStreamArrayExtractor<llvm::pdb::DbiModuleDescriptor>>&, unsigned int, unsigned int) | Error readArray(VarStreamArray<T, U> &Array, uint32_t Size,
uint32_t Skew = 0) {
BinaryStreamRef S;
if (auto EC = readStreamRef(S, Size))
return EC;
Array.setUnderlyingStream(S, Skew);
return Error::success();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdx
movb $0x0, 0x28(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
callq 0x316990
cmpq $0x0, (%rbx)
jne 0xfdbf7
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
leaq 0x8(%rsp), %rsi
mov... | /llvm/Support/BinaryStreamReader.h |
llvm::FixedStreamArray<llvm::support::detail::packed_endian_specific_integral<unsigned short, (llvm::endianness)1, 1ul, 1ul>>::end() const | FixedStreamArrayIterator<T> end() const {
return FixedStreamArrayIterator<T>(*this, size());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x28(%rsi)
jne 0xfddc2
movq 0x20(%r14), %rax
jmp 0xfddd9
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xfddd7
movq (%rdi), %rax
callq *0x28(%rax)
subq 0x18(%r14), %rax
jmp 0xfddd9
xorl %eax, %eax
movq (%r14), %rcx
movq %rcx, (%rbx)
movq 0x8(%r14),... | /llvm/Support/BinaryStreamArray.h |
llvm::Error llvm::BinaryStreamReader::readArray<llvm::support::detail::packed_endian_specific_integral<int, (llvm::endianness)1, 1ul, 1ul>>(llvm::FixedStreamArray<llvm::support::detail::packed_endian_specific_integral<int, (llvm::endianness)1, 1ul, 1ul>>&, unsigned int) | Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
if (NumItems == 0) {
Array = FixedStreamArray<T>();
return Error::success();
}
if (NumItems > UINT32_MAX / sizeof(T))
return make_error<BinaryStreamError>(
stream_error_code::invalid_array_size);
BinaryStreamR... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testl %ecx, %ecx
je 0xfde64
cmpl $0x40000000, %ecx # imm = 0x40000000
jb 0xfdebb
movl $0x30, %edi
callq 0x8b140
movq %rax, %r14
movq %rax, %rdi
movl $0x2, %esi
callq 0x316596
movq %r14, (%rbx)
jmp 0xfdfad
xorps %xmm0, %xmm0
leaq 0x8... | /llvm/Support/BinaryStreamReader.h |
llvm::FixedStreamArray<llvm::pdb::SectionContrib>::operator[](unsigned int) const | const T &operator[](uint32_t Index) const {
assert(Index < size());
uint32_t Off = Index * sizeof(T);
ArrayRef<uint8_t> Data;
if (auto EC = Stream.readBytes(Off, sizeof(T), Data)) {
assert(false && "Unexpected failure reading from stream");
// This should never happen since we asserted that ... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rax
leal (%rsi,%rsi,8), %ecx
leal (%rcx,%rcx,2), %edx
addl %esi, %edx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x8(%rsp), %rbx
movl $0x1c, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x316f0a
movq (%rbx), %rax
testq %rax, %rax
je 0x10037b
movq $0x0, 0x8(%rs... | /llvm/Support/BinaryStreamArray.h |
llvm::pdb::GlobalsStream::GlobalsStream(std::unique_ptr<llvm::msf::MappedBlockStream, std::default_delete<llvm::msf::MappedBlockStream>>) | GlobalsStream::GlobalsStream(std::unique_ptr<MappedBlockStream> Stream)
: Stream(std::move(Stream)) {} | xorl %eax, %eax
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movb %al, 0x60(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movb %al, 0x90(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movq (%rsi), %rax
movq %rax, 0x40a0(%rdi)
movq $0x0, (%rsi)
retq
nop
| /DebugInfo/PDB/Native/GlobalsStream.cpp |
llvm::pdb::InfoStream::reload() | Error InfoStream::reload() {
BinaryStreamReader Reader(*Stream);
if (auto EC = Reader.readObject(Header))
return joinErrors(
std::move(EC),
make_error<RawError>(raw_error_code::corrupt_file,
"PDB Stream does not contain a header."));
switch (Header->Version) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x316736
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x1c, %ecx
callq 0... | /DebugInfo/PDB/Native/InfoStream.cpp |
llvm::pdb::ModuleDebugStreamRef::ModuleDebugStreamRef(llvm::pdb::DbiModuleDescriptor const&, std::unique_ptr<llvm::msf::MappedBlockStream, std::default_delete<llvm::msf::MappedBlockStream>>) | ModuleDebugStreamRef::ModuleDebugStreamRef(
const DbiModuleDescriptor &Module,
std::unique_ptr<MappedBlockStream> Stream)
: Mod(Module), Stream(std::move(Stream)) {} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x30, %rdi
movq %rdx, %rsi
callq 0x102eb6
xorl %eax, %eax
movb %al, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
mov... | /DebugInfo/PDB/Native/ModuleDebugStream.cpp |
void llvm::pdb::dumpSymbolField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(llvm::raw_ostream&, llvm::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | void dumpSymbolField(raw_ostream &OS, StringRef Name, T Value, int Indent) {
OS << "\n";
OS.indent(Indent);
OS << Name << ": " << Value;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x23cb7c(%rip), %rsi # 0x33fd83
movl $0x1, %edx
callq 0x90d0a
movq %r12, %rdi
movl %ebp, %esi
callq 0xb363a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x90d0a
leaq 0x... | /llvm/DebugInfo/PDB/PDBExtras.h |
llvm::pdb::GSIHashTable::begin() const | GSIHashIterator begin() const { return GSIHashIterator(HashRecords.begin()); } | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x103517
movq 0x3e9a7f(%rip), %rcx # 0x4ecf88
cmpb $0x0, (%rcx)
je 0x103513
incl 0x8(%rax)
jmp 0x103517
lock
incl 0x8(%rax)
movups 0x18(%rsi), %xmm0
movups 0x28... | /llvm/DebugInfo/PDB/Native/GlobalsStream.h |
llvm::pdb::NativeEnumTypes::getChildAtIndex(unsigned int) const | std::unique_ptr<PDBSymbol> NativeEnumTypes::getChildAtIndex(uint32_t N) const {
if (N < Matches.size()) {
SymIndexId Id = Session.getSymbolCache().findSymbolByTypeIndex(Matches[N]);
return Session.getSymbolCache().getSymbolById(Id);
}
return nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, %eax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x1042b4
movq %rsi, %r14
movq 0x28(%rsi), %rdi
addq $0x18, %rdi
movl (%rcx,%rax,4), %esi
callq 0xf0418
movq 0x28(%r14), %rsi
addq $0x18, %rsi
movq %rbx, %rdi
mo... | /DebugInfo/PDB/Native/NativeEnumTypes.cpp |
llvm::pdb::NativeExeSymbol::findChildren(llvm::pdb::PDB_SymType) const | std::unique_ptr<IPDBEnumSymbols>
NativeExeSymbol::findChildren(PDB_SymType Type) const {
switch (Type) {
case PDB_SymType::Compiland: {
return std::unique_ptr<IPDBEnumSymbols>(new NativeEnumModules(Session));
break;
}
case PDB_SymType::ArrayType:
return Session.getSymbolCache().createTypeEnumerator(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leal -0xb(%rdx), %eax
cmpl $0xd, %eax
ja 0x104519
leaq 0x243cb6(%rip), %rcx # 0x348160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %r14
addq $0x18, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (... | /DebugInfo/PDB/Native/NativeExeSymbol.cpp |
llvm::pdb::NativeTypeFunctionSig::initialize() | void NativeTypeFunctionSig::initialize() {
if (IsMemberFunction) {
ClassParentId =
Session.getSymbolCache().findSymbolByTypeIndex(MemberFunc.ClassType);
initializeArgList(MemberFunc.ArgumentList);
} else {
initializeArgList(Proc.ArgumentList);
}
} | pushq %rbx
movq %rdi, %rbx
movl $0x22, %eax
cmpb $0x1, 0x60(%rdi)
jne 0x1093ed
movq 0x8(%rbx), %rdi
addq $0x18, %rdi
movl 0x1e(%rbx), %esi
callq 0xf0418
movl %eax, 0x34(%rbx)
movl $0x2a, %eax
movl (%rbx,%rax), %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1093fa
nop
| /DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp |
llvm::pdb::NativeTypePointer::isMultipleInheritance() const | bool NativeTypePointer::isMultipleInheritance() const {
if (!isMemberPointer())
return false;
return isInheritanceKind(
Record->getMemberInfo(),
PointerToMemberRepresentation::MultipleInheritanceData,
PointerToMemberRepresentation::MultipleInheritanceFunction);
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x4e0(%rax)
testb %al, %al
jne 0x10a1a5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x4e8(%rax)
testb %al, %al
je 0x10a1c2
movzwl 0x2c(%rbx), %eax
andl $-0x5, %eax
shlq $0x20, %rax
movabsq $0x200000000, %rcx # imm = 0x200000000
cmpq %rcx, %rax
sete %al
jmp 0x10a1c4
... | /DebugInfo/PDB/Native/NativeTypePointer.cpp |
llvm::pdb::NativeTypeVTShape::dump(llvm::raw_ostream&, int, llvm::pdb::PdbSymbolIdField, llvm::pdb::PdbSymbolIdField) const | void NativeTypeVTShape::dump(raw_ostream &OS, int Indent,
PdbSymbolIdField ShowIdFields,
PdbSymbolIdField RecurseIdFields) const {
NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
dumpSymbolIdField(OS, "lexicalParentId", 0, Indent, Session,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1070dc
movq 0x8(%r15), %r9
subq $0x8, %rsp
leaq 0x23d482(%rip), %rsi # 0x3480eb
movl $0xf, %edx
movq %r14, %rdi
xorl %ecx, %ecx
movl %ebx, %r8d
pushq %r12
pushq %r13
pushq ... | /DebugInfo/PDB/Native/NativeTypeVTShape.cpp |
llvm::msf::MappedBlockStream::createStream(unsigned int, llvm::msf::MSFStreamLayout const&, llvm::BinaryStreamRef, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&) | std::unique_ptr<MappedBlockStream> MappedBlockStream::createStream(
uint32_t BlockSize, const MSFStreamLayout &Layout, BinaryStreamRef MsfData,
BumpPtrAllocator &Allocator) {
return std::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
BlockSize, Layout, MsfData, Allocator);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movl $0x80, %edi
callq 0x8b140
movq %rax, %r14
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r13), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x10bec7
... | /DebugInfo/MSF/MappedBlockStream.cpp |
llvm::msf::MappedBlockStream::tryReadContiguously(unsigned long, unsigned long, llvm::ArrayRef<unsigned char>&) | bool MappedBlockStream::tryReadContiguously(uint64_t Offset, uint64_t Size,
ArrayRef<uint8_t> &Buffer) {
if (Size == 0) {
Buffer = ArrayRef<uint8_t>();
return true;
}
// Attempt to fulfill the request with a reference directly into the stream.
// This can work... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
testq %rdx, %rdx
je 0x10c604
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rsi
movl 0x8(%rdi), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
movq %rdx, %r15
xorl %edx, %edx
movq %rcx, %r8
subq %r15, %r8
xorl %r9d, %r9d
movq %r14, %ra... | /DebugInfo/MSF/MappedBlockStream.cpp |
llvm::DWARFContext::compile_units() | compile_unit_range compile_units() {
return make_filter_range(info_section_units(), isCompileUnit);
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x38(%rax), %edx
cmpl $-0x1, %edx
cmovel 0x8(%rax), %edx
movq (%rax), %rcx
leaq (%rcx,%rdx,8), %rax
testl %edx, %edx
je 0x11595c
leaq (,%rdx,8), %rdx
movq (%rcx), %rsi
movb 0x60(%rsi), %sil
andb $-0x5, %sil
cmpb $0x2, %sil
jne 0x1... | /llvm/DebugInfo/DWARF/DWARFContext.h |
(anonymous namespace)::ThreadSafeState::getDebugAbbrev() | const DWARFDebugAbbrev *getDebugAbbrev() override {
std::unique_lock<std::recursive_mutex> LockGuard(Mutex);
return ThreadUnsafeDWARFContextState::getDebugAbbrev();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1b8(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x11ed02
movb $0x1, 0x8(%r14)
movq %rbx, %rdi
callq 0x11cf6c
movq %rax, %rbx
cmpb $0x1, 0x8(%r14)
jne 0x11c4f7
leaq 0x8(%rsp), %rdi
callq 0x11ed3e
movq %rbx, %r... | /DebugInfo/DWARF/DWARFContext.cpp |
std::pair<llvm::DenseMapIterator<unsigned long, llvm::RelocAddrEntry, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::RelocAddrEntry>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::RelocAddrEntry, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::Dens... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x120fb8
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x11fd72
xorl %ecx, %ecx
jmp 0x11fd9b
movq %r14,... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.