name string | code string | asm string | file string |
|---|---|---|---|
uv_get_process_title | int uv_get_process_title(char* buffer, size_t size) {
if (buffer == NULL || size == 0)
return UV_EINVAL;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
uv_once(&process_title_mutex_once, init_process_title_mutex_once);
uv_mutex_lock(&proce... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36f61e
cmpq $0x0, -0x18(%rbp)
jne 0x36f62a
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x36f6c8
cmpq $0x0, 0xaf896(%rip) # 0x41eec8
jne 0x36f640
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
poll_cb | static void poll_cb(uv_fs_t* req) {
uv_stat_t* statbuf;
struct poll_ctx* ctx;
uint64_t interval;
uv_fs_poll_t* handle;
ctx = container_of(req, struct poll_ctx, fs_req);
handle = ctx->parent_handle;
if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
goto out;
if (req->result != 0) ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3555e0
cmpl $0x0, %eax
je 0x36fa22
movq -0x28(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x3, %eax
... | /JeremieA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_fs_poll_stop | int uv_fs_poll_stop(uv_fs_poll_t* handle) {
struct poll_ctx* ctx;
if (!uv_is_active((uv_handle_t*)handle))
return 0;
ctx = handle->poll_ctx;
assert(ctx != NULL);
assert(ctx->parent_handle == handle);
/* Close the timer if it's active. If it's inactive, there's a stat request
* in progress and poll... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3555e0
cmpl $0x0, %eax
jne 0x36fbd6
movl $0x0, -0x4(%rbp)
jmp 0x36fcab
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x36fbeb
jmp 0x36fc0a
leaq 0x32a73(%rip), %rdi # 0x3a... | /JeremieA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_fs_poll_getpath | int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
struct poll_ctx* ctx;
size_t required_len;
if (!uv_is_active((uv_handle_t*)handle)) {
*size = 0;
return UV_EINVAL;
}
ctx = handle->poll_ctx;
assert(ctx != NULL);
required_len = strlen(ctx->path);
if (required_len >= *s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3555e0
cmpl $0x0, %eax
jne 0x36fdf9
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x36fe9c
movq -0x10(%rbp), %rax
movq 0x60(%rax)... | /JeremieA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
timer_cb | static void timer_cb(uv_timer_t* timer) {
struct poll_ctx* ctx;
ctx = container_of(timer, struct poll_ctx, timer_handle);
assert(ctx->parent_handle != NULL);
assert(ctx->parent_handle->poll_ctx == ctx);
ctx->start_time = uv_now(ctx->loop);
if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
a... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x370094
jmp 0x3700b3
leaq 0x47407(%rip), %rdi # 0x3b74a2
leaq 0x4731e(%rip), %rsi # 0x3b73c0
movl $0xb0, %edx
leaq 0x4740f(%rip), %rcx ... | /JeremieA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_inet_ntop | int uv_inet_ntop(int af, const void* src, char* dst, size_t size) {
switch (af) {
case AF_INET:
return (inet_ntop4(src, dst, size));
case AF_INET6:
return (inet_ntop6(src, dst, size));
default:
return UV_EAFNOSUPPORT;
}
/* NOTREACHED */
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x37016e
jmp 0x370164
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x370184
jmp 0x37019a
movq -0x10(%rbp), %rdi
movq -0x18(%... | /JeremieA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_ntop6 | static int inet_ntop6(const unsigned char *src, char *dst, size_t size) {
/*
* Note that int32_t and int16_t need only be "at least" large enough
* to contain a value of the specified size. On some systems, like
* Crays, there is no such thing as an integer variable with 16 bits.
* Keep this in mind if y... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x12820
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x3702e3
movq -0x10(%rbp), %rax
movslq -0x94(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl... | /JeremieA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_pton4 | static int inet_pton4(const char *src, unsigned char *dst) {
static const char digits[] = "0123456789";
int saw_digit, octets, ch;
unsigned char tmp[sizeof(struct in_addr)], *tp;
saw_digit = 0;
octets = 0;
*(tp = tmp) = 0;
while ((ch = *src++) != '\0') {
const char *pch;
if ((pch = strchr(digits... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x24(... | /JeremieA[P]CMake/Utilities/cmlibuv/src/inet.c |
uv__strtok | char* uv__strtok(char* str, const char* sep, char** itr) {
const char* sep_itr;
char* tmp;
char* start;
if (str == NULL)
start = tmp = *itr;
else
start = tmp = str;
if (tmp == NULL)
return NULL;
while (*tmp != '\0') {
sep_itr = sep;
while (*sep_itr != '\0') {
if (*tmp == *sep_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x370be8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x370bf4
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%r... | /JeremieA[P]CMake/Utilities/cmlibuv/src/strtok.c |
uv__threadpool_cleanup | __attribute__((destructor))
#endif
void uv__threadpool_cleanup(void) {
unsigned int i;
if (nthreads == 0)
return;
#ifndef __MVS__
/* TODO(gabylb) - zos: revisit when Woz compiler is available. */
post(&exit_message, UV__WORK_CPU);
#endif
for (i = 0; i < nthreads; i++)
if (uv_thread_join(threads + i... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xae311(%rip) # 0x41efc0
jne 0x370cb6
jmp 0x370d4c
leaq 0xae313(%rip), %rdi # 0x41efd0
xorl %esi, %esi
callq 0x370d60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xae2ec(%rip), %eax # 0x41efc0
jae 0x370d03
movq 0xae303(%rip), %rdi # 0x41efe0
mo... | /JeremieA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
init_once | static void init_once(void) {
#ifndef _WIN32
/* Re-initialize the threadpool after fork.
* Note that this discards the global mutex and condition as well
* as the work queue.
*/
if (pthread_atfork(NULL, NULL, &reset_once))
abort();
#endif
init_threads();
} | pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, %esi
leaq 0x531(%rip), %rdx # 0x371400
movq %rsi, %rdi
callq 0x380a90
cmpl $0x0, %eax
je 0x370ee1
callq 0x13300
callq 0x371420
popq %rbp
retq
nopl (%rax,%rax)
| /JeremieA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
fixedtables | local void fixedtables(struct inflate_state FAR *state) {
#ifdef BUILDFIXED
static int virgin = 1;
static code *lenfix, *distfix;
static code fixed[544];
/* build fixed huffman tables if first call (may not be thread safe) */
if (virgin) {
unsigned sym, bits;
static code *next;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x434bd(%rip), %rcx # 0x3be3f0
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0x43ca3(%rip), %rcx # 0x3bebf0
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x7c(%rax)
popq %rbp
retq
... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateGetDictionary | int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef *dictionary,
uInt *dictLength) {
struct inflate_state FAR *state;
/* check state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* copy dictionary */
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3783c0
cmpl $0x0, %eax
je 0x37b21e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x37b2b8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateGetHeader | int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head) {
struct inflate_state FAR *state;
/* check state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
/* save header structure */... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3783c0
cmpl $0x0, %eax
je 0x37b3f7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x37b439
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%r... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateSync | int ZEXPORT inflateSync(z_streamp strm) {
unsigned len; /* number of bytes to look at or looked at */
int flags; /* temporary to save header status */
unsigned long in, out; /* temporary to save total_in and total_out */
unsigned char buf[4]; /* to restore bit b... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3783c0
cmpl $0x0, %eax
je 0x37b476
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x37b651
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x37b4a2
m... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateValidate | int ZEXPORT inflateValidate(z_streamp strm, int check) {
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (check && state->wrap)
state->wrap |= 4;
else
state->wrap &= ~4;
return Z_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3783c0
cmpl $0x0, %eax
je 0x37ba36
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x37ba75
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x37ba61
... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateMark | long ZEXPORT inflateMark(z_streamp strm) {
struct inflate_state FAR *state;
if (inflateStateCheck(strm))
return -(1L << 16);
state = (struct inflate_state FAR *)strm->state;
return (long)(((unsigned long)((long)state->back)) << 16) +
(state->mode == COPY ? state->length :
(s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3783c0
cmpl $0x0, %eax
je 0x37baa4
movq $-0x10000, -0x8(%rbp) # imm = 0xFFFF0000
jmp 0x37bb1c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x1bec(%rax), %rax
shlq $0x1... | /JeremieA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib__tr_stored_block | void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf,
ulg stored_len, int last) {
send_bits(s, (STORED_BLOCK<<1) + last, 3); /* send block type */
bi_windup(s); /* align on byte boundary */
put_short(s, (ush)stored_len);
put_short(s, (ush)~stored_l... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x3, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %eax
movl $0x10, %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jle 0x37c492
movl -0x1c(%rbp), %eax
addl $0x0, %eax
movl %ea... | /JeremieA[P]CMake/Utilities/cmzlib/trees.c |
cmsys::kwsysUnPutEnv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static int kwsysUnPutEnv(const std::string& env)
{
size_t pos = env.find('=');
if (pos != std::string::npos) {
std::string name = env.substr(0, pos);
unsetenv(name.c_str());
} else {
unsetenv(env.c_str());
}
return 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x3d
popq %rsi
xorl %edx, %edx
callq 0x4550
cmpq $-0x1, %rax
je 0x5ad3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4450
movq (%r14), %rdi
callq 0x45a0
movq %r14, %rdi
callq 0x4888
addq $0x28, %rsp
popq %rbx
po... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::MakeDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const*) | bool SystemTools::MakeDirectory(const std::string& path, const mode_t* mode)
{
if (SystemTools::PathExists(path)) {
return SystemTools::FileIsDirectory(path);
}
if (path.empty()) {
return false;
}
std::string dir = path;
SystemTools::ConvertToUnixSlashes(dir);
std::string::size_type pos = 0;
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5cc0
testb %al, %al
je 0x5b8d
movq %r14, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5cec
cmpq $0x0, 0x8(%r14)
je 0x5c5c
leaq 0x28(%rsp), %r15
movq %r15,... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FileIsDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static DWORD SystemToolsMakeRegistryMode(DWORD mode,
SystemTools::KeyWOW64 view)
{
// only add the modes when on a system that supports Wow64.
static FARPROC wow64p =
GetProcAddress(GetModuleHandleW(L"kernel32"), "IsWow64Process");
if (wow64p == NULL) {
return mode... | pushq %r14
pushq %rbx
subq $0x10b8, %rsp # imm = 0x10B8
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5d63
movq (%rdi), %rsi
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rax, %rbx
decq %rbx
je 0x5d76
movzbl (%rsi,%rbx), %ecx
cmpl $0x5c, %ecx
je 0x5d29
cmpl $0x2f, %ec... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::SetPermissions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, bool) | bool SystemTools::SetPermissions(const std::string& file, mode_t mode,
bool honor_umask)
{
if (!SystemTools::PathExists(file)) {
return false;
}
if (honor_umask) {
mode_t currentMask = umask(0);
umask(currentMask);
mode &= ~currentMask;
}
#ifdef _WIN32
if (_wch... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0x5cc0
testb %al, %al
je 0x5e00
testb %bpl, %bpl
je 0x5def
xorl %edi, %edi
callq 0x4770
movl %eax, %ebp
movl %eax, %edi
callq 0x4770
notl %ebp
andl %ebp, %ebx
movq (%r14), %rdi
movl %ebx, %esi
callq 0x43b0
testl %eax, %eax
setns %al
... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ReplaceString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SystemTools::ReplaceString(std::string& source, const char* replace,
size_t replaceSize, const std::string& with)
{
const char* src = source.c_str();
char* searchPos = const_cast<char*>(strstr(src, replace));
// get out quick if string is not found
if (!searchPos) {
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbp
movq %rbp, %rdi
callq 0x4100
testq %rax, %rax
je 0x5eca
movq %rax, %r13
movq %rbp, %rdi
callq 0x47c0
movq %rax, (%rsp)
subq %rbp, %r13
addq %rax, %r13
movq 0x8(%... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ReplaceString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, char const*) | void SystemTools::ReplaceString(std::string& source, const char* replace,
const char* with)
{
// do while hangs if replaceSize is 0
if (!*replace) {
return;
}
SystemTools::ReplaceString(source, replace, strlen(replace),
with ? with : "");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rsi)
je 0x5f39
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x41d0
movq %rax, %r12
testq %r15, %r15
leaq 0x723e(%rip), %rsi # 0xd146
cmovneq %r15, %rsi
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq ... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CopyFileIfDifferent(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>> const&) | bool SystemTools::CopyFileIfDifferent(const std::string& source,
const std::string& destination)
{
// special check for a destination that is a directory
// FilesDiffer does not handle file to directory compare
if (SystemTools::FileIsDirectory(destination)) {
std::string ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5cec
testb %al, %al
je 0x6fb9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x45b0
movq %r15, %rdi
callq 0x5894
leaq 0x8(%rsp), %rdi
pushq $0x2f
popq %rsi
callq 0x4360
leaq 0x48(%rsp), %rdi
... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CopyFileAlways(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>> const&) | bool SystemTools::CopyFileAlways(const std::string& source,
const std::string& destination)
{
// If files are the same do not copy
if (SystemTools::SameFile(source, destination)) {
return true;
}
mode_t perm = 0;
bool perms = SystemTools::GetPermissions(source, perm);
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1450, %rsp # imm = 0x1450
movq %rsi, %r15
movq %rdi, %r14
callq 0x5f6a
movb $0x1, %bl
testb %al, %al
jne 0x7440
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %r14, %rdi
callq 0x77ba
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x45b0
m... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetLineFromStream(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool*, long) | bool SystemTools::GetLineFromStream(std::istream& is, std::string& line,
bool* has_newline /* = 0 */,
long sizeLimit /* = -1 */)
{
// Start with an empty line.
line = "";
// Early short circuit return if stream is no good. Just return
// f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x5a2f(%rip), %rsi # 0xd146
movq %r12, %rdi
callq 0x4800
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x773c
xorl %eax, %eax
movl $0x0, %ebp
testq %rbx, %rbx
jne 0x... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetFilenameExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::GetFilenameExtension(const std::string& filename)
{
std::string name = SystemTools::GetFilenameName(filename);
std::string::size_type dot_pos = name.find('.');
if (dot_pos != std::string::npos) {
return name.substr(dot_pos);
} else {
return "";
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7024
pushq $0x2e
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4550
cmpq $-0x1, %rax
je 0x9a8b
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4450
jmp 0x9a9f
leaq 0x36b4(%rip), %rs... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetFilenameLastExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::GetFilenameLastExtension(const std::string& filename)
{
std::string name = SystemTools::GetFilenameName(filename);
std::string::size_type dot_pos = name.rfind('.');
if (dot_pos != std::string::npos) {
return name.substr(dot_pos);
} else {
return "";
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7024
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x4840
cmpq $-0x1, %rax
je 0x9b0c
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4450
jmp 0x9b20
leaq 0x3633(%rip... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetFilenameWithoutExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::GetFilenameWithoutExtension(
const std::string& filename)
{
std::string name = SystemTools::GetFilenameName(filename);
std::string::size_type dot_pos = name.find('.');
if (dot_pos != std::string::npos) {
return name.substr(0, dot_pos);
} else {
return name;
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7024
pushq $0x2e
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4550
cmpq $-0x1, %rax
je 0x9b8a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4450
jmp 0x9bcc
leaq 0x10(%rbx), %rcx
movq %... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetFilenameWithoutLastExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::GetFilenameWithoutLastExtension(
const std::string& filename)
{
std::string name = SystemTools::GetFilenameName(filename);
std::string::size_type dot_pos = name.rfind('.');
if (dot_pos != std::string::npos) {
return name.substr(0, dot_pos);
} else {
return name;
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7024
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x4840
cmpq $-0x1, %rax
je 0x9c35
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4450
jmp 0x9c77
leaq 0x10(%rbx), %rcx
... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FileHasSignature(char const*, char const*, long) | bool SystemTools::FileHasSignature(const char* filename, const char* signature,
long offset)
{
if (!filename || !signature) {
return false;
}
FILE* fp = Fopen(filename, "rb");
if (!fp) {
return false;
}
fseek(fp, offset, SEEK_SET);
bool res = false;
size_t s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9d5e
movq %rdx, %r15
movq %rdi, %rsi
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x4c8c
movq (%r12), %rdi
leaq 0x3484(%rip), %rsi # 0xd... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::DetectFileType(char const*, unsigned long, double) | SystemTools::FileTypeEnum SystemTools::DetectFileType(const char* filename,
unsigned long length,
double percent_bin)
{
if (!filename || percent_bin < 0) {
return SystemTools::FileTypeUnknown;
}
if (Sy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x9ece
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x9ece
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c8c
... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FileIsFullPath(char const*, unsigned long) | bool SystemTools::FileIsFullPath(const char* in_name, size_t len)
{
#if defined(_WIN32) || defined(__CYGWIN__)
// On Windows, the name must be at least two characters long.
if (len < 2) {
return false;
}
if (in_name[1] == ':') {
return true;
}
if (in_name[0] == '\\') {
return true;
}
#else
/... | testq %rsi, %rsi
je 0xa2d0
movb (%rdi), %al
cmpb $0x7e, %al
sete %cl
cmpb $0x2f, %al
sete %al
orb %cl, %al
retq
xorl %eax, %eax
retq
nop
| /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetShortPath(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>>&) | bool SystemTools::GetShortPath(const std::string& path, std::string& shortPath)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
std::string tempPath = path; // create a buffer
// if the path passed in has quotes around it, first remove the quotes
if (!path.empty() && path[0] == '"' && path.back() == '"') {
tem... | pushq %rax
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4250
movb $0x1, %al
popq %rcx
retq
nop
| /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::MakeCidentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::MakeCidentifier(const std::string& s)
{
std::string str(s);
if (str.find_first_of("0123456789") == 0) {
str = "_" + str;
}
std::string permited_chars("_"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x45b0
leaq 0x2e32(%rip), %rsi # 0xd1a6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4220
testq %rax, %rax
jne 0xa3af
leaq 0x2de5(%rip), %rsi # 0xd16f
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xaecd
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::IsSubDirectory(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>> const&) | bool SystemTools::IsSubDirectory(const std::string& cSubdir,
const std::string& cDir)
{
if (cDir.empty()) {
return false;
}
std::string subdir = cSubdir;
std::string dir = cDir;
SystemTools::ConvertToUnixSlashes(subdir);
SystemTools::ConvertToUnixSlashes(dir);
if (subd... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xa666
movq %rdi, %rsi
leaq 0x28(%rsp), %rdi
callq 0x45b0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x45b0
leaq 0x28(%rsp), %rdi
callq 0x5894
leaq 0x8(%rsp), %rdi
callq 0x5894
movq 0x10(%rsp), %rcx
cmpq %rcx, 0x30(%rsp)
setbe %al
testq %rcx... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::Delay(unsigned int) | void SystemTools::Delay(unsigned int msec)
{
#ifdef _WIN32
Sleep(msec);
#else
// The sleep function gives 1 second resolution and the usleep
// function gives 1e-6 second resolution but on some platforms has a
// maximum sleep time of 1 second. This could be re-implemented to
// use select with masked signal... | pushq %rbx
movl %edi, %ebx
cmpl $0x3e8, %edi # imm = 0x3E8
jb 0xa6b7
movl $0x3e8, %ecx # imm = 0x3E8
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %ebx
movl %eax, %edi
callq 0x4300
imull $0x3e8, %ebx, %edi # imm = 0x3E8
popq %rbx
jmp 0x45f0
nop
| /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetOperatingSystemNameAndVersion[abi:cxx11]() | std::string SystemTools::GetOperatingSystemNameAndVersion()
{
std::string res;
#ifdef _WIN32
char buffer[256];
OSVERSIONINFOEXA osvi;
BOOL bOsVersionInfoEx;
ZeroMemory(&osvi, sizeof(osvi));
osvi.dwOSVersionInfoSize = sizeof(osvi);
# ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
# pragma warning(push)
... | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
retq
| /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ParseURLProtocol(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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool SystemTools::ParseURLProtocol(const std::string& URL,
std::string& protocol,
std::string& dataglom)
{
// match 0 entire url
// match 1 protocol
// match 2 dataglom following protocol://
kwsys::RegularExpression urlRe(VTK_URL_PROTOCOL_REG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2ac2(%rip), %rsi # 0xd1b9
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xaf44
movq %r12, %rdi
movq %r15, %rsi
callq 0xaf68
movl %eax, %ebp
testb %al, %al
je 0xa761
movq %rsp, %rdi
leaq 0x20... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ParseURL(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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char... | bool SystemTools::ParseURL(const std::string& URL, std::string& protocol,
std::string& username, std::string& password,
std::string& hostname, std::string& dataport,
std::string& database)
{
kwsys::RegularExpression urlRe(VTK_URL_REGEX);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x20(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x2a0d(%rip), %rsi # 0xd1cf
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xaf44
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaf68
mov... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ClassInitialize() | void SystemTools::ClassInitialize()
{
#ifdef __VMS
SetVMSFeature("DECC$FILENAME_UNIX_ONLY", 1);
#endif
// Allocate the translation map first.
SystemTools::TranslationMap = new SystemToolsTranslationMap;
#ifdef _WIN32
SystemTools::PathCaseMap = new SystemToolsPathCaseMap;
SystemTools::EnvMap = new SystemToolsE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8d8, %rsp # imm = 0x8D8
pushq $0x30
popq %rdi
callq 0x4420
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x8b08(%rip) # 0x13468
leaq 0x... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ClassFinalize() | void SystemTools::ClassFinalize()
{
delete SystemTools::TranslationMap;
#ifdef _WIN32
delete SystemTools::PathCaseMap;
delete SystemTools::EnvMap;
#endif
#ifdef __CYGWIN__
delete SystemTools::Cyg2Win32Map;
#endif
} | pushq %rbx
movq 0x8858(%rip), %rbx # 0x13468
testq %rbx, %rbx
je 0xac1d
movq %rbx, %rdi
callq 0xb24a
pushq $0x30
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4430
nop
| /micst[P]CMake/Source/kwsys/SystemTools.cxx |
Realpath(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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | inline void Realpath(const std::string& path, std::string& resolved_path,
std::string* errorMessage = KWSYS_NULLPTR)
{
char resolved_name[KWSYS_SYSTEMTOOLS_MAXPATH];
errno = 0;
char* ret = realpath(path.c_str(), resolved_name);
if (ret) {
resolved_path = ret;
} else if (errorMessage)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4060
movq %rax, %r12
andl $0x0, (%rax)
movq (%r15), %rdi
movq %rsp, %rsi
callq 0x4160
testq %rax, %rax
je 0xacd2
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xad12
testq %r14, %r14
je ... | /micst[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::RegularExpressionMatch::match[abi:cxx11](int) const | inline std::string RegularExpressionMatch::match(int n) const
{
if (this->startp[n] == 0) {
return std::string();
} else {
return std::string(
this->startp[n],
static_cast<std::string::size_type>(this->endp[n] - this->startp[n]));
}
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movslq %edx, %rcx
movq (%rsi,%rcx,8), %rsi
testq %rsi, %rsi
je 0xb235
movq 0x50(%rax,%rcx,8), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4cc8
jmp 0xb245
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax... | /micst[P]CMake/build_O2/Source/cmsys/RegularExpression.hxx |
cmsysEncoding_mbstowcs | size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* str, size_t n)
{
if (str == 0) {
return (size_t)-1;
}
#ifdef _WIN32
return MultiByteToWideChar(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str, -1, dest,
(int)n) -
1;
#else
return mbstowcs(dest, str, n);
#endif
} | testq %rsi, %rsi
jne 0x4050
pushq $-0x1
popq %rax
retq
| /micst[P]CMake/Source/kwsys/EncodingC.c |
cmsysEncoding_DupToWide | wchar_t* kwsysEncoding_DupToWide(const char* str)
{
wchar_t* ret = NULL;
size_t length = kwsysEncoding_mbstowcs(NULL, str, 0) + 1;
if (length > 0) {
ret = (wchar_t*)malloc((length) * sizeof(wchar_t));
if (ret) {
ret[0] = 0;
kwsysEncoding_mbstowcs(ret, str, length);
}
}
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb700
movq %rax, %r15
incq %r15
je 0xb755
leaq (,%r15,4), %rdi
callq 0x4570
testq %rax, %rax
je 0xb753
movq %rax, %rbx
andl $0x0, (%rax)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb700
jm... | /micst[P]CMake/Source/kwsys/EncodingC.c |
cmsysEncoding_wcstombs | size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* str, size_t n)
{
if (str == 0) {
return (size_t)-1;
}
#ifdef _WIN32
return WideCharToMultiByte(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str, -1, dest,
(int)n, NULL, NULL) -
1;
#else
return wcstombs(dest, str, n);
#endif
} | testq %rsi, %rsi
jne 0x4370
pushq $-0x1
popq %rax
retq
| /micst[P]CMake/Source/kwsys/EncodingC.c |
cmsysEncoding_DupToNarrow | char* kwsysEncoding_DupToNarrow(const wchar_t* str)
{
char* ret = NULL;
size_t length = kwsysEncoding_wcstombs(0, str, 0) + 1;
if (length > 0) {
ret = (char*)malloc(length);
if (ret) {
ret[0] = 0;
kwsysEncoding_wcstombs(ret, str, length);
}
}
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb75e
movq %rax, %r15
incq %r15
je 0xb7ae
movq %r15, %rdi
callq 0x4570
testq %rax, %rax
je 0xb7ac
movq %rax, %rbx
movb $0x0, (%rax)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb75e
jmp 0xb... | /micst[P]CMake/Source/kwsys/EncodingC.c |
cmsys::Directory::Directory() | Directory::Directory()
{
this->Internal = new DirectoryInternals;
} | pushq %rbx
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x4420
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x28(%rax), %rcx
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| /micst[P]CMake/Source/kwsys/Directory.cxx |
cmsys::Directory::Load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Directory::Load(const std::string& name)
{
this->Clear();
DIR* dir = opendir(name.c_str());
if (!dir) {
return 0;
}
for (kwsys_dirent* d = readdir(dir); d; d = readdir(dir)) {
this->Internal->Files.push_back(d->d_name);
}
this->Internal->Path = name;
closedir(dir);
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0xb83e
movq (%rbx), %rdi
callq 0x4660
movq %rax, %r14
testq %rax, %rax
je 0xb8e3
movq %r14, %rdi
callq 0x4680
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
movq (%r15), %rbp
testq %rax, %rax
je 0xb8cc
ad... | /micst[P]CMake/Source/kwsys/Directory.cxx |
CLI::OptionAlreadyAdded::OptionAlreadyAdded(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | explicit OptionAlreadyAdded(std::string name)
: OptionAlreadyAdded(name + " is already added", ExitCodes::OptionAlreadyAdded) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2db94
leaq 0x141df(%rip), %rsi # 0x2f7d3
movq %r14, %rdi
callq 0x55d0
movq %rsp, %rsi
movq %rb... | /CLIUtils[P]CLI11/include/CLI/Error.hpp |
CLI::detail::valid_alias_name_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline bool valid_alias_name_string(const std::string &str) {
static const std::string badChars(std::string("\n") + '\0');
return (str.find_first_of(badChars) == std::string::npos);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb 0x20ceb(%rip), %al # 0x3e888
testb %al, %al
je 0x1dbc8
movq 0x20cc0(%rip), %rsi # 0x3e868
movq 0x20cc1(%rip), %rcx # 0x3e870
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5450
cmpq $-0x1, %rax
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x20... | /CLIUtils[P]CLI11/include/CLI/StringTools.hpp |
CLI::App::_process_callbacks() | CLI11_INLINE void App::_process_callbacks() {
for(App_p &sub : subcommands_) {
// process the priority option_groups first
if(sub->get_name().empty() && sub->parse_complete_callback_) {
if(sub->count_all() > 0) {
sub->_process_callbacks();
sub->run_callba... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2c0(%rdi), %r14
movq 0x2c8(%rdi), %r15
cmpq %r15, %r14
je 0x23573
movq (%r14), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x23549
addq $0x10, %r14
jmp 0x23534
cmpq $0x0, 0x80(%rdi)
je 0x23543
callq 0x9582
testq %rax, %rax
je 0x23543
movq (%r14), %rdi
callq 0x2351e
movq (%r14),... | /CLIUtils[P]CLI11/include/CLI/impl/App_inl.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::rjoin<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_s... | std::string rjoin(const T &v, std::string delim = ",") {
std::ostringstream s;
for(std::size_t start = 0; start < v.size(); start++) {
if(start > 0)
s << delim;
s << v[v.size() - start - 1];
}
return s.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x53d0
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x24498
movq $-0x20, %r13
xorl %ebp, %ebp
movq %rsp, %r12
testq %rbp, %rbp
je 0x2446d
movq (... | /CLIUtils[P]CLI11/include/CLI/StringTools.hpp |
CLI::ExtrasError::~ExtrasError() | explicit ExtrasError(std::vector<std::string> args)
: ExtrasError((args.size() > 1 ? "The following arguments were not expected: "
: "The following argument was not expected: ") +
detail::rjoin(args, " "),
ExitCodes::ExtrasEr... | pushq %rbx
movq %rdi, %rbx
leaq 0x19077(%rip), %rax # 0x3d678
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x24616
callq 0x52b0
movq %rbx, %rdi
callq 0x5300
movq %rbx, %rdi
popq %rbx
jmp 0x52b0
nop
| /CLIUtils[P]CLI11/include/CLI/Error.hpp |
CLI::Success::~Success() | Success() : Success("Successfully completed, should be caught and quit", ExitCodes::Success) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x17e63(%rip), %rax # 0x3d678
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x2582a
callq 0x52b0
movq %rbx, %rdi
callq 0x5300
movq %rbx, %rdi
popq %rbx
jmp 0x52b0
nop
| /CLIUtils[P]CLI11/include/CLI/Error.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::join<std::vector<std::unique_ptr<CLI::Option, std::default_delete<CLI::Option>>, std::allocator<std::unique_ptr<CLI::Option, std::default_delete<CLI::Option>>>>, CLI::App::_process_requirements()::'lambda'(std::unique_ptr<CLI::O... | std::string join(const T &v, Callable func, std::string delim = ",") {
std::ostringstream s;
auto beg = std::begin(v);
auto end = std::end(v);
auto loc = s.tellp();
while(beg != end) {
auto nloc = s.tellp();
if(nloc > loc) {
s << delim;
loc = nloc;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, 0x30(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x53d0
movq (%rbx), %r13
movq 0x8(%rbx), %rbp
movq %r12, %rdi
callq 0x5270
movq %r14, 0x28(%rsp)
... | /CLIUtils[P]CLI11/include/CLI/StringTools.hpp |
bool CLI::detail::lexical_conversion<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, st... | bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
output.erase(output.begin(), output.end());
if(strings.empty()) {
return true;
}
if(strings.size() == 1 && strings[0] == "{}") {
return true;
}
bool skip_remaining = false;
if(strings.size()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
callq 0x1ab08
movq (%r14), %rdi
movq 0x8(%r14), %rax
movb $0x1, %bpl
cmpq %rax, %rdi
je 0x29211
movq %rax, %rcx
subq %rdi, %rcx
cmpq $0x20, %rcx
jne 0... | /CLIUtils[P]CLI11/include/CLI/TypeTools.hpp |
CLI::detail::streamOutAsParagraph(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | CLI11_INLINE std::ostream &streamOutAsParagraph(std::ostream &out,
const std::string &text,
std::size_t paragraphWidth,
const std::string &linePrefix,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
testl %r8d, %r8d
jne 0x2c600
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x5320
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %... | /CLIUtils[P]CLI11/include/CLI/impl/StringTools_inl.hpp |
mbedtls_ecp_point_read_binary | int mbedtls_ecp_point_read_binary( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *pt,
const unsigned char *buf, size_t ilen )
{
int ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
size_t plen;
ECP_VALIDATE_RET( grp != NULL );
ECP_VALIDAT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffb080, %ebp # imm = 0xFFFFB080
testq %rcx, %rcx
je 0x8335
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
addq $0x8, %rdi
callq 0x182df
cmpq $0x0, 0x60(%r13)
je 0x827f
movq %rax, %r15
cmpq $0x0, 0x78(%r13)
je 0... | /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_read_key | int mbedtls_ecp_read_key( mbedtls_ecp_group_id grp_id, mbedtls_ecp_keypair *key,
const unsigned char *buf, size_t buflen )
{
int ret = 0;
ECP_VALIDATE_RET( key != NULL );
ECP_VALIDATE_RET( buf != NULL );
if( ( ret = mbedtls_ecp_group_load( &key->grp, grp_id ) ) != 0 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %r12d
movq %rsi, %rdi
movl %r12d, %esi
callq 0xb3c0
movl %eax, %ebp
testl %eax, %eax
jne 0x9fbc
cmpq $0x0, 0x60(%rbx)
je 0x9f95
movq 0x78(%rbx), %rax
testq %rax, %rax
setne %cl
cmpl $0x9, %r12d
setne %dl
mo... | /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_hmac_drbg_free | void mbedtls_hmac_drbg_free( mbedtls_hmac_drbg_context *ctx )
{
if( ctx == NULL )
return;
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_free( &ctx->mutex );
#endif
mbedtls_md_free( &ctx->md_ctx );
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_hmac_drbg_context ) );
} | testq %rdi, %rdi
je 0xd9d8
pushq %rbx
movq %rdi, %rbx
callq 0xdfe0
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf370
retq
| /ARMmbed[P]mbed-crypto/library/hmac_drbg.c |
mbedtls_md_finish | int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
{
if( ctx == NULL || ctx->md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD2_C)
case MBEDTLS_MD_MD2:
return( mbedtls_md2_finish_ret( ctx->md_c... | testq %rdi, %rdi
je 0xe340
movq (%rdi), %rax
testq %rax, %rax
je 0xe340
movl 0x8(%rax), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0xe340
leaq 0xff7e(%rip), %rcx # 0x1e2ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x12d28
movl $0xffffaf00, %eax # imm = 0xFFFFAF00
retq
movq ... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_md_hmac | int mbedtls_md_hmac( const mbedtls_md_info_t *md_info,
const unsigned char *key, size_t keylen,
const unsigned char *input, size_t ilen,
unsigned char *output )
{
mbedtls_md_context_t ctx;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
if( md... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xe769
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %edx
callq 0xe10d
testl %ea... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_internal_sha1_process | int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
const unsigned char data[64] )
{
uint32_t temp, W[16], A, B, C, D, E;
SHA1_VALIDATE_RET( ctx != NULL );
SHA1_VALIDATE_RET( (const unsigned char *)data != NULL );
GET_UINT32_BE( W[ 0], data, 0 );
GET_U... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl (%rsi), %r12d
movl 0x4(%rsi), %eax
bswapl %r12d
bswapl %eax
movq %rax, -0x38(%rsp)
movl 0x8(%rsi), %r15d
movq %rdi, -0x10(%rsp)
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %r11d
movl 0x10(%rdi), %r10d
movl 0x14(%rdi), %ecx
movl 0x18(%rdi), ... | /ARMmbed[P]mbed-crypto/library/sha1.c |
mbedtls_sha256_starts | int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 )
{
SHA256_VALIDATE_RET( ctx != NULL );
SHA256_VALIDATE_RET( is224 == 0 || is224 == 1 );
ctx->total[0] = 0;
ctx->total[1] = 0;
if( is224 == 0 )
{
/* SHA-256 */
ctx->state[0] = 0x6A09E667;
ctx->state[1... | movq $0x0, (%rdi)
testl %esi, %esi
je 0x1222b
movaps 0xc980(%rip), %xmm0 # 0x1eba0
jne 0x12234
movaps 0xc987(%rip), %xmm1 # 0x1ebb0
jmp 0x1223b
movaps 0xc95e(%rip), %xmm0 # 0x1eb90
je 0x12222
movaps 0xc985(%rip), %xmm1 # 0x1ebc0
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%rdi)
movl %esi, 0x68(%rdi)
retq... | /ARMmbed[P]mbed-crypto/library/sha256.c |
mbedtls_timing_get_delay | int mbedtls_timing_get_delay( void *data )
{
mbedtls_timing_delay_context *ctx = (mbedtls_timing_delay_context *) data;
unsigned long elapsed_ms;
if( ctx->fin_ms == 0 )
return( -1 );
elapsed_ms = mbedtls_timing_get_timer( &ctx->timer, 0 );
if( elapsed_ms >= ctx->fin_ms )
return( 2... | cmpl $0x0, 0x24(%rdi)
je 0x13ef2
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x60d0
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq (%rbx), %rcx
imulq $0x3e8, %rcx, %rcx # imm = 0x3E8
subq 0x8(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x... | /ARMmbed[P]mbed-crypto/library/timing.c |
mbedtls_aesni_inverse_key | void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%x... | shll $0x4, %edx
movslq %edx, %rax
addq %rsi, %rax
addq $-0x10, %rax
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
cmpq %rsi, %rax
jbe 0x16b25
movdqu (%rax), %xmm0
aesimc %xmm0, %xmm0
movdqu %xmm0, (%rdi)
addq $-0x10, %rax
jmp 0x16b09
movups (%rax), %xmm0
movups %xmm0, (%rdi)
retq
| /ARMmbed[P]mbed-crypto/library/aesni.c |
mbedtls_asn1_write_octet_string | int mbedtls_asn1_write_octet_string( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, buf, size ) );
MBEDT... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
jne 0x17c4d
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx,... | /ARMmbed[P]mbed-crypto/library/asn1write.c |
mbedtls_mpi_write_string | int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix,
char *buf, size_t buflen, size_t *olen )
{
int ret = 0;
size_t n;
char *p;
mbedtls_mpi T;
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET( olen != NULL );
MPI_VALIDATE_RET( buflen == 0 || buf != N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
leal -0x11(%rbp), %eax
movl $0xfffffffc, %ebx # imm = 0xFFFFFFFC
cmpl $-0xf, %eax
jb 0x188f8
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r13
callq 0x1826b
cmpl $0x4, %ebp
setae %cl
shrq %cl, %rax
cmpl... | /ARMmbed[P]mbed-crypto/library/bignum.c |
ZyrexUpdateThread | ZyanStatus ZyrexUpdateThread(ZyanThreadId thread_id)
{
ZyanThreadId tid;
ZYAN_CHECK(ZyanThreadGetCurrentThreadId(&tid));
if (g_transaction_data.transaction_thread_id != tid)
{
return ZYAN_STATUS_INVALID_OPERATION;
}
#ifdef ZYAN_WINDOWS
ZYAN_ASSERT(g_transaction_data.pending_operations... | pushq %rax
movq %rsp, %rdi
callq 0xc61f
testl %eax, %eax
js 0x437e
movq 0x5ed73(%rip), %rax # 0x630e0
cmpq (%rsp), %rax
movl $0x100000, %ecx # imm = 0x100000
movl $0x80100005, %eax # imm = 0x80100005
cmovel %ecx, %eax
popq %rcx
retq
| /zyantific[P]zyan-hook-engine/src/Transaction.c |
ZydisDecoderDecodeFull | ZyanStatus ZydisDecoderDecodeFull(const ZydisDecoder* decoder,
const void* buffer, ZyanUSize length, ZydisDecodedInstruction* instruction,
ZydisDecodedOperand* operands, ZyanU8 operand_count, ZydisDecodingFlags flags)
{
if (!decoder || !buffer || !length || !instruction || (operand_count && !operands) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %sil
orb %al, %sil
testq %rcx, %rcx
sete %dil
testq %r14, %r14
sete %r8b
movl $0x80100004, %eax # imm = 0x80100004
orb %dil, %... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisDecoderDecodeInstruction | ZyanStatus ZydisDecoderDecodeInstruction(const ZydisDecoder* decoder, ZydisDecoderContext* context,
const void* buffer, ZyanUSize length, ZydisDecodedInstruction* instruction)
{
if (!decoder || !instruction)
{
return ZYAN_STATUS_INVALID_ARGUMENT;
}
if (!buffer || !length)
{
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, %rbp
testq %rdi, %rdi
sete %cl
testq %r8, %r8
sete %dl
movl $0x80100004, %eax # imm = 0x80100004
orb %cl, %dl
jne 0x7bff
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %dl
movl $0x80200000, %eax # ... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisDecodeInstruction | static ZyanStatus ZydisDecodeInstruction(ZydisDecoderState* state,
ZydisDecodedInstruction* instruction)
{
ZYAN_ASSERT(state);
ZYAN_ASSERT(instruction);
// Iterate through the decoder tree
const ZydisDecoderTreeNode* node = ZydisDecoderTreeGetRootNode();
const ZydisDecoderTreeNode* temp = ZYAN_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
testq %rdi, %rdi
je 0xa339
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x14(%rsi), %rax
movq %rax, 0x60(%rsp)
leaq 0x108(%rsi), %rax
movq %rax, 0x58(%rsp)
leaq 0x117(%rsi), %rax
movq %rax, 0x78(%rsp)
leaq 0x208a4(%rip), %r13 # 0x286e8... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisInputNext | static ZyanStatus ZydisInputNext(ZydisDecoderState* state,
ZydisDecodedInstruction* instruction, ZyanU8* value)
{
ZYAN_ASSERT(state);
ZYAN_ASSERT(instruction);
ZYAN_ASSERT(value);
if (instruction->length >= ZYDIS_MAX_INSTRUCTION_LENGTH)
{
return ZYDIS_STATUS_INSTRUCTION_TOO_LONG;
}
... | testq %rdx, %rdx
je 0xb829
movl $0x80200002, %eax # imm = 0x80200002
cmpb $0xe, 0x8(%rsi)
ja 0xb822
cmpq $0x0, 0x18(%rdi)
je 0xb823
movq 0x10(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rdi)
movb (%rax), %al
movb %al, (%rdx)
incb 0x8(%rsi)
decq 0x18(%rdi)
movl $0x100000, %eax # imm = 0x100000
retq
m... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisInputNextBytes | static ZyanStatus ZydisInputNextBytes(ZydisDecoderState* state,
ZydisDecodedInstruction* instruction, ZyanU8* value, ZyanU8 number_of_bytes)
{
ZYAN_ASSERT(state);
ZYAN_ASSERT(instruction);
ZYAN_ASSERT(value);
if (instruction->length + number_of_bytes > ZYDIS_MAX_INSTRUCTION_LENGTH)
{
re... | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xb89d
movq %rdi, %rbx
movzbl 0x8(%rsi), %edi
movzbl %cl, %r14d
addl %r14d, %edi
movl $0x80200002, %eax # imm = 0x80200002
cmpl $0xf, %edi
ja 0xb895
movl $0x80200000, %eax # imm = 0x80200000
cmpq %r14, 0x18(%rbx)
jb 0xb895
movb %dil, 0x8(%rsi)
movq 0x10(%... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisDecodeModRM | static void ZydisDecodeModRM(ZydisDecodedInstruction* instruction, ZyanU8 data)
{
ZYAN_ASSERT(instruction);
ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM));
ZYAN_ASSERT(instruction->raw.modrm.offset == instruction->length - 1);
instruction->attributes |= ZYDIS_ATTRIB_HAS_MODRM;
i... | pushq %rax
movq 0x20(%rdi), %rax
testb $0x1, %al
jne 0xb903
movzbl 0x123(%rdi), %ecx
movzbl 0x8(%rdi), %edx
decl %edx
cmpl %ecx, %edx
jne 0xb922
orq $0x1, %rax
movq %rax, 0x20(%rdi)
movl %esi, %eax
shrb $0x6, %al
movb %al, 0x120(%rdi)
movl %esi, %eax
shrb $0x3, %al
andb $0x7, %al
movb %al, 0x121(%rdi)
andb $0x7, %sil
m... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/Decoder.c |
ZydisGetElementInfo | void ZydisGetElementInfo(ZydisInternalElementType element, ZydisElementType* type,
ZydisElementSize* size)
{
static const struct
{
ZydisElementType type;
ZydisElementSize size;
} lookup[ZYDIS_IELEMENT_TYPE_MAX_VALUE + 1] =
{
{ ZYDIS_ELEMENT_TYPE_INVALID , 0 },
{ ZY... | cmpl $0x18, %edi
jae 0xc543
movl %edi, %eax
leaq 0x5187b(%rip), %rcx # 0x5ddb0
movl (%rcx,%rax,8), %edi
movl %edi, (%rsi)
movzwl 0x4(%rcx,%rax,8), %eax
movw %ax, (%rdx)
retq
pushq %rax
leaq 0x5256b(%rip), %rdi # 0x5eab6
leaq 0x52486(%rip), %rsi # 0x5e9d8
leaq 0x5258e(%rip), %rcx # 0x5eae7
movl $0xa3, %e... | /zyantific[P]zyan-hook-engine/dependencies/zydis/src/SharedData.c |
ZyanMemoryGetSystemPageSize | ZyanU32 ZyanMemoryGetSystemPageSize()
{
#if defined(ZYAN_WINDOWS)
SYSTEM_INFO system_info;
GetSystemInfo(&system_info);
return system_info.dwPageSize;
#elif defined(ZYAN_POSIX)
return sysconf(_SC_PAGE_SIZE);
#endif
} | pushq $0x1e
popq %rdi
jmp 0x4130
| /zyantific[P]zyan-hook-engine/dependencies/zycore/src/API/Memory.c |
ZyanVectorInitEx | ZyanStatus ZyanVectorInitEx(ZyanVector* vector, ZyanUSize element_size, ZyanUSize capacity,
ZyanMemberProcedure destructor, ZyanAllocator* allocator, ZyanU8 growth_factor,
ZyanU8 shrink_threshold)
{
if (!vector || !element_size || !allocator || (growth_factor < 1))
{
return ZYAN_STATUS_INVALID_A... | pushq %rax
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rsi
testq %rdi, %rdi
sete %dil
testq %rdx, %rdx
sete %r10b
orb %dil, %r10b
testq %r8, %r8
sete %dil
testl %r9d, %r9d
sete %r11b
orb %dil, %r11b
orb %r10b, %r11b
je 0xc744
movl $0x80100004, %eax # imm = 0x80100004
popq %rcx
retq
movq (%r8), %r11
testq %r11, %r... | /zyantific[P]zyan-hook-engine/dependencies/zycore/src/Vector.c |
ZyanVectorInitCustomBuffer | ZyanStatus ZyanVectorInitCustomBuffer(ZyanVector* vector, ZyanUSize element_size,
void* buffer, ZyanUSize capacity, ZyanMemberProcedure destructor)
{
if (!vector || !element_size || !buffer || !capacity)
{
return ZYAN_STATUS_INVALID_ARGUMENT;
}
vector->allocator = ZYAN_NULL;
vect... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r9b
orb %al, %r9b
testq %rdx, %rdx
sete %r10b
testq %rcx, %rcx
sete %r11b
movl $0x80100004, %eax # imm = 0x80100004
orb %r10b, %r11b
orb %r9b, %r11b
jne 0xc7f6
andq $0x0, (%rdi)
movw $0x1, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
... | /zyantific[P]zyan-hook-engine/dependencies/zycore/src/Vector.c |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, int, 0>(fmt::v9::appender, int) | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(ab... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x73b76(%rip), %rcx # 0x97b60
movq (%rcx,%rax,8), %rdi
addq %r14, %rdi
movq %rdi, %r15
shrq $0x20, %r15
movl %esi, %eax
shrl $0x1f, %eax
sa... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fast_float::from_chars_result_t<char> fast_float::from_chars<int, char, int>(char const*, char const*, int&, int) | FASTFLOAT_CONSTEXPR20
from_chars_result_t<UC> from_chars(UC const* first, UC const* last, T& value, int base) noexcept {
static_assert (is_supported_char_type<UC>(), "only char, wchar_t, char16_t and char32_t are supported");
from_chars_result_t<UC> answer;
#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default... | movq %rdi, %rax
cmpq %rsi, %rdi
sete %r8b
leal -0x25(%rcx), %edi
cmpl $-0x23, %edi
setb %dil
orb %r8b, %dil
movl $0x16, %edi
jne 0x336b8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movb (%rax), %dl
xorl %edi, %edi
movb %dl, -0x11(%rsp)
cmpb $0x2d, %dl
sete %dil
addq %rax, %r... | /njoy[P]ENDFtk/build_O3/_deps/fast_float-src/include/fast_float/parse_number.h |
int njoy::tools::disco::Integer<2u>::read<int, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, st... | static Representation read( Iterator& iter, const Iterator& ) {
unsigned int position = 0;
const auto end = iter + Width;
Representation value = 0;
skipSpaces( iter, position );
if ( isNewLine( iter ) || isEndOfFile( iter ) || Width == position ) {
return value;
}
skipPlusSign( ite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x2(%rax), %r14
movl $0x0, 0xc(%rsp)
xorl %r15d, %r15d
cmpb $0x20, (%rax)
movl $0x0, %r12d
movl $0x0, %ebp
jne 0x33712
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb 0x1(%rax), %al
movl $0x1, %ebp
cmpb $0x20, %al... | /njoy[P]ENDFtk/build_O3/_deps/tools-src/src/tools/disco/Integer.hpp |
spdlog::initialize_logger(std::shared_ptr<spdlog::logger>) | SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger)
{
details::registry::instance().initialize_logger(std::move(logger));
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x34f78
movups (%rbx), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rax, (%rbx)
leaq 0xa3cc6(%rip), %rdi # 0xd8c08
callq 0x34fe8
movq 0x8(%rsp), %rdi
addq $0x10, %rsp
testq %rdi, %rdi
je 0x34f5b
popq %rbx
jmp 0x2370e
popq %rb... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/spdlog-inl.h |
spdlog::details::registry::initialize_logger(std::shared_ptr<spdlog::logger>) | SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone());
if (err_handler_)
{
new_logger->set_error_handler(err_handler_);
}
// set new level according to pre... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x35126
movq (%r14), %r15
movq 0xe8(%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x367d8
movq 0x8(%rsp), %rdi
testq %rdi, %rd... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::flush_on(spdlog::level::level_enum) | SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush_on(log_level);
}
flush_level_ = log_level;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x3570b
movq 0x88(%rbx), %rax
testq %rax, %rax
je 0x356f7
movq 0x28(%rax), %rcx
movl %ebp, %edx
xchgl %edx, 0x44(%rcx)
movq (%rax), %rax
jmp 0x356e4
movl %ebp, 0xf4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::apply_all(std::function<void (std::shared_ptr<spdlog::logger>)> const&) | SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
fun(l.second);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x359e4
movq 0x88(%rbx), %r12
testq %r12, %r12
je 0x359c9
movq %rsp, %r15
movq 0xa25e0(%rip), %r13 # 0xd7f58
movq 0x28(%r12), %rax
movq %rax, (%rsp)
movq 0x30(%r12), %rax
movq %... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::drop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SPDLOG_INLINE void registry::drop(const std::string &logger_name)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.erase(logger_name);
if (default_logger_ && default_logger_->name() == logger_name)
{
default_logger_.reset();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x35a9c
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x3c4f0
movq 0x130(%rbx), %rax
testq %rax, %rax
je 0x35a8d
movq 0x10(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x35a8d
testq %rdx, %rdx
je 0x35a72
movq (%r14), %rsi
movq 0x8... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::default_logger() | SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x17940
testl %eax, %eax
jne 0x35c4e
movq 0x130(%r14), %rax
movq %rax, (%rbx)
movq 0x138(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x35c3b
movq 0xa232b(%rip), %rcx # 0xd7f58
cmpb $0x0, (%rcx)
je 0x35c37
incl 0x8(%rax)
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::flush_all() | SPDLOG_INLINE void registry::flush_all()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
{
l.second->flush();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x369be
leaq 0x88(%rbx), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x369af
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x3699b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x174c0
movl %eax, %edi
callq 0x17... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::sinks::base_sink<std::mutex>::log(spdlog::details::log_msg const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
{
std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17940
testl %eax, %eax
jne 0x3aabc
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
mo... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<std::mutex>::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
{
std::lock_guard<Mutex> lock(mutex_);
set_pattern_(pattern);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17940
testl %eax, %eax
jne 0x3ab54
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
mo... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<std::mutex>::set_pattern_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3aca5
movq (%r14), %rax
movq $0x0, (%r14)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ac48
movq (%rdi), %rax
callq *0x8(%rax)
m... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<spdlog::details::null_mutex>::set_formatter_(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
{
formatter_ = std::move(sink_formatter);
} | movq %rdi, %rax
movq (%rsi), %rcx
movq $0x0, (%rsi)
movq 0x10(%rdi), %rdi
movq %rcx, 0x10(%rax)
testq %rdi, %rdi
je 0x3affa
movq (%rdi), %rax
jmpq *0x8(%rax)
retq
nop
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::pattern_formatter::~pattern_formatter() | class SPDLOG_API pattern_formatter final : public formatter
{
public:
using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local,
std::string eol = spdlog::details::os::def... | pushq %rbx
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x3b1b8
leaq 0x90(%rbx), %rdi
callq 0x38958
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x3b13a
movq (%rax), %rsi
incq %rsi
callq 0x17610
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x3b152
movq (%rax), %rsi
incq %rsi
callq 0x17610
m... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter.h |
spdlog::details::full_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
{
using std::chrono::duration_cast;
using std::chrono::milliseconds;
using std::chrono::seconds;
// cache the date/time part for the next second.
auto duration = msg.time.time_since... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r12
movabsq $0x112e0be826d694b3, %r15 # imm = 0x112E0BE826D694B3
movq %r15, %rax
imulq 0x18(%rsi)
movq %rdx, %r13
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %r13
addq %ra... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::scoped_padder::scoped_padder(unsigned long, spdlog::details::padding_info const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest)
: padinfo_(padinfo)
, dest_(dest)
{
remaining_pad_ = static_cast<long>(padinfo.width_) - static_cast<long>(wrapped_size);
if (remaining_pad_ <= 0)
{
return;
}
if (... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x5dd4f(%rip), %rsi # 0x9b76f
movq %rsi, 0x18(%rdi)
movq $0x40, 0x20(%rdi)
movq (%rdx), %r14
subq %rax, %r14
movq %r14, 0x10(%rdi)
jle 0x3da77
movq %rdi, %rbx
movl 0x8(%rdx), %eax
cmpl $0x2, %eax
je 0x3da5a
testl %eax, %eax... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::a_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movslq 0x18(%rdx), %rax
leaq 0x948a8(%rip), %rcx # 0xd2608
movq (%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x17250
movq %rax, %r12
addq $0x8, %r14
movq %rsp, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3da0a... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.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.