name string | code string | asm string | file string |
|---|---|---|---|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %r13
movups %xmm0, (%r13)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r13)
movq %rcx, %rdi
callq 0x3fd60
movq %rax, 0x20(%r13)
movq %r12, 0x28(%r13)
movq (%r... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmInstallRuntimeDependencySet::AddBundleExecutable(cmInstallTargetGenerator*) | bool AddBundleExecutable(cmInstallTargetGenerator* bundleExecutable)
{
return this->AddBundleExecutable(
cm::make_unique<TargetItem>(bundleExecutable));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x3f450
leaq 0x5b5d57(%rip), %rcx # 0x84d660
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x16ed48
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x297933
... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySet.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [3]>(cmAlphaNum const&, cmAlphaNum const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [3... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r8, %rdi
callq 0x3fd60
movq %rax, 0x30(%r15)
m... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [38]>(cmAlphaNum const&, cmAlphaNum const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r8, %rdi
callq 0x3fd60
movq %rax, 0x30(%r15)
m... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmInstallCommandArguments::cmInstallCommandArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | cmInstallCommandArguments::cmInstallCommandArguments(
std::string defaultComponent)
: DefaultComponentName(std::move(defaultComponent))
{
this->Bind("DESTINATION"_s, this->Destination);
this->Bind("COMPONENT"_s, this->Component);
this->Bind("NAMELINK_COMPONENT"_s, this->NamelinkComponent);
this->Bind("EXCLU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x70(%rdi), %rcx
leaq 0x80... | /JKorbelRA[P]CMake/Source/cmInstallCommandArguments.cxx |
cmInstallCommandArguments::CheckPermissions() | bool cmInstallCommandArguments::CheckPermissions()
{
this->PermissionsString.clear();
return std::all_of(this->Permissions.begin(), this->Permissions.end(),
[this](std::string const& perm) -> bool {
return cmInstallCommandArguments::CheckPermissions(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x170(%rdi), %r14
movq $0x0, 0x178(%rdi)
movq 0x170(%rdi), %rax
movb $0x0, (%rax)
movq 0xf8(%rdi), %rbx
movq 0x100(%rdi), %r12
movq %r12, %r13
subq %rbx, %r13
movq %r13, %rbp
sarq $0x7, %rbp
testq %rbp, %rbp
jle 0x299cb3
incq %rbp
movq %r... | /JKorbelRA[P]CMake/Source/cmInstallCommandArguments.cxx |
cmInstallCxxModuleBmiGenerator::cmInstallCxxModuleBmiGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vecto... | cmInstallCxxModuleBmiGenerator::cmInstallCxxModuleBmiGenerator(
std::string target, std::string const& dest, std::string file_permissions,
std::vector<std::string> const& configurations, std::string const& component,
MessageLevel message, bool exclude_from_all, bool optional,
cmListFileBacktrace backtrace)
: ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x777d0
leaq 0x30(%rsp), %rbp
movq %r... | /JKorbelRA[P]CMake/Source/cmInstallCxxModuleBmiGenerator.cxx |
cmInstallCxxModuleBmiGenerator::GetDestination(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmInstallCxxModuleBmiGenerator::GetDestination(
std::string const& config) const
{
return cmGeneratorExpression::Evaluate(this->Destination,
this->LocalGenerator, config);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x70(%rsi), %rsi
movq 0x78(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x777d0
movq 0xf0(%r15), %rdx
leaq 0x10(%rsp), %r15... | /JKorbelRA[P]CMake/Source/cmInstallCxxModuleBmiGenerator.cxx |
CreateInstallGenerator(cmMakefile&, 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>>>> const&) | static void CreateInstallGenerator(cmMakefile& makefile,
std::string const& dest,
std::vector<std::string> const& files)
{
// Construct the destination. This command always installs under
// the prefix. We skip the leading slash given by the us... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq $-0x1, %rcx
callq 0x41560
movq %r15, %rdi
callq 0x486ff8
cmpq $0x0, 0x90(%rsp)
jne 0x29ac83
leaq 0x3baca8(%rip), %rcx # 0x655914
leaq 0x88(%rsp... | /JKorbelRA[P]CMake/Source/cmInstallFilesCommand.cxx |
FindInstallSource[abi:cxx11](cmMakefile&, char const*) | static std::string FindInstallSource(cmMakefile& makefile, const char* name)
{
if (cmSystemTools::FileIsFullPath(name) ||
cmGeneratorExpression::Find(name) == 0) {
// This is a full path.
return name;
}
// This is a relative path.
std::string tb = cmStrCat(makefile.GetCurrentBinaryDirectory(), '/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x48cf84
testb %al, %al
jne 0x29c302
leaq 0x48(%rsp), %rdi
leaq 0x78(%rsp), %rdx
movq %r14, %rsi
callq 0x5c38c
leaq 0x48(%rsp), %rdi
callq 0x393df6
movq %rax, %r12
lea... | /JKorbelRA[P]CMake/Source/cmInstallProgramsCommand.cxx |
(anonymous namespace)::HandleInsertCommand(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 HandleInsertCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4) {
status.SetError("sub-command INSERT requires at least three arguments.");
return false;
}
const std::string& listName = args[1];
// expand the variable
int item... | pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
subq %r14, %rax
cmpq $0x7f, %rax
ja 0x29e516
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3dad94(%rip), %rsi # 0x679270
leaq 0x3dadc2(%rip), %rdx # 0x6792a5
leaq 0x30(%rsp), %r... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandleTransformCommand(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&)::Command::~Command() | Command(const std::string& listName)
: ListName(listName)
, OutputName(listName)
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x2a4014
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2a4023
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x60(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x2a403a
movq (%rdi), %rax
ca... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::cmLoadedCommand::InitialPass(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 cmLoadedCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
{
if (!this->Impl->InitialPass) {
return true;
}
// clear the error string
if (this->Impl->Error) {
free(this->Impl->Error);
}
// create argc and argv and then invoke the c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x18(%rdi), %rax
movb $0x1, %bl
cmpq $0x0, 0x20(%rax)
je 0x2a8271
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x2a8087
callq 0x41e70
movq (%r14), %r13
movq 0x8(%r14), %rdi
subq %r13, %rdi
movq %rdi, %r1... | /JKorbelRA[P]CMake/Source/cmLoadCommandCommand.cxx |
cmCreateSourceFile() | static void* CCONV cmCreateSourceFile()
{
return new cmCPluginAPISourceFile;
} | pushq %rax
movl $0xb8, %edi
callq 0x3f450
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileGetPropertyAsBool(void*, char const*) | static int CCONV cmSourceFileGetPropertyAsBool(void* arg, const char* prop)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
return rsf->GetPropertyAsBool(prop) ? 1 : 0;
}
return cmIsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2aa3d8
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5c38c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cf1c0
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2aa3e7
movq 0x18(%rsp), %rsi
incq... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmCopyFileIfDifferent(char const*, char const*) | static void CCONV cmCopyFileIfDifferent(const char* name1, const char* name2)
{
cmSystemTools::CopyFileIfDifferent(name1, name2);
} | pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5c38c
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rbx, %rsi
callq 0x5c38c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x488af8
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ab02... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmGetFilenamePath(char const*) | static char* CCONV cmGetFilenamePath(const char* name)
{
std::string sres = cmSystemTools::GetFilenamePath(name);
return strdup(sres.c_str());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5c38c
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x4897be
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ab170
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3f310
leaq 0x40... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmake::GetTopCheckInProgressMessage[abi:cxx11]() | std::string GetTopCheckInProgressMessage()
{
auto message = this->CheckInProgressMessages.top();
this->CheckInProgressMessages.pop();
return message;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x848(%rsi), %rax
cmpq 0x850(%rsi), %rax
jne 0x2b0456
movq 0x860(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
addq $0x818, %r14 # imm = 0x818
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
mo... | /JKorbelRA[P]CMake/Source/cmake.h |
SetPropertyCommand::HandleAndValidateSourceFileDirectoryScopes(cmExecutionStatus&, bool, bool, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_str... | bool HandleAndValidateSourceFileDirectoryScopes(
cmExecutionStatus& status, bool source_file_directory_option_enabled,
bool source_file_target_option_enabled,
std::vector<std::string>& source_file_directories,
std::vector<std::string>& source_file_target_directories,
std::vector<cmMakefile*>& source_file_dire... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
callq 0x2bcedd
testb %al, %al
je 0x2bcff2
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2bca44
xorl %eax, %eax
addq $0x8, %... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
cmSetPropertyCommand(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 cmSetPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
// Get the scope on which to set the property.
std::string const& scopeName = args.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
subq %r14, %rax
cmpq $0x20, %rax
ja 0x2bd6db
leaq 0x90(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3b5b75(%rip), %rsi # 0x673204
leaq 0x3b5b97(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
cmSetTargetPropertiesCommand(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 cmSetTargetPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
// first identify the properties arguments
auto propsIter = std::fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x20, %rax
ja 0x2bfbee
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3b363d(%rip), %rsi # 0x673204
leaq 0x3b365f(%rip),... | /JKorbelRA[P]CMake/Source/cmSetTargetPropertiesCommand.cxx |
cmSourceGroupCommand(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 cmSourceGroupCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
// If only two arguments are given, the pre-1.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rax
cmpq %rax, %rdi
je 0x2c0788
movq (%rbx), %rcx
movq %rcx, 0x68(%rsp)
subq %rdi, %rax
cmpq $0x40, %rax
jne 0x2c06f1
addq $0x20, %rdi
leaq 0x3c... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
checkSingleParameterArgumentPreconditions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::alloc... | static bool checkSingleParameterArgumentPreconditions(
const std::string& argument, const ParsedArguments& parsedArguments,
std::string& errorMsg)
{
auto foundArgument = parsedArguments.find(argument);
if (foundArgument != parsedArguments.end()) {
const std::vector<std::string>& optionArguments = foundArgum... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0xa6f74
movq %rax, %rcx
addq $0x8, %r15
movb $0x1, %al
cmpq %r15, %rcx
je 0x2c14cd
movq 0x40(%rcx), %rdx
movq 0x48(%rcx), %rcx
cmpq %rcx, %rdx
je 0x2c1425
subq %rdx, %rcx
cmpq $0x21, %... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
cmSubcommandTable::cmSubcommandTable(std::initializer_list<std::pair<cm::static_string_view, bool (*)(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&)>>) | cmSubcommandTable::cmSubcommandTable(std::initializer_list<InitElem> init)
: Impl(init.begin(), init.end())
{
std::sort(this->Impl.begin(), this->Impl.end(),
[](Elem const& left, Elem const& right) {
return left.first < right.first;
});
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %rdx
leaq 0xf(%rsp), %rcx
callq 0x2c8910
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x2c8186
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # ... | /JKorbelRA[P]CMake/Source/cmSubcommandTable.cxx |
(anonymous namespace)::TargetCompileFeaturesImpl::HandleDirectContent(cmTarget*, 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, bool) | bool HandleDirectContent(cmTarget* tgt,
const std::vector<std::string>& content,
bool /*prepend*/, bool /*system*/) override
{
cmStandardLevelResolver standardResolver(this->Makefile);
for (std::string const& it : content) {
std::string error;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x30(%rdi), %rax
movq %rax, 0x30(%rsp)
movq (%rdx), %r12
movq 0x8(%rdx), %r14
movb $0x1, %al
cmpq %r14, %r12
je 0x2c97b0
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
leaq 0x18(%rsp), %rbx
leaq 0x30(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %rb... | /JKorbelRA[P]CMake/Source/cmTargetCompileFeaturesCommand.cxx |
(anonymous namespace)::TargetCompileOptionsImpl::HandleMissingTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void HandleMissingTarget(const std::string& name) override
{
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
cmStrCat("Cannot specify compile options for target \"", name,
"\" which is not built by this project."));
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x30(%rdi), %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x28(%rsp), %rsi
movq $0x2b, (%rsi)
leaq 0x3b392a(%rip), %rdx # 0x67d287
movq %rdx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq $0x25, 0x20(%rsi)
leaq 0x3a5ab6(%rip), %rax # 0x66f42e
movq %rax, ... | /JKorbelRA[P]CMake/Source/cmTargetCompileOptionsCommand.cxx |
(anonymous namespace)::TargetCompileOptionsImpl::HandleDirectContent(cmTarget*, 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, bool) | bool HandleDirectContent(cmTarget* tgt,
const std::vector<std::string>& content,
bool prepend, bool /*system*/) override
{
cmPolicies::PolicyStatus policyStatus =
this->Makefile->GetPolicyStatus(cmPolicies::CMP0101);
if (policyStatus == cmPolicies::O... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movl $0x65, %esi
xorl %edx, %edx
callq 0x1982a0
cmpl $0x2, %eax
setae %r12b
movq 0x30(%r15), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1987c0
movq (%r15), %rax
movq %rsp... | /JKorbelRA[P]CMake/Source/cmTargetCompileOptionsCommand.cxx |
(anonymous namespace)::TargetIncludeDirectoriesImpl::HandleInterfaceContent(cmTarget*, 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, bool) | void TargetIncludeDirectoriesImpl::HandleInterfaceContent(
cmTarget* tgt, const std::vector<std::string>& content, bool prepend,
bool system)
{
this->cmTargetPropCommandBase::HandleInterfaceContent(tgt, content, prepend,
system);
if (system) {
std::str... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2ce378
testl %ebp, %ebp
je 0x2c9d95
movq (%r14), %rax
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x30(%rax)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3b35ee(%r... | /JKorbelRA[P]CMake/Source/cmTargetIncludeDirectoriesCommand.cxx |
cmTimestamp::FileModificationTime(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | std::string cmTimestamp::FileModificationTime(const char* path,
const std::string& formatString,
bool utcFlag) const
{
std::string real_path =
cmSystemTools::GetRealPathResolvingWindowsSubst(path);
if (!cmsys::SystemToo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %r8d, %r14d
movq %rcx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
leaq 0xb(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5c38c
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
xorl %edx, %e... | /JKorbelRA[P]CMake/Source/cmTimestamp.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<ArgumentParser::MaybeEmpty<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>>>>>>(ArgumentParser::M... | 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x2d4049
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rsp, %rdi
callq 0x41390
movq (%r12), %rbp
movq 0x8(%r12), %r13
movq (%rbp), %rsi
movq 0x8(... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmVariableWatchCommand(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 cmVariableWatchCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("must be called with at least one argument.");
return false;
}
std::string const& variable = args[0];
std::string command;
if (args.size() > 1)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
cmpq %rax, %r14
je 0x2d60e4
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
subq %r14, %rax
cmpq $0x21, %rax
jb 0x2d6002
leaq 0x20(%r14), %rsi
leaq 0x88(%rsp), %rdi
ca... | /JKorbelRA[P]CMake/Source/cmVariableWatchCommand.cxx |
cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake*) | cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
: cmGlobalCommonGenerator(cm)
{
#ifdef _WIN32
cm->GetState()->SetWindowsShell(true);
#endif
this->FindMakeProgramFile = "CMakeNinjaFindMake.cmake";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0x3d2948
leaq 0x5762ff(%rip), %rax # 0x850ef0
movq %rax, (%rbx)
leaq 0x6f8(%rbx), %rcx
xorl %eax, %eax
movl %eax, 0x6f8(%rbx)
movq %rax, 0x700(%rbx)
movq %rcx, 0x708(%rbx)
movq %rcx, 0x710(%rbx)
movq %rax, 0x718(... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::CheckNinjaFeatures() | void cmGlobalNinjaGenerator::CheckNinjaFeatures()
{
this->NinjaSupportsConsolePool =
!cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
RequiredNinjaVersionForConsolePool());
this->NinjaSupportsImplicitOuts = !cmSystemTools::VersionCompare(
cmSystem... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x9b0(%rdi), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movl $0x352e31, (%r12) # imm = 0x352E31
movq $0x3, -0x8(%r12)
leaq 0x8(%rsp), %rdx
movl $0x2, %edi
movq %r14, %rsi
callq 0x1e9f68
xorb $0x1, %al
movb %al, 0x9d0(%rbx)
mo... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::ListSubsetWithAll(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>> co... | cm::optional<std::set<std::string>> cmGlobalNinjaGenerator::ListSubsetWithAll(
const std::set<std::string>& all, const std::set<std::string>& defaults,
const std::vector<std::string>& items)
{
std::set<std::string> result;
for (auto const& item : items) {
if (item == "all") {
if (items.size() == 1) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%r14), %r13
movq 0x8(%r14), %... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmcmd_cmake_ninja_dyndep(__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::allocator<... | int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
std::vector<std::string>::const_iterator argEnd)
{
std::vector<std::string> arg_full =
cmSystemTools::HandleResponseFile(argBeg, argEnd);
std::string arg_dd;
std::string arg_lang;
std::string arg_tdi;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb88, %rsp # imm = 0xB88
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x2f8(%rsp), %r14
movq %r14, %rdi
callq 0x1e3f58
leaq 0xf0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xd0(%rsp), %rcx
mov... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaMultiGenerator::AppendNinjaFileArgument(cmGlobalGenerator::GeneratedMakeCommand&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmGlobalNinjaGenerator::OpenBuildFileStreams()
{
if (!this->OpenFileStream(this->BuildFileStream,
cmGlobalNinjaGenerator::NINJA_BUILD_FILE)) {
return false;
}
// Write a comment about this file.
*this->BuildFileStream
<< "# This file contains all the build statements de... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x8(%rdx)
je 0x2ec7b1
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x39486c(%rip), %rsi # 0x680fe1
movq %rbx, %rdi
callq 0x9c46a
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ec7e2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x78758
leaq 0x10(%rsp), %rax
movq... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteNinjaWorkDir(std::ostream&) | void cmLocalNinjaGenerator::WriteNinjaWorkDir(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
cmGlobalNinjaGenerator::WriteComment(
os, "Logical path to working directory; prefix for absolute paths.");
cmGlobalNinjaGenerator* ng = this->GetGlobalNinjaGenerator();
std::string ninja_workdir = th... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2d81a6
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x38c7ba(%rip), %rsi # 0x681648
leaq 0x38c7f0(%rip), %rdx # 0x681685
leaq 0x8(%rsp), %rdi
callq 0x5c768
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmNinjaTargetGenerator::GetTargetFilePath(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&) const | std::string cmNinjaTargetGenerator::GetTargetFilePath(
const std::string& name, const std::string& config) const
{
std::string path = this->GetTargetOutputDir(config);
if (path.empty() || path == ".") {
return name;
}
path += cmStrCat('/', name);
return path;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rdx
callq *0x20(%rax)
cmpq $0x0, 0x8(%r15)
je 0x2fba86
leaq 0x359f2d(%rip), %rsi # 0x655914
movq %rsp, %rdi
callq 0x411b0
testl %eax, %eax
je 0x2fba86
leaq 0x70(%rsp), %rax
... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::MacOSXContentGeneratorType::~MacOSXContentGeneratorType() | MacOSXContentGeneratorType(cmNinjaTargetGenerator* g,
std::string fileConfig)
: Generator(g)
, FileConfig(std::move(fileConfig))
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x546ebf(%rip), %rax # 0x851520
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x30a67c
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x3f310
| /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.h |
cmNinjaNormalTargetGenerator::~cmNinjaNormalTargetGenerator() | cmNinjaNormalTargetGenerator::~cmNinjaNormalTargetGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x5462db(%rip), %rax # 0x851588
movq %rax, (%rdi)
movq 0xe8(%rdi), %rdi
leaq 0xf8(%rbx), %rax
cmpq %rax, %rdi
je 0x30b2ce
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq %rbx, %rdi
popq %rbx
jmp 0x2f8b8a
nop
| /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::LanguageLinkerCudaFatbinaryRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmNinjaNormalTargetGenerator::LanguageLinkerCudaFatbinaryRule(
const std::string& config) const
{
return cmStrCat(
this->TargetLinkLanguage(config), "_FATBINARY__",
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
'_', config);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x3a06ca
movq (%r12), %r13
movq 0x8(%r12), %r12
movq 0x8(%r15), %rdi
callq 0x3972bc
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2d83d8
leaq... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmGlobalGhsMultiGenerator::OrderedTargetDependSet::OrderedTargetDependSet(cmTargetDependSet const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmGlobalGhsMultiGenerator::OrderedTargetDependSet::OrderedTargetDependSet(
TargetDependSet const& targets, std::string const& first)
: derived(TargetCompare(first))
{
this->insert(targets.begin(), targets.end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x777d0
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
cmpq %r... | /JKorbelRA[P]CMake/Source/cmGlobalGhsMultiGenerator.cxx |
cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator() | cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x531201(%rip), %rax # 0x851c70
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x320a90
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x320aae
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0x... | /JKorbelRA[P]CMake/Source/cmGhsMultiTargetGenerator.cxx |
cmGhsMultiTargetGenerator::Generate() | void cmGhsMultiTargetGenerator::Generate()
{
// Determine type of target for this project
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::EXECUTABLE: {
// Get the name of the executable to generate.
this->TargetNameReal =
this->GeneratorTarget->GetExecutableNames(this->ConfigN... | pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3972b4
cmpl $0x6, %eax
ja 0x320f2a
movl %eax, %eax
leaq 0x362a16(%rip), %rcx # 0x683538
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0xc8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3b2bd2
leaq 0x68(%... | /JKorbelRA[P]CMake/Source/cmGhsMultiTargetGenerator.cxx |
cmGhsMultiTargetGenerator::WriteCompilerFlags(std::ostream&, 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&) | void cmGhsMultiTargetGenerator::WriteCompilerFlags(std::ostream& fout,
std::string const&,
const std::string& language)
{
auto flagsByLangI = this->FlagsByLanguage.find(language);
if (flagsByLangI != this->FlagsByL... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
movq %rcx, %rsi
callq 0x79d1c
addq $0x28, %r14
cmpq %r14, %rax
je 0x321ade
cmpq $0x0, 0x48(%rax)
je 0x321ade
addq $0x40, %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e4262
movq ... | /JKorbelRA[P]CMake/Source/cmGhsMultiTargetGenerator.cxx |
cmGhsMultiTargetGenerator::WriteBuildEvents(std::ostream&) | void cmGhsMultiTargetGenerator::WriteBuildEvents(std::ostream& fout)
{
this->WriteBuildEventsHelper(fout,
this->GeneratorTarget->GetPreBuildCommands(),
std::string("prebuild"),
#ifdef _WIN32
std::string("preexecShell")
#else
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x39b5de
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x361427(%rip), %rsi # 0x683627
leaq 0x361428(%rip), %rdx # 0x68362f
leaq 0x20(%rsp), %rdi
callq 0x5c768
lea... | /JKorbelRA[P]CMake/Source/cmGhsMultiTargetGenerator.cxx |
cmGhsMultiTargetGenerator::VisitCustomCommand(std::set<cmSourceFile const*, std::less<cmSourceFile const*>, std::allocator<cmSourceFile const*>>&, std::set<cmSourceFile const*, std::less<cmSourceFile const*>, std::allocator<cmSourceFile const*>>&, std::vector<cmSourceFile const*, std::allocator<cmSourceFile const*>>&, ... | bool cmGhsMultiTargetGenerator::VisitCustomCommand(
std::set<cmSourceFile const*>& temp, std::set<cmSourceFile const*>& perm,
std::vector<cmSourceFile const*>& order, cmSourceFile const* si)
{
/* check if permanent mark is set*/
if (perm.find(si) == perm.end()) {
/* set temporary mark; check if revisit*/
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r8, (%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x32524a
leaq 0x8(%r14), %rdx
movq %rdx, %rcx
xorl %esi, %esi
cmpq %r8, 0x20(%rax)
setb %sil
cmovaeq %rax, %rcx
movq 0x1... | /JKorbelRA[P]CMake/Source/cmGhsMultiTargetGenerator.cxx |
cmListFileLexer_yy_create_buffer | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 charac... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq 0x41ec0
testq %rax, %rax
je 0x32768d
movq %rax, %r15
movl %ebp, 0x18(%rax)
addl $0x2, %ebp
movslq %ebp, %rdi
callq 0x41ec0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x32768d
movl $0x1, 0x20(%r15)... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexerAppend | static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
int length)
{
char* temp;
int newSize;
/* If the appended text will fit in the buffer, do not reallocate. */
newSize = lexer->token.length + length + 1;
if (lexer->token.text && newSize <= lexer->si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
leal (%r14,%rbp), %r15d
leal (%r14,%rbp), %eax
incl %eax
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0x327751
movslq %ebp, %rbp
cmpl 0x30(%rbx), %r15d
jge 0x327765
addq %rbp, %r13
movq %r13, ... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_yyrestart | void yyrestart (FILE * input_file , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack (yyscanner);
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
}
yy_init_buffer( YY_CURRENT_BUFFER, ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x3278d5
movq 0x18(%rbx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x327903
movq %rbx, %rdi
callq 0x3275a1
movq 0x8(%rbx), %rdi
movl $0x4000, %esi # imm = 0x4000
movq %rbx, %rdx
callq 0x327631
movq 0x18(%rbx), ... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_yy_scan_bytes | YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = (yy_size_t) (_yybytes_len + 2);
buf = (char *) yyalloc( n , yyscanner );
if ( ! buf )
YY_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r13
leal 0x2(%r15), %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x41ec0
testq %rax, %rax
je 0x327d60
movq %rax, %r12
testl %r15d, %r15d
jle 0x327d32
movl %r15d, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3f250
movslq ... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_yylex_init_extra | int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
struct yyguts_t dummy_yyguts;
yyset_extra (yy_user_defined, &dummy_yyguts);
if (ptr_yy_globals == NULL){
errno = EINVAL;
return 1;
}
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), ... | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x327e9a
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x90, %esi
callq 0x41eb8
movq %rax, (%r14)
testq %rax, %rax
je 0x327ea7
movq %rbx, (%rax)
xorl %eax, %eax
jmp 0x327eb7
callq 0x415e0
movl $0x16, (%rax)
jmp 0x327eb2
callq 0x415e0
movl $0xc, (%rax)
movl $0... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmCommonTargetGenerator::ComputeTargetCompilePDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmCommonTargetGenerator::ComputeTargetCompilePDB(
const std::string& config) const
{
std::string compilePdbPath;
if (this->GeneratorTarget->GetType() > cmStateEnums::OBJECT_LIBRARY) {
return compilePdbPath;
}
compilePdbPath = this->GeneratorTarget->GetCompilePDBPath(config);
if (compilePdbP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
callq 0x3972b4
cmpl $0x4, %eax
jg 0x3301a4
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
... | /JKorbelRA[P]CMake/Source/cmCommonTargetGenerator.cxx |
cmComputeLinkInformation::ComputeLinkTypeInfo() | void cmComputeLinkInformation::ComputeLinkTypeInfo()
{
// Check whether archives may actually be shared libraries.
this->ArchivesMayBeShared =
this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
"TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
// First assume we cannot do link type stuff.
this->LinkTypeE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0xd8(%rdi), %rax
movq 0x770(%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x352d10(%rip), %rsi # 0x685f79
leaq 0x352d2b(%rip), %rdx # 0x685f9b
leaq 0x8(%rsp), %rdi
callq 0x5c768
leaq 0x8(%rsp), ... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkDepends::LinkEntry::LinkEntry(BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, cmGeneratorTarget const*) | LinkEntry(BT<std::string> item, cmGeneratorTarget const* target = nullptr)
: Item(std::move(item))
, Target(target)
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rax
cmpq %rax, %rdi
je 0x33e046
movq %rdi, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x33e04c
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rbx)
movq %ra... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.h |
cmComputeTargetDepends::ComputeIntermediateGraph() | void cmComputeTargetDepends::ComputeIntermediateGraph()
{
this->IntermediateGraph.resize(0);
this->IntermediateGraph.resize(this->InitialGraph.size());
int n = static_cast<int>(this->InitialGraph.size());
for (int i = 0; i < n; ++i) {
auto const& initialEdges = this->InitialGraph[i];
auto& intermediate... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
leaq 0x70(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x343460
movq 0x60(%r15), %rsi
subq 0x58(%r15), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rbx, %rsi
movq %r14, %r... | /JKorbelRA[P]CMake/Source/cmComputeTargetDepends.cxx |
escapeForShellOldStyle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string escapeForShellOldStyle(const std::string& str)
{
std::string result;
#if defined(_WIN32) && !defined(__CYGWIN__)
// if there are spaces
std::string temp = str;
if (temp.find(" ") != std::string::npos &&
temp.find("\"") == std::string::npos) {
result = cmStrCat('"', str, '"');
re... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0x348587
testl %eax, %eax
jne 0x348597
jmp 0x3485a7
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x41c20
movb (%r14), %al
movsbl %al, %esi... | /JKorbelRA[P]CMake/Source/cmCustomCommandGenerator.cxx |
cmELFInternalImpl<cmELFTypes32>::cmELFInternalImpl(cmELF*, std::unique_ptr<std::istream, std::default_delete<std::istream>>, cmELFInternal::ByteOrderType) | cmELFInternalImpl<Types>::cmELFInternalImpl(cmELF* external,
std::unique_ptr<std::istream> fin,
ByteOrderType order)
: cmELFInternal(external, std::move(fin), order)
{
// Read the main header.
if (!this->Read(this->ELFHeader))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq (%rdx), %rax
xorl %edi, %edi
movq %rdi, (%rdx)
movq %rsi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl %ecx, 0x18(%rbx)
movl %edi, 0x1c(%rbx)
leaq 0x30(%rbx), %rax
movl %edi, 0x30(%rbx)
movq %rdi, 0... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmExprParserHelper::ParseString(char const*, int) | int cmExprParserHelper::ParseString(const char* str, int verb)
{
if (!str) {
return 0;
}
// printf("Do some parsing: %s\n", str);
this->Verbose = verb;
this->InputBuffer = str;
this->InputBufferPos = 0;
this->CurrentLine = 0;
this->Result = 0;
yyscan_t yyscanner;
cmExpr_yylex_init(&yyscanner)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
testq %rsi, %rsi
je 0x34e100
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x44(%rdi)
leaq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
movq %rsi, %rdi
callq 0x3fd60
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
movq ... | /JKorbelRA[P]CMake/Source/cmExprParserHelper.cxx |
cmExprParserHelper::LexInput(char*, int) | int cmExprParserHelper::LexInput(char* buf, int maxlen)
{
// std::cout << "JPLexInput ";
// std::cout.write(buf, maxlen);
// std::cout << std::endl;
if (maxlen < 1) {
return 0;
}
if (this->InputBufferPos < this->InputBuffer.size()) {
buf[0] = this->InputBuffer[this->InputBufferPos++];
if (buf[0]... | xorl %eax, %eax
testl %edx, %edx
jle 0x34e646
movq (%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x34e643
leaq 0x1(%rcx), %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
movb (%rax,%rcx), %cl
movb %cl, (%rsi)
movl $0x1, %eax
cmpb $0xa, %cl
jne 0x34e646
incl 0x40(%rdi)
retq
movb $0xa, (%rsi)
retq
nop
| /JKorbelRA[P]CMake/Source/cmExprParserHelper.cxx |
cmFileAPI::BuildClientRequests(Json::Value const&) | cmFileAPI::ClientRequests cmFileAPI::BuildClientRequests(
Json::Value const& requests)
{
ClientRequests result;
if (requests.isNull()) {
result.Error = "'requests' member missing";
return result;
}
if (!requests.isArray()) {
result.Error = "'requests' member is not an array";
return result;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %rdx, %rdi
callq 0... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildReply(cmFileAPI::Query const&) | Json::Value cmFileAPI::BuildReply(Query const& q)
{
Json::Value reply = Json::objectValue;
for (Object const& o : q.Known) {
std::string const& name = ObjectName(o);
reply[name] = this->AddReplyIndexObject(o);
}
for (std::string const& name : q.Unknown) {
reply[name] = cmFileAPI::BuildReplyError("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, %esi
callq 0x502710
movq (%r14), %r12
movq %r14, 0x8(%rsp)
movq 0x8(%r14), %r14
cmpq %r14, %r12
je 0x372f1d
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x37313a
m... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileInstaller::cmFileInstaller(cmExecutionStatus&) | cmFileInstaller::cmFileInstaller(cmExecutionStatus& status)
: cmFileCopier(status, "INSTALL")
{
// Installation does not use source permissions by default.
this->UseSourcePermissions = false;
// Check whether to copy files always or only if they have changed.
std::string install_always;
if (cmSystemTools::G... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x2ca5ef(%rip), %rdx # 0x655f3f
callq 0x388544
leaq 0x4c6ebc(%rip), %rax # 0x852818
movq %rax, (%rbx)
movl $0x4, 0xf4(%rbx)
leaq 0x118(%rbx), %rcx
xorl %eax, %eax
movq %rax, 0xf8(%rbx)
movl $0x0, 0x100(%rbx)
mo... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
cmFileInstaller::InstallFile(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&, cmFileCopier::MatchProperties) | bool cmFileInstaller::InstallFile(const std::string& fromFile,
const std::string& toFile,
MatchProperties match_properties)
{
if (this->InstallMode == cmInstallMode::COPY) {
return this->cmFileCopier::InstallFile(fromFile, toFile, match_propertie... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0xf8(%rdi), %eax
testl %eax, %eax
je 0x38be5a
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addl $-0x3,... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
cmFileInstaller::CheckKeyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFileInstaller::CheckKeyword(std::string const& arg)
{
if (arg == "TYPE") {
if (this->CurrentMatchRule) {
this->NotAfterMatch(arg);
} else {
this->Doing = DoingType;
}
} else if (arg == "FILES") {
if (this->CurrentMatchRule) {
this->NotAfterMatch(arg);
} else {
this... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x31df44(%rip), %rsi # 0x6aac4d
movq %r14, %rdi
callq 0x411b0
testl %eax, %eax
je 0x38ce2d
leaq 0x30374a(%rip), %rsi # 0x69046a
movq %r14, %rdi
callq 0x411b0
testl %eax, %eax
je 0x38ce4a
leaq 0x2e4a20(... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [46]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [46]) | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq %rcx, %rdi
callq 0x3fd60
movq %rax, 0x20(%r15)
movq %rbx, 0x28(%r15)
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e31... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmFileSetVisibilityIsForSelf(cmFileSetVisibility) | bool cmFileSetVisibilityIsForSelf(cmFileSetVisibility vis)
{
switch (vis) {
case cmFileSetVisibility::Interface:
return false;
case cmFileSetVisibility::Public:
case cmFileSetVisibility::Private:
return true;
}
return false;
} | cmpl $0x2, %edi
setb %al
retq
| /JKorbelRA[P]CMake/Source/cmFileSet.cxx |
cmFileSet::CompileDirectoryEntries() const | void cmFileSet::ClearFileEntries()
{
this->FileEntries.clear();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r14
movq 0x50(%rsi), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %r14
je 0x38ee03
leaq 0x50(%rsp), %rbx
leaq 0x68(%rsp), %r15
leaq 0x20(%rsp),... | /JKorbelRA[P]CMake/Source/cmFileSet.cxx |
cmFortranParser_s::cmFortranParser_s(cmFortranCompiler, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | cmFortranParser_s::cmFortranParser_s(cmFortranCompiler fc,
std::vector<std::string> includes,
std::set<std::string> defines,
cmFortranSourceInfo& info)
: Compiler(std::move(fc))
, IncludePath(std::move(inc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rax
cmpq %rax, %rdi
je 0x3901e1
movq %rdi, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x3901e7
movups (%rax), %x... | /JKorbelRA[P]CMake/Source/cmFortranParserImpl.cxx |
cmFortranParser_RuleUseIntrinsic(cmFortranParser_s*, char const*) | void cmFortranParser_RuleUseIntrinsic(cmFortranParser* parser,
const char* module_name)
{
if (parser->InPPFalseBranch) {
return;
}
// syntax: "use, intrinsic:: module_name"
// requires: "module_name.mod"
std::string const& mod_name = cmSystemTools::LowerCase(module... | pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x148(%rdi)
jne 0x390cec
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5c38c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x487ff2
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x390c93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f... | /JKorbelRA[P]CMake/Source/cmFortranParserImpl.cxx |
cmFortranParser_RuleInclude(cmFortranParser_s*, char const*) | void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name)
{
if (parser->InPPFalseBranch) {
return;
}
// If processing an include statement there must be an open file.
assert(!parser->FileStack.empty());
// Get the directory containing the source in which the include
// statement appe... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x148(%rdi)
jne 0x390efc
movq %rdi, %rbx
movq 0xb0(%rdi), %rax
cmpq 0x90(%rdi), %rax
je 0x390f0a
movq %rsi, %r14
cmpq 0xb8(%rbx), %rax
jne 0x390e62
movq 0xc8(%rbx), %rcx
movl $0x1f8, %eax # imm = 0x1F8
addq -0x8(%rcx), %rax
le... | /JKorbelRA[P]CMake/Source/cmFortranParserImpl.cxx |
cmFortranParser_RuleElse(cmFortranParser_s*) | void cmFortranParser_RuleElse(cmFortranParser* parser)
{
// if the parent branch is false do nothing!
if (parser->InPPFalseBranch > 1) {
return;
}
// parser->InPPFalseBranch is either 0 or 1. We change it depending on
// parser->SkipToEnd.top()
if (!parser->SkipToEnd.empty() && parser->SkipToEnd.top()... | cmpq $0x1, 0x148(%rdi)
ja 0x3918af
movq 0x180(%rdi), %rax
cmpq 0x160(%rdi), %rax
je 0x3918a6
cmpq 0x188(%rdi), %rax
jne 0x39189b
movq 0x198(%rdi), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movl $0x1, %ecx
cmpb $0x0, -0x1(%rax)
jne 0x3918a8
xorl %ecx, %ecx
movq %rcx, 0x148(%rdi)
retq
| /JKorbelRA[P]CMake/Source/cmFortranParserImpl.cxx |
cmFSPermissions::stringToModeT(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&) | bool cmFSPermissions::stringToModeT(std::string const& arg,
mode_t& permissions)
{
if (arg == "OWNER_READ") {
permissions |= mode_owner_read;
} else if (arg == "OWNER_WRITE") {
permissions |= mode_owner_write;
} else if (arg == "OWNER_EXECUTE") {
permissions |= mode... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e67b4(%rip), %rsi # 0x678bd1
callq 0x411b0
testl %eax, %eax
je 0x392500
leaq 0x2e67ab(%rip), %rsi # 0x678bdc
movq %r14, %rdi
callq 0x411b0
testl %eax, %eax
je 0x392507
leaq 0x2e67a0(%rip), %rsi # 0x678be8
movq %r14, %rdi
callq 0x411b0
tes... | /JKorbelRA[P]CMake/Source/cmFSPermissions.cxx |
cmGeneratorExpressionEvaluationFile::GetInputFileName[abi:cxx11](cmLocalGenerator*) | std::string cmGeneratorExpressionEvaluationFile::GetInputFileName(
cmLocalGenerator* lg)
{
std::string inputFileName = this->Input;
if (cmSystemTools::FileIsFullPath(inputFileName)) {
inputFileName = cmSystemTools::CollapseFullPath(inputFileName);
} else {
inputFileName = this->FixRelativePath(inputFil... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x777d0
movq %rbx, %rdi
callq 0x48b370
testb %al, %al
je 0x39373d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionEvaluationFile.cxx |
cmGeneratorExpression::IsValidTargetName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmGeneratorExpression::IsValidTargetName(const std::string& input)
{
// The ':' is supported to allow use with IMPORTED targets. At least
// Qt 4 and 5 IMPORTED targets use ':' as the namespace delimiter.
static cmsys::RegularExpression targetNameValidator("^[A-Za-z0-9_.:+-]+$");
return targetNameValidato... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x4d1d1f(%rip), %al # 0x867170
testb %al, %al
je 0x39546e
movq (%rbx), %rsi
leaq 0x4d1c41(%rip), %rdi # 0x8670a0
movq %rdi, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x486846
leaq 0x4d1cfb(%rip), %rdi # 0x867170
callq 0x3fbc0
testl %eax, %eax
je 0x39545... | /JKorbelRA[P]CMake/Source/cmGeneratorExpression.cxx |
cmGeneratorExpressionInterpreter::Evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const std::string& cmGeneratorExpressionInterpreter::Evaluate(
std::string expression, const std::string& property)
{
this->CompiledGeneratorExpression =
this->GeneratorExpression.Parse(std::move(expression));
// Specify COMPILE_OPTIONS to DAGchecker, same semantic as COMPILE_FLAGS
cmGeneratorExpressionDAG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rcx
leaq 0x10(%rsi), %rax
cmpq %rax, %rcx
je 0x3955f2
movq %rcx, 0x30(%rsp)
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
jmp 0x3955fa
movups (%rax), %xmm0
movups ... | /JKorbelRA[P]CMake/Source/cmGeneratorExpression.cxx |
cmGeneratorTarget::GetOutputName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | std::string cmGeneratorTarget::GetOutputName(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
// Lookup/compute/cache the output name for this configuration.
OutputNameKey key(config, artifact);
auto i = this->OutputNameMap.find(key);
if (i == this->OutputNameMap.end()) {
// Add em... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa8(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x7... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetFilePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | std::string cmGeneratorTarget::GetFilePrefix(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
if (this->IsImported()) {
cmValue prefix = this->GetFilePrefixInternal(config, artifact);
return prefix ? *prefix : std::string();
}
std::string prefix;
std::string suffix;
std::str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1ec9ae
testb %al, %al
je 0x397e70
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x327239(%rip), %rdx # 0x6bf049
leaq 0x8(%rsp), %rdi
movq %r... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetFileSuffixInternal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | cmValue cmGeneratorTarget::GetFileSuffixInternal(
std::string const& config, cmStateEnums::ArtifactType artifact,
const std::string& language) const
{
// no suffix for non-main target types.
if (this->GetType() != cmStateEnums::STATIC_LIBRARY &&
this->GetType() != cmStateEnums::SHARED_LIBRARY &&
thi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1f3d38
cmpl $0x1, %eax
je 0x398b03
movq (%rbx), %rdi
callq 0x1f3d38
cmpl $0x2, %eax
je 0x398b03
movq (%rbx), %rdi
callq 0x1f3d38
cmpl $0x3, %eax
je 0x398b03
... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::IsFrameworkOnApple() const | bool cmGeneratorTarget::IsFrameworkOnApple() const
{
return ((this->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->GetType() == cmStateEnums::STATIC_LIBRARY) &&
this->Makefile->IsOn("APPLE") &&
this->GetPropertyAsBool("FRAMEWORK"));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1f3d38
cmpl $0x2, %eax
je 0x399074
movq (%rbx), %rdi
callq 0x1f3d38
cmpl $0x1, %eax
jne 0x399110
movq 0x8(%rbx), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2be450(%rip), %rsi # 0x6574d9
leaq 0x2be44e(... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::AppendLanguageSideEffects(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::set<cmGeneratorTarget const*, std::less<cmGeneratorTarget const*>, std::allocator<cmGeneratorTarget const*>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std:... | void cmGeneratorTarget::AppendLanguageSideEffects(
std::map<std::string, std::set<cmGeneratorTarget const*>>& sideEffects) const
{
static const std::set<cm::string_view> LANGS_WITH_NO_SIDE_EFFECTS = {
"C"_s, "CXX"_s, "OBJC"_s, "OBJCXX"_s, "ASM"_s, "CUDA"_s, "HIP"_s
};
for (auto const& lang : this->GetAllCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
movb 0x4cbd13(%rip), %al # 0x8673e8
testb %al, %al
je 0x39b77a
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x39b87e
movq 0x18(%r15), %r15
leaq 0x30(%rsp), %rbp
cmpq %rbp, %r15
je ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
(anonymous namespace)::handleSystemIncludesDep(cmLocalGenerator*, cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget const*, cmGeneratorExpressionDAGChecker*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocat... | void handleSystemIncludesDep(cmLocalGenerator* lg,
cmGeneratorTarget const* depTgt,
const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2e0b17(%rip), %rsi # 0x67d2de
leaq 0x2e0b34(%rip), %rdx # 0x67d302
... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetSourceFilePaths(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<BT<std::string>> cmGeneratorTarget::GetSourceFilePaths(
std::string const& config) const
{
std::vector<BT<std::string>> files;
if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) {
// At configure-time, this method can be called as part of getting the
// LOCATION prope... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x88(%rax), %rax
cmpb $0x0, 0x6e9(%rax)
movq %rdi, 0x10(%rsp)
je 0x39d7db
movq %rdi,... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*, std::allocator<cmSourceFile*>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*>& files,
const std::string& config) const
{
std::vector<BT<cmSourceFile*>> tmp = this->GetSourceFiles(config);
files.reserve(tmp.size());
for (BT<cmSourceFile*>& v : tmp) {
files.push_back(v.Value);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x39f1ee
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
movq %rbx, %rdi
callq 0x3c263c
movq 0x8(%rsp), %r14
... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeKindedSources(cmGeneratorTarget::KindedSources&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void cmGeneratorTarget::ComputeKindedSources(KindedSources& files,
std::string const& config) const
{
// Get the source file paths by string.
std::vector<BT<std::string>> srcs = this->GetSourceFilePaths(config);
cmsys::RegularExpression header_regex(CM_HEADER_REGEX);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rsi, 0x50(%rsp)
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x39d6dc
xorl %eax, %eax
leaq 0x228(%rsp), %r15
movq %rax, 0xb0(%r15)
movq %rax, 0xc0(%r15)
movl $0x0, 0xc8(%r15)
movl $0xaa, %ed... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetPDBDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGeneratorTarget::GetPDBDirectory(const std::string& config) const
{
if (OutputInfo const* info = this->GetOutputInfo(config)) {
// Return the directory in which the target will be built.
return info->PdbDir;
}
return "";
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3ba9ce
testq %rax, %rax
je 0x3a0590
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x777d0
jmp 0x3a05a9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x31eaab(%rip), %rdx # 0x6... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetLinkerLanguage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGeneratorTarget::GetLinkerLanguage(
const std::string& config) const
{
return this->GetLinkClosure(config)->LinkerLanguage;
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3a363a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x777d0
movq %rbx, %rax
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::HaveBuildTreeRPATH(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmGeneratorTarget::HaveBuildTreeRPATH(const std::string& config) const
{
if (this->GetPropertyAsBool("SKIP_BUILD_RPATH")) {
return false;
}
std::string build_rpath;
if (this->GetBuildRPATH(config, build_rpath)) {
return true;
}
if (cmLinkImplementationLibraries const* impl =
this->GetLi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c3947(%rip), %rsi # 0x664751
leaq 0x2c3950(%rip), %rdx # 0x664761
leaq 0x8(%rsp), %rdi
callq 0x5c768
movq (%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1f4174
movl %eax, %e... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetAppBundleDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget::BundleDirectoryLevel) const | std::string cmGeneratorTarget::GetAppBundleDirectory(
const std::string& config, BundleDirectoryLevel level) const
{
std::string fpath = cmStrCat(
this->GetFullName(config, cmStateEnums::RuntimeBinaryArtifact), '.');
cmValue ext = this->GetProperty("BUNDLE_EXTENSION");
fpath += (ext ? *ext : "app");
if (s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x39c002
movq (%r12), %rax
movq 0x8(%r12), %rcx
leaq 0x10(%rsp), %r13
movl $0x1, %edx
movq %rdx, -0x10(%r13)
movq %r13, -0x8(%r13)
movb $0x... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetExportMacro[abi:cxx11]() const | const std::string* cmGeneratorTarget::GetExportMacro() const
{
// Define the symbol for targets that export symbols.
if (this->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->GetType() == cmStateEnums::MODULE_LIBRARY ||
this->IsExecutableWithExports()) {
if (cmValue custom_export_name = this->Get... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1f3d38
cmpl $0x2, %eax
je 0x3a346e
movq (%rbx), %rdi
callq 0x1f3d38
cmpl $0x3, %eax
je 0x3a346e
movq %rbx, %rdi
callq 0x3a35ac
testb %al, %al
je 0x3a3569
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2e9f49(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
(anonymous namespace)::processOptions(cmGeneratorTarget const*, (anonymous namespace)::EvaluatedTargetPropertyEntries const&, std::vector<BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>... | void processOptions(cmGeneratorTarget const* tgt,
EvaluatedTargetPropertyEntries const& entries,
std::vector<BT<std::string>>& options,
std::unordered_set<std::string>& uniqueOptions,
bool debugOptions, const char* logName, OptionsParse par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r9d, 0x7c(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdi, 0x128(%rsp)
movq %rdx, 0x130(%rsp)
cmpq %rdx, %rsi
je 0x3aafac
movq %r8, %r14
movq %rsi, %r13
movb 0x180(%rsp), %al
xorb $0x1, %al
movl %eax, 0x2c(%rsp)
lea... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeVersionedName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_strin... | void cmGeneratorTarget::ComputeVersionedName(
std::string& vName, std::string const& prefix, std::string const& base,
std::string const& suffix, std::string const& name, cmValue version) const
{
vName = this->Makefile->IsOn("APPLE") ? (prefix + base) : name;
if (version) {
vName += ".";
vName += *versio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, 0x40(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2a3827(%rip), %rsi # 0x6574d9
leaq 0x2a3825(%rip), %rdx # ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetTargetObjectNames(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>>>>&) con... | void cmGeneratorTarget::GetTargetObjectNames(
std::string const& config, std::vector<std::string>& objects) const
{
std::vector<cmSourceFile const*> objectSources;
this->GetObjectSources(objectSources, config);
std::map<cmSourceFile const*, std::string> mapping;
for (cmSourceFile const* sf : objectSources) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rdi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
callq 0x399b60
leaq 0x90(%rsp), %rbp
movl $0x0, (%rbp)
xorl %eax, %eax
movq %rax, 0... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty(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&) const | bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty(
const std::string& p, const std::string& config) const
{
if (this->GetType() == cmStateEnums::OBJECT_LIBRARY ||
this->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
return false;
}
return this->GetCompatibleInterfaces(config).PropsNum... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x1f3d38
cmpl $0x4, %eax
je 0x3b50a4
movq (%r15), %rdi
callq 0x1f3d38
cmpl $0x7, %eax
jne 0x3b50a8
xorl %eax, %eax
jmp 0x3b50d2
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b4b64
movq %rax, %r14
leaq 0x90(%rax), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::IsLinkInterfaceDependentNumberMaxProperty(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&) const | bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMaxProperty(
const std::string& p, const std::string& config) const
{
if (this->GetType() == cmStateEnums::OBJECT_LIBRARY ||
this->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
return false;
}
return this->GetCompatibleInterfaces(config).PropsNum... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x1f3d38
cmpl $0x4, %eax
je 0x3b5100
movq (%r15), %rdi
callq 0x1f3d38
cmpl $0x7, %eax
jne 0x3b5104
xorl %eax, %eax
jmp 0x3b5128
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b4b64
movq %rax, %r14
leaq 0x60(%rax), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
char const* getTypedProperty<char const*>(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorExpressionInterpreter*) | const char* getTypedProperty<const char*>(
cmGeneratorTarget const* tgt, const std::string& prop,
cmGeneratorExpressionInterpreter* genexInterpreter)
{
cmValue value = tgt->GetProperty(prop);
if (genexInterpreter == nullptr) {
return value.GetCStr();
}
return genexInterpreter->Evaluate(value ? *value ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
callq 0x3974ca
movq %rax, %rbx
testq %r15, %r15
je 0x3b5f68
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
testq %rbx, %rbx
je 0x3b5f72
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x777d0
jmp... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
std::pair<bool, char const*> consistentProperty<char const*>(char const*, char const*, CompatibleType) | std::pair<bool, const char*> consistentProperty(const char* lhs,
const char* rhs,
CompatibleType t)
{
if (!lhs && !rhs) {
return { true, lhs };
}
if (!lhs) {
return { true, rhs };
}
if (!rhs) {
return {... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ecx
movq %rsi, %r14
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %sil
movq %rdi, %rdx
cmoveq %r14, %rdx
orb %al, %sil
movb $0x1, %al
jne 0x3b6175
movq %rdi, %rbx
leal -0x2(%rcx), %eax
cmpl $0x2, %eax
jb 0x3b6150
cmpl $0x1, %ecx
je 0x3b615f
testl %ecx, %ecx
jne 0x3b617a
mo... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::AddISPCGeneratedObject(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmGeneratorTarget::AddISPCGeneratedObject(std::vector<std::string>&& objs,
std::string const& config)
{
std::string config_upper;
if (!config.empty()) {
config_upper = cmSystemTools::UpperCase(config);
}
auto iter = this->ISPCGeneratedObjects.find(config_u... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpq $0x0, 0x8(%rdx)
je 0x3b76a9
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x48806a
movq %rsp, %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
ca... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ResolveLinkItem(BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, cmLocalGenerator const*) const | cmLinkItem cmGeneratorTarget::ResolveLinkItem(BT<std::string> const& name,
cmLocalGenerator const* lg) const
{
auto bt = name.Backtrace;
TargetOrString resolved = this->ResolveTargetReference(name.Value, lg);
if (!resolved.Target) {
return cmLinkItem(resolved.Str... | pushq %r15
pushq %r14
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdx), %rax
movq %rax, (%rsp)
movq 0x28(%rdx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3b82c7
movq 0x4a5c9f(%rip), %rsi # 0x85df58
cmpb $0x0, (%rsi)
je 0x3b82c3
incl 0x8(%rax)
jmp 0x3b82c7
lo... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetConfigCommonSourceFilesForXcode(std::vector<cmSourceFile*, std::allocator<cmSourceFile*>>&) const | bool cmGeneratorTarget::GetConfigCommonSourceFilesForXcode(
std::vector<cmSourceFile*>& files) const
{
std::vector<std::string> const& configs =
this->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
auto it = configs.begin();
const std::string& firstConfig = *it;
this->GetSourceFilesWithou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x98(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x19f060
movq (%r14), %r14
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
ca... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.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.