name string | code string | asm string | file string |
|---|---|---|---|
cmsys::SystemTools::FindProgram(char const*, 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>>>> const&, bool) | std::string SystemTools::FindProgram(const char* nameIn,
const std::vector<std::string>& userPaths,
bool no_system_path)
{
if (!nameIn || !*nameIn) {
return "";
}
return SystemTools::FindProgram(std::string(nameIn), userPaths,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3f82b9
movq %rsi, %r15
cmpb $0x0, (%rsi)
je 0x3f82b9
movl %ecx, %ebp
movq %rdx, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0x39d50
leaq (%rax,%r15), %rdx
leaq 0x8(%rsp), ... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetRealPath(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::string SystemTools::GetRealPath(const std::string& path,
std::string* errorMessage)
{
std::string ret;
Realpath(path, ret, errorMessage);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x3fc322
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3f88c9
movq (%r15), %rsi
incq %rsi
... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FindProgramPath(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>>&, char const*, char const*, char const*) | bool SystemTools::FindProgramPath(const char* argv0, std::string& pathOut,
std::string& errorMsg, const char* exeName,
const char* buildDir,
const char* installPrefix)
{
std::vector<std::string> failures;
std::stri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %r9, 0x38(%rsp)
movq %r8, %rbp
movq %rcx, %r12
movq %rdx, 0x48(%rsp)
movq %rsi, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
leaq 0x214215(%rip), %... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FileIsFullPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SystemToolsStatic::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;
}
#e... | cmpq $0x0, 0x8(%rdi)
je 0x3f9345
movq (%rdi), %rax
movb (%rax), %al
cmpb $0x7e, %al
sete %cl
cmpb $0x2f, %al
sete %al
orb %cl, %al
retq
xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::(anonymous namespace)::CollapseFullPathImpl(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*) | std::string CollapseFullPathImpl(std::string const& in_path,
std::string const* in_base)
{
// Collect the output path components.
std::vector<std::string> out_components;
// Split the input path components.
std::vector<std::string> path_components;
SystemTools::SplitPath(in_p... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %ecx, %ecx
movq %rcx, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rcx, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rax, %rdi
movl $0x1, %edx
callq 0x3f9c82
movq 0x48(%rsp), %rsi
subq 0x40(%rsp), %rsi... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::JoinPath(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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::alloca... | std::string SystemTools::JoinPath(
std::vector<std::string>::const_iterator first,
std::vector<std::string>::const_iterator last)
{
// Construct result in a single string.
std::string result;
size_t len = 0;
for (auto i = first; i != last; ++i) {
len += 1 + i->size();
}
result.reserve(len);
// Th... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x3f9efa
xorl %esi, %esi
movq %r15, %rax
movq 0x8(%rax), %rcx
addq %rcx, %rsi
incq %rsi
addq $0x20, %rax
cmpq %r14,... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::Split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&, char) | bool SystemTools::Split(const std::string& str,
std::vector<std::string>& lines, char separator)
{
std::string data(str);
std::string::size_type lpos = 0;
while (lpos < data.length()) {
std::string::size_type rpos = data.find_first_of(separator, lpos);
if (rpos == std::string::npos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movq %rsi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x5b7c4
movb $0x1, %bpl
cmpq $0x0, 0x8(%r15)
je 0x3fa097
xor... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::Split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&) | bool SystemTools::Split(const std::string& str,
std::vector<std::string>& lines)
{
std::string data(str);
std::string::size_type lpos = 0;
while (lpos < data.length()) {
std::string::size_type rpos = data.find_first_of('\n', lpos);
if (rpos == std::string::npos) {
// Line end... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5b7c4
movb $0x1, %bpl
cmpq $0x0, 0x8(%r14)
je 0x3fa241
leaq 0x18(%rsp), %rb... | /JKorbelRA[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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x3fa6c2
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
callq 0x39d50
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r12
movq %r1... | /JKorbelRA[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 0x3fa856
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3fa856
movq %rsi, %r13
movq %rdi, %r15
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemToolsStatic::FileIsFullPath(char const*, unsigned long) | bool SystemToolsStatic::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;
}
#e... | testq %rsi, %rsi
je 0x3faf3c
movb (%rdi), %al
cmpb $0x7e, %al
sete %cl
cmpb $0x2f, %al
sete %al
orb %cl, %al
retq
xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetCurrentDateTime[abi:cxx11](char const*) | std::string SystemTools::GetCurrentDateTime(const char* format)
{
char buf[1024];
time_t t;
time(&t);
strftime(buf, sizeof(buf), format, localtime(&t));
return std::string(buf);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x410, %rsp # imm = 0x410
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3aaa0
movq %r15, %rdi
callq 0x3a730
leaq 0x10(%rsp), %r15
movl $0x400, %esi # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x3b130
leaq... | /JKorbelRA[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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5b7c4
leaq 0x1f57a3(%rip), %rsi # 0x5f07ab
movl $0xa, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x39560
testq %rax, %rax
jne 0x3fb0... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::GetPermissions(char const*, unsigned int&) | Status SystemTools::GetPermissions(const char* file, mode_t& mode)
{
if (!file) {
return Status::POSIX(EINVAL);
}
return SystemTools::GetPermissions(std::string(file), mode);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x3fb252
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x39d50
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b4c6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f76e0
mo... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::SetPermissions(char const*, unsigned int, bool) | Status SystemTools::SetPermissions(const char* file, mode_t mode,
bool honor_umask)
{
if (!file) {
return Status::POSIX(EINVAL);
}
return SystemTools::SetPermissions(std::string(file), mode, honor_umask);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x3fb2f0
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x39d50
leaq (%rax,%r14), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b4c6
movzbl %bpl, %edx
movq %r15... | /JKorbelRA[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)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::DecodeURL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::DecodeURL(const std::string& url)
{
kwsys::RegularExpression urlByteRe(VTK_URL_BYTE_REGEX);
std::string ret;
for (size_t i = 0; i < url.length(); i++) {
if (urlByteRe.find(url.substr(i, 3))) {
char bytes[] = { url[i + 1], url[i + 2], '\0' };
ret += static_cast<char>(strtou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x28(%rsp), %r15
movq %r12, 0xb0(%r15)
movq %r12, 0xc0(%r15)
movl $0x0, 0xc8(%r15)
movl $0xaa, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x39a90
leaq 0x1f5131(%rip), %rsi # 0x5f0... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemToolsAppendComponents(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>>>>&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | static void SystemToolsAppendComponents(
std::vector<std::string>& out_components,
std::vector<std::string>::iterator first,
std::vector<std::string>::iterator last)
{
static const std::string up = "..";
static const std::string cur = ".";
for (std::vector<std::string>::const_iterator i = first; i != last; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x3960eb(%rip), %al # 0x792230
testb %al, %al
movq %rdx, (%rsp)
je 0x3fc29f
movb 0x396101(%rip), %al # 0x792258
testb %al, %al
jne 0x3fc287
leaq 0x3960f2(%rip), %r12 # 0x792258
mo... | /JKorbelRA[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 = 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 %r13
pushq %r12
pushq %rbx
subq $0x1000, %rsp # imm = 0x1000
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3b610
movq %rax, %r12
movl $0x0, (%rax)
movq (%r15), %rdi
movq %rsp, %rsi
callq 0x3a470
testq %rax, %rax
je 0x3fc378
movq %rax, %r13
movq 0x8(%rbx), %r14
movq %rax, ... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemInformationImplementation::GetProcessorCacheXSize(long) const | int SystemInformationImplementation::GetProcessorCacheXSize(
long int dwCacheID) const
{
switch (dwCacheID) {
case SystemInformation::CPU_FEATURE_L1CACHE:
return this->Features.L1CacheSize;
case SystemInformation::CPU_FEATURE_L2CACHE:
return this->Features.L2CacheSize;
case SystemInformation... | cmpq $0x20000, %rsi # imm = 0x20000
je 0x3fcd84
cmpq $0x10000, %rsi # imm = 0x10000
je 0x3fcd80
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $0x8000, %rsi # imm = 0x8000
jne 0x3fcd87
movl 0x18(%rdi), %eax
retq
movl 0x1c(%rdi), %eax
retq
movl 0x20(%rdi), %eax
retq
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::DoesCPUSupportFeature(long) const | bool SystemInformationImplementation::DoesCPUSupportFeature(
long int dwFeature) const
{
bool bHasFeature = false;
// Check for MMX instructions.
if (((dwFeature & SystemInformation::CPU_FEATURE_MMX) != 0) &&
this->Features.HasMMX)
bHasFeature = true;
// Check for MMX+ instructions.
if (((dwFeat... | xorl %eax, %eax
testb $0x1, %sil
movzbl 0x6(%rdi), %ecx
cmovel %eax, %ecx
testb $0x1, 0x27(%rdi)
movl $0x1, %eax
movl %ecx, %edx
cmovnel %eax, %edx
testb $0x2, %sil
cmovel %ecx, %edx
testb $0x1, 0x7(%rdi)
movl %edx, %ecx
cmovnel %eax, %ecx
testb $0x4, %sil
cmovel %edx, %ecx
testb $0x1, 0x8(%rdi)
movl %ecx, %edx
cmovnel... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformation::GetMemoryDescription[abi:cxx11](char const*, char const*) | std::string SystemInformation::GetMemoryDescription(
const char* hostLimitEnvVarName, const char* procLimitEnvVarName)
{
std::ostringstream oss;
oss << "Host Total: " << this->GetHostMemoryTotal()
<< " KiB, Host Available: "
<< this->GetHostMemoryAvailable(hostLimitEnvVarName)
<< " KiB, Process ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x3b3d0
leaq 0x1f351e(%rip), %rsi # 0x5f0c0d
movl $0xc, %edx
movq %r12, %rdi
callq 0x3b4d0
leaq 0x1f3f6a(%rip), %rax # 0x5f166d
leaq 0x... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetHostMemoryTotal() | int GetFieldFromFile(const char* fileName, const char* fieldName, T& value)
{
const char* fieldNames[2] = { fieldName, nullptr };
T values[1] = { T(0) };
int ierr = GetFieldsFromFile(fileName, fieldNames, values);
if (ierr) {
return ierr;
}
value = values[0];
return 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x1f3e01(%rip), %rax # 0x5f166d
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorl %ebx, %ebx
movq %rbx, 0x8(%rsi)
leaq 0x8(%rsp), %r14
movq %rbx, (%r14)
leaq 0x1f3eb7(%rip), %rdi # 0x5f1740
movq %r14, %rdx
callq 0x400f07
negl %eax
sbbq %rbx, %rbx
orq (%r14), %rbx
movq %rbx, ... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetHostMemoryUsed() | long long SystemInformationImplementation::GetHostMemoryUsed()
{
#if defined(_WIN32)
# if defined(_MSC_VER) && _MSC_VER < 1300
MEMORYSTATUS stat;
stat.dwLength = sizeof(stat);
GlobalMemoryStatus(&stat);
return (stat.dwTotalPhys - stat.dwAvailPhys) / 1024;
# else
MEMORYSTATUSEX statex;
statex.dwLength = si... | subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
leaq 0x1f3e0e(%rip), %rdi # 0x5f1740
leaq 0x382bd7(%rip), %rsi # 0x780510
callq 0x400f07
testl %eax, %eax
je 0x3fd96c
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x1f3de8(%rip), %rdi # 0x5f1... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetProcessId() | long long SystemInformationImplementation::GetProcessId()
{
#if defined(_WIN32)
return GetCurrentProcessId();
#elif defined(__linux) || defined(__APPLE__) || defined(__OpenBSD__) || \
defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \
defined(__CYGWIN__)
return getpid();
#else
... | pushq %rax
callq 0x3bb60
cltq
popq %rcx
retq
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::SetStackTraceOnError(int) | void SystemInformationImplementation::SetStackTraceOnError(int enable)
{
#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
static int saOrigValid = 0;
static struct sigaction saABRTOrig;
static struct sigaction saSEGVOrig;
static struct sigaction saTERMOrig;
static struct sigaction saINTOr... | pushq %rbx
subq $0xa0, %rsp
testl %edi, %edi
sete %cl
movb 0x3946e1(%rip), %al # 0x792264
orb %al, %cl
testb $0x1, %cl
je 0x3fdc2f
testl %edi, %edi
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3fdd48
leaq 0x3946c3(%rip), %rsi # 0x792268
movl $0x6, %edi
xorl %edx, %edx
callq 0x3ad20
leaq 0x394748(%rip), %rsi # ... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetProgramStack[abi:cxx11](int, int) | std::string SystemInformationImplementation::GetProgramStack(int firstFrame,
int wholePath)
{
std::ostringstream oss;
std::string programStack;
#ifdef KWSYS_SYSTEMINFORMATION_HAS_DBGHELP
(void)wholePath;
void* stack[TRACE_MAX_STACK_FRAMES];
HANDLE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe88, %rsp # imm = 0xE88
movl %edx, 0x34(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x108(%rsp), %rdi
callq 0x3b3d0
leaq 0x10(%r14), %r15
movq %r15, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x1f3916(%rip), %rsi # 0x5f16... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::RunCPUCheck() | void SystemInformationImplementation::RunCPUCheck()
{
#ifdef _WIN32
// Check to see if this processor supports CPUID.
bool supportsCPUID = DoesCPUSupportCPUID();
if (supportsCPUID) {
// Retrieve the CPU details.
RetrieveCPUIdentity();
this->FindManufacturer();
RetrieveCPUFeatures();
}
// The... | jmp 0x3fe862
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryOSInformation() | bool SystemInformationImplementation::QueryOSInformation()
{
#if defined(_WIN32)
this->OSName = "Windows";
OSVERSIONINFOEXW osvi;
BOOL bIsWindows64Bit;
BOOL bOsVersionInfoEx;
char operatingSystem[256];
// Try calling GetVersionEx using the OSVERSIONINFOEX structure.
ZeroMemory(&osvi, sizeof(OSVERSIONIN... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
leaq 0x2(%rsp), %rdi
callq 0x39140
testl %eax, %eax
jne 0x3ffda9
leaq 0x128(%rbx), %r14
movq 0x130(%rbx), %r15
leaq 0x2(%rsp), %r12
movq %r12, %rdi
callq 0x39d50
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryLinuxMemory() | bool SystemInformationImplementation::QueryLinuxMemory()
{
#if defined(__linux)
unsigned long tv = 0;
unsigned long tp = 0;
unsigned long av = 0;
unsigned long ap = 0;
char buffer[1024]; // for reading lines
int linuxMajor = 0;
int linuxMinor = 0;
// Find the Linux kernel version first
struct utsna... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5f8, %rsp # imm = 0x5F8
movq %rdi, %r14
xorl %r15d, %r15d
movq %r15, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %r15, 0x10(%rsp)
movq %r15, 0x8(%rsp)
leaq 0x6a(%rsp), %rdi
callq 0x39140
testl %eax, %eax
je 0x3ffe40
movq 0x3860ee(%rip), %rbx... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::RetrieveCPUFeatures() | bool SystemInformationImplementation::RetrieveCPUFeatures()
{
#if USE_CPUID
int cpuinfo[4] = { 0, 0, 0, 0 };
if (!call_cpuid(1, cpuinfo)) {
return false;
}
// Retrieve the features of CPU present.
this->Features.HasFPU =
((cpuinfo[3] & 0x00000001) != 0); // FPU Present --> Bit 0
this->Features.Has... | xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::FindManufacturer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SystemInformationImplementation::FindManufacturer(
const std::string& family)
{
if (this->ChipID.Vendor == "GenuineIntel")
this->ChipManufacturer = Intel; // Intel Corp.
else if (this->ChipID.Vendor == "UMC UMC UMC ")
this->ChipManufacturer = UMC; // United Microelectronics Corp.
else if (this->Chi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
leaq 0x1f0c3d(%rip), %rsi # 0x5f0d8d
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x40030e
leaq 0x1f0c33(%rip), %rsi # 0x5f0d9a
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x400315
leaq 0x1f0c29... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::RetrieveCPUCacheDetails() | bool SystemInformationImplementation::RetrieveCPUCacheDetails()
{
#if USE_CPUID
int L1Cache[4] = { 0, 0, 0, 0 };
int L2Cache[4] = { 0, 0, 0, 0 };
// Check to see if what we are about to do is supported...
if (RetrieveCPUExtendedLevelSupport(0x80000005)) {
if (!call_cpuid(0x80000005, L1Cache)) {
retur... | movl 0x1c(%rdi), %eax
andl 0x18(%rdi), %eax
cmpl $-0x1, %eax
setne %al
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::RetrieveProcessorSerialNumber() | bool SystemInformationImplementation::RetrieveProcessorSerialNumber()
{
// Check to see if the processor supports the processor serial number.
if (!this->Features.HasSerial) {
return false;
}
#if USE_CPUID
int SerialNumber[4];
if (!call_cpuid(3, SerialNumber)) {
return false;
}
// Process the r... | xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::RetrieveCPUPowerManagement() | bool SystemInformationImplementation::RetrieveCPUPowerManagement()
{
// Check to see if what we are about to do is supported...
if (!RetrieveCPUExtendedLevelSupport(static_cast<int>(0x80000007))) {
this->Features.ExtendedFeatures.PowerManagement.HasFrequencyID = false;
this->Features.ExtendedFeatures.PowerM... | pushq %rbx
movq %rdi, %rbx
movl $0x80000007, %esi # imm = 0x80000007
callq 0x40038c
testb %al, %al
jne 0x400432
movw $0x0, 0x34(%rbx)
movb $0x0, 0x36(%rbx)
xorl %eax, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::(anonymous namespace)::StacktraceSignalHandler(int, siginfo_t*, void*) | void StacktraceSignalHandler(int sigNo, siginfo_t* sigInfo,
void* /*sigContext*/)
{
# if defined(__linux) || defined(__APPLE__)
std::ostringstream oss;
oss << std::endl
<< "========================================================="
<< std::endl
<< "Process id " << get... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3b3d0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3b7c0
movsbl %al, %esi
leaq 0x28(%rsp), %rdi
callq 0x3a310
movq %rax, %rdi
cal... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryWindowsMemory() | bool SystemInformationImplementation::QueryWindowsMemory()
{
#if defined(_WIN32)
# if defined(_MSC_VER) && _MSC_VER < 1300
MEMORYSTATUS ms;
unsigned long tv, tp, av, ap;
ms.dwLength = sizeof(ms);
GlobalMemoryStatus(&ms);
# define MEM_VAL(value) dw##value
# else
MEMORYSTATUSEX ms;
DWORDLONG tv, tp, av, ... | xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetCyclesDifference(void (*)(unsigned int), unsigned int) | long long SystemInformationImplementation::GetCyclesDifference(
DELAY_FUNC DelayFunction, unsigned int uiParameter)
{
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
unsigned __int64 stamp1, stamp2;
# ifdef _M_ARM64
stamp1 = _ReadStatusReg(ARM64_PMCCNTR_EL0);
DelayFunction(uiParameter);
stamp2 = _ReadStatusReg(... | movq $-0x1, %rax
retq
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::GetAPICId() | unsigned char SystemInformationImplementation::GetAPICId()
{
int Regs[4] = { 0, 0, 0, 0 };
#if USE_CPUID
if (!this->IsSMTSupported()) {
return static_cast<unsigned char>(-1); // HT not supported
} // Logical processor = 1
call_cpuid(1, Regs);
#endif
return static_c... | xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryBSDMemory() | bool SystemInformationImplementation::QueryBSDMemory()
{
#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__DragonFly__)
int ctrl[2] = { CTL_HW, HW_PHYSMEM };
# if defined(HW_PHYSMEM64)
int64_t k;
ctrl[1] = HW_PHYSMEM64;
# else
int k;
# endif
size_t sz = sizeof(k);
... | xorl %eax, %eax
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::TrimNewline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void SystemInformationImplementation::TrimNewline(std::string& output)
{
// remove \r
std::string::size_type pos = 0;
while ((pos = output.find('\r', pos)) != std::string::npos) {
output.erase(pos);
}
// remove \n
pos = 0;
while ((pos = output.find('\n', pos)) != std::string::npos) {
output.erase... | pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x3b960
cmpq $-0x1, %rax
je 0x402290
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x4022c8
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movl $0xd, %esi
movq %rax, %rdx
jmp 0x402264
movq %rbx, %rdi
movl $0xa, %es... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
curl_easy_duphandle | struct Curl_easy *curl_easy_duphandle(struct Curl_easy *data)
{
struct Curl_easy *outcurl = calloc(1, sizeof(struct Curl_easy));
if(!outcurl)
goto fail;
/*
* We setup a few buffers we need. We should probably make them
* get setup on-demand in the code, as that would probably decrease
* the likeline... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x1458, %esi # imm = 0x1458
callq *0x385086(%rip) # 0x787f68
testq %rax, %rax
je 0x40307d
movq %rax, %rbx
movl 0x6cc(%r14), %eax
movl %eax, 0x6cc(%rbx)
movl $0x1b0, %esi # imm = 0x1B0
leaq (%rbx,%rs... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_easy_recv | CURLcode curl_easy_recv(struct Curl_easy *data, void *buffer, size_t buflen,
size_t *n)
{
curl_socket_t sfd;
CURLcode result;
ssize_t n1;
struct connectdata *c;
if(Curl_is_in_callback(data))
return CURLE_RECURSIVE_API_CALL;
result = easy_connection(data, &sfd, &c);
if(result)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x40daca
movl %eax, %ecx
movl $0x5d, %eax
testb %cl, %cl
jne 0x4034cf
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x4034db
testl %eax, %eax
jne 0x4034cf
cmpq $0x0, 0x18(... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
conn_upkeep | static int conn_upkeep(struct Curl_easy *data,
struct connectdata *conn,
void *param)
{
/* Param is unused. */
(void)param;
if(conn->handler->connection_check) {
/* briefly attach the connection to this transfer for the purpose of
checking it */
Curl_a... | movq 0x398(%rsi), %rax
cmpq $0x0, 0x70(%rax)
je 0x4036f2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40b2f7
movq 0x398(%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq *0x70(%rax)
movq %rbx, %rdi
callq 0x40b217
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
nopl (... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_pushheader_byname | char *curl_pushheader_byname(struct curl_pushheaders *h, const char *header)
{
/* Verify that we got a good easy handle in the push header struct,
mostly to detect rubbish input fast(er). Also empty header name
is just a rubbish too. We have to allow ":" at the beginning of
the header, but header == ":... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x404112
movq (%rdi), %r15
testq %r15, %r15
je 0x404112
movq %rsi, %rbx
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x404115
cmpl $0xc0dedbad, (%r15) # imm = 0xC0DEDBAD
jne 0x404115
movzbl (%rbx), %eax
testl %eax, %eax
je 0x4... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_done_sending | CURLcode Curl_http2_done_sending(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
if((conn->handler == &Curl_handler_http2_ssl) ||
(conn->handler == &Curl_handler_http2)) {
/* make sure this is only attempted for HTTP/2 transfers */
struc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x0, 0xc(%rsp)
movq 0x398(%rsi), %rax
leaq 0x37c108(%rip), %rcx # 0x780558
cmpq %rcx, %rax
setne %cl
leaq 0x37c18b(%rip), %rdx # 0x7805e8
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x4044ef
movq %rsi, %r15
movq %rdi, %rbx
movq 0x198(%rdi), %rax
movq 0x4a8(... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
h2_process_pending_input | static int h2_process_pending_input(struct Curl_easy *data,
struct http_conn *httpc,
CURLcode *err)
{
ssize_t nread;
char *inbuf;
ssize_t rv;
nread = httpc->inbuflen - httpc->nread_inbuf;
inbuf = httpc->inbuf + httpc->nread_inbuf;
set... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x60(%rsi), %rdi
movq 0x80(%rsi), %r13
movq 0x88(%rsi), %rsi
subq %rsi, %r13
addq 0x78(%r15), %rsi
movq %r14, 0x58(%r15)
movq %r13, %rdx
callq 0x448125
movq %rax, %r12
testq %rax, %rax
js 0x404550
cmpq %r12, %r13... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_setup | CURLcode Curl_http2_setup(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result;
struct http_conn *httpc = &conn->proto.httpc;
struct HTTP *stream = data->req.p.http;
DEBUGASSERT(data->state.buffer);
stream->stream_id = -1;
Curl_dyn_init(&stream->header_recvbuf, DY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x198(%rdi), %r12
movl $0xffffffff, 0x228(%r12) # imm = 0xFFFFFFFF
leaq 0x230(%r12), %r15
movl $0x20000, %esi # imm = 0x20000
movq %r15, %rdi
callq 0x426968
leaq 0x258(%r12), %rdi
movl $0x20000, %esi ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_stream_pause | CURLcode Curl_http2_stream_pause(struct Curl_easy *data, bool pause)
{
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
/* if it isn't HTTP/2, we're done */
if(!(data->conn->handler->protocol & PROTO_FAMILY_HTTP) ||
!data->conn->proto.httpc.h2)
return CURLE_OK;
#ifdef NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE
els... | pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r14
movq 0x398(%r14), %rcx
xorl %eax, %eax
testb $0x3, 0x84(%rcx)
je 0x4051f7
movq %rdi, %rbx
movq 0x4a8(%r14), %rdi
testq %rdi, %rdi
je 0x4051f7
movq 0x198(%rbx), %rax
xorb $0x1, %sil
movzbl %sil, %ecx
shll $0x19, %ecx
movl 0x228(%rax), %edx
xorl %esi, %esi
callq 0x44... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_add_child | CURLcode Curl_http2_add_child(struct Curl_easy *parent,
struct Curl_easy *child,
bool exclusive)
{
if(parent) {
struct Curl_http2_dep **tail;
struct Curl_http2_dep *dep = calloc(1, sizeof(struct Curl_http2_dep));
if(!dep)
return CURLE_OUT_O... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x4052b0
leaq 0x382d50(%rip), %rax # 0x787f68
movl $0x1, %edi
movl $0x10, %esi
callq *(%rax)
testq %rax, %rax
je 0x405281
movq %rbx, 0x8(%rax)
leaq 0xa48(%r14), %rcx
movq 0xa48(%r14), %rdx
testq %rdx, %rdx
sete %sil
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_http2_remove_child | void Curl_http2_remove_child(struct Curl_easy *parent, struct Curl_easy *child)
{
struct Curl_http2_dep *last = 0;
struct Curl_http2_dep *data = parent->set.stream_dependents;
DEBUGASSERT(child->set.stream_depends_on == parent);
while(data && data->data != child) {
last = data;
data = data->next;
}
... | pushq %rbx
movq %rsi, %rbx
addq $0xa48, %rdi # imm = 0xA48
xorl %eax, %eax
movq %rdi, %rdx
movq %rax, %rcx
movq (%rdx), %rax
testq %rax, %rax
je 0x40531e
movq %rax, %rdx
cmpq %rbx, 0x8(%rax)
jne 0x4052f1
testq %rcx, %rcx
movq (%rax), %rdx
cmovneq %rcx, %rdi
movq %rdx, (%rdi)
leaq 0x382c37(%rip), %rcx # 0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
h2_pri_spec | static void h2_pri_spec(struct Curl_easy *data,
nghttp2_priority_spec *pri_spec)
{
struct HTTP *depstream = (data->set.stream_depends_on?
data->set.stream_depends_on->req.p.http:NULL);
int32_t depstream_id = depstream? depstream->stream_id:0;
nghttp2_priority_sp... | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0xa38(%rdi), %rcx
xorl %esi, %esi
testq %rcx, %rcx
je 0x4056a7
movq 0x198(%rcx), %rcx
testq %rcx, %rcx
je 0x4056a7
movl 0x228(%rcx), %esi
movl 0xa40(%rbx), %edx
movq 0xa92(%rbx), %rcx
shrq $0x2d, %rcx
andl $0x1, %ecx
movq %rax, %rdi
callq 0x44377c
movl 0xa40(%rbx), %eax
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
on_data_chunk_recv | static int on_data_chunk_recv(nghttp2_session *session, uint8_t flags,
int32_t stream_id,
const uint8_t *mem, size_t len, void *userp)
{
struct HTTP *stream;
struct Curl_easy *data_s;
size_t nread;
struct connectdata *conn = (struct connectdata *)userp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r12
movq %rcx, %r14
movl %edx, %ebx
movl %edx, %esi
callq 0x44b01f
xorl %ebp, %ebp
testq %rax, %rax
je 0x405ea5
movq %rax, %r15
movq 0x198(%rax), %r13
testq %r13, %r13
je 0x405e82
movl %ebx, 0x4(%rsp)
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
on_begin_headers | static int on_begin_headers(nghttp2_session *session,
const nghttp2_frame *frame, void *userp)
{
struct HTTP *stream;
struct Curl_easy *data_s = NULL;
(void)userp;
data_s = nghttp2_session_get_stream_user_data(session, frame->hd.stream_id);
if(!data_s) {
return 0;
}
H2BUG... | pushq %rax
movl 0x8(%rsi), %esi
callq 0x44b01f
xorl %eax, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
http2_stream_free | static void http2_stream_free(struct HTTP *http)
{
if(http) {
Curl_dyn_free(&http->header_recvbuf);
for(; http->push_headers_used > 0; --http->push_headers_used) {
free(http->push_headers[http->push_headers_used - 1]);
}
free(http->push_headers);
http->push_headers = NULL;
}
} | testq %rdi, %rdi
je 0x4063fd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x230, %rdi # imm = 0x230
callq 0x42697b
movq 0x298(%rbx), %rax
testq %rax, %rax
je 0x4063db
leaq 0x381b97(%rip), %r14 # 0x787f50
movq 0x290(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdi
callq *(%r14)
movq 0x298(%rbx), %rax
dec... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
http2_handle_stream_close | static ssize_t http2_handle_stream_close(struct connectdata *conn,
struct Curl_easy *data,
struct HTTP *stream, CURLcode *err)
{
struct http_conn *httpc = &conn->proto.httpc;
if(httpc->pause_stream_id == stream->stream_id) {
http... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl 0x4d8(%rdi), %eax
cmpl 0x228(%rdx), %eax
jne 0x40644b
movl $0x0, 0x4d8(%r12)
movq 0x1170(%r14), %rax
subq %rax, 0x4e0(%r12)
movq $0x0, 0x1170(%r14)
jmp 0x406469
movq 0x1170(%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
Curl_output_digest | CURLcode Curl_output_digest(struct Curl_easy *data,
bool proxy,
const unsigned char *request,
const unsigned char *uripath)
{
CURLcode result;
unsigned char *path = NULL;
char *tmp = NULL;
char *response;
size_t len;
bool ha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, %rbx
movl %esi, %eax
shll $0x4, %eax
movl %esi, %r14d
shll $0x5, %r14d
leaq 0xdc0(%r14), %rcx
movq %rcx, 0x8(%rsp)
leaq 0xd50(%rdi), %rcx
leaq 0xd88(%rdi), %r12
movl %esi, 0x4(%rsp)
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_digest.c |
curl_mime_data | CURLcode curl_mime_data(curl_mimepart *part,
const char *data, size_t datasize)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_content(part);
if(data) {
if(datasize == CURL_ZERO_TERMINATED)
datasize = strlen(data);
part->data = malloc(datasize + 1);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x406d21
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x40693b
xorl %ebx, %ebx
testq %r12, %r12
je 0x406d2d
cmpq $-0x1, %r15
jne 0x406cbb
movq %r12, %rdi
callq 0x39d50
movq %rax, %r15
leaq 0x381286(%rip), %rax # 0x787f48
leaq 0x1(%r1... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
curl_mime_data_cb | CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
curl_read_callback readfunc,
curl_seek_callback seekfunc,
curl_free_callback freefunc, void *arg)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_co... | testq %rdi, %rdi
je 0x406ee8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r15
callq 0x40693b
xorl %eax, %eax
testq %rbp, %rbp
je 0x406ed9
movq %rbp, 0x28(%r15)
movq %r13, 0x30(%r15)
movq %r14, 0x38(... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
curl_mime_addpart | curl_mimepart *curl_mime_addpart(curl_mime *mime)
{
curl_mimepart *part;
if(!mime)
return NULL;
part = (curl_mimepart *) malloc(sizeof(*part));
if(part) {
Curl_mime_initpart(part, mime->easy);
part->parent = mime;
if(mime->lastpart)
mime->lastpart->nextpart = part;
else
mime-... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x406feb
movq %rdi, %r14
leaq 0x380fb3(%rip), %rax # 0x787f48
movl $0x1c0, %edi # imm = 0x1C0
callq *(%rax)
testq %rax, %rax
je 0x406feb
movq %rax, %rbx
movq (%r14), %r15
movq %rax, %rdi
addq $0x10, %rdi
movl $0x1a8, %edx # imm = 0x1A8
xorl %... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
mime_mem_read | static size_t mime_mem_read(char *buffer, size_t size, size_t nitems,
void *instream)
{
curl_mimepart *part = (curl_mimepart *) instream;
size_t sz = curlx_sotouz(part->datasize - part->state.offset);
(void) size; /* Always 1.*/
if(!nitems)
return STOP_FILLING;
if(sz > nite... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movq 0x78(%rcx), %rdi
subq 0x90(%rcx), %rdi
callq 0x41e720
testq %rbx, %rbx
je 0x4071a2
testq %rax, %rax
je 0x4071ab
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq 0x20(%r15), %r12
movq 0x90(%r15), %rdi
callq 0x41e720
addq %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
mime_file_read | static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
void *instream)
{
curl_mimepart *part = (curl_mimepart *) instream;
if(!nitems)
return STOP_FILLING;
if(mime_open_file(part))
return READ_ERROR;
return fread(buffer, size, nitems, part->fp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4072d0
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
jne 0x4072b7
movq 0x20(%r12), %rdi
leaq 0x191f2b(%rip), %rsi # 0x5991d0
callq 0x3b7f0
movq %rax, %rcx
movq %rax, 0x48(%r12)
testq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
mime_file_free | static void mime_file_free(void *ptr)
{
curl_mimepart *part = (curl_mimepart *) ptr;
if(part->fp) {
fclose(part->fp);
part->fp = NULL;
}
Curl_safefree(part->data);
part->data = NULL;
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x407306
callq 0x39e60
movq $0x0, 0x48(%rbx)
leaq 0x380c43(%rip), %rax # 0x787f50
movq 0x20(%rbx), %rdi
callq *(%rax)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
curl_mime_encoder | CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
const struct mime_encoder *mep;
if(!part)
return result;
part->encoder = NULL;
if(!encoding)
return CURLE_OK; /* Removing current encoder. */
for(mep = encoders; mep->name; m... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x407376
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x98(%rdi)
testq %rsi, %rsi
je 0x40737d
movl $0x2b, %ebp
leaq 0x379335(%rip), %r15 # 0x780680
leaq 0x20d06a(%rip), %rsi # 0x6143bc
movq %rbx, %rdi
callq 0x41546a
testl %eax, %eax
je 0x407... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
mime_subparts_seek | static int mime_subparts_seek(void *instream, curl_off_t offset, int whence)
{
curl_mime *mime = (curl_mime *) instream;
curl_mimepart *part;
int result = CURL_SEEKFUNC_OK;
if(whence != SEEK_SET || offset)
return CURL_SEEKFUNC_CANTSEEK; /* Only support full rewind. */
if(mime->state.state == MIMESTAT... | pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
setne %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x4074c1
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x0, 0x50(%rdi)
je 0x4074c1
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x4074b1
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x40792a
testl %eax, %eax
cmovnel %e... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
mime_part_rewind | static int mime_part_rewind(curl_mimepart *part)
{
int res = CURL_SEEKFUNC_OK;
enum mimestate targetstate = MIMESTATE_BEGIN;
if(part->flags & MIME_BODY_ONLY)
targetstate = MIMESTATE_BODY;
cleanup_encoder_state(&part->encstate);
if(part->state.state > targetstate) {
res = CURL_SEEKFUNC_CANTSEEK;
i... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rdi), %r14d
movl 0x80(%rdi), %eax
addl %r14d, %r14d
andl $0x4, %r14d
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rdi)
movq $0x0, 0xb0(%rdi)
cmpl %r14d, %eax
jbe 0x407988
movq 0x30(%rbx), %rax
movl $0x2, %ebp
testq %rax, %rax
je 0x407998
movq 0x40(%rbx), %rdi
xorl %... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
Curl_mime_contenttype | const char *Curl_mime_contenttype(const char *filename)
{
/*
* If no content type was specified, we scan through a few well-known
* extensions and pick the first we match!
*/
struct ContentType {
const char *extension;
const char *type;
};
static const struct ContentType ctts[] = {
{".gif",... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x407bd6
movq %rdi, %rbx
callq 0x39d50
movq %rax, %r15
addq %rax, %rbx
movl $0x8, %r13d
leaq 0x378b70(%rip), %rbp # 0x780710
xorl %r14d, %r14d
movq -0x8(%r13,%rbp), %r12
movq %r12, %rdi
callq 0x39d50
cmpq %rax, %r15
jb 0... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
escape_string | static char *escape_string(struct Curl_easy *data,
const char *src, enum mimestrategy strategy)
{
CURLcode result;
struct dynbuf db;
const char * const *table;
const char * const *p;
/* replace first character by rest of string. */
static const char * const mimetable[] = {
"\\... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testl %edx, %edx
je 0x4080ae
leaq 0x378730(%rip), %r15 # 0x7807d0
testq %rdi, %rdi
je 0x4080b5
testb $0x1, 0x9f4(%rdi)
je 0x4080b5
leaq 0x3786fb(%rip), %r15 # 0x7807b0
leaq 0x8(%rsp), %r14
movl $0x7a1200, %esi # imm = 0x7A1200
mo... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
Curl_mime_unpause | void Curl_mime_unpause(curl_mimepart *part)
{
if(part) {
if(part->lastreadstatus == CURL_READFUNC_PAUSE)
part->lastreadstatus = 1; /* Successful read status. */
if(part->kind == MIMEKIND_MULTIPART) {
curl_mime *mime = (curl_mime *) part->arg;
if(mime) {
curl_mimepart *subpart;
... | testq %rdi, %rdi
je 0x408182
cmpq $0x10000001, 0x1b8(%rdi) # imm = 0x10000001
jne 0x40815a
movq $0x1, 0x1b8(%rdi)
cmpl $0x4, 0x18(%rdi)
jne 0x408182
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x408182
pushq %rbx
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x408181
movq %rbx, %rdi
callq 0x40813d
movq 0x10(%rbx), %rbx
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
encoder_base64_size | static curl_off_t encoder_base64_size(curl_mimepart *part)
{
curl_off_t size = part->datasize;
if(size <= 0)
return size; /* Unknown size or no data. */
/* Compute base64 character count. */
size = 4 * (1 + (size - 1) / 3);
/* Effective character count must include CRLFs. */
return size + 2 * ((si... | movq 0x78(%rdi), %rcx
testq %rcx, %rcx
jle 0x4084a5
decq %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
movq %rdx, %rsi
andq $-0x2, %rsi
movabsq $-0x7047dc11f7047dc1, %rdx # imm = 0x8FB823EE08FB823F
movq %rcx, %rax
mulq %rdx
shrq $0x4, %rdx
andq $-0x2, %rdx
leaq (%rdx,%rsi,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
encoder_qp_read | static size_t encoder_qp_read(char *buffer, size_t size, bool ateof,
curl_mimepart *part)
{
struct mime_encoder_state *st = &part->encstate;
char *ptr = buffer;
size_t cursize = 0;
int softlinebreak;
char buf[4];
/* On all platforms, input is supposed to be ASCII compatible: f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xa8(%rcx), %rbp
cmpq 0xb0(%rcx), %rbp
jae 0x408650
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xa0(%rcx), %rax
movq %rax, 0x10(%rsp)
movzbl %dl, %eax
movl %eax, 0x4(%rsp)
movq $0x0, 0x8(%rsp)
movzbl 0xb8(%r14,%rbp), %eax
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
qp_lookahead_eol | static int qp_lookahead_eol(struct mime_encoder_state *st, int ateof, size_t n)
{
n += st->bufbeg;
if(n >= st->bufend && ateof)
return 1;
if(n + 2 > st->bufend)
return ateof? 0: -1;
if(qp_class[st->buf[n] & 0xFF] == QP_CR &&
qp_class[st->buf[n + 1] & 0xFF] == QP_LF)
return 1;
return 0;
} | addq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
cmpq %rcx, %rdx
setae %r8b
testl %esi, %esi
setne %r9b
movl $0x1, %eax
testb %r8b, %r9b
jne 0x4086e0
leaq 0x2(%rdx), %r8
cmpq %rcx, %r8
jbe 0x4086c1
xorl %eax, %eax
cmpl $0x1, %esi
sbbl %eax, %eax
retq
movzbl 0x18(%rdi,%rdx), %esi
leaq 0x1e9d73(%rip), %rcx # 0x5f2440
cmpb $... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
curl_mvsnprintf | int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
va_list ap_save)
{
int retcode;
struct nsprintf info;
info.buffer = buffer;
info.length = 0;
info.max = maxlength;
retcode = dprintf_formatf(&info, addbyter, format, ap_save);
if(info.max) {
/* we terminate t... | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
leaq 0x129f(%rip), %rsi # 0x409cb7
movq %rbx, %rdi
callq 0x408a46
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x408a40
movq 0x8(%rsp), %rcx
cmpq 0x10(%rsp), %rdx
jne 0x408a3d
movb $0x0, -0x1(%rcx)
decl %eax
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mprintf.c |
curl_mprintf | int curl_mprintf(const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = dprintf_formatf(stdout, fputc, format, ap_save);
va_end(ap_save);
return retcode;
} | subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x409fec
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mprintf.c |
Curl_expire | void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
{
struct Curl_multi *multi = data->multi;
struct curltime *nowp = &data->state.expiretime;
struct curltime set;
/* this is only interesting while there is still an associated multi struct
remaining! */
if(!multi)
return;
DEB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xb8(%rdi), %rbp
testq %rbp, %rbp
je 0x40a6f5
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4157c0
movq %rax, %rcx
movl %edx, %esi
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rdx
mo... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
singlesocket | static CURLMcode singlesocket(struct Curl_multi *multi,
struct Curl_easy *data)
{
curl_socket_t socks[MAX_SOCKSPEREASYHANDLE];
int i;
struct Curl_sh_entry *entry;
curl_socket_t s;
int num;
unsigned int curraction;
unsigned char actions[MAX_SOCKSPEREASYHANDLE];
int rc;
fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x18(%rsp)
leaq 0x8(%rsp), %rcx
movq %rsi, (%rcx)
pcmpeqd %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movdqa %xmm0, (%rsi)
movl $0xffffffff, 0x10(%rsi) # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x40b445
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
Curl_attach_connection | void Curl_attach_connection(struct Curl_easy *data,
struct connectdata *conn)
{
DEBUGASSERT(!data->conn);
DEBUGASSERT(conn);
data->conn = conn;
Curl_llist_insert_next(&conn->easyq, conn->easyq.tail, data,
&data->conn_queue);
if(conn->handler->attach)
c... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x18(%rdi)
leaq 0x3c0(%rsi), %rdi
movq 0x3c8(%rsi), %rsi
leaq 0x38(%r14), %rcx
movq %r14, %rdx
callq 0x43691b
movq 0x398(%rbx), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x40b337
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %r14, %rdi
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
multi_getsock | static int multi_getsock(struct Curl_easy *data,
curl_socket_t *socks)
{
struct connectdata *conn = data->conn;
/* The no connection case can happen when this is called from
curl_multi_remove_handle() => singlesocket() => multi_getsock().
*/
if(!conn)
return 0;
switch(data->... | movq %rsi, %rdx
movq 0x18(%rdi), %rsi
xorl %eax, %eax
testq %rsi, %rsi
je 0x40b54b
movl 0x50(%rdi), %ecx
addl $-0x3, %ecx
cmpl $0x9, %ecx
ja 0x40b54b
leaq 0x1e74e3(%rip), %r8 # 0x5f2950
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movq 0x398(%rsi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x40b4ff
jmpq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
curl_multi_perform | CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
{
struct Curl_easy *data;
CURLMcode returncode = CURLM_OK;
struct Curl_tree *t;
struct curltime now = Curl_now();
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4157c0
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
movl $0x1, %r15d
testq %rbx, %rbx
je 0x40bb77
cmpl $0xbab1e, (%rbx) # imm = 0xBAB1E
jne 0x40bb77
movl $0x8, %r15d
cmpb $0x0, 0x187(%rbx)
jne 0x4... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
sigpipe_ignore | static void sigpipe_ignore(struct Curl_easy *data,
struct sigpipe_ignore *ig)
{
/* get a local copy of no_signal because the Curl_easy might not be
around when we restore */
ig->no_signal = data->set.no_signal;
if(!data->set.no_signal) {
struct sigaction action;
/* first, e... | movl 0xa92(%rdi), %eax
shrl $0x1f, %eax
movb %al, 0x98(%rsi)
testb $-0x80, 0xa95(%rdi)
jne 0x40bc02
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movl $0x98, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x39a90
movl $0xd, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3ad20
movq %rsp, %r14
movl $0x98, %edx
movq %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/sigpipe.h |
multi_socket | static CURLMcode multi_socket(struct Curl_multi *multi,
bool checkall,
curl_socket_t s,
int ev_bitmask,
int *running_handles)
{
CURLMcode result = CURLM_OK;
struct Curl_easy *data = NULL;
struct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x4157c0
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
testl %r15d, %r15d
je 0x40d765
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40ba63
movl $0x1, %ebp
cmpl... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
curl_multi_socket_all | CURLMcode curl_multi_socket_all(struct Curl_multi *multi, int *running_handles)
{
CURLMcode result;
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
result = multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
if(CURLM_OK >= result)
result = Curl_update_timer(multi);
return result;
... | pushq %rbx
movl $0x8, %eax
cmpb $0x0, 0x187(%rdi)
jne 0x40d934
movq %rsi, %r8
movq %rdi, %rbx
movl $0x1, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x40d6de
testl %eax, %eax
jle 0x40d936
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x40a73e
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
Curl_multiuse_state | void Curl_multiuse_state(struct Curl_easy *data,
int bundlestate) /* use BUNDLE_* defines */
{
struct connectdata *conn;
DEBUGASSERT(data);
DEBUGASSERT(data->multi);
conn = data->conn;
DEBUGASSERT(conn);
DEBUGASSERT(conn->bundle);
conn->bundle->multiuse = bundlestate;
process_p... | movq 0x18(%rdi), %rax
movq 0x548(%rax), %rax
movl %esi, (%rax)
movq 0xb8(%rdi), %rdi
jmp 0x40b292
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
Curl_pgrsResetTransferSizes | void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
{
if(size >= 0) {
data->progress.size_dl = size;
data->progress.flags |= PGRS_DL_SIZE_KNOWN;
}
else {
data->progress.size_dl = 0;
data->progress.flags &= ~PGRS_DL_SIZE_KNOWN;
}
} | xorps %xmm0, %xmm0
movups %xmm0, 0xab0(%rdi)
andb $-0x61, 0xadc(%rdi)
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/progress.c |
Curl_rand | CURLcode Curl_rand(struct Curl_easy *data, unsigned char *rnd, size_t num)
{
CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
DEBUGASSERT(num > 0);
while(num) {
unsigned int r;
size_t left = num < sizeof(unsigned int) ? num : sizeof(unsigned int);
result = randit(data, &r);
if(result)
retur... | testq %rdx, %rdx
je 0x40e955
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r13
cmpq $0x4, %rbx
movl $0x4, %r12d
cmovbq %rbx, %r12
movl $0x4, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x420d04
testl %eax, %eax
je 0x40e91e
cm... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/rand.c |
Curl_wait_ms | int Curl_wait_ms(timediff_t timeout_ms)
{
int r = 0;
if(!timeout_ms)
return 0;
if(timeout_ms < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#if defined(MSDOS)
delay(timeout_ms);
#elif defined(WIN32)
/* prevent overflow, timeout_ms is typecast to ULONG/DWORD. */
#if TIMEDIFF_T_MAX >= ULONG_MAX
if(... | pushq %rbx
testq %rdi, %rdi
je 0x40ea15
js 0x40ea19
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
cmpq %rdx, %rdi
cmovbq %rdi, %rdx
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x399e0
negl %eax
sbbl %ebx, %ebx
jmp 0x40ea29
xorl %ebx, %ebx
jmp 0x40ea29
callq 0x3b610
movl $0x16, (%rax)
movl $0xffffffff, %ebx ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/select.c |
Curl_poll | int Curl_poll(struct pollfd ufds[], unsigned int nfds, timediff_t timeout_ms)
{
#ifdef HAVE_POLL_FINE
int pending_ms;
#else
fd_set fds_read;
fd_set fds_write;
fd_set fds_err;
curl_socket_t maxfd;
#endif
bool fds_none = TRUE;
unsigned int i;
int r;
if(ufds) {
for(i = 0; i < nfds; i++) {
if(u... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x40eb40
movq %rdi, %rbx
movl %esi, %r14d
xorl %eax, %eax
cmpl $-0x1, (%rbx,%rax,8)
jne 0x40eb4f
incq %rax
cmpq %rax, %r14
jne 0x40eb32
movq %rdx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40e9f0
testq %rdx, %rdx
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/select.c |
Curl_write | CURLcode Curl_write(struct Curl_easy *data,
curl_socket_t sockfd,
const void *mem,
size_t len,
ssize_t *written)
{
ssize_t bytes_written;
CURLcode result = CURLE_OK;
struct connectdata *conn;
int num;
DEBUGASSERT(data);
DEBUGASS... | pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
leaq 0xc(%rsp), %r8
movl $0x0, (%r8)
movq 0x18(%rdi), %r9
xorl %eax, %eax
cmpl %esi, 0x1e4(%r9)
sete %al
movl %eax, %esi
callq *0x208(%r9,%rax,8)
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
js 0x40eeae
addq $0x10, %rsp
popq %rbx
retq
movl 0xc(%rsp), %ecx... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/sendf.c |
Curl_recv_plain | ssize_t Curl_recv_plain(struct Curl_easy *data, int num, char *buf,
size_t len, CURLcode *code)
{
struct connectdata *conn;
curl_socket_t sockfd;
ssize_t nread;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
conn = data->conn;
sockfd = conn->sock[num];
/* Check and return data that ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rsi
movl 0x1e0(%rax,%rsi,4), %edi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x3b400
movq %rax, %r15
movl $0x0, (%rbx)
cmpq $-0x1, %rax
jne 0x40f027
callq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/sendf.c |
curl_slist_free_all | void curl_slist_free_all(struct curl_slist *list)
{
struct curl_slist *next;
struct curl_slist *item;
if(!list)
return;
item = list;
do {
next = item->next;
Curl_safefree(item->data);
free(item);
item = next;
} while(next);
} | testq %rdi, %rdi
je 0x413fc1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x373fb3(%rip), %r14 # 0x787f50
movq (%rbx), %rdi
movq 0x8(%rbx), %r15
callq *(%r14)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq *(%r14)
movq %r15, %rbx
testq %r15, %r15
jne 0x413f9d
popq %rbx
popq %r14
popq %r15
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/slist.c |
Curl_splaygetbest | struct Curl_tree *Curl_splaygetbest(struct curltime i,
struct Curl_tree *t,
struct Curl_tree **removed)
{
static const struct curltime tv_zero = {0, 0};
struct Curl_tree *x;
if(!t) {
*removed = NULL; /* none removed since there was no ro... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rdx, %rdx
je 0x41532f
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
callq 0x415198
leaq 0x20(%rax), %rcx
cmpq %r14, 0x20(%rax)
jg 0x415367
jl 0x415336
cmpl %ebp, 0x28(%rax)
jle 0x415336
xorl %r15d, %r15d
jm... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/splay.c |
Curl_splayremove | int Curl_splayremove(struct Curl_tree *t,
struct Curl_tree *removenode,
struct Curl_tree **newroot)
{
static const struct curltime KEY_NOTUSED = {
~0, -1
}; /* will *NEVER* appear */
struct Curl_tree *x;
if(!t || !removenode)
return 1;
if(compare(KEY_NOTUSED... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %sil
movl $0x1, %eax
orb %cl, %sil
jne 0x415444
movq %rdx, %rbx
movq %rdi, %rdx
movq 0x20(%r14), %rdi
cmpq $-0x1, %rdi
sete %al
movl 0x28(%r14), %esi
cmpl $-0x1, %esi
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4153d9
movq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/splay.c |
Curl_strncasecompare | int Curl_strncasecompare(const char *first, const char *second, size_t max)
{
while(*first && *second && max) {
if(Curl_raw_toupper(*first) != Curl_raw_toupper(*second)) {
break;
}
max--;
first++;
second++;
}
if(0 == max)
return 1; /* they are equal this far */
return Curl_raw_tou... | movb (%rdi), %al
testb %al, %al
je 0x41550f
incq %rdi
leaq 0x1dec72(%rip), %rcx # 0x5f4150
movzbl (%rsi), %r9d
testq %r9, %r9
je 0x41550a
testq %rdx, %rdx
je 0x41550a
movzbl %al, %eax
movb (%rax,%rcx), %r8b
cmpb (%r9,%rcx), %r8b
jne 0x415521
decq %rdx
incq %rsi
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x4154de
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/strcase.c |
curl_share_strerror | const char *
curl_share_strerror(CURLSHcode error)
{
#ifndef CURL_DISABLE_VERBOSE_STRINGS
switch(error) {
case CURLSHE_OK:
return "No error";
case CURLSHE_BAD_OPTION:
return "Unknown share option";
case CURLSHE_IN_USE:
return "Share currently in use";
case CURLSHE_INVALID:
return "Invalid s... | cmpl $0x5, %edi
ja 0x4156d8
movl %edi, %eax
leaq 0x1dfe78(%rip), %rcx # 0x5f5548
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x1df945(%rip), %rax # 0x5f5024
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/strerror.c |
curl_url_strerror | const char *
curl_url_strerror(CURLUcode error)
{
#ifndef CURL_DISABLE_VERBOSE_STRINGS
switch(error) {
case CURLUE_OK:
return "No error";
case CURLUE_BAD_HANDLE:
return "An invalid CURLU pointer was passed as argument";
case CURLUE_BAD_PARTPOINTER:
return "An invalid 'part' argument was passed as ... | cmpl $0x1d, %edi
ja 0x4156f6
movl %edi, %eax
leaq 0x1dfe72(%rip), %rcx # 0x5f5560
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x1dfc60(%rip), %rax # 0x5f535d
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/strerror.c |
Curl_posttransfer | CURLcode Curl_posttransfer(struct Curl_easy *data)
{
#if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(HAVE_MSG_NOSIGNAL)
/* restore the signal handler for SIGPIPE before we get back */
if(!data->set.no_signal)
signal(SIGPIPE, data->state.prev_signal);
#else
(void)data; /* unused parameter */
#endif
... | xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/transfer.c |
conn_free | static void conn_free(struct connectdata *conn)
{
DEBUGASSERT(conn);
Curl_free_idnconverted_hostname(&conn->host);
Curl_free_idnconverted_hostname(&conn->conn_to_host);
#ifndef CURL_DISABLE_PROXY
Curl_free_idnconverted_hostname(&conn->http_proxy.host);
Curl_free_idnconverted_hostname(&conn->socks_proxy.host)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x36fc22(%rip), %r15 # 0x787f50
movq 0x148(%rdi), %rdi
callq *(%r15)
xorl %r14d, %r14d
movq %r14, 0x148(%rbx)
movq 0x108(%rbx), %rdi
callq *(%r15)
movq %r14, 0x108(%rbx)
movq 0x150(%rbx), %rdi
callq *(%r15)
movq %r14, 0x150(%rbx)
movq 0x110(%rbx), %rdi
callq *(%r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/url.c |
Curl_builtin_scheme | const struct Curl_handler *Curl_builtin_scheme(const char *scheme,
size_t schemelen)
{
const struct Curl_handler * const *pp;
const struct Curl_handler *p;
/* Scan protocol handler table and match against 'scheme'. The handler may
be changed later when the proto... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $-0x1, %rsi
jne 0x418561
movq %rbx, %rdi
callq 0x39d50
movq %rax, %r14
leaq 0x368848(%rip), %r15 # 0x780db0
leaq 0x368319(%rip), %r12 # 0x780888
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4154ce
testl %eax, ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/url.c |
Curl_parse_login_details | CURLcode Curl_parse_login_details(const char *login, const size_t len,
char **userp, char **passwdp,
char **optionsp)
{
CURLcode result = CURLE_OK;
char *ubuf = NULL;
char *pbuf = NULL;
char *obuf = NULL;
const char *psep = NULL;
const char... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r12
callq 0x39d50
movl $0x2b, %ebx
cmpq $0x7a1200, %rax # imm = 0x7A1200
ja 0x418817
testq %r13, %r13
je 0x41861a
movq %r12, %rdi
movl $0x3a, %esi
c... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/url.c |
concat_url | static char *concat_url(char *base, const char *relurl)
{
/***
TRY to append this new path to the old URL
to the right of the host part. Oh crap, this is doomed to cause
problems in the future...
*/
struct dynbuf newest;
char *protsep;
char *pathsep;
bool host_changed = FALSE;
const char *useurl ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1d8c9c(%rip), %rsi # 0x5f681e
callq 0x3a010
leaq 0x2(%rax), %r14
testq %rax, %rax
cmoveq %r15, %r14
movb (%rbx), %bpl
cmpb $0x2f, %bpl
jne 0x41dbb4
cmpb $0x2f, 0x1(%rbx)
jne 0x41dc4b
movb $0x0, (... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/urlapi.c |
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.