name string | code string | asm string | file string |
|---|---|---|---|
cmake::FindPackage(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 cmake::FindPackage(const std::vector<std::string>& args)
{
this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetGlobalGenerator(cm::make_unique<cmGlobalGenerator>(this));
cmStateSnapshot snapshot = this->G... | pushq %rbp
movq %rsp, %rbp
subq $0x960, %rsp # imm = 0x960
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x728(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x720(%rbp)
callq 0x2d49b0
movq -0x728(%rbp), %rdi
movq -0x720(%rbp), %rsi
callq 0x31dd20
jmp 0x31c453
leaq -0x30(%rbp), %rd... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81cc19(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, std::string failedMsg, Values t,
RequiresSeparator s, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(std::move(failedMsg))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(s)
,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x81cacd(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, std::string failedMsg, Values t,
RequiresSeparator s, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(std::move(failedMsg))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(s)
,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x81c71d(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81c4b9(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81c379(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81c239(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81c0f9(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81bac9(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81b639(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81b4f9(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x81ac39(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmake::PrintGeneratorList() | void cmake::PrintGeneratorList()
{
#ifndef CMAKE_BOOTSTRAP
cmDocumentation doc;
auto generators = this->GetGeneratorsDocumentation();
doc.AppendSection("Generators", generators);
std::cerr << "\n";
doc.PrintDocumentation(cmDocumentation::ListGenerators, std::cerr);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x179d70
movq -0xe0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x330020
jmp 0x3252fb
leaq 0x83e5a9(%rip), %rsi # 0xb638ab
leaq -0xb0(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x17e... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::HandleDeleteCacheVariables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int cmake::HandleDeleteCacheVariables(const std::string& var)
{
std::vector<std::string> argsSplit = cmExpandedList(var, true);
// erase the property to avoid infinite recursion
this->State->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", "");
if (this->GetIsInTryCompile()) {
return 0;
}
std::vec... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x320(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e200
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl ... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::LoadCache() | int cmake::LoadCache()
{
// could we not read the cache
if (!this->LoadCache(this->GetHomeOutputDirectory())) {
// if it does exist, but isn't readable then warn the user
std::string cacheFile =
cmStrCat(this->GetHomeOutputDirectory(), "/CMakeCache.txt");
if (cmSystemTools::FileExists(cacheFile)) ... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x31dcc0
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x3270c0
testb $0x1, %al
jne 0x328fda
movq -0xd0(%rbp), %rdi
callq 0x31dcc0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::SetDeprecatedWarningsAsErrors(bool) | void cmake::SetDeprecatedWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=deprecated
if (b) {
value = "TRUE";
}
// equivalent to -Wno-error=deprecated
else {
value = "FALSE";
}
this->AddCacheEntry("CMAKE_ERROR_DEPRECATED", value,
"Whether to issue de... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
testb $0x1, -0x9(%rbp)
je 0x329e83
leaq 0x818ac7(%rip), %rsi # 0xb4292c
leaq -0x30(%rbp), %rdi
callq 0x3b9f0
jmp 0x329... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::SetDevWarningsAsErrors(bool) | void cmake::SetDevWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=dev
if (b) {
value = "FALSE";
}
// equivalent to -Wno-error=dev
else {
value = "TRUE";
}
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_ERRORS", value,
"Suppress errors that are meant ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
testb $0x1, -0x9(%rbp)
je 0x32a0a3
leaq 0x81fbac(%rip), %rsi # 0xb49c31
leaq -0x30(%rbp), %rdi
callq 0x3b9f0
jmp 0x32a... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::CreateDefaultGlobalGenerator() | void cmake::CreateDefaultGlobalGenerator()
{
auto gen = this->EvaluateDefaultGlobalGenerator();
#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW)
// This print could be unified for all platforms
std::cout << "-- Building for: " << gen->GetName() << "\n";
#endif
this->SetGlobalGenerator(s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x32c710
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x240200
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x31e030
jmp... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::SaveCache(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmake::SaveCache(const std::string& path)
{
bool result = this->State->SaveCache(path, this->GetMessenger());
static const auto entries = { "CMAKE_CACHE_MAJOR_VERSION",
"CMAKE_CACHE_MINOR_VERSION",
"CMAKE_CACHE_PATCH_VERSION",
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x770, %rdi # imm = 0x770
callq 0x344670
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x240350
movq -0x80(%rbp), %rd... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::EvaluateDefaultGlobalGenerator() | std::unique_ptr<cmGlobalGenerator> cmake::EvaluateDefaultGlobalGenerator()
{
if (!this->EnvironmentGenerator.empty()) {
auto gen = this->CreateGlobalGenerator(this->EnvironmentGenerator);
if (!gen) {
cmSystemTools::Error("CMAKE_GENERATOR was set but the specified "
"generator ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x4a0, %rdi # imm = 0x4A0
callq 0x3b870
testb $0x1, %al
jne 0x32c820
movq -0x78(%rbp), %rdi
movq -0x68(%rb... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::PreLoadCMakeFiles() | void cmake::PreLoadCMakeFiles()
{
std::vector<std::string> args;
std::string pre_load = this->GetHomeDirectory();
if (!pre_load.empty()) {
pre_load += "/PreLoad.cmake";
if (cmSystemTools::FileExists(pre_load)) {
this->ReadListFile(args, pre_load);
}
}
pre_load = this->GetHomeOutputDirectory(... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x60530
movq -0x60(%rbp), %rdi
callq 0x31dcf0
movq %rax, -0x58(%rbp)
jmp 0x32c89f
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3b400
jmp 0x32c8ae
leaq -0x40(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::Run(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) | int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
{
// Process the arguments
this->SetArgs(args);
if (cmSystemTools::GetErrorOccurredFlag()) {
return -1;
}
if (this->GetWorkingMode() == HELP_MODE) {
return 0;
}
// Log the trace format version to the desired output
if (this-... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x180(%rbp)
movq -0x18(%rbp), %rsi
callq 0x31e410
callq 0x627b0
testb $0x1, %al
jne 0x32c9f9
jmp 0x32ca05
movl $0xffff... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmakeCheckStampList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool cmakeCheckStampList(const std::string& stampList)
{
// If the stamp list does not exist CMake must rerun to generate it.
if (!cmSystemTools::FileExists(stampList)) {
std::cout << "CMake is re-running because generate.stamp.list "
<< "is missing.\n";
return false;
}
cmsys::ifstr... | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f8de0
testb $0x1, %al
jne 0x32d017
movq 0xbccebd(%rip), %rdi # 0xef9eb0
leaq 0x83849b(%rip), %rsi # 0xb65495
callq 0x3d690
movq %rax, %rdi
leaq 0x8383f1(%rip), %rsi # 0xb653fa
callq 0x3d... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::GetAllExtensions[abi:cxx11]() const | std::vector<std::string> cmake::GetAllExtensions() const
{
std::vector<std::string> allExt = this->CLikeSourceFileExtensions.ordered;
allExt.insert(allExt.end(), this->HeaderFileExtensions.ordered.begin(),
this->HeaderFileExtensions.ordered.end());
// cuda extensions are also in SourceFileExtensio... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x4c0, %rsi # imm = 0x4C0
callq 0x85020
movq -0xd8(%rbp),... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::GetSystemInformation(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>>>>&) | int cmake::GetSystemInformation(std::vector<std::string>& args)
{
// so create the directory
std::string resultFile;
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
std::string destPath = cwd + "/__cmake_systeminformation";
cmSystemTools::RemoveADirectory(destPath);
if (!cmSystemTools::MakeDi... | pushq %rbp
movq %rsp, %rbp
subq $0x1540, %rsp # imm = 0x1540
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1460(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d1f0
leaq -0x58(%rbp), %rdi
callq 0x2d49b0
jmp 0x3303a2
leaq 0x834ad5(%rip), %rdx # 0xb64e7e
leaq -0x88(%rbp), %rdi
leaq... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::BuildWorkflowStep(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&) | std::function<int()> cmake::BuildWorkflowStep(
const std::vector<std::string>& args)
{
cmUVProcessChainBuilder builder;
builder
.AddCommand(args)
# ifdef _WIN32
.SetExternalStream(cmUVProcessChainBuilder::Stream_OUTPUT, _fileno(stdout))
.SetExternalStream(cmUVProcessChainBuilder::Stream_ERROR, _filen... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x729450
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x729520
movq %rax, -0x90(%rbp)
j... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, std::string failedMsg, Values t,
FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(std::move(failedMsg))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x7ffdd1(%rip), %rsi # 0xb3fab3
callq 0x6... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<c... | cmCommandLineArgument(std::string n, Values t, FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(cmStrCat("Invalid value used with ", n))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
, StoreCall(std::forward<Func... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq %rax, -0x120(%rbp)
leaq 0x7fe389(%rip), %rsi # 0xb3fab3
leaq -0x50(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool matches(std::string const& input) const
{
bool matched = false;
if (this->Type == Values::Zero) {
matched = (input == this->Name);
} else if (this->SeparatorNeeded == RequiresSeparator::No) {
matched = cmHasPrefix(input, this->Name);
} else if (cmHasPrefix(input, this->Name)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
cmpl $0x0, 0x60(%rax)
jne 0x3450b0
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x40, %rsi
callq 0x6d150
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x3451d8
m... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
cmCMakePresetsGraph::BuildPreset const* cmake::FindPresetForWorkflow<cmCMakePresetsGraph::BuildPreset>(cm::static_string_view, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmCMakePresetsGraph::PresetPair<cmCMakePresetsGraph::BuildPreset>, std::less<std::__cxx11::basic_string<... | const T* cmake::FindPresetForWorkflow(
cm::static_string_view type,
const std::map<std::string, cmCMakePresetsGraph::PresetPair<T>>& presets,
const cmCMakePresetsGraph::WorkflowPreset::WorkflowStep& step)
{
auto it = presets.find(step.PresetName);
if (it == presets.end()) {
cmSystemTools::Error(cmStrCat("... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0xff830
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmAddTestCommand(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&, cmExecutionStatus&) | bool cmAddTestCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (!args.empty() && args[0] == "NAME") {
return cmAddTestCommandHandleNameMode(args, status);
}
// First argument is the name of the test Second argument is the name of
// the executable to run (... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x36ba09
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d540
movq %rax, %rdi
leaq 0x7f5c42(%rip), %rsi # 0xb61629
callq 0x85b10... | /JKorbelRA[P]CMake/Source/cmAddTestCommand.cxx |
cmAuxSourceDirectoryCommand(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&, cmExecutionStatus&) | bool cmAuxSourceDirectoryCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
std::string sourceListValue;
... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
je 0x36cd28
movq -0x18(%rbp), %rax
movq %rax, -0x2e0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x3c460
movq -0x2d8(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmAuxSourceDirectoryCommand.cxx |
(anonymous namespace)::GetValue(cmExecutionStatus&, 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&) | cm::optional<std::string> GetValue(cmExecutionStatus& status,
std::string const& key,
std::string const& variable)
{
const auto prefix = "DISTRIB_"_s;
if (!cmHasPrefix(key, prefix)) {
return {};
}
static const std::map<std::string, std::... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x7f562e(%rip), %rdi # 0xb67c31
movl $0x8, %esi
callq 0x10eca0
movq %rax, -0x30(%rbp)
m... | /JKorbelRA[P]CMake/Source/cmCMakeHostSystemInformationCommand.cxx |
(anonymous namespace)::cmCMakeLanguageCommandEVAL(std::vector<cmListFileArgument, std::allocator<cmListFileArgument>> const&, cmExecutionStatus&) | bool cmCMakeLanguageCommandEVAL(std::vector<cmListFileArgument> const& args,
cmExecutionStatus& status)
{
cmMakefile& makefile = status.GetMakefile();
cmListFileContext context = makefile.GetBacktrace().Top();
std::vector<std::string> expandedArgs;
makefile.ExpandArguments(args, ... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bfb20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x220710
movq -0x250(%rbp), %rdi
callq 0x1d7740
movq %rax, -0x248(%... | /JKorbelRA[P]CMake/Source/cmCMakeLanguageCommand.cxx |
cmCMakePathCommand(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&, cmExecutionStatus&) | bool cmCMakePathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("must be called with at least two arguments.");
return false;
}
static cmSubcommandTable const subcommand{
{ "GET"_s, HandleGetCommand },
{ "SE... | pushq %rbp
movq %rsp, %rbp
subq $0x7d0, %rsp # imm = 0x7D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x381f58
movq -0x18(%rbp), %rax
movq %rax, -0x560(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x558(%rbp)
callq 0x3c460
movq -0x558(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleSetCommand(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&, cmExecutionStatus&) | bool HandleSetCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3 || args.size() > 4) {
status.SetError("SET must be called with two or three arguments.");
return false;
}
if (args[1].empty()) {
status.SetError("Invalid name for path va... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jb 0x3839f5
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
jbe 0x383a87
movq -0x18(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x39(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleAppendCommand(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&, cmExecutionStatus&) | bool HandleAppendCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args[1].empty()) {
status.SetError("Invalid name for path variable.");
return false;
}
static OutputVariableParser const parser{};
const auto arguments = parser.Parse(args);
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6d540
movq %rax, %rdi
callq 0x3b870
testb $0x1, %al
jne 0x383e42
jmp 0x383ed4
movq -0x18(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleRemoveExtensionCommand(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&, cmExecutionStatus&) | bool HandleRemoveExtensionCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
struct Arguments : public ArgumentParser::ParseResult
{
cm::optional<ArgumentParser::NonEmpty<std::string>> Output;
bool LastOnly = false;
};
static auto const parser =... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0xb7c84e(%rip) # 0xf016c8
jne 0x384f4f
leaq 0xb7c841(%rip), %rdi # 0xf016c8
callq 0x3d080
cmpl $0x0, %eax
je 0x384f4f
leaq -0xa0(%rbp), %rdi
callq 0x38c6a0
jmp 0x384ea3
leaq 0x813d13(%rip... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleReplaceExtensionCommand(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&, cmExecutionStatus&) | bool HandleReplaceExtensionCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
struct Arguments : public ArgumentParser::ParseResult
{
cm::optional<ArgumentParser::NonEmpty<std::string>> Output;
bool LastOnly = false;
};
static auto const parser... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0xb7c3de(%rip) # 0xf01758
jne 0x38544f
leaq 0xb7c3d1(%rip), %rdi # 0xf01758
callq 0x3d080
cmpl $0x0, %eax
je 0x38544f
leaq -0xa0(%rbp), %rdi
callq 0x38d540
jmp 0x3853a3
leaq 0x813813(%rip... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleNormalPathCommand(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&, cmExecutionStatus&) | bool HandleNormalPathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
static OutputVariableParser const parser{};
const auto arguments = parser.Parse(args);
if (arguments.MaybeReportError(status.GetMakefile())) {
return true;
}
if (!parser.GetInput... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0xb7bd8e(%rip) # 0xf017e8
jne 0x385aa1
leaq 0xb7bd85(%rip), %rdi # 0xf017e8
callq 0x3d080
cmpl $0x0, %eax
je 0x385aa1
leaq 0xb7bcec(%rip), %rdi # 0xf01760
callq 0x38bd80
jmp 0x385a7b
l... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleNativePathCommand(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&, cmExecutionStatus&) | bool HandleNativePathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3 || args.size() > 4) {
status.SetError("NATIVE_PATH must be called with two or three arguments.");
return false;
}
static NormalizeParser const parser;
const ... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jb 0x385f85
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
jbe 0x386017
movq -0x18(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x39(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleConvertCommand(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&, cmExecutionStatus&) | bool HandleConvertCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
const auto pathSep = ";"_s;
#else
const auto pathSep = ":"_s;
#endif
const auto cmakePath = "TO_CMAKE_PATH_LIST"_s;
const auto nativePath = "TO_NATIV... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x7fa5a1(%rip), %rdi # 0xb809db
movl $0x1, %esi
callq 0x10eca0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x7e3f46(%rip), %rdi # 0xb6a399
movl $0x12, %esi
callq 0x10eca0
movq %rax, -0x3... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleCompareCommand(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&, cmExecutionStatus&) | bool HandleCompareCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 5) {
status.SetError("COMPARE must be called with four arguments.");
return false;
}
static std::map<cm::string_view,
std::function<bool(const cmCMak... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
je 0x386e78
movq -0x18(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x3c460
movq -0x260(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleIsRelativeCommand(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&, cmExecutionStatus&) | bool HandleIsRelativeCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("IS_RELATIVE must be called with two arguments.");
return false;
}
std::string inputPath;
if (!getInputPath(args[1], status, inputPath)) {... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x387c48
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3c460
movq -0xf0(%rbp), %rdx
leaq 0x7e2... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleIsPrefixCommand(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&, cmExecutionStatus&) | bool HandleIsPrefixCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4 || args.size() > 5) {
status.SetError("IS_PREFIX must be called with three or four arguments.");
return false;
}
static NormalizeParser const parser;
const auto ... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
jb 0x387ec5
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
jbe 0x387f57
movq -0x18(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x39(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::getInputPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool getInputPath(const std::string& arg, cmExecutionStatus& status,
std::string& path)
{
cmValue def = status.GetMakefile().GetDefinition(arg);
if (!def) {
status.SetError("undefined variable for input path.");
return false;
}
path = *def;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bfb20
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x220440
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x62230
testb $0x1, %al
jne 0x388cfe
movq -0x18(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
bool cmArgumentParser<(anonymous namespace)::OutputVariable>::Parse<cmRange<__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_s... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38c690
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
(anonymous namespace)::HandleHasItemCommand(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&, cmExecutionStatus&, std::function<bool (cmCMakePath const&)> const&) | bool HandleHasItemCommand(
std::vector<std::string> const& args, cmExecutionStatus& status,
const std::function<bool(const cmCMakePath&)>& has_item)
{
if (args.size() != 3) {
status.SetError(
cmStrCat(args.front(), " must be called with two arguments."));
return false;
}
std::string inputPath;
... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x390f60
movq -0x18(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36b7a0
movq %rax, %rsi
leaq -0x70(%rbp... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleHasParentPathCommand(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&, cmExecutionStatus&)::$_0::operator()(cmCMakePath const&) const | bool HandleIsAbsoluteCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("IS_ABSOLUTE must be called with two arguments.");
return false;
}
std::string inputPath;
if (!getInputPath(args[1], status, inputPath)) {... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x398210
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
cmExecProgramCommand(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&, cmExecutionStatus&) | bool cmExecProgramCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
std::string arguments;
bool doingargs = false;
int count = 0;
std::string output_va... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x39f145
jmp 0x39f1d7
movq -0x18(%rbp), %rax
movq %rax, -0x340(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0x3c460
movq -0x338(%rbp)... | /JKorbelRA[P]CMake/Source/cmExecProgramCommand.cxx |
(anonymous namespace)::cmExecuteProcessCommandAppend(std::vector<char, std::allocator<char>>&, char const*, int) | void cmExecuteProcessCommandAppend(std::vector<char>& output, const char* data,
int length)
{
#if defined(__APPLE__)
// HACK on Apple to work around bug with inserting at the
// end of an empty vector. This resulted in random failures
// that were hard to reproduce.
if (outpu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rax
addq %rax, %rdx
callq 0x3a5c30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmExecuteProcessCommand.cxx |
bool cmArgumentParser<cmExecuteProcessCommand(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&, cmExecutionStatus&)::Arguments>::Parse<std::vector<std::__cxx11::basic_string<... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a4880
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
cmExportCommand(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&, cmExecutionStatus&) | bool cmExportCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with too few arguments");
return false;
}
if (args[0] == "PACKAGE") {
return HandlePackage(args, status);
}
struct Arguments
{
std::st... | pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp # imm = 0x1050
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x3a8618
movq -0x18(%rbp), %rax
movq %rax, -0xe38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xe30(%rbp)
callq 0x3c460
movq -0xe30(%rbp), %rdx
leaq ... | /JKorbelRA[P]CMake/Source/cmExportCommand.cxx |
HandlePackage(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&, cmExecutionStatus&) | static bool HandlePackage(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
// Parse PACKAGE mode arguments.
enum Doing
{
DoingNone,
DoingPackage
};
Doing doing = DoingPackage;
std::string package;
for (unsigned int i = 1; i < args.size(); ++i) {
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x5c0, %rsp # imm = 0x5C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3d1f0
movl $0x1, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0x518(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
movq %rax, %rcx
movq -0x518(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmExportCommand.cxx |
StorePackageRegistry(cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const*) | static void StorePackageRegistry(cmMakefile& mf, std::string const& package,
const char* content, const char* hash)
{
# if defined(__HAIKU__)
char dir[B_PATH_NAME_LENGTH];
if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
B_OK) {
return;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x488(%rbp)
callq 0x3d1f0
movq -0x488(%rbp), %rsi
leaq 0x7c15a1(%rip), %rdi # 0xb6bdca
callq 0x7f8000
movb %al, -0x479(%r... | /JKorbelRA[P]CMake/Source/cmExportCommand.cxx |
(anonymous namespace)::HandleUploadCommand(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&, cmExecutionStatus&) | bool HandleUploadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if !defined(CMAKE_BOOTSTRAP)
if (args.size() < 3) {
status.SetError("UPLOAD must be called with at least three arguments.");
return false;
}
auto i = args.begin();
++i;
std::string fil... | pushq %rbp
movq %rsp, %rbp
subq $0xd90, %rsp # imm = 0xD90
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x3b5808
movq -0x18(%rbp), %rax
movq %rax, -0xa48(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa40(%rbp)
callq 0x3c460
movq -0xa40(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleStringsCommand(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&, cmExecutionStatus&) | bool HandleStringsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("STRINGS requires a file name and output variable");
return false;
}
// Get the file to read.
std::string fileName = args[1];
if (!cmsys::Syste... | pushq %rbp
movq %rsp, %rbp
subq $0xb30, %rsp # imm = 0xB30
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x3b92e8
movq -0x18(%rbp), %rax
movq %rax, -0xa38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa30(%rbp)
callq 0x3c460
movq -0xa30(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleCopyFile(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&, cmExecutionStatus&) | bool HandleCopyFile(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("COPY_FILE must be called with at least two additional "
"arguments");
return false;
}
// Compute full path for old and new names.
std::s... | pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp # imm = 0x5B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x3bbaf8
movq -0x18(%rbp), %rax
movq %rax, -0x4a0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x498(%rbp)
callq 0x3c460
movq -0x498(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleRPathChangeCommand(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&, cmExecutionStatus&) | bool HandleRPathChangeCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
// Evaluate arguments.
std::string file;
cm::optional<std::string> oldRPath;
cm::optional<std::string> newRPath;
bool removeEnvironmentRPath = false;
cmArgumentParser<void> parser;
... | pushq %rbp
movq %rsp, %rbp
subq $0x570, %rsp # imm = 0x570
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d1f0
leaq -0x60(%rbp), %rdi
callq 0x12ec40
leaq -0x88(%rbp), %rdi
callq 0x12ec40
movb $0x0, -0x89(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x39dbe0
leaq -0x118(%rbp), %rdi
callq... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleReadElfCommand(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&, cmExecutionStatus&) | bool HandleReadElfCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4) {
status.SetError("READ_ELF must be called with at least three additional "
"arguments.");
return false;
}
std::string const& fileNameArg = args[... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
jae 0x3beb78
movq -0x18(%rbp), %rax
movq %rax, -0x370(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x368(%rbp)
callq 0x3c460
movq -0x368(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleRealPathCommand(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&, cmExecutionStatus&) | bool HandleRealPathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("REAL_PATH requires a path and an output variable");
return false;
}
struct Arguments : public ArgumentParser::ParseResult
{
cm::optional<s... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x3bf3b8
movq -0x18(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x2d0(%rbp)
callq 0x3c460
movq -0x2d0(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleGenerateCommand(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&, cmExecutionStatus&) | bool HandleGenerateCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 5) {
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
struct Arguments : public ArgumentParser::ParseResult
{
cm::optional<std::s... | pushq %rbp
movq %rsp, %rbp
subq $0xa70, %rsp # imm = 0xA70
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
jae 0x3c0418
movq -0x18(%rbp), %rax
movq %rax, -0x810(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x808(%rbp)
callq 0x3c460
movq -0x808(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleReadSymlinkCommand(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&, cmExecutionStatus&) | bool HandleReadSymlinkCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError(
cmStrCat(args[0], " requires a file name and output variable"));
return false;
}
const std::string& filename = args[1];
const std... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x3c2d30
movq -0x18(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d540
movq %rax, %rsi
leaq -0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleCreateLinkCommand(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&, cmExecutionStatus&) | bool HandleCreateLinkCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("CREATE_LINK must be called with at least two additional "
"arguments");
return false;
}
std::string const& fileName = ar... | pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x3c2fd8
movq -0x18(%rbp), %rax
movq %rax, -0x5d8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x5d0(%rbp)
callq 0x3c460
movq -0x5d0(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleWriteImpl(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, cmExecutionStatus&) | bool HandleWriteImpl(std::vector<std::string> const& args, bool append,
cmExecutionStatus& status)
{
auto i = args.begin();
i++; // Get rid of subcommand
std::string fileName = *i;
if (!cmsys::SystemTools::FileIsFullPath(*i)) {
fileName =
cmStrCat(status.GetMakefile().GetCurrent... | pushq %rbp
movq %rsp, %rbp
subq $0x5c0, %rsp # imm = 0x5C0
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62f40
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x550(%rbp)
xorl %esi, %esi
callq 0x39ca30
movq -0x550(%r... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::cmWriteToFileCallback(void*, unsigned long, unsigned long, void*) | size_t cmWriteToFileCallback(void* ptr, size_t size, size_t nmemb, void* data)
{
int realsize = static_cast<int>(size * nmemb);
cmsys::ofstream* fout = static_cast<cmsys::ofstream*>(data);
if (fout) {
const char* chPtr = static_cast<char*>(ptr);
fout->write(chPtr, realsize);
}
return realsize;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3c8bec
movq -0x8(%rbp), %rax
movq %rax, -... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::cmFileDownloadProgressCallback(void*, double, double, double, double) | int cmFileDownloadProgressCallback(void* clientp, double dltotal, double dlnow,
double ultotal, double ulnow)
{
cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
static_cast<void>(ultotal);
static_cast<void>(ulnow);
std::string status;
if (helper... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3d1f0
movq -0x78(%rbp), %rsi
movq -0x30(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::cURLProgressHelper::UpdatePercentage(double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool UpdatePercentage(double value, double total, std::string& status)
{
long OldPercentage = this->CurrentPercentage;
if (total > 0.0) {
this->CurrentPercentage = std::lround(value / total * 100.0);
if (this->CurrentPercentage > 100) {
// Avoid extra progress reports for unexpected data ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3c8f1b
movsd -0x10(%rbp)... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::cmFileUploadProgressCallback(void*, double, double, double, double) | int cmFileUploadProgressCallback(void* clientp, double dltotal, double dlnow,
double ultotal, double ulnow)
{
cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
static_cast<void>(dltotal);
static_cast<void>(dlnow);
std::string status;
if (helper->Up... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3d1f0
movq -0x78(%rbp), %rsi
movq -0x30(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
bool cmArgumentParser<(anonymous namespace)::HandleRename(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&, cmExecutionStatus&)::Arguments>::Parse<cmRange<__gnu_cxx::__normal... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cbf20
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
(anonymous namespace)::HandleRemoveImpl(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, cmExecutionStatus&) | bool HandleRemoveImpl(std::vector<std::string> const& args, bool recurse,
cmExecutionStatus& status)
{
for (std::string const& arg :
cmMakeRange(args).advance(1)) // Get rid of subcommand
{
std::string fileName = arg;
if (fileName.empty()) {
std::string const r = recurse ?... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2dd7a0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x2dd7f0
movq %rax, -0x30(... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::HandleTouchImpl(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, cmExecutionStatus&) | bool HandleTouchImpl(std::vector<std::string> const& args, bool create,
cmExecutionStatus& status)
{
// File command has at least one argument
assert(args.size() > 1);
for (std::string const& arg :
cmMakeRange(args).advance(1)) // Get rid of subcommand
{
std::string tfile = arg;... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x1, %rax
jbe 0x3ce48c
jmp 0x3ce4ab
leaq 0x7a0aaf(%rip), %rdi # 0xb6ef42
leaq 0x7a0ab8(%rip), %rsi # 0x... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
(anonymous namespace)::AddEvaluationFile(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basi... | void AddEvaluationFile(const std::string& inputName,
const std::string& targetName,
const std::string& outputExpr,
const std::string& condition, bool inputIsContent,
const std::string& newLineCharacter, mode_t permissions,
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movb %r8b, %al
movq 0x18(%rbp), %r8
movl 0x10(%rbp), %r8d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq 0x18(%rbp), %rdi
callq 0x2bfb20
movq ... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
bool cmArgumentParser<(anonymous namespace)::HandleGenerateCommand(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&, cmExecutionStatus&)::Arguments>::Parse<cmRange<__gnu_cxx:... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d0060
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
bool cmArgumentParser<(anonymous namespace)::HandleGetRuntimeDependenciesCommand(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&, cmExecutionStatus&)::Arguments>::Parse<cmRa... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d1910
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<cmRange<RangeIterators::TransformIterator<__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::al... | std::string cmJoin(Range const& rng, cm::string_view separator)
{
if (rng.empty()) {
return std::string();
}
std::ostringstream os;
auto it = rng.begin();
auto const end = rng.end();
os << *it;
while (++it != end) {
os << separator << *it;
}
return os.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d8ff0
testb $0x1, %al
jne 0x3d8d5b
jmp 0x3d8d6c
movq -0x230(%rb... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmFindLibraryCommand::FindLibrary[abi:cxx11]() | std::string cmFindLibraryCommand::FindLibrary()
{
std::string library;
if (this->SearchFrameworkFirst || this->SearchFrameworkOnly) {
library = this->FindFrameworkLibrary();
}
if (library.empty() && !this->SearchFrameworkOnly) {
library = this->FindNormalLibrary();
}
if (library.empty() && this->Sea... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3d1f0
movq -0x90(%rbp), %rax
testb $0x1, 0x170(%rax)
jne 0x3dfd18
movq -0x90(%rbp), %rax
tes... | /JKorbelRA[P]CMake/Source/cmFindLibraryCommand.cxx |
(anonymous namespace)::get_prefixes[abi:cxx11](cmMakefile*) | std::string const& get_prefixes(cmMakefile* mf)
{
#ifdef _WIN32
static std::string defaultPrefix = ";lib";
#else
static std::string defaultPrefix = "lib";
#endif
cmValue prefixProp = mf->GetDefinition("CMAKE_FIND_LIBRARY_PREFIXES");
return (prefixProp) ? *prefixProp : defaultPrefix;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0xb218d2(%rip) # 0xf021b8
jne 0x3e094e
leaq 0xb218c9(%rip), %rdi # 0xf021b8
callq 0x3d080
cmpl $0x0, %eax
je 0x3e094e
leaq -0x9(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3c460
movq -0x58(%rbp), %rdx
leaq 0xb21887(%rip), %rdi # 0xf021... | /JKorbelRA[P]CMake/Source/cmFindLibraryCommand.cxx |
cmFindLibraryHelper::HasValidSuffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFindLibraryHelper::HasValidSuffix(std::string const& name)
{
for (std::string suffix : this->Suffixes) {
if (name.length() <= suffix.length()) {
continue;
}
// Check if the given name ends in a valid library suffix.
if (name.substr(name.size() - suffix.length()) == suffix) {
return ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x622c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
c... | /JKorbelRA[P]CMake/Source/cmFindLibraryCommand.cxx |
cmFindPackageCommand::AppendSuccessInformation() | void cmFindPackageCommand::AppendSuccessInformation()
{
{
std::string const transitivePropName =
cmStrCat("_CMAKE_", this->Name, "_TRANSITIVE_DEPENDENCY");
this->Makefile->GetState()->SetGlobalProperty(transitivePropName, "False");
}
std::string const found = cmStrCat(this->Name, "_FOUND");
std::s... | pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp # imm = 0x3C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x370(%rbp)
leaq 0x781a01(%rip), %rsi # 0xb6aee2
leaq -0x58(%rbp), %rdi
movq %rdi, -0x380(%rbp)
callq 0x62090
movq -0x370(%rbp), %rsi
addq $0x1e0, %rsi # imm = 0x1E0
leaq -0x88(%rb... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FindPackageUsingConfigMode() | bool cmFindPackageCommand::FindPackageUsingConfigMode()
{
this->Variable = cmStrCat(this->Name, "_DIR");
// Add the default name.
if (this->Names.empty()) {
this->Names.push_back(this->Name);
}
// Add the default configs.
if (this->Configs.empty()) {
for (std::string const& n : this->Names) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x230(%rbp)
addq $0x1e0, %rsi # imm = 0x1E0
leaq -0x58(%rbp), %rdi
callq 0x61ca0
leaq -0x88(%rbp), %rdi
leaq 0x77086c(%rip), %rsi # 0xb5b284
callq 0x62090
leaq -0x28(%rbp), %rdi
le... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FindModule(bool&) | bool cmFindPackageCommand::FindModule(bool& found)
{
std::string moduleFileName = cmStrCat("Find", this->Name, ".cmake");
bool system = false;
std::string debugBuffer = cmStrCat(
"find_package considered the following paths for ", moduleFileName, ":\n");
std::string mfile = this->Makefile->GetModulesFile(
... | pushq %rbp
movq %rsp, %rbp
subq $0x580, %rsp # imm = 0x580
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x540(%rbp)
leaq 0x7853a2(%rip), %rsi # 0xb71c37
leaq -0x68(%rbp), %rdi
movq %rdi, -0x538(%rbp)
callq 0x62090
movq -0x540(%rbp), %rsi
addq $0x1e0, %rsi # i... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FindConfig() | bool cmFindPackageCommand::FindConfig()
{
// Compute the set of search prefixes.
this->ComputePrefixes();
// Look for the project's configuration file.
bool found = false;
if (this->DebugMode) {
this->DebugBuffer = cmStrCat(this->DebugBuffer,
"find_package considered the ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x3ede40
movq -0x208(%rbp), %rax
movb $0x0, -0x9(%rbp)
testb $0x1, 0x54(%rax)
je 0x3ed9b3
movq -0x208(%rbp), %rsi
addq $0x410, %rsi # imm = 0x410
leaq -0x60(%rbp), %... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FillPrefixesPackageRedirect() | void cmFindPackageCommand::FillPrefixesPackageRedirect()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRedirect];
const auto redirectDir =
this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_REDIRECTS_DIR");
if (redirectDir && !redirectDir->empty()) {
paths.AddPath(*redirectDir);
}
if (t... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
addq $0xf0, %rdi
leaq 0xb139a8(%rip), %rsi # 0xf02210
callq 0x3fbd10
movq %rax, %rcx
movq -0x110(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x170(%rax), %rax
movq %rax, -0x108(%rbp)
... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FillPrefixesCMakeVariable() | void cmFindPackageCommand::FillPrefixesCMakeVariable()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::CMake];
std::string debugBuffer;
std::size_t debugOffset = 0;
paths.AddCMakePath("CMAKE_PREFIX_PATH");
if (this->DebugMode) {
debugBuffer = "CMAKE_PREFIX_PATH variable [CMAKE_FIND_USE_CMAKE_PATH].... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
addq $0xf0, %rdi
leaq 0xb16ba0(%rip), %rsi # 0xf05868
callq 0x3fbd10
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FillPrefixesCMakeEnvironment() | void cmFindPackageCommand::FillPrefixesCMakeEnvironment()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
std::string debugBuffer;
std::size_t debugOffset = 0;
// Check the environment variable with the same name as the cache
// entry.
paths.AddEnvPath(this->Variable);
if (this->... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
addq $0xf0, %rdi
leaq 0xb16838(%rip), %rsi # 0xf05890
callq 0x3fbd10
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
movq -0x2c8(%rbp), %rsi
movq $0x0, -0x38(%rbp)
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FillPrefixesUserRegistry() | void cmFindPackageCommand::FillPrefixesUserRegistry()
{
#if defined(_WIN32) && !defined(__CYGWIN__)
this->LoadPackageRegistryWinUser();
#elif defined(__HAIKU__)
char dir[B_PATH_NAME_LENGTH];
if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) ==
B_OK) {
std::string fname = cmStrCa... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3d1f0
movq -0xf0(%rbp), %rsi
leaq 0x77c402(%rip), %rdi # 0xb6bdca
callq 0x7f8000
movb %al, -0xe1(%rbp)
jmp 0x3ef9d5
movb -0xe1... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::LoadPackageRegistryDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmSearchPath&) | void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir,
cmSearchPath& outPaths)
{
cmsys::Directory files;
if (!files.Load(dir)) {
return;
}
std::string fname;
for (unsigned long i = 0; i < files.GetNumberOfFiles(); ++i) {
fname = cmS... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x330(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x328(%rbp)
callq 0x7efe50
movq -0x328(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, ... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator&>(cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_tr... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f88b0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3f88d0
leaq -0x40(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f30a9
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmProjectDirectoryListGenerator&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator&>(cmFindPackageCommand::S... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f8cd0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f8cf0
leaq -0x48(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmProjectDirectoryListGenerator&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator&, (anonymous namespace)::... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f8cd0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x3f8cf0
leaq -0x50(%rbp), %rdi
callq 0x3b870
xor... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmProjectDirectoryListGenerator&, (anonymous namespace)::cmEnumPathSegmentsGenerator&, (anonymous namespace)::cmProjectDir... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f8cd0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x3f8cf0
leaq -0x50(%rbp), %rdi
callq 0x3b870
xor... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmMacProjectDirectoryListGenerator&, (anonymous namespace)::cmAppendPathSegmentGenerator&, (anonymous namespace):... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f9670
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x3f8cf0
leaq -0x58(%rbp), ... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFindPackageCommand::SearchAppBundlePrefix(std::string const& prefix_in)
{
assert(!prefix_in.empty() && prefix_in.back() == '/');
// Strip the trailing slash because the path generator is about to
// add one.
std::string const prefix = prefix_in.substr(0, prefix_in.size() - 1);
auto searchFn = [this](... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b870
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x141(%rbp)
jne 0x3f466e
movq -0x18(%rbp), %rdi
callq 0x3c370
m... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmMacProjectDirectoryListGenerator&, (anonymous namespace)::cmAppendPathSegmentGenerator&>(cmFindPackageCommand::... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f9670
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f8cf0
leaq -0x48(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmAppendPathSegmentGenerator&, (anonymous namespace)::cmProjectDirectoryListGenerator&>(cmFindPackageCommand::SearchPrefix... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f94e0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f9520
leaq -0x48(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmAppendPathSegmentGenerator&>(cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f94e0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3f9520
leaq -0x40(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f96d9
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmAppendPathSegmentGenerator&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator&>(cmFindPackageComm... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f94e0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f9520
leaq -0x48(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator&>(cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f88b0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3f88d0
leaq -0x40(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f9a09
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchFrameworkPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmAppendPathSegmentGenerator&, (anonymous namespace)::cmFileListGeneratorGlob&>(cmFindPackageCommand::SearchFrame... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f94e0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f9520
leaq -0x48(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
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.