name string | code string | asm string | file string |
|---|---|---|---|
ArgumentParser::Instance::Bind(ArgumentParser::NonEmpty<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>>>>>&) | void Instance::Bind(NonEmpty<std::vector<std::string>>& val)
{
this->Bind(
[&val](cm::string_view arg) -> Continue {
val.emplace_back(arg);
return Continue::Yes;
},
ExpectAtLeast{ 1 });
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, 0x8(%r14)
movq %rsi, (%r14)
leaq 0x641(%rip), %rax # 0x120a02
movq %rax, 0x18(%r14)
leaq 0x658(%rip), %rax # 0x120a24
movq %rax, 0x10(%r14)
addq $0x40, %rdi
movq %r14, %rsi
callq 0x120a92
movq $0x1, 0x38(%rbx)
movq 0x10(%... | /JKorbelRA[P]CMake/Source/cmArgumentParser.cxx |
ArgumentParser::Instance::Consume(unsigned long, std::basic_string_view<char, std::char_traits<char>>) | void Instance::Consume(std::size_t pos, cm::string_view arg)
{
auto const it = this->Bindings.Keywords.Find(arg);
if (it != this->Bindings.Keywords.end()) {
this->FinishKeyword();
this->Keyword = it->first;
this->KeywordValuesSeen = 0;
this->DoneWithPositional = true;
if (this->Bindings.ParsedKe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq (%rdi), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x11ffc4
cmpq 0x8(%rbp), %rax
je 0x120546
movq %rax, %r12... | /JKorbelRA[P]CMake/Source/cmArgumentParser.cxx |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset>::operator()(cmCMakePresetsGraph::TestPreset&, Json::Value const*) const | E operator()(T& out, const Json::Value* value, CallState&&... state) const
{
if (!value && this->AnyRequired) {
return this->Fail;
}
if (value && !value->isObject()) {
return this->Fail;
}
Json::Value::Members extraFields;
if (value) {
extraFields = value-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1499e4
movq %r14, %rdi
callq 0x50419e
testb %al, %al
je 0x1499ea
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmGlobalGenerator::SetExternalMakefileProjectGenerator(std::unique_ptr<cmExternalMakefileProjectGenerator, std::default_delete<cmExternalMakefileProjectGenerator>>) | void cmGlobalGenerator::SetExternalMakefileProjectGenerator(
std::unique_ptr<cmExternalMakefileProjectGenerator> extraGenerator)
{
this->ExtraGenerator = std::move(extraGenerator);
if (this->ExtraGenerator) {
this->ExtraGenerator->SetGlobalGenerator(this);
}
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
movq $0x0, (%rsi)
movq 0x4a8(%rbx), %rax
movq %rdi, 0x4a8(%rbx)
testq %rax, %rax
je 0x1651a1
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x4a8(%rbx), %rdi
testq %rdi, %rdi
je 0x1651b3
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
po... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetFilesReplacedDuringGenerate(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>>>>&) | void cmGlobalGenerator::GetFilesReplacedDuringGenerate(
std::vector<std::string>& filenames)
{
filenames.clear();
std::copy(this->FilesReplacedDuringGenerate.begin(),
this->FilesReplacedDuringGenerate.end(),
std::back_inserter(filenames));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x78040
movq 0x4b0(%r15), %r14
movq 0x4b8(%r15), %r15
subq %r14, %r15
sarq $0x5, %r15
testq %r15, %r15
jle 0x165251
incq %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7488c
addq $0x20, %r14
decq %r15
cmpq $0x1, %r15
... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetNamedRuntimeDependencySet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmInstallRuntimeDependencySet* cmGlobalGenerator::GetNamedRuntimeDependencySet(
const std::string& name)
{
auto it = this->RuntimeDependencySetsByName.find(name);
if (it == this->RuntimeDependencySetsByName.end()) {
auto set = cm::make_unique<cmInstallRuntimeDependencySet>(name);
it =
this->RuntimeD... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x668(%rdi), %r15
movq %r15, %rdi
callq 0x16ea58
movq %rax, %r14
leaq 0x670(%rbx), %rax
cmpq %rax, %r14
jne 0x166b98
movl $0xa0, %edi
callq 0x3f450
movq %rax, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
mo... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<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::c... | 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
cmpq $0x0, 0x28(%rsi)
je 0x16d1a8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x41390
movq 0x18(%r12), %r13
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
m... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmLinkLineComputer::ConvertToOutputFormat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmLinkLineComputer::ConvertToOutputFormat(std::string const& input)
{
cmOutputConverter::OutputFormat shellFormat = cmOutputConverter::SHELL;
if (this->ForResponse) {
shellFormat = cmOutputConverter::RESPONSE;
} else if (this->UseWatcomQuote) {
shellFormat = cmOutputConverter::WATCOMQUOTE;
}... | pushq %rbx
movq %rdi, %rbx
movl $0x3, %r8d
cmpb $0x0, 0x38(%rsi)
jne 0x16fb2e
movl $0x1, %r8d
cmpb $0x0, 0x39(%rsi)
jne 0x16fb2e
movzbl 0x3a(%rsi), %r8d
addl %r8d, %r8d
movq 0x30(%rsi), %rsi
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x1b3da2
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmLinkLineComputer.cxx |
cmLinkLineComputer::ComputeLinkPath(cmComputeLinkInformation&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmLinkLineComputer::ComputeLinkPath(
cmComputeLinkInformation& cli, std::string const& libPathFlag,
std::string const& libPathTerminator)
{
std::string linkPath;
std::vector<BT<std::string>> linkPathList;
this->ComputeLinkPath(cli, libPathFlag, libPathTerminator, linkPathList);
cli.AppendValues(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %edx, %edx
movq %rdx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %r8
movq %rdx, 0x10(%r8)
xorps %xmm0, %xmm0
movaps %xmm0, (%r8)
movq %rsi, %rdi
movq %r14, %rsi
movq %rcx, %rdx
m... | /JKorbelRA[P]CMake/Source/cmLinkLineComputer.cxx |
cmLinkLineComputer::ComputeLinkLibraries(cmComputeLinkInformation&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmLinkLineComputer::ComputeLinkLibraries(
cmComputeLinkInformation& cli, std::string const& stdLibString)
{
std::string linkLibraries;
std::vector<BT<std::string>> linkLibrariesList;
this->ComputeLinkLibraries(cli, stdLibString, linkLibrariesList);
cli.AppendValues(linkLibraries, linkLibrariesList... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %edx, %edx
movq %rdx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rax
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq (%rsi), %r8
movq %rsi, %rdi
movq %r14, %rsi
movq %rcx, %... | /JKorbelRA[P]CMake/Source/cmLinkLineComputer.cxx |
cmListFileParser::~cmListFileParser() | cmListFileParser::~cmListFileParser()
{
cmListFileLexer_Delete(this->Lexer);
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x327f50
leaq 0x60(%rbx), %rdi
callq 0x17417a
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x1712b8
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1712c7
popq %rbx
jmp 0x75c64
popq %rbx
retq
movq %rax, %rdi
c... | /JKorbelRA[P]CMake/Source/cmListFileCache.cxx |
cmListFileParser::ParseFile(char const*) | bool cmListFileParser::ParseFile(const char* filename)
{
this->FileName = filename;
#ifdef _WIN32
std::string expandedFileName = cmsys::Encoding::ToNarrow(
cmSystemTools::ConvertToWindowsExtendedPath(filename));
filename = expandedFileName.c_str();
#endif
// Open the file.
cmListFileLexer_BOM bom;
if ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movq 0x28(%rdi), %rdi
leaq 0x24(%rsp), %rdx
callq 0x327f66
testl %eax, %eax
je 0x17159e
movl 0x24(%rsp), %eax
cmpl $0x1, %eax
jne 0x1715d7
movq 0x28(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x327f66
leaq 0x10(%rsp), %r14
movq %r14, -0... | /JKorbelRA[P]CMake/Source/cmListFileCache.cxx |
operator==(cmListFileContext const&, cmListFileContext const&) | bool operator==(const cmListFileContext& lhs, const cmListFileContext& rhs)
{
return lhs.Line == rhs.Line && lhs.FilePath == rhs.FilePath;
} | movq 0x40(%rdi), %rax
cmpq 0x40(%rsi), %rax
jne 0x174063
movq 0x28(%rdi), %rdx
cmpq 0x28(%rsi), %rdx
jne 0x174063
testq %rdx, %rdx
je 0x174066
pushq %rax
movq 0x20(%rsi), %rsi
movq 0x20(%rdi), %rdi
callq 0x40880
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
| /JKorbelRA[P]CMake/Source/cmListFileCache.cxx |
cmLocalGenerator::ProcessEvaluationFiles(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>>>>&) | void cmLocalGenerator::ProcessEvaluationFiles(
std::vector<std::string>& generatedFiles)
{
for (const auto& geef : this->Makefile->GetEvaluationFiles()) {
geef->Generate(this);
if (cmSystemTools::GetFatalErrorOccurred()) {
return;
}
std::vector<std::string> files = geef->GetFiles();
std::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, 0x70(%rsp)
movq 0x70(%rdi), %rdi
callq 0x19b650
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
cmpq %rax, %r15
je 0x177c4d
addq $0x8, %r15
leaq 0x50(%rsp), %r12
movq -0x8(%r15), %rdi
movq 0x70(%rs... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::ComputeTargetCompileFeatures() | bool cmLocalGenerator::ComputeTargetCompileFeatures()
{
// Collect the set of configuration types.
std::vector<std::string> configNames =
this->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
using LanguagePair = std::pair<std::string, std::string>;
std::vector<LanguagePair> pairedLanguages{... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x19f060
leaq 0x4de041(%rip), %rsi # 0x657444
leaq 0x4efefb(%rip), %rdx # 0x669305
leaq 0x38(%rsp), %r14
movq %r14, %rdi
cal... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::AddCompileOptions(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>>>>>&, cmGeneratorTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
cmGeneratorTarget* target,
const std::string& lang,
const std::string& config)
{
std::string langFlagRegexVar = cmStr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %r8, 0x30(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rcx), %rax
movq %rcx, 0x38(%rsp)
movq 0x8(%rcx), %rcx
leaq 0x78(%rsp), %rsi
movq $0x6, (%rsi)
leaq 0x4e64e7(%rip), %rdx # 0x6607e7
m... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
detail::AddCustomCommandToTarget(cmLocalGenerator&, cmCommandOrigin, cmTarget*, cmCustomCommandType, std::unique_ptr<cmCustomCommand, std::default_delete<cmCustomCommand>>) | void AddCustomCommandToTarget(cmLocalGenerator& lg, cmCommandOrigin origin,
cmTarget* target, cmCustomCommandType type,
std::unique_ptr<cmCustomCommand> cc)
{
// Add the command to the appropriate build step for the target.
cc->SetEscapeAllowMakeVars(true)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq (%r8), %rdi
movl $0x1, %esi
callq 0x345b02
movq (%rbx), %r13
movq %r14, %rdi
callq 0x1ed0f6
movq %r13, %rdi
movq %rax, %rsi
callq 0x345bb6
movq (%rbx), %rdi
c... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
detail::AddUtilityCommand(cmLocalGenerator&, cmCommandOrigin, cmTarget*, std::unique_ptr<cmCustomCommand, std::default_delete<cmCustomCommand>>) | void AddUtilityCommand(cmLocalGenerator& lg, cmCommandOrigin origin,
cmTarget* target, std::unique_ptr<cmCustomCommand> cc)
{
// They might be moved away
auto byproducts = cc->GetByproducts();
auto lfbt = cc->GetBacktrace();
// Use an empty comment to avoid generation of default comment.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rcx), %rdi
callq 0x3458ca
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x9c4c8
movq (%r15), %rdi
callq 0x345b0a
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax),... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::GetIncludeDirectoriesImplicit(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>>>>&, cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>,... | void cmLocalGenerator::GetIncludeDirectoriesImplicit(
std::vector<std::string>& dirs, cmGeneratorTarget const* target,
const std::string& lang, const std::string& config, bool stripImplicitDirs,
bool appendAllImplicitDirs) const
{
std::vector<BT<std::string>> tmp = this->GetIncludeDirectoriesImplicit(
targe... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17b7ec
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rsi... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::GetDeviceLinkFlags(cmLinkLineDeviceComputer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__... | void cmLocalGenerator::GetDeviceLinkFlags(
cmLinkLineDeviceComputer& linkLineComputer, const std::string& config,
std::string& linkLibs, std::string& linkFlags, std::string& frameworkPath,
std::string& linkPath, cmGeneratorTarget* target)
{
cmGeneratorTarget::DeviceLinkSetter setter(*target);
cmComputeLinkIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x50(%rsp)
movq %r8, %r14
movq %rcx, 0x48(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0xc8(%rsp), %rbx
movq %rbx, 0x78(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3b6236
movb %al, 0xf(%rsp)
movb %al, 0x80(%rsp)... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::OutputLinkLibraries(cmComputeLinkInformation*, cmLinkLineComputer*, 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>>>>>&, std::__cxx11::basic_string<char, std... | void cmLocalGenerator::OutputLinkLibraries(
cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer,
std::vector<BT<std::string>>& linkLibraries, std::string& frameworkPath,
std::vector<BT<std::string>>& linkPath)
{
cmComputeLinkInformation& cli = *pcli;
std::string linkLanguage = cli.GetLinkLan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r13
movq %r8, 0x100(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x100(%rsi), %rsi
movq 0x108(%r14), %rdx
addq %rsi, %rdx
lea... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::AppendDefines(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>>>>&, std::__cxx... | void cmLocalGenerator::AppendDefines(std::set<std::string>& defines,
std::string const& defines_list) const
{
std::set<BT<std::string>> tmp;
this->AppendDefines(tmp, cmExpandListWithBacktrace(defines_list));
for (BT<std::string> const& i : tmp) {
defines.emplace(i.Value);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r13
movl $0x0, (%r13)
xorl %eax, %eax
movq %rax, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
movq %rax, 0x20(%r13)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGeneratorCheckObjectName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, unsigned long) | bool cmLocalGeneratorCheckObjectName(std::string& objName,
std::string::size_type dir_len,
std::string::size_type max_total_len)
{
// Enforce the maximum file name length if possible.
std::string::size_type max_obj_len = max_total_len;
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
subq %rsi, %rdx
jbe 0x18b40e
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movb $0x1, %bpl
subq %rdx, %rbx
jbe 0x18b4fe
addq $0x20, %rbx
movq %r14, %rdi
movl $0x2f, %esi
movq %rbx, %rdx
callq 0x41920
cmpq $-0x1, %rax
je 0x18b3f2
movq %rax, %r15
jmp 0x18b415
movq %r14,... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::GetTargetDirectory[abi:cxx11](cmGeneratorTarget const*) const | std::string cmLocalGenerator::GetTargetDirectory(
const cmGeneratorTarget* /*unused*/) const
{
cmSystemTools::Error("GetTargetDirectory"
" called on cmLocalGenerator");
return "";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4cc43e(%rip), %rsi # 0x6588a0
leaq 0x4cc464(%rip), %rdx # 0x6588cd
movq %rsp, %r14
movq %r14, %rdi
callq 0x5c768
movq %r14, %rdi
callq 0x1e3a78
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18c492
movq 0... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::CheckDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmLocalGenerator::CheckDefinition(std::string const& define) const
{
// Many compilers do not support -DNAME(arg)=sdf so we disable it.
std::string::size_type pos = define.find_first_of("(=");
if (pos != std::string::npos) {
if (define[pos] == '(') {
std::ostringstream e;
/* clang-format off ... | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %rbx
leaq 0x4cc2be(%rip), %rsi # 0x6588ec
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3f560
cmpq $-0x1, %rax
je 0x18c70f
movq (%rbx), %rcx
cmpb $0x28, (%rcx,%rax)
jne 0x18c70f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x41390
l... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmLocalGenerator::CreateUtilityOutput(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&,... | std::string cmLocalGenerator::CreateUtilityOutput(
std::string const& targetName, std::vector<std::string> const&,
cmListFileBacktrace const&)
{
std::string force =
cmStrCat(this->GetCurrentBinaryDirectory(), "/CMakeFiles/", targetName);
// The output is not actually created so mark it symbolic.
if (cmSou... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1e1a36
movq %r12, %rdi
callq 0x1dd58c
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rax, (%r12)
movq %rcx, 0x8(%r12)
movq $0xc, 0x10(%r12)
leaq 0x4fcc9... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
(anonymous namespace)::CreateGeneratedSource(cmLocalGenerator&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmLocalGenerator::OutputRole, cmCommandOrigin, cmListFileBacktrace const&) | void CreateGeneratedSource(cmLocalGenerator& lg, const std::string& output,
cmLocalGenerator::OutputRole role,
cmCommandOrigin origin,
const cmListFileBacktrace& lfbt)
{
if (cmGeneratorExpression::Find(output) != std::string::npos) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %r8, %rbx
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x393df6
cmpq $-0x1, %rax
je 0x18e5b0
movq 0x88(%r15), %rax
movq 0x78(%rax), %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4caa71(%rip)... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommandGenerator&&) | cmCustomCommandGenerator(cmCustomCommandGenerator&&) = default; | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rsi), %rdx
leaq 0x18(%rsi), %rax
cmpq %rax, %rdx
je 0x195593
movq %rdx, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
jmp 0x195599
movups (%rax), %xmm0
movups %xm... | /JKorbelRA[P]CMake/Source/cmCustomCommandGenerator.h |
cmRulePlaceholderExpander::ExpandVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmRulePlaceholderExpander::ExpandVariable(
std::string const& variable)
{
if (this->ReplaceValues->LinkFlags) {
if (variable == "LINK_FLAGS") {
return this->ReplaceValues->LinkFlags;
}
}
if (this->ReplaceValues->Manifests) {
if (variable == "MANIFESTS") {
return this->Replace... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xd0(%rsi), %rcx
cmpq $0x0, 0xc0(%rcx)
je 0x195c60
leaq 0x4ec78d(%rip), %rsi # 0x6823d6
movq %r15, %rdi
callq 0x411b0
movq 0xd0(%r14), %rcx
testl %eax, %eax
je 0x1962db
cmpq $0x0, 0... | /JKorbelRA[P]CMake/Source/cmRulePlaceholderExpander.cxx |
cmMakefile::GetCurrentLogLevel() const | cmake* cmMakefile::GetCMakeInstance() const
{
return this->GlobalGenerator->GetCMakeInstance();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x2c8(%rdi), %rax
movq 0x78(%rax), %rax
movl 0x810(%rax), %ebx
testl %ebx, %ebx
je 0x1980a9
cmpb $0x0, 0x814(%rax)
jne 0x19809a
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4c1824(%rip), %rsi # 0x65986c
leaq 0x4c1834(... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::GetCustomCommandTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmObjectLibraryCommands, cmListFileBacktrace const&) const | cmTarget* cmMakefile::GetCustomCommandTarget(
const std::string& target, cmObjectLibraryCommands objLibCommands,
const cmListFileBacktrace& lfbt) const
{
// Find the target to which to add the custom command.
auto ti = this->Targets.find(target);
if (ti == this->Targets.end()) {
MessageType messageType =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
addq $0x80, %rdi
callq 0x1ae9e6
testq %rax, %rax
je 0x19c972
movq %rax, %r12
addq $0x28, %r12
testl %ebp, %ebp
jne 0x19c8e7
movq %r12, %rdi
callq 0x1f3d38
cmp... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::AppendCustomCommandToOutput(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... | void cmMakefile::AppendCustomCommandToOutput(
const std::string& output, const std::vector<std::string>& depends,
const cmImplicitDependsList& implicit_depends,
const cmCustomCommandLines& commandLines)
{
// Validate custom commands.
if (this->ValidateCustomCommand(commandLines)) {
// Dispatch command cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r8, %rsi
callq 0x19c6b4
testb %al, %al
je 0x19da5f
leaq 0x28(%rsp), %rdi
movq %r12, -0x8(%rdi)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r15),... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::AddNewUtilityTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | cmTarget* cmMakefile::AddNewUtilityTarget(const std::string& utilityName,
bool excludeFromAll)
{
cmTarget* target = this->AddNewTarget(cmStateEnums::UTILITY, utilityName);
if (excludeFromAll) {
target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
}
return target;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movl $0x5, %edx
xorl %ecx, %ecx
callq 0x1a2434
movq %rax, %rbx
testl %ebp, %ebp
je 0x19ddb8
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b7bc1(%rip), %rsi # 0x65593c
leaq 0x4b7bca(%rip), %rdx # 0x65594c
leaq 0x8(%rsp), %r14
movq ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::RemoveDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmMakefile::RemoveDefinition(const std::string& name)
{
this->StateSnapshot.RemoveDefinition(name);
#ifndef CMAKE_BOOTSTRAP
cmVariableWatch* vv = this->GetVariableWatch();
if (vv) {
vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS,
nullptr, this);
}
#endif
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x2d0, %rdi # imm = 0x2D0
callq 0x1e0a82
movq 0x2c8(%rbx), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x1a1eff
movq 0x760(%rax), %rdi
testq %rdi, %rdi
je 0x1a1eff
movq %r14, %rsi
movl $0x4, %edx
xorl %ecx, %ecx
movq %rbx, %r8
addq $0x... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::PlatformIs32Bit() const | bool cmMakefile::PlatformIs32Bit() const
{
if (cmValue plat_abi = this->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
if (*plat_abi == "ELF X32") {
return false;
}
}
if (cmValue sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
return atoi(sizeof_dptr->c_str()) == 4;
}
return fal... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b746f(%rip), %rsi # 0x65a6c7
leaq 0x4b7483(%rip), %rdx # 0x65a6e2
movq %rsp, %rdi
callq 0x5c768
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x198628
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::IsDefinitionSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmMakefile::IsDefinitionSet(const std::string& name) const
{
cmValue def = this->StateSnapshot.GetDefinition(name);
if (!def) {
def = this->GetState()->GetInitializedCacheValue(name);
}
#ifndef CMAKE_BOOTSTRAP
if (cmVariableWatch* vv = this->GetVariableWatch()) {
if (!def) {
vv->VariableAcces... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x2d0, %rdi # imm = 0x2D0
callq 0x1e0952
movq %rax, %r15
testq %rax, %rax
jne 0x1a3ba0
movq 0x2c8(%rbx), %rax
movq 0x78(%rax), %rax
movq 0x770(%rax), %rdi
movq %r14, %rsi
callq 0x1d5b6a
movq %rax, %r15
movq 0x2c8(%rbx), %... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::DeferCall(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmListFileFunction) | bool cmMakefile::CheckCMP0037(std::string const& targetName,
cmStateEnums::TargetType targetType) const
{
MessageType messageType = MessageType::AUTHOR_WARNING;
std::ostringstream e;
bool issueMessage = false;
switch (this->GetPolicyStatus(cmPolicies::CMP0037)) {
case cmPolicie... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x300(%rdi), %rbx
testq %rbx, %rbx
je 0x1a5755
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rax
cmpq %rax, %rdi
je 0x1a56a2
movq %rdi, (%rsp)
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
jmp 0x1a56a9
movups (%rax), %xmm0
movups %xmm0,... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::DeferGetCallIds[abi:cxx11]() const | cm::optional<std::string> cmMakefile::DeferGetCallIds() const
{
cm::optional<std::string> ids;
if (this->Defer) {
ids = cmJoin(
cmMakeRange(this->Defer->Commands)
.filter([](DeferCommand const& dc) -> bool { return !dc.Id.empty(); })
.transform(
[](DeferCommand const& dc) -> std:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movb $0x0, 0x20(%rdi)
movq 0x300(%rsi), %rax
testq %rax, %rax
je 0x1a58f6
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x1a5827
cmpq $0x0, 0x8(%r13)
jne 0x1a5827
addq $0x50, %r13
jmp... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::ListFileScope::ListFileScope(cmMakefile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ListFileScope(cmMakefile* mf, std::string const& filenametoread)
: Makefile(mf)
{
this->Makefile->Backtrace = this->Makefile->Backtrace.Push(
cmListFileContext::FromListFilePath(filenametoread));
this->Makefile->StateSnapshot =
this->Makefile->GetState()->CreateInlineListFileSnapshot(
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movb $0x1, 0x8(%rdi)
addq $0x2e8, %r15 # imm = 0x2E8
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x1abc96
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1741... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefileProfilingData::StartEntry(cmListFileFunction const&, cmListFileContext const&) | void cmMakefileProfilingData::StartEntry(const cmListFileFunction& lff,
cmListFileContext const& lfc)
{
cm::optional<Json::Value> argsValue(cm::in_place, Json::objectValue);
if (!lff.Arguments().empty()) {
std::string args;
for (auto const& a : lff.Arguments()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x98(%rsp)
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
movl $0x7, %esi
callq 0x502710
movb $0x1, 0x28(%r12)
movq %rbx, 0x90(%rsp)
movq (%rbx), %rax
movq 0x50(%rax), %r14
movq... | /JKorbelRA[P]CMake/Source/cmMakefileProfilingData.cxx |
cmMakefileProfilingData::RAII::operator=(cmMakefileProfilingData::RAII&&) | cmMakefileProfilingData::RAII& cmMakefileProfilingData::RAII::operator=(
RAII&& other) noexcept
{
if (this->Data) {
this->Data->StopEntry();
}
this->Data = other.Data;
other.Data = nullptr;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1b2f9f
callq 0x1b2c90
movq (%r14), %rax
movq %rax, (%rbx)
movq $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5c5e1
nop
| /JKorbelRA[P]CMake/Source/cmMakefileProfilingData.cxx |
cmOutputConverter::ComputeRelativePathTopSource() | void cmOutputConverter::ComputeRelativePathTopSource()
{
// Walk up the buildsystem directory tree to find the highest source
// directory that contains the current source directory.
cmStateSnapshot snapshot = this->StateSnapshot;
for (cmStateSnapshot parent = snapshot.GetBuildsystemDirectoryParent();
pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x20(%rsp), %rsi
movq %rax, 0x10(%rsi)
movups (%rdi), %xmm0
movaps %xmm0, (%rsi)
movq %rsp, %r14
movq %r14, %rdi
callq 0x1e0310
movq %r14, %rdi
callq 0x1e0298
testb %al, %al
je 0x1b39f7
leaq 0x3... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmOutputConverter::ConvertToOutputFormat[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>, cmOutputConverter::OutputFormat) const | std::string cmOutputConverter::ConvertToOutputFormat(cm::string_view source,
OutputFormat output) const
{
std::string result(source);
// Convert it to an output path.
if (output == SHELL || output == WATCOMQUOTE || output == NINJAMULTI) {
result = this->Con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
addq %rcx, %rdx
movq %rcx, %rsi
callq 0x5c768
cmpl $0x2, %ebp
ja 0x1b3e6d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmOutputConverter::EscapeForShell[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>, bool, bool, bool, bool, bool) const | std::string cmOutputConverter::EscapeForShell(cm::string_view str,
bool makeVars, bool forEcho,
bool useWatcomQuote,
bool unescapeNinjaConfiguration,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %ebp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movb 0x6aeb8d(%rip), %al # 0x862b68
testb %al, %al
je 0x1b4124
leaq 0x6aeb4e(%rip), %rdi #... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmOutputConverter::Shell_CharNeedsQuotes(char, int) | bool cmOutputConverter::Shell_CharNeedsQuotes(char c, int flags)
{
/* On Windows the built-in command shell echo never needs quotes. */
if (!(flags & Shell_Flag_IsUnix) && (flags & Shell_Flag_EchoWindows)) {
return false;
}
/* On all platforms quotes are needed to preserve whitespace. */
if (Shell_Char... | movl %esi, %eax
andl $0x104, %eax # imm = 0x104
cmpl $0x4, %eax
jne 0x1b46ef
xorl %eax, %eax
retq
movsbl %dil, %ecx
movb $0x1, %al
cmpl $0x9, %ecx
je 0x1b4732
cmpl $0x20, %ecx
je 0x1b4732
movl %esi, %edx
shrl $0xa, %edx
andl $0x1, %edx
cmpb $0x2d, %dil
sete %dil
testb %dl, %dil
jne 0x1b4732
leal -0x23(%rcx),... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmOutputConverter::Shell_ArgumentNeedsQuotes(std::basic_string_view<char, std::char_traits<char>>, int) | bool cmOutputConverter::Shell_ArgumentNeedsQuotes(cm::string_view in,
int flags)
{
/* The empty string needs quotes. */
if (in.empty()) {
return true;
}
/* Scan the string for characters that require quoting. */
for (cm::string_view::iterator cit = in.b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
testq %rdi, %rdi
je 0x1b486c
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq (%rsi,%rdi), %r12
movq %rsi, %r13
testb $0x40, %bpl
je 0x1b47fc
movq %r13, %rdi
movq %r12, %rsi
callq 0x1b4754
movq %rax, %r13
cmpq %r12, %rax
je ... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmPolicies::GetPolicyDeprecatedWarning[abi:cxx11](cmPolicies::PolicyID) | std::string cmPolicies::GetPolicyDeprecatedWarning(cmPolicies::PolicyID id)
{
std::ostringstream msg;
/* clang-format off */
msg <<
"The OLD behavior for policy " << idToString(id) << " "
"will be removed from a future version of CMake.\n"
"The cmake-policies(7) manual explains that the OLD behaviors ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41390
leaq 0x4a5e37(%rip), %rsi # 0x65c125
movl $0x1c, %edx
movq %r14, %rdi
callq 0x41490
movl %ebp, %edi
callq 0x1b6014
testq %rax, %rax
je 0x1b6324
movq %rax, %r1... | /JKorbelRA[P]CMake/Source/cmPolicies.cxx |
cmProcessOutput::cmProcessOutput(cmProcessOutput::Encoding, unsigned int) | cmProcessOutput::cmProcessOutput(Encoding encoding, unsigned int maxSize)
{
#if defined(_WIN32)
codepage = 0;
bufferSize = maxSize;
if (encoding == None) {
codepage = defaultCodepage;
} else if (encoding == Auto) {
codepage = GetConsoleCP();
} else if (encoding == UTF8) {
codepage = CP_UTF8;
} e... | retq
nop
| /JKorbelRA[P]CMake/Source/cmProcessOutput.cxx |
cmProcessOutput::DecodeText(char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long) | bool cmProcessOutput::DecodeText(const char* data, size_t length,
std::string& decoded, size_t id)
{
return this->DecodeText(std::string(data, length), decoded, id);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5c768
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41cc0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1b6a2b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3f310
movb $0x1... | /JKorbelRA[P]CMake/Source/cmProcessOutput.cxx |
cmProcessTools::RunProcess(cmsysProcess_s*, cmProcessTools::OutputParser*, cmProcessTools::OutputParser*, cmProcessOutput::Encoding) | void cmProcessTools::RunProcess(struct cmsysProcess_s* cp, OutputParser* out,
OutputParser* err, Encoding encoding)
{
cmsysProcess_Execute(cp);
char* data = nullptr;
int length = 0;
int p;
cmProcessOutput processOutput(encoding);
std::string strdata;
while ((out || err) &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x47fba8
xorl %r12d, %r12d
movq %r12, 0x30(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0xb(%rsp), %rdi
movl %ebp, %esi
movl $0x400, %edx # imm = 0x400
callq 0x1b69d8
le... | /JKorbelRA[P]CMake/Source/cmProcessTools.cxx |
cmQtAutoGenInitializer::GetQtVersion(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::pair<cmQtAutoGen::IntegerVersion, unsigned int>
cmQtAutoGenInitializer::GetQtVersion(cmGeneratorTarget const* target,
std::string mocExecutable)
{
// Converts a char ptr to an unsigned int value
auto toUInt = [](const char* const input) -> unsigned int {
unsigned long t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %r12
movq %rdi, 0x28(%rsp)
leaq 0xd8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x49986d(%rip), %rsi # 0x65f62d
leaq 0x499876(%rip), %rdx # 0x65f63d
leaq 0xc8(%rsp), %rdi
callq 0x5c768
leaq 0x18(%r... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmRST::ProcessFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool cmRST::ProcessFile(std::string const& fname, bool isModule)
{
cmsys::ifstream fin(fname.c_str());
if (fin) {
this->DocDir = cmSystemTools::GetFilenamePath(fname);
if (isModule) {
this->ProcessModule(fin);
} else {
this->ProcessRST(fin);
}
this->OutputLinePending = true;
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x3f100
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x40(%rsp,%rax), %r15d
testb $0x5, %r15b
jne 0x1cb328... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ProcessRST(std::istream&) | void cmRST::ProcessRST(std::istream& is)
{
std::string line;
while (cmSystemTools::GetLineFromStream(is, line)) {
this->ProcessLine(line);
}
this->Reset();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq $-0x1, %rcx
callq 0x489406
testb %al, %al
je 0x1cb875
movq %rbx, %rd... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ProcessInclude(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmRST::IncludeType) | bool cmRST::ProcessInclude(std::string file, IncludeType type)
{
bool found = false;
if (this->IncludeDepth < 10) {
cmRST r(this->OS, this->DocRoot);
r.IncludeDepth = this->IncludeDepth + 1;
r.OutputLinePending = this->OutputLinePending;
if (type != IncludeTocTree) {
r.Replace = this->Replace;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe58, %rsp # imm = 0xE58
cmpl $0x9, 0x28(%rdi)
jg 0x1cc5c1
movq %rdi, %rbx
movq %rsi, %r14
movl %edx, %ebp
movq (%rdi), %r12
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmScriptGenerator::~cmScriptGenerator() | cmScriptGenerator::~cmScriptGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x681343(%rip), %rax # 0x84ea70
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x1cd748
movq (%rax), %rsi
incq %rsi
callq 0x3f310
leaq 0x28(%rbx), %rdi
callq 0x5c554
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x1cd76a
movq (%rbx), %rsi
i... | /JKorbelRA[P]CMake/Source/cmScriptGenerator.cxx |
cmScriptGenerator::CreateConfigTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmScriptGenerator::CreateConfigTest(const std::string& config)
{
std::string result = cmStrCat(this->RuntimeConfigVariable, " MATCHES \"^(");
if (!config.empty()) {
cmScriptGeneratorEncodeConfig(config, result);
}
result += ")$\"";
return result;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq $0xc, 0x10(%rsi)
leaq 0x492227(%rip), %rax # 0x65fa1d
movq %rax, 0x18(%rsi)
movl $0x2, %edx
callq 0x1e311c
cmpq $0x0, 0x8(%r14)
je 0x1cd81... | /JKorbelRA[P]CMake/Source/cmScriptGenerator.cxx |
cmLinkedTree<cmStateDetail::PolicyStackEntry>::Pop(cmLinkedTree<cmStateDetail::PolicyStackEntry>::iterator) | iterator Pop(iterator it)
{
assert(!this->Data.empty());
assert(this->UpPositions.size() == this->Data.size());
bool const isLast = this->IsLast(it);
++it;
// If this is the last entry then no other entry can refer
// to it so we can drop its storage.
if (isLast) {
this->Data.pop_bac... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x1e21c8
movq %rdi, %rbx
movq 0x20(%rdi), %r15
subq 0x18(%rdi), %r15
sarq $0x3, %r15
subq %rcx, %rax
sarq $0x6, %rax
cmpq %rax, %r15
jne 0x1e21e7
movq %rdx, %r14
movq %rsp, ... | /JKorbelRA[P]CMake/Source/cmLinkedTree.h |
cmLinkedTree<cmDefinitions>::iterator::operator*() | ReferenceType operator*()
{
assert(this->Tree);
assert(this->Tree->UpPositions.size() == this->Tree->Data.size());
assert(this->Position <= this->Tree->Data.size());
assert(this->Position > 0);
return this->Tree->GetReference(this->Position - 1);
} | pushq %rax
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x1e2441
movq 0x20(%rdx), %rcx
subq 0x18(%rdx), %rcx
sarq $0x3, %rcx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rsi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rsi
cmpq %rsi, %rcx
jne 0x1e2460
movq 0x8(%rdi), %rdx
cmp... | /JKorbelRA[P]CMake/Source/cmLinkedTree.h |
cmRemoveQuotes[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | std::string cmRemoveQuotes(cm::string_view str)
{
// We process only strings that have two quotes at least.
// Also front() and back() are only defined behavior on non empty strings.
if (str.size() >= 2 && //
str.front() == '"' && //
str.back() == '"') {
// Remove a quote from the front and bac... | pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
cmpq $0x2, %rsi
jb 0x1e2a99
cmpb $0x22, (%rax)
jne 0x1e2a99
cmpb $0x22, -0x1(%rax,%rdx)
jne 0x1e2a99
incq %rax
addq $-0x2, %rdx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5c768
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmStringAlgorithms.cxx |
cmStrToULongLong(char const*, unsigned long long*) | bool cmStrToULongLong(const char* str, unsigned long long* value)
{
errno = 0;
char* endp;
while (cmIsSpace(*str)) {
++str;
}
if (*str == '-') {
return false;
}
*value = strtoull(str, &endp, 10);
return (*endp == '\0') && (endp != str) && (errno == 0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x415e0
movq %rax, %rbx
movl $0x0, (%rax)
movsbl (%r15), %ebp
testl %ebp, %ebp
js 0x1e335d
movl %ebp, %edi
callq 0x40b80
testl %eax, %eax
je 0x1e335d
incq %r15
movq %r15, %rcx
movq %rcx, %r15
movsbl (%rcx), %eb... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoinImpl<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::string cmJoinImpl(Range const& rng, cm::string_view separator,
cm::string_view initial)
{
if (rng.empty()) {
return { std::begin(initial), std::end(initial) };
}
std::string result;
result.reserve(initial.size() + getJoinedLength(rng, separator));
result.append(std::begin(init... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
je 0x1e360a
movq %rcx, %r14
movq %rdx, %r15
leaq 0x10(%rbx), %rcx
movq %rcx, (%rsp)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
mov... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.cxx |
cmake::ActualConfigure() | int cmake::ActualConfigure()
{
// Construct right now our path conversion table before it's too late:
this->UpdateConversionPathTable();
this->CleanupCommandsAndMacros();
cmSystemTools::RemoveADirectory(this->GetHomeOutputDirectory() +
"/CMakeFiles/CMakeScratch");
int res =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
callq 0x218f58
movq %rbx, %rdi
callq 0x20b8e2
movq 0x770(%rbx), %rdi
callq 0x1d7fe0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
... | /JKorbelRA[P]CMake/Source/cmake.cxx |
GetProjectCommands(cmState*) | void GetProjectCommands(cmState* state)
{
state->AddBuiltinCommand("add_compile_definitions",
cmAddCompileDefinitionsCommand);
state->AddBuiltinCommand("add_custom_command", cmAddCustomCommandCommand);
state->AddBuiltinCommand("add_custom_target", cmAddCustomTargetCommand);
state->Add... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4412a8(%rip), %rsi # 0x669e6b
leaq 0x4412b8(%rip), %rdx # 0x669e82
leaq 0x8(%rsp), %rdi
callq 0x5c768
leaq 0x203d(%rip), %rdx # 0x22ac18
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d6bfe
movq 0x8(%rsp... | /JKorbelRA[P]CMake/Source/cmCommands.cxx |
cmAddCustomTargetCommand(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 cmAddCustomTargetCommand(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();
std::string const& targetName = args[0]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r15
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x22d5a9
movq %rdi, %r13
movq (%r15), %rbx
leaq 0x4471b6(%rip), %rsi # 0x6746d0
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3f560
cmpq $-0... | /JKorbelRA[P]CMake/Source/cmAddCustomTargetCommand.cxx |
cmAddDependenciesCommand(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 cmAddDependenciesCommand(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 const& target_name = arg... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r13
subq %r15, %r13
cmpq $0x20, %r13
jbe 0x22e3b8
movq %rdi, %r14
movq (%rbx), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a9f8e
testb %al, %al
je 0x22e371
movq (%r15), %rax
movq 0x8(%r15), %rcx
... | /JKorbelRA[P]CMake/Source/cmAddDependenciesCommand.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 %r14
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
cmpq $0x20, %rax
ja 0x23b6af
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x43622a(%rip), %rsi # 0x67189c
leaq 0x43624e(%rip), %rdx # 0x6718c7
leaq 0x8(%rsp), %rdi
callq 0x5c768
addq $0x8, ... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleReplaceFilenameCommand(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 HandleReplaceFilenameCommand(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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movb 0x627f74(%rip), %al # 0x864f78
testb %al, %al
je 0x23d267
leaq 0x627edd(%rip), %rsi # 0x864ef0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x240540
movq (%r14), %rsi
movq %rbx, ... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
movb 0x6278f9(%rip), %al # 0x865098
testb %al, %al
je 0x23db13
leaq 0x627862(%rip), %r12 # 0x865010
movq 0x6278cb(%rip), %rsi # 0x865080
leaq 0x6278c4(%rip), %r15 # 0... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
(anonymous namespace)::HandleIsAbsoluteCommand(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 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cmpq $0x60, %rax
jne 0x23f3b4
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
addq $0x20, %rdi
leaq 0x28(%rsp), %... | /JKorbelRA[P]CMake/Source/cmCMakePathCommand.cxx |
cmCMakePolicyCommand(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 cmCMakePolicyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("requires at least one argument.");
return false;
}
if (args[0] == "SET") {
return HandleSetMode(args, status);
}
if (args[0] == "GET") {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
cmpq 0x8(%r14), %rdi
je 0x243064
leaq 0x49627c(%rip), %rsi # 0x6d91eb
callq 0x411b0
testl %eax, %eax
je 0x24309b
movq (%r14), %rdi
leaq 0x46270f(%rip), %rsi # 0x6a5695
callq 0x411b0
testl %eax, %eax
je 0... | /JKorbelRA[P]CMake/Source/cmCMakePolicyCommand.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rax
subq %r12, %rax
cmpq $0x40, %rax
ja 0x25ae89
leaq 0xf0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x418a5b(%rip), %rsi # 0x673898
leaq 0x418a95(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmFileCommand.cxx |
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>& cmArgumentParser<(anonymous namespace)... | cmArgumentParser& Bind(cm::static_string_view name, T Result::*member)
{
this->Base::Bind(name, [member](Instance& instance) {
instance.Bind(static_cast<Result*>(instance.Result)->*member);
});
return *this;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rcx
movq $0x0, 0x8(%rcx)
movq $0x8, (%rcx)
leaq 0x99(%rip), %rax # 0x26082c
movq %rax, 0x18(%rcx)
leaq 0xa0(%rip), %rax # 0x26083e
movq %rax, 0x10(%rcx)
callq 0xbf92c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2607be
movq %rsp, %rdi
movq %rdi, %rsi
... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
cmArgumentParser<(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&)::Arguments>& cmArgumentParser<(anonymous na... | cmArgumentParser& Bind(cm::static_string_view name, T Result::*member)
{
this->Base::Bind(name, [member](Instance& instance) {
instance.Bind(static_cast<Result*>(instance.Result)->*member);
});
return *this;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0xb1(%rip), %rcx # 0x260e02
movq %rcx, 0x18(%rax)
leaq 0xb8(%rip), %rcx # 0x260e14
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0xbf92c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x260d7f
movq %rsp, %rdi
... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
cmArgumentParser<(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&)::Arguments>& cmArgumentParser<(anonymous... | cmArgumentParser& Bind(cm::static_string_view name, T Result::*member)
{
this->Base::Bind(name, [member](Instance& instance) {
instance.Bind(static_cast<Result*>(instance.Result)->*member);
});
return *this;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x9b(%rip), %rcx # 0x261dd4
movq %rcx, 0x18(%rax)
leaq 0xa2(%rip), %rcx # 0x261de6
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0xbf92c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x261d67
movq %rsp, %rdi
... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [23], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [23], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [23], int, char [3], char const*, char [4]>(c... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r12
movq %rdi, %rbx
movq 0x120(%rsp), %rbp
movups (%rsi), %xmm0
leaq 0x38(%rsp), %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq %rcx, %rdi
callq 0x3fd60
movq %rax, 0... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmFindBase::~cmFindBase() | virtual ~cmFindBase() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x5ef241(%rip), %rax # 0x853be8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x238(%rdi), %rdi
leaq 0x248(%rbx), %rax
cmpq %rax, %rdi
je 0x2649cc
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0x210(%rbx), %rdi
leaq 0x220(%rbx), %rax
cmpq %rax, %rdi
je 0x2649ea
movq (%rax), %rsi
incq %rsi
... | /JKorbelRA[P]CMake/Source/cmFindBase.h |
cmFindLibraryHelper::AddName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmFindLibraryHelper::AddName(std::string const& name)
{
Name entry;
// Consider checking the raw name too.
entry.TryRaw = this->HasValidSuffix(name);
entry.Raw = name;
// Build a regular expression to match library names.
std::string regex = cmStrCat('^', this->PrefixRegexStr);
this->RegexFromLiter... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x38(%rsp), %r12
movb %al, -0x18(%r12)
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x48(%rsp), %r14
movq %rax, 0xb0(%r14)
movq %rax, 0xc0(%r14)
movl $0x0, 0x... | /JKorbelRA[P]CMake/Source/cmFindLibraryCommand.cxx |
cmFindLibraryCommand::FindNormalLibraryNamesPerDir[abi:cxx11]() | std::string cmFindLibraryCommand::FindNormalLibraryNamesPerDir()
{
// Search for all names in each directory.
cmFindLibraryHelper helper(this->FindCommandName, this->Makefile, this);
for (std::string const& n : this->Names) {
helper.AddName(n);
}
// Search every directory.
for (std::string const& sp : t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x188(%rsi), %rsi
movq 0x190(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x777d0
movq 0x178(%r14), %rdx
lea... | /JKorbelRA[P]CMake/Source/cmFindLibraryCommand.cxx |
cmFindPackageCommand::Sort(__gnu_cxx::__normal_iterator<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::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | void cmFindPackageCommand::Sort(std::vector<std::string>::iterator begin,
std::vector<std::string>::iterator end,
SortOrderType const order,
SortDirectionType const dir)
{
if (order == Name_order) {
if (dir == Dec) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %edx
je 0x267775
cmpl $0x1, %edx
jne 0x267875
cmpl $0x1, %ecx
jne 0x2677e2
cmpq %rbx, %r14
je 0x267875
movq %rbx, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, ... | /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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1e0(%rdi), %rax
movq 0x1e8(%rdi), %rcx
leaq 0xb0(%rsp), %r15
movq $0x4, (%r15)
leaq 0x4073dc(%rip), %rdx # 0x675403
movq %rdx, 0x8(%r15)
movq %rcx, 0x10(%r15)
movq %rax, 0x18(%r15)... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FindPrefixedConfig() | bool cmFindPackageCommand::FindPrefixedConfig()
{
std::vector<std::string> const& prefixes = this->SearchPaths;
return std::any_of(
prefixes.begin(), prefixes.end(),
[this](std::string const& p) -> bool { return this->SearchPrefix(p); });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x120(%rdi), %rbx
movq 0x128(%rdi), %r12
movq %r12, %r13
subq %rbx, %r13
movq %r13, %rbp
sarq $0x7, %rbp
testq %rbp, %rbp
jle 0x26f594
incq %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x272238
testb %al, %al
jne 0x26f5e4
le... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::FillPrefixesPackageRoot() | void cmFindPackageCommand::FillPrefixesPackageRoot()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRoot];
// Add the PACKAGE_ROOT_PATH from each enclosing find_package call.
for (auto pkgPaths = this->Makefile->FindPackageRootPathStack.rbegin();
pkgPaths != this->Makefile->FindPackageRootPa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r13
addq $0xf0, %rdi
leaq 0x5f964d(%rip), %rsi # 0x869150
callq 0x2769a4
movq %rax, %r14
movq 0x170(%r13), %rax
movq 0x30(%rax), %r12
cmpq 0x10(%rax), %r12
je 0x26fb8b
movq 0x38(%rax), %rbp
movq 0x48(%rax), %rax
movq %rax,... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
addq $0xf0, %rdi
leaq 0x5f9285(%rip), %rsi # 0x8691a0
callq 0x2769a4
movq %rax, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x200(%rbx), %rsi
movq %rax, %rdi
callq 0x2... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindPackageCommand::CheckVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFindPackageCommand::CheckVersion(std::string const& config_file)
{
bool result = false; // by default, assume the version is not ok.
bool haveResult = false;
std::string version = "unknown";
// Get the filename without the .cmake extension.
std::string::size_type pos = config_file.rfind('.');
std::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4389a0(%rip), %rsi # 0x6aa053
leaq 0x4389a0(%rip), %rdx # 0x6aa05a
leaq 0x48(%rsp), %rdi
callq 0x5c768
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1,... | /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&>(cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<cha... | 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x78040
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x275c6e
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x78040
movq 0x10(%r14), %rax
movq %rax, 0x28(%r14)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x50(%rsp)
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x78040
movq 0x10(%r12), %rax
movq %rax, 0x28(%r12)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, 0... | /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)::cmAppendPath... | 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, 0x10(%rsp)
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x78040
movq 0x10(%r12), %rax
movq %rax, 0x28(%r12)
leaq 0x18(%rsp), %r13
movq %r13, %r... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
(anonymous namespace)::cmFileListGeneratorGlob::GetNextCandidate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string GetNextCandidate(const std::string& parent)
{
if (this->Files.empty()) {
// Glob the set of matching files.
std::string expr = cmStrCat(parent, this->Pattern);
cmsys::Glob g;
if (!g.FindFiles(expr)) {
return {};
}
this->Files = g.GetFiles();
this->Curr... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x2761ee
movups (%r14), %xmm0
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movq %rdx, 0x8(%rsi)
movups %xmm0, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x1e311c
leaq 0x28(%rsp), %rdi
... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmFindProgramCommand::FindAppBundle[abi:cxx11]() | std::string cmFindProgramCommand::FindAppBundle()
{
for (std::string const& name : this->Names) {
std::string appName = name + std::string(".app");
std::string appPath =
cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
if (!appPath.empty()) {
std::string executable = this->Get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x1f0(%rsi), %rbx
movq 0x1f8(%rsi), %r12
cmpq %r12, %rbx
je 0x27ae19
movq %rsi, %r14
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rbp
addq $0x128, %r14 # imm = 0x128
leaq 0x20(%rsp), %r13
movq %r15, 0x20(... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::GetBundleExecutable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmFindProgramCommand::GetBundleExecutable(
std::string const& bundlePath)
{
std::string executable;
(void)bundlePath;
#if defined(__APPLE__)
// Started with an example on developer.apple.com about finding bundles
// and modified from that.
// Get a CFString of the app bundle path
// XXX - Is ... | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
retq
| /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::~cmFindProgramHelper() | cmFindProgramHelper(std::string debugName, cmMakefile* makefile,
cmFindBase const* base)
: DebugSearches(std::move(debugName), base)
, Makefile(makefile)
, FindBase(base)
, PolicyCMP0109(makefile->GetPolicyStatus(cmPolicies::CMP0109))
{
#if defined(_WIN32) || defined(__CYGWIN__) ... | pushq %rbx
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x437048
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x27b567
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x27b57f
movq (%rax), %rsi
incq %rsi
callq 0x3f310
leaq 0x38(%rbx), %rdi
callq 0x5c5... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmBlockCommand(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 cmBlockCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
struct Arguments : public ArgumentParser::ParseResult
{
cm::optional<ArgumentParser::NonEmpty<std::vector<std::string>>> ScopeFor;
ArgumentParser::MaybeEmpty<std::vector<std::string>> Propagate;
};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbx
movq %rdi, %r14
movb 0x5e782b(%rip), %al # 0x865c70
testb %al, %al
je 0x27e8ec
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
leaq 0xd8(%r... | /JKorbelRA[P]CMake/Source/cmBlockCommand.cxx |
cmArgumentParser<cmBlockCommand(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>& cmArgumentParser<cmBlockCommand(std::vector<std::__cxx11::b... | cmArgumentParser& Bind(cm::static_string_view name, T Result::*member)
{
this->Base::Bind(name, [member](Instance& instance) {
instance.Bind(static_cast<Result*>(instance.Result)->*member);
});
return *this;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rcx
movq $0x0, 0x8(%rcx)
movq $0x30, (%rcx)
leaq 0x10d(%rip), %rax # 0x27ebe2
movq %rax, 0x18(%rcx)
leaq 0x132(%rip), %rax # 0x27ec12
movq %rax, 0x10(%rcx)
callq 0xbf92c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x27eb00
movq %rsp, %rdi
movq %rdi, %rsi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
(anonymous namespace)::cmBlockFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmBlockFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
cmExecutionStatus& inStatus)
{
auto& mf = inStatus.GetMakefile();
// Invoke all the functions that were collected in the block.
for (cmListFileFunction const& fn : functions) {
cmExecutionStatus... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0x8(%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %r13
cmpq %r13, %r15
je 0x27ef03
movq 0x8(%rsp), %rax
movq (%rax), %r12
leaq 0x50(%rsp), %r14
leaq 0x68(%rsp), %rbx
movq %r12, 0x38(%rsp)
movq %r14, 0x40(%rsp)
movabsq $0x2e726f72726... | /JKorbelRA[P]CMake/Source/cmBlockCommand.cxx |
cmGetCMakePropertyCommand(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 cmGetCMakePropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
std::string const& variable = args[0];
std::string output = "NOTFOUND";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r13
subq %r14, %r13
leaq 0x18(%rsp), %r12
cmpq $0x20, %r13
jbe 0x280785
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x3d3f4f(%rip), %rsi # 0x654637
leaq 0x3d3f50(%rip)... | /JKorbelRA[P]CMake/Source/cmGetCMakePropertyCommand.cxx |
(anonymous namespace)::HandleFilesMode(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 HandleFilesMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
Helper helper(status);
// This is the FILES mode.
bool programs = (args[0] == "PROGRAMS");
cmInstallCommandArguments ica(helper.DefaultComponentName);
ArgumentParser::MaybeEmpty<std::vector<std::strin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq %rdi, %r14
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
movq %rsi, 0x28(%rsp)
callq 0x292714
movq (%r14), %rdi
leaq 0x3e9575(%rip), %r15 # 0x6779db
movq %r15, %rsi
callq 0x411b0
movl %eax, 0x3c(%rsp)
leaq 0xe0(... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::GetCxxModulesBmiDestination[abi:cxx11](cmInstallCommandArguments const*) const | std::string Helper::GetCxxModulesBmiDestination(
const cmInstallCommandArguments* args) const
{
if (args) {
return args->GetDestination();
}
return {};
} | pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x293e73
movq %rsi, %rdi
callq 0x2999c2
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x777d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [24]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [24]) | 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 |
cmInstallRuntimeDependencySet::AddModule(cmInstallTargetGenerator*) | void AddModule(cmInstallTargetGenerator* module)
{
this->AddModule(cm::make_unique<TargetItem>(module));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x3f450
leaq 0x5b7039(%rip), %rcx # 0x84d660
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x16ed3e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x29664f
movq (%rdi), %ra... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySet.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.