name string | code string | asm string | file string |
|---|---|---|---|
cmGeneratorTarget::UsesDefaultOutputDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | const std::string& Evaluate(cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& /*lang*/) const override
{
std::map<std::strin... | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rcx
callq 0x2f412e
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2f4101
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x39320
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %... | /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 0xa3ab8
movq (%r14), %r14
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
cal... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::IsCSharpOnly() const | bool cmGeneratorTarget::IsCSharpOnly() const
{
// Only certain target types may compile CSharp.
if (this->GetType() != cmStateEnums::SHARED_LIBRARY &&
this->GetType() != cmStateEnums::STATIC_LIBRARY &&
this->GetType() != cmStateEnums::EXECUTABLE) {
return false;
}
std::set<std::string> languages... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xfdc48
cmpl $0x2, %eax
je 0x2f7c87
movq (%rbx), %rdi
callq 0xfdc48
cmpl $0x1, %eax
je 0x2f7c87
movq (%rbx), %rdi
callq 0xfdc48
testl %eax, %eax
je 0x2f7c87
xorl %ebx, %ebx
jmp 0x2f7d68
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d49da
le... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::HasPackageReferences() const | bool cmGeneratorTarget::HasPackageReferences() const
{
return this->IsInBuildSystem() &&
!this->GetProperty("VS_PACKAGE_REFERENCES")->empty();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2d4a78
testb %al, %al
je 0x2f7f4e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2e411e(%rip), %rsi # 0x5dc023
leaq 0x2e412c(%rip), %rdx # 0x5dc038
movq %rsp, %r14
movq %r14, %rdi
callq 0x5b4c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmTargetCollectLinkLanguages::Visit(cmLinkItem const&) | void Visit(cmLinkItem const& item)
{
if (!item.Target) {
return;
}
if (!this->Visited.insert(item.Target).second) {
return;
}
cmLinkInterface const* iface = item.Target->GetLinkInterface(
this->Config, this->HeadTarget, this->SecondPass);
if (!iface) {
return;
}
... | cmpq $0x0, 0x20(%rsi)
je 0x2fbdf6
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %r14
addq $0x30, %rdi
movq %r14, %rsi
callq 0x97b76
testb $0x1, %dl
je 0x2fbde9
movq (%r14), %rdi
movq 0x28(%rbx), %rdx
movzbl 0x60(%rbx), %ecx
movq %rbx, %rsi
callq 0x2f... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmTargetSelectLinker::Choose[abi:cxx11]() | std::string Choose()
{
if (this->Preferred.empty()) {
return "";
}
if (this->Preferred.size() > 1) {
std::ostringstream e;
e << "Target " << this->Target->GetName()
<< " contains multiple languages with the highest linker preference"
<< " (" << this->Preference << "):\n";... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rax
cmpq $0x1, %rax
je 0x2fc01c
testq %rax, %rax
jne 0x2fbe88
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x311011(%rip), %rdx # 0x60ce89
movq %rbx, %rdi
mov... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
bool checkInterfacePropertyCompatibility<bool>(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, CompatibleType, bool*) | PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
const std::string& p,
const std::string& config,
const char* defaultValue,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movl %r8d, 0xc(%rsp)
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x18(%rsp)
movq (%rdi), %rdi
callq 0xfe084
movl %eax, 0x8(%rsp)
movq (%r14), %rdi
callq 0x1036ae
leaq 0x260(%rsp), ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
char const* checkInterfacePropertyCompatibility<char const*>(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, CompatibleType, char const**) | PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
const std::string& p,
const std::string& config,
const char* defaultValue,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movl %r8d, 0x4c(%rsp)
movq %rcx, 0xb0(%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movq %rdi, 0x18(%rsp)
callq 0x2d0626
testq %rax, %rax
je 0x2ff679
movq (%rax), %r15
jmp 0x2ff67c
xorl %r15d, %r15d
movq... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
TargetPropertyEntryString::GetBacktrace() const | cmListFileBacktrace GetBacktrace() const override
{
return this->PropertyValue.Backtrace;
} | movq %rdi, %rax
movq 0x30(%rsi), %rcx
movq %rcx, (%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x301ee5
movq 0x484080(%rip), %rdx # 0x785f58
cmpb $0x0, (%rdx)
je 0x301ee1
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
TargetPropertyEntryFileSet::Evaluate(cmLocalGenerator*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget const*, cmGeneratorExpressionDAGChecker*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const std::string& Evaluate(cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& /*lang*/) const override
{
std::map<std::strin... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movq %rsi, %r8
leaq 0x48(%rsp), %r15
movl $0x0, (%r15)
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rcx, 0x20(%r15)
movq 0x38(%rdi), %r11
leaq 0x10(%rdi), %rsi
leaq 0x30(%rdi), %rcx
... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGlobalGenerator::cmGlobalGenerator(cmake*) | cmGlobalGenerator::cmGlobalGenerator(cmake* cm)
: CMakeInstance(cm)
{
// By default the .SYMBOLIC dependency is not needed on symbolic rules.
this->NeedSymbolicMark = false;
// by default use the native paths
this->ForceUnixPaths = false;
// By default do not try to support color.
this->ToolSupportsColo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x46d5ba(%rip), %rax # 0x77b170
movq %rax, (%rdi)
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x48(%rdi), %rbp
movq %rbp, 0x38(%rdi)
... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GenerateImportFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmGlobalGenerator::GenerateImportFile(const std::string& file)
{
auto const it = this->BuildExportSets.find(file);
if (it != this->BuildExportSets.end()) {
bool result = it->second->GenerateImportFile();
if (!this->ConfigureDoneCMP0026AndCMP0024) {
for (const auto& m : this->Makefiles) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x148(%rdi), %rbx
movq %rbx, %rdi
callq 0x321176
movq %rax, %r14
leaq 0x150(%r15), %rax
cmpq %rax, %r14
je 0x30f5ff
movq 0x40(%r14), %rdi
callq 0x28c5b2
movl %eax, %ebp
cmpb $0x0, 0x6e9(%r15)
je 0x30f60c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::CreateLocalGenerators() | void cmGlobalGenerator::CreateLocalGenerators()
{
this->LocalGeneratorSearchIndex.clear();
this->LocalGenerators.clear();
this->LocalGenerators.reserve(this->Makefiles.size());
for (const auto& m : this->Makefiles) {
auto lg = this->CreateLocalGenerator(m.get());
this->IndexLocalGenerator(lg.get());
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x280, %rdi # imm = 0x280
callq 0x320458
leaq 0x98(%rbx), %r14
movq 0x98(%rbx), %r15
movq 0xa0(%rbx), %r12
cmpq %r15, %r12
je 0x315426
movq %r15, %r13
movq (%r13), %rdi
testq %rdi, %rdi
je 0x31540e
movq (%rdi), %rax... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::Configure() | void cmGlobalGenerator::Configure()
{
this->FirstTimeProgress = 0.0f;
this->ClearGeneratorMembers();
this->NextDeferId = 0;
cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
snapshot.GetDirectory().SetCurrentSource(
this->CMakeInstance->GetHomeDirectory());
snapshot.GetDirectory().... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %rbx
movl $0x0, 0x6e0(%rdi)
callq 0x30e720
movq $0x0, 0x470(%rbx)
movq 0x78(%rbx), %rax
movq 0x788(%rax), %rcx
leaq 0x1e0(%rsp), %r15
movq %rcx, 0x10(%r15)
movups 0x778(%rax), %xmm0
movaps %xmm0, (%r1... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::CreateDefaultGlobalTargets(std::vector<cmGlobalGenerator::GlobalTargetInfo, std::allocator<cmGlobalGenerator::GlobalTargetInfo>>&) | void cmGlobalGenerator::CreateDefaultGlobalTargets(
std::vector<GlobalTargetInfo>& targets)
{
this->AddGlobalTarget_Package(targets);
this->AddGlobalTarget_PackageSource(targets);
this->AddGlobalTarget_Test(targets);
this->AddGlobalTarget_EditCache(targets);
this->AddGlobalTarget_RebuildCache(targets);
th... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x31b77a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31bd1c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c0e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c616
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c9d6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile*, 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::vector<cmGeneratorTarget const*, std::allocator<cmGener... | void cmGlobalGenerator::CreateImportedGenerationObjects(
cmMakefile* mf, const std::vector<std::string>& targets,
std::vector<const cmGeneratorTarget*>& exports)
{
this->CreateGenerationObjects(ImportedOnly);
auto const mfit =
std::find_if(this->Makefiles.begin(), this->Makefiles.end(),
[mf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %esi
callq 0x315e8a
movq 0x80(%r14), %rax
movq 0x88(%r14), %rcx
movq %rcx, %rdi
subq %rax, %rdi
movq %rdi, %rsi
sarq $0x5, %rsi
testq %rsi, %rsi
jle 0x316947
andq $-0x2... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::FinalizeTargetConfiguration() | void cmGlobalGenerator::FinalizeTargetConfiguration()
{
std::vector<std::string> const langs =
this->CMakeInstance->GetState()->GetEnabledLanguages();
// Construct per-target generator information.
for (const auto& mf : this->Makefiles) {
const cmBTStringRange noConfigCompileDefinitions =
mf->GetCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x78(%rdi), %rax
movq 0x770(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0xdfa6e
movq 0x80(%rbx), %r12
movq 0x88(%rbx), %rax
movq %rax, 0x48(%rsp)
cmpq %rax, %r12
je 0x3173b6
leaq 0x98(%rsp), %rbx
leaq 0x90(%rsp), %r14
le... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::CheckRuleHashes() | void cmGlobalGenerator::CheckRuleHashes()
{
#if !defined(CMAKE_BOOTSTRAP)
std::string home = this->GetCMakeInstance()->GetHomeOutputDirectory();
std::string pfile = cmStrCat(home, "/CMakeFiles/CMakeRuleHashes.txt");
this->CheckRuleHashes(pfile, home);
this->WriteRuleHashes(pfile);
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x119d64
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x5b7c4
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x40(%rsp), %rsi
movq... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::ComputeTargetDepends() | bool cmGlobalGenerator::ComputeTargetDepends()
{
cmComputeTargetDepends ctd(this);
if (!ctd.Compute()) {
return false;
}
for (cmGeneratorTarget const* target : ctd.GetTargets()) {
ctd.GetTargetDirectDepends(target, this->TargetDependencies[target]);
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c0fc4
movq %r14, %rdi
callq 0x3c120e
movb %al, 0x7(%rsp)
testb %al, %al
je 0x3187c3
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %rbp
cmpq %rbp, %r13
je 0x3187c3
ad... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetLocalGeneratorTargetsInOrder(cmLocalGenerator*) const | std::vector<cmGeneratorTarget*>
cmGlobalGenerator::GetLocalGeneratorTargetsInOrder(cmLocalGenerator* lg) const
{
std::vector<cmGeneratorTarget*> gts;
cm::append(gts, lg->GetGeneratorTargets());
std::sort(gts.begin(), gts.end(),
[this](cmGeneratorTarget const* l, cmGeneratorTarget const* r) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x148(%rdx), %r12
movq 0x150(%rdx), %r13
cmpq %r13, %r12
je 0x3188cb
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq (%r12), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetEnabledLanguages(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 cmGlobalGenerator::GetEnabledLanguages(
std::vector<std::string>& lang) const
{
lang = this->CMakeInstance->GetState()->GetEnabledLanguages();
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x78(%rdi), %rax
movq 0x770(%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xdfa6e
movq 0x10(%rbx), %rax
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm1, (%rdi)
mo... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::SplitFrameworkPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGlobalGenerator::FrameworkFormat) const | cm::optional<cmGlobalGenerator::FrameworkDescriptor>
cmGlobalGenerator::SplitFrameworkPath(const std::string& path,
FrameworkFormat format) const
{
// Check for framework structure:
// (/path/to/)?FwName.framework
// or (/path/to/)?FwName.framework/FwName(.tbd)?
// or (/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x474211(%rip), %al # 0x78ed00
testb %al, %al
je 0x31b31f
leaq 0x188(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3fa44c
cmpq $0x0, 0x8(%r15)
je 0x... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::AddGlobalTarget_Package(std::vector<cmGlobalGenerator::GlobalTargetInfo, std::allocator<cmGlobalGenerator::GlobalTargetInfo>>&) | void cmGlobalGenerator::AddGlobalTarget_Package(
std::vector<GlobalTargetInfo>& targets)
{
auto& mf = this->Makefiles[0];
std::string configFile =
cmStrCat(mf->GetCurrentBinaryDirectory(), "/CPackConfig.cmake");
if (!cmSystemTools::FileExists(configFile)) {
return;
}
static const auto reservedTarge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, 0x40(%rsp)
movq %rdi, %r14
movq 0x80(%rdi), %rax
movq %rax, 0x38(%rsp)
movq (%rax), %rdi
callq 0xa5b4a
movq (%rax), %rcx
movq 0x8(%rax), %rax
leaq 0x48(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rs... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::AddGlobalTarget_Test(std::vector<cmGlobalGenerator::GlobalTargetInfo, std::allocator<cmGlobalGenerator::GlobalTargetInfo>>&) | void cmGlobalGenerator::AddGlobalTarget_Test(
std::vector<GlobalTargetInfo>& targets)
{
auto& mf = this->Makefiles[0];
if (!mf->IsOn("CMAKE_TESTING_ENABLED")) {
return;
}
static const auto reservedTargets = { "test", "RUN_TESTS" };
for (auto const& target : reservedTargets) {
if (!this->CheckCMP003... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %r15
movq 0x80(%rdi), %r12
movq (%r12), %rbx
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x27d450(%rip), %rsi # 0x599564
leaq 0x27d45e(%rip), %rdx # 0x599579
leaq 0x68(%rsp... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::AddGlobalTarget_RebuildCache(std::vector<cmGlobalGenerator::GlobalTargetInfo, std::allocator<cmGlobalGenerator::GlobalTargetInfo>>&) const | void cmGlobalGenerator::AddGlobalTarget_RebuildCache(
std::vector<GlobalTargetInfo>& targets) const
{
const char* rebuildCacheTargetName = this->GetRebuildCacheTargetName();
if (!rebuildCacheTargetName) {
return;
}
GlobalTargetInfo gti;
gti.Name = rebuildCacheTargetName;
gti.Message = "Running CMake t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x110(%rax)
testq %rax, %rax
je 0x31cc15
movq %rax, %r14
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x68(%rsp), %r12
movq %r12, -0x10(... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetPredefinedTargetsFolder[abi:cxx11]() const | std::string cmGlobalGenerator::GetPredefinedTargetsFolder() const
{
cmValue prop = this->GetCMakeInstance()->GetState()->GetGlobalProperty(
"PREDEFINED_TARGETS_FOLDER");
if (prop) {
return *prop;
}
return "CMakePredefinedTargets";
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x78(%rsi), %rax
movq 0x770(%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c0a43(%rip), %rsi # 0x5de409
leaq 0x2c0a55(%rip), %rdx # 0x5de422
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5b4c6
movq %r14, %rdi
movq %... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::GetDirectoryContent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::set<std::string> const& cmGlobalGenerator::GetDirectoryContent(
std::string const& dir, bool needDisk)
{
DirectoryContent& dc = this->DirectoryContentMap[dir];
if (needDisk) {
long mt = cmSystemTools::ModifiedTime(dir);
if (mt != dc.LastDiskTime) {
// Reset to non-loaded directory content.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
addq $0x4f8, %rdi # imm = 0x4F8
callq 0x320058
movq %rax, %rbx
testl %ebp, %ebp
je 0x31e104
movq %r14, %rdi
callq 0x3f7c4c
movq %rax, 0x10(%rsp)
cmpq (%rbx), %rax
je 0x31e104
leaq 0x38(%rbx), %r... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalGenerator::CreateAnonymousRuntimeDependencySet() | cmInstallRuntimeDependencySet*
cmGlobalGenerator::CreateAnonymousRuntimeDependencySet()
{
auto set = cm::make_unique<cmInstallRuntimeDependencySet>();
auto* retval = set.get();
this->RuntimeDependencySets.push_back(std::move(set));
return retval;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movl $0xa0, %edi
callq 0x39460
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3379a0
movq %rbx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x31f4f... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.cxx |
cmGlobalUnixMakefileGenerator3::Configure() | void cmGlobalUnixMakefileGenerator3::Configure()
{
// Initialize CMAKE_EDIT_COMMAND cache entry.
this->GetEditCacheCommand();
this->cmGlobalGenerator::Configure();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x120(%rax)
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x324cfc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x39320
movq %rbx, %rdi
callq 0x315540
addq $0x28, %rsp
popq %rbx
pop... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_... | void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(
const std::string& sourceFile, const std::string& workingDirectory,
const std::string& compileCommand, const std::string& objPath)
{
if (!this->CommandDatabase) {
std::string commandDatabaseName =
this->GetCMakeInstance()->GetHomeOutputDirectory... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x7a8(%rdi), %rdi
testq %rdi, %rdi
je 0x325e32
leaq 0x2b2dad(%rip), %rsi # 0x5d8bd0
movl $0x2, %edx
callq 0x3b4d0
jmp 0x325ed8
movq 0x78(%r13), %rdi
c... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::v... | std::vector<cmGlobalGenerator::GeneratedMakeCommand>
cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
const std::string& makeProgram, const std::string& /*projectName*/,
const std::string& /*projectDir*/,
std::vector<std::string> const& targetNames, const std::string& /*config*/,
int jobs, bool verbose, co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movb 0xb0(%rsp), %al
xorps %xmm0, %xmm0
movups %xmm0, 0x29(%rsp)
movaps %xmm0, 0x20(%rsp)
testb %al, %al
je 0x32817f
callq 0xf2ca0
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(std::ostream&, 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>,... | void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
std::ostream& ruleFileStream, std::set<std::string>& emitted)
{
std::vector<std::string> depends;
std::vector<std::string> commands;
bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
if (regenerate) {
depends.emplace_bac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r12
movq %rsi, 0x38(%rsp)
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
xorl %eax, %eax
movq %rax, 0x90(%rsp)
movq %rax, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %rax
movq %... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::GetName[abi:cxx11]() const | std::string GetName() const override
{
return cmGlobalUnixMakefileGenerator3::GetActualName();
} | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movabsq $0x6b614d2078696e55, %rcx # imm = 0x6B614D2078696E55
movq %rcx, 0x10(%rdi)
movabsq $0x73656c6966656b61, %rcx # imm = 0x73656C6966656B61
movq %rcx, 0x16(%rdi)
movq $0xe, 0x8(%rdi)
movb $0x0, 0x1e(%rdi)
retq
nop
| /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.h |
cmGlobVerificationManager::CacheEntryKey::operator<(cmGlobVerificationManager::CacheEntryKey const&) const | bool cmGlobVerificationManager::CacheEntryKey::operator<(
const CacheEntryKey& r) const
{
if (this->Recurse < r.Recurse) {
return true;
}
if (this->Recurse > r.Recurse) {
return false;
}
if (this->ListDirectories < r.ListDirectories) {
return true;
}
if (this->ListDirectories > r.ListDirecto... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb (%rdi), %al
movb (%rsi), %cl
movb $0x1, %bl
cmpb %cl, %al
jb 0x32b1d5
jbe 0x32b1c5
xorl %ebx, %ebx
jmp 0x32b1d5
movq %rsi, %r14
movq %rdi, %r15
movb 0x1(%rdi), %al
movb 0x1(%rsi), %cl
cmpb %cl, %al
jae 0x32b1e1
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
pop... | /JKorbelRA[P]CMake/Source/cmGlobVerificationManager.cxx |
cmGraphVizWriter::PathSafeString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmGraphVizWriter::PathSafeString(std::string const& str)
{
std::string pathSafeStr;
// We'll only keep alphanumerical characters, plus the following ones that
// are common, and safe on all platforms:
auto const extra_chars = std::set<char>{ '.', '-', '_' };
for (char c : str) {
if (std::isa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x15(%rsp), %rsi
movw $0x2d2e, (%rsi) # imm = 0x2D2E
movb $0x5f, 0x2(%rsi)
leaq 0x18(%rs... | /JKorbelRA[P]CMake/Source/cmGraphVizWriter.cxx |
cmGraphVizWriter::WriteConnection(cmGeneratedFileStream&, cmLinkItem const&, cmLinkItem const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmGraphVizWriter::WriteConnection(cmGeneratedFileStream& fs,
cmLinkItem const& depender,
cmLinkItem const& dependee,
std::string const& edgeStyle)
{
auto const& dependerName = depender.AsStr();
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movq %rdx, %rdi
callq 0x340c26
movq %rax, %r14
movq %rbx, %rdi
callq 0x340c26
movq %rax, %rbx
leaq 0x2a9ef7(%rip), %rsi # 0x5d702f
movl $0x5, %edx
movq %r13, %rdi
callq 0x3b4d0
addq ... | /JKorbelRA[P]CMake/Source/cmGraphVizWriter.cxx |
cmGraphVizWriter::ItemNameWithAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGraphVizWriter::ItemNameWithAliases(
std::string const& itemName) const
{
std::vector<std::string> items;
for (auto const& lg : this->GlobalGenerator->GetLocalGenerators()) {
for (auto const& aliasTargets : lg->GetMakefile()->GetAliasTargets()) {
if (aliasTargets.second == itemName) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x3c8(%rsi), %rax
movq 0x98(%rax), %rbx
movq 0xa0(%rax), %rax
movq %rax, (%rsp)
cmpq %rax, %rbx
je 0x32e5e7
leaq 0x30(%rsp), %r15... | /JKorbelRA[P]CMake/Source/cmGraphVizWriter.cxx |
cmInstallGenerator::CreateComponentTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | std::string cmInstallGenerator::CreateComponentTest(
const std::string& component, bool exclude_from_all, bool all_components)
{
if (all_components) {
if (exclude_from_all) {
return "CMAKE_INSTALL_COMPONENT";
}
return {};
}
std::string result = "CMAKE_INSTALL_COMPONENT STREQUAL \"";
result ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
testl %r8d, %r8d
je 0x330d05
testb %bpl, %bpl
je 0x330d52
leaq 0x293c3b(%rip), %rsi # 0x5c492f
leaq 0x293c4b(%rip), %rdx # 0x5c4946
movq %rbx, %rdi
callq 0x5b4c6
jmp 0x330d5e
movq %rdx, %... | /JKorbelRA[P]CMake/Source/cmInstallGenerator.cxx |
cmInstallGenerator::AddTweak(std::ostream&, cmScriptGeneratorIndent, 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::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | void cmInstallGenerator::AddTweak(std::ostream& os, Indent indent,
const std::string& config,
std::string const& dir,
std::vector<std::string> const& files,
const TweakMethod& tweak)
{... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %r9, %r13
movq %rcx, %r15
movq %rdx, %rbp
movl %esi, %r14d
movq %rdi, %rbx
movq (%r8), %rax
movq 0x8(%r8), %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
jne 0x3312d9
movq (%r15), %rcx
movq 0x8(%r15), %rdx
movq (%ra... | /JKorbelRA[P]CMake/Source/cmInstallGenerator.cxx |
cmInstallGetRuntimeDependenciesGenerator::GenerateScriptForConfig(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmScriptGeneratorIndent) | void cmInstallGetRuntimeDependenciesGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
std::string installNameTool =
this->LocalGenerator->GetMakefile()->GetSafeDefinition(
"CMAKE_INSTALL_NAME_TOOL");
os << indent << "file(GET_RUNTIME_DEPENDENCIES\n"
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0x1d0(%rdi), %rax
movq 0x70(%rax), %r14
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2adbcf(%rip), %rsi # 0x5df7bd
leaq 0x2adbdf(%rip), %rdx # 0x5df7d... | /JKorbelRA[P]CMake/Source/cmInstallGetRuntimeDependenciesGenerator.cxx |
cmInstallExportGenerator::GenerateScript(std::ostream&) | void cmInstallExportGenerator::GenerateScript(std::ostream& os)
{
// Skip empty sets.
if (this->ExportSet->GetTargetExports().empty()) {
std::ostringstream e;
e << "INSTALL(EXPORT) given unknown export \""
<< this->ExportSet->GetName() << "\"";
cmSystemTools::Error(e.str());
return;
}
// ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, %rbx
movq 0xc8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x333300
movq %rsi, %r14
movq %rbx, %rdi
callq 0x333146
leaq 0x160(%rbx), %rdi
xorl %esi, %esi
callq 0x3f532a
movq 0x160(%rbx), %rax
movq 0x16... | /JKorbelRA[P]CMake/Source/cmInstallExportGenerator.cxx |
cmInstalledFile::AppendProperty(cmMakefile const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void cmInstalledFile::AppendProperty(cmMakefile const* mf,
const std::string& prop,
const std::string& value,
bool /*asString*/)
{
cmListFileBacktrace backtrace = mf->GetBacktrace();
cmGeneratorExpression ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x9d218
movq (%r12), %rcx
movq 0x8(%r12), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x334e7c
movq 0x4510ea(%rip), %rcx # 0x785f58
cmpb $0x... | /JKorbelRA[P]CMake/Source/cmInstalledFile.cxx |
cmInstallFileSetGenerator::~cmInstallFileSetGenerator() | cmInstallFileSetGenerator::~cmInstallFileSetGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x445d81(%rip), %rax # 0x77b890
movq %rax, (%rdi)
movq 0xf8(%rdi), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x335b30
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq 0xc8(%rbx), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x335b4e
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq %... | /JKorbelRA[P]CMake/Source/cmInstallFileSetGenerator.cxx |
cmInstallFilesGenerator::GetFiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<std::string> cmInstallFilesGenerator::GetFiles(
std::string const& config) const
{
std::vector<std::string> files;
if (this->ActionsPerConfig) {
for (std::string const& f : this->Files) {
cmExpandList(
cmGeneratorExpression::Evaluate(f, this->LocalGenerator, config),
files);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x1, 0x68(%rsi)
movq %rdi, (%rsp)
jne 0x3366eb
movq 0xd0(%r14), %rbp
movq 0xd8(%r14), %rbx
cmpq %rbx, %rbp
je 0x3366fa
movq %rdx, %r15
leaq 0x28(%rsp), %... | /JKorbelRA[P]CMake/Source/cmInstallFilesGenerator.cxx |
cmInstallRuntimeDependencySetGenerator::GenerateAppleLibraryScript(std::ostream&, 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_t... | void cmInstallRuntimeDependencySetGenerator::GenerateAppleLibraryScript(
std::ostream& os, const std::string& config,
const std::vector<std::string>& evaluatedRPaths, Indent indent)
{
os << indent << "if(NOT " << this->TmpVarPrefix
<< "_dep MATCHES \"\\\\.framework/\")\n";
auto depName = cmStrCat(this->Tm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %r14d
movq %rcx, 0x60(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
testl %r8d, %r8d
jle 0x339392
leaq 0x28a440(%rip), %rbp # 0x5c37ba
movl %r14d, %r15d
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySetGenerator.cxx |
cmInstallScriptGenerator::~cmInstallScriptGenerator() | cmInstallScriptGenerator::~cmInstallScriptGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x440d2b(%rip), %rax # 0x77bb30
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x33ae26
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq %rbx, %rdi
popq %rbx
jmp 0x330280
nop
| /JKorbelRA[P]CMake/Source/cmInstallScriptGenerator.cxx |
cmInstallScriptGenerator::GenerateScriptForConfig(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmScriptGeneratorIndent) | void cmInstallScriptGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
this->AddScriptInstallRule(os, indent, this->GetScript(config));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x33aef4
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x33b062
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je ... | /JKorbelRA[P]CMake/Source/cmInstallScriptGenerator.cxx |
cmLinkLineComputer::ComputeLinkLibs[abi:cxx11](cmComputeLinkInformation&) | std::string cmLinkLineComputer::ComputeLinkLibs(cmComputeLinkInformation& cli)
{
std::string linkLibs;
std::vector<BT<std::string>> linkLibsList;
this->ComputeLinkLibs(cli, linkLibsList);
cli.AppendValues(linkLibs, linkLibsList);
return linkLibs;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x340e7a
movq %rsp, %rd... | /JKorbelRA[P]CMake/Source/cmLinkLineComputer.cxx |
cmLinkLineDeviceComputer::ComputeRequiresDeviceLinking(cmComputeLinkInformation&) | bool cmLinkLineDeviceComputer::ComputeRequiresDeviceLinking(
cmComputeLinkInformation& cli)
{
// Determine if this item might requires device linking.
// For this we only consider targets
using ItemVector = cmComputeLinkInformation::ItemVector;
ItemVector const& items = cli.GetItems();
return std::any_of(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdi
callq 0x270edc
movq (%rax), %rbx
movq 0x8(%rax), %r15
movq %r15, %r12
subq %rbx, %r12
movq %r12, %rbp
sarq $0x3, %rbp
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
imulq %r13, %rbp
sarq $0x2, %rbp
testq %rbp, %r... | /JKorbelRA[P]CMake/Source/cmLinkLineDeviceComputer.cxx |
requireDeviceLinking(cmGeneratorTarget&, cmLocalGenerator&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool requireDeviceLinking(cmGeneratorTarget& target, cmLocalGenerator& lg,
const std::string& config)
{
if (!target.GetGlobalGenerator()->GetLanguageEnabled("CUDA")) {
return false;
}
if (target.GetType() == cmStateEnums::OBJECT_LIBRARY) {
return false;
}
if (!lg.GetMakefil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2d03fe
movq %rax, %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x256e16(%rip), %rsi # 0x59a14f
leaq 0x256e13(%rip), %rdx # 0x59a153
leaq 0x8(%rsp), %rdi
callq 0x5b4c... | /JKorbelRA[P]CMake/Source/cmLinkLineDeviceComputer.cxx |
cmListFileParser::~cmListFileParser() | cmListFileParser::~cmListFileParser()
{
cmListFileLexer_Delete(this->Lexer);
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x3b102c
leaq 0x60(%rbx), %rdi
callq 0xb1258
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x343990
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x34399f
popq %rbx
jmp 0x944ea
popq %rbx
retq
movq %rax, %rdi
ca... | /JKorbelRA[P]CMake/Source/cmListFileCache.cxx |
cmListFileParser::CheckNesting() const | cm::optional<cmListFileContext> cmListFileParser::CheckNesting() const
{
std::vector<NestingState> stack;
for (auto const& func : this->ListFile->Functions) {
auto const& name = func.LowerCaseName();
if (name == "if") {
stack.push_back({
NestingStateEnum::If,
cmListFileContext::FromLi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq (%rsi), %rax
movq (%rax), %r14
movq 0x8(%rax), %rax
movq %rax, 0x210(%rsp)
cmpq %rax, %r14
je 0x34542e
movq %rsi, %r15
movq ... | /JKorbelRA[P]CMake/Source/cmListFileCache.cxx |
cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator*, cmMakefile*, cmLocalCommonGenerator::WorkDir) | cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator* gg,
cmMakefile* mf, WorkDir wd)
: cmLocalGenerator(gg, mf)
, WorkingDirectory(wd)
{
this->ConfigNames =
this->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
callq 0x77b84
leaq 0x434b99(%rip), %rax # 0x77be38
movq %rax, (%rbx)
movl %ebp, 0x338(%rbx)
leaq 0x340(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x340(%rbx)
movq $0x0, 0x350(%rbx)
movq 0x70(%rbx), %rsi
movq %rsp, %rdi
xor... | /JKorbelRA[P]CMake/Source/cmLocalCommonGenerator.cxx |
cmLocalCommonGenerator::GetTargetFortranFlags(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmLocalCommonGenerator::GetTargetFortranFlags(
cmGeneratorTarget const* target, std::string const& config)
{
std::string flags;
// Enable module output if necessary.
this->AppendFlags(
flags, this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODOUT_FLAG"));
// Add a module output directory fl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x90(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, 0x28(%rsp)
movb $0x0, 0x10(%rdi)
movq 0x70(%rsi), %rbx
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%... | /JKorbelRA[P]CMake/Source/cmLocalCommonGenerator.cxx |
cmLocalUnixMakefileGenerator3::WriteLocalAllRules(std::ostream&) | void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
std::ostream& ruleFileStream)
{
this->WriteDisclaimer(ruleFileStream);
// Write the main entry point target. This must be the VERY first
// target so that make with no arguments will run it.
{
// Just depend on the all target to drive the build.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
callq 0x34cd46
xorl %eax, %eax
leaq 0x90(%rsp), %rdi
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq %rax, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
leaq 0x27ba1... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmLocalUnixMakefileGenerator3::AppendEcho(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&, c... | void cmLocalUnixMakefileGenerator3::AppendEcho(
std::vector<std::string>& commands, std::string const& text, EchoColor color,
EchoProgress const* progress)
{
// Choose the color for the text.
std::string color_name;
if (this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile) {
// See cmake::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r15
movq %rdx, %r12
movq %rsi, 0xa0(%rsp)
movq %rdi, %r14
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x88(%rdi), %rax
cmpb $0x1, 0x6e7(%rax)
jne 0x34eeb2
cmpb $0x1, 0x426(%r14)
jn... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmLocalUnixMakefileGenerator3::UpdateDependencies(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | bool cmLocalUnixMakefileGenerator3::UpdateDependencies(
const std::string& tgtInfo, bool verbose, bool color)
{
// read in the target info file
if (!this->Makefile->ReadListFile(tgtInfo) ||
cmSystemTools::GetErrorOccurredFlag()) {
cmSystemTools::Error("Target DependInfo.cmake file not found");
}
bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x918, %rsp # imm = 0x918
movl %ecx, 0x7c(%rsp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x9faca
testb %al, %al
je 0x350a82
leaq 0x439992(%rip), %rax # 0x78a3fa
cmpb $0x0, (%rax)
jne 0x350a82
leaq 0... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmLocalUnixMakefileGenerator3::GetTargetDirectory[abi:cxx11](cmGeneratorTarget const*) const | std::string cmLocalUnixMakefileGenerator3::GetTargetDirectory(
cmGeneratorTarget const* target) const
{
std::string dir = cmStrCat("CMakeFiles/", target->GetName());
#if defined(__VMS)
dir += "_dir";
#else
dir += ".dir";
#endif
return dir;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2d0418
movq (%rax), %rcx
movq 0x8(%rax), %rax
leaq 0x8(%rsp), %rsi
movq $0xb, (%rsi)
leaq 0x2847ec(%rip), %rdx # 0x5d8722
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq 0xec4ec
leaq ... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmMakefileTargetGenerator::CreateRuleFile() | void cmMakefileTargetGenerator::CreateRuleFile()
{
// Create a directory for this target.
this->TargetBuildDirectory =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->TargetBuildDirectoryFull =
this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory);
cmSystemTools::Mak... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x78(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
callq *0x70(%rax)
leaq 0x100(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a1e0
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
c... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::WriteObjectDependRules(cmSourceFile 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>>>>&) | void cmMakefileTargetGenerator::WriteObjectDependRules(
cmSourceFile const& source, std::vector<std::string>& depends)
{
// Create the list of dependencies known at cmake time. These are
// shared between the object file and dependency scanning rule.
depends.push_back(source.GetFullPath());
if (cmValue objec... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0xd79b2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cc0a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x25de2a(%rip), %rsi # 0x5bfee9
leaq 0x25de31(%rip), %rdx # 0x5bfef7
leaq 0x8(%rsp), %r15
movq ... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::WriteTargetCleanRules() | void cmMakefileTargetGenerator::WriteTargetCleanRules()
{
std::vector<std::string> depends;
std::vector<std::string> commands;
// Construct the clean target name.
std::string cleanTarget = cmStrCat(
this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget),
"/clean");
// Construct the ... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rdx
movq 0x78(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0x34c6ec
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
leaq ... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::GetLinkRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmMakefileTargetGenerator::GetLinkRule(
const std::string& linkRuleVar)
{
std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar);
if (this->GeneratorTarget->HasImplibGNUtoMS(this->GetConfigName())) {
std::string ruleVar =
cmStrCat("CMAKE_",
this->GeneratorTa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq %rdx, %rsi
callq 0xa851a
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5b7c4
movq 0x8(%r14), %r15
leaq 0x60(%rsp), %... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::CheckUseResponseFileForObjects(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmMakefileTargetGenerator::CheckUseResponseFileForObjects(
std::string const& l) const
{
// Check for an explicit setting one way or the other.
std::string const responseVar =
"CMAKE_" + l + "_USE_RESPONSE_FILE_FOR_OBJECTS";
if (cmValue val = this->Makefile->GetDefinition(responseVar)) {
if (!val->... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x23e4c6(%rip), %rsi # 0x5a4306
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5c5a1
leaq 0x27c9b3(%rip), %rsi # 0x5e2807
movq %r14, %rdi
callq 0x3a750
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::CreateResponseFile(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::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::all... | std::string cmMakefileTargetGenerator::CreateResponseFile(
const std::string& name, std::string const& options,
std::vector<std::string>& makefile_depends)
{
// FIXME: Find a better way to determine the response file encoding,
// perhaps using tool-specific platform information variables.
// For now, use the ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x80(%rsi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
cmpl $0x2, %eax
jne 0x366140
movq 0x10(%r15), %rbp
le... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(bool) | void cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(
bool relink)
{
#ifndef CMAKE_BOOTSTRAP
const bool requiresDeviceLinking = requireDeviceLinking(
*this->GeneratorTarget, *this->LocalGenerator, this->GetConfigName());
if (!requiresDeviceLinking) {
return;
}
std::vector<std::string> ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x78(%rdi), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x356cee
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x343307
movl %eax, %r14d
leaq 0x10(%rsp), %r... | /JKorbelRA[P]CMake/Source/cmMakefileExecutableTargetGenerator.cxx |
cmOrderDirectories::cmOrderDirectories(cmGlobalGenerator*, cmGeneratorTarget const*, char const*) | cmOrderDirectories::cmOrderDirectories(cmGlobalGenerator* gg,
const cmGeneratorTarget* target,
const char* purpose)
{
this->GlobalGenerator = gg;
this->Target = target;
this->Purpose = purpose;
this->Computed = false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbp
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x48(%rsp)
movq %rax, 0x10(%rdi)
xorl %r13d, %r13d
movq %r13, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
addq $0x30, %rdi
l... | /JKorbelRA[P]CMake/Source/cmOrderDirectories.cxx |
cmOrderDirectories::CollectOriginalDirectories() | void cmOrderDirectories::CollectOriginalDirectories()
{
// Add user directories specified for inclusion. These should be
// indexed first so their original order is preserved as much as
// possible subject to the constraints.
this->AddOriginalDirectories(this->UserDirectories);
// Add directories containing... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x78(%rdi), %rsi
callq 0x376d9a
movq 0x48(%rbx), %r14
movq 0x50(%rbx), %r15
cmpq %r15, %r14
je 0x376474
movq (%r14), %r12
movq 0x8(%r12), %rdi
leaq 0x38(%r12), %rsi
callq 0x376e00
movl %eax, 0x78(%r12)
addq $0x8, %r14
jmp 0x376452
leaq 0x90(%rb... | /JKorbelRA[P]CMake/Source/cmOrderDirectories.cxx |
cmOrderDirectories::DiagnoseCycle() | void cmOrderDirectories::DiagnoseCycle()
{
// Report the cycle at most once.
if (this->CycleDiagnosed) {
return;
}
this->CycleDiagnosed = true;
// Construct the message.
std::ostringstream e;
e << "Cannot generate a safe " << this->Purpose << " for target "
<< this->Target->GetName()
<< " bec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
cmpb $0x0, 0x284(%rdi)
jne 0x377407
movq %rdi, %rbx
movb $0x1, 0x284(%rdi)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3b3d0
leaq 0x26be3a(%rip), %rsi # 0x5e3000
movl $0x17, %edx
movq %r14, %rdi
callq 0x3b4... | /JKorbelRA[P]CMake/Source/cmOrderDirectories.cxx |
cmOrderDirectoriesConstraint::FindConflicts(unsigned int) | void FindConflicts(unsigned int index)
{
for (unsigned int i = 0; i < this->OD->OriginalDirectories.size(); ++i) {
// Check if this directory conflicts with the entry.
std::string const& dir = this->OD->OriginalDirectories[i];
if (!this->OD->IsSameDirectory(dir, this->Directory) &&
thi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x220(%rdi), %rax
cmpq %rax, 0x228(%rdi)
je 0x3776a2
movl %esi, %ebx
leaq 0x38(%r14), %r15
movl $0x1, %ebp
xorl %r12d, %r12d
movq %r12, %r13
shlq $0x5, %r13
addq %rax, %r13
movq %r13, %rsi
movq %r15, %... | /JKorbelRA[P]CMake/Source/cmOrderDirectories.cxx |
cmPropertyDefinitionMap::GetPropertyDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmProperty::ScopeType) const | cmPropertyDefinition const* cmPropertyDefinitionMap::GetPropertyDefinition(
const std::string& name, cmProperty::ScopeType scope) const
{
auto it = this->Map_.find(KeyType(name, scope));
if (it != this->Map_.end()) {
return &it->second;
}
return nullptr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b7c4
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x379... | /JKorbelRA[P]CMake/Source/cmPropertyDefinition.cxx |
cmQtAutoGen::QuotedCommand(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 cmQtAutoGen::QuotedCommand(std::vector<std::string> const& command)
{
std::string res;
for (std::string const& item : command) {
if (!res.empty()) {
res.push_back(' ');
}
std::string const cesc = cmQtAutoGen::Quoted(item);
if (item.empty() || (cesc.size() > (item.size() + 2)) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %rbp
cmpq %rbp, %r12
je 0x37ab7a
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
cmpq $0x0, 0x8(%rbx)
je 0x37... | /JKorbelRA[P]CMake/Source/cmQtAutoGen.cxx |
cmQtAutoGen::RccLister::list(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>>>>&, std::__cxx11::... | bool cmQtAutoGen::RccLister::list(std::string const& qrcFile,
std::vector<std::string>& files,
std::string& error, bool verbose) const
{
error.clear();
if (!cmSystemTools::FileExists(qrcFile, true)) {
error =
cmStrCat("The resource file ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x68(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq $0x0, 0x8(%rcx)
movq (%rcx), %rax
movb $0x0, (%rax)
movq %rsi, %rdi
movl $0x1, %esi
callq 0x3f592e
testb %al, %al
je 0x3... | /JKorbelRA[P]CMake/Source/cmQtAutoGen.cxx |
cmQtAutoGenerator::MakeParentDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmQtAutoGenerator::MakeParentDirectory(std::string const& filename)
{
bool success = true;
std::string const dirName = cmSystemTools::GetFilenamePath(filename);
if (!dirName.empty()) {
success = static_cast<bool>(cmSystemTools::MakeDirectory(dirName));
}
return success;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3f777a
cmpq $0x0, 0x8(%rbx)
je 0x37ce43
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3f532a
testl %eax, %eax
sete %bl
jmp 0x37ce45
movb $0x1, %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37ce60
movq 0x10(%rsp), %rsi
... | /JKorbelRA[P]CMake/Source/cmQtAutoGenerator.cxx |
cmQtAutoGenerator::InfoT::GetStringConfig(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool) const | bool cmQtAutoGenerator::InfoT::GetStringConfig(std::string const& key,
std::string& value,
bool required) const
{
{ // Try config
std::string const configKey = this->ConfigKey(key);
Json::Value const& jval = this->Js... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x28(%rsp), %rbx
movl $0x1, %edx
movq %rdx, -0x10(%rbx)
movq %rbx, -0x8(%rbx)
movb $0x5f, (%rbx)
movq 0x28(%rdi), %rdi... | /JKorbelRA[P]CMake/Source/cmQtAutoGenerator.cxx |
cmQtAutoGenerator::InfoT::GetArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equ... | bool cmQtAutoGenerator::InfoT::GetArray(std::string const& key,
std::unordered_set<std::string>& list,
bool required) const
{
Json::Value const& jval = this->Json_[key];
if (!jval.isArray()) {
if (!jval.isNull() || required) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x45f9b8
movq %rax, %r12
movq %rax, %rdi
callq 0x45eb3e
testb %al, %al
jne 0x37dd8b
movq %r12, %rdi
callq 0x45eb36
xorb $0x1, %al
orb %bpl, %al
cmpb $0x1, %al
jne 0x37dd8b
movq (... | /JKorbelRA[P]CMake/Source/cmQtAutoGenerator.cxx |
cmQtAutoGenGlobalInitializer::InitializeCustomTargets() | bool cmQtAutoGenGlobalInitializer::InitializeCustomTargets()
{
// Initialize global autogen targets
{
std::string const comment = "Global AUTOGEN target";
for (auto const& pair : this->GlobalAutoGenTargets_) {
this->GetOrCreateGlobalTarget(pair.first, pair.second, comment);
}
}
// Initialize g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x262de9(%rip), %rsi # 0x5e3626
leaq 0x262df7(%rip), %rdx # 0x5e363b
movq %rsp, %rdi
callq 0x5b4c6
movq 0x30(%rbx), %r14
leaq 0x20(%rbx), %r13
cmpq %r13, %r14
je 0x38087c
movq ... | /JKorbelRA[P]CMake/Source/cmQtAutoGenGlobalInitializer.cxx |
cmQtAutoGenInitializer::InitRcc() | bool cmQtAutoGenInitializer::InitRcc()
{
// Rcc executable
{
if (!this->GetQtExecutable(this->Rcc, "rcc", false)) {
return false;
}
// Evaluate test output on demand
CompilerFeatures& features = *this->Rcc.ExecutableFeatures;
if (!features.Evaluated) {
// Look for list options
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2129be(%rip), %rsi # 0x596ad8
leaq 0x2129ba(%rip), %rdx # 0x596adb
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5b4c6
leaq 0x8b8(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x389a... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
void (anonymous namespace)::InfoWriter::SetConfigArray<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... | void InfoWriter::SetConfigArray(
std::string const& key,
cmQtAutoGenInitializer::ConfigStrings<CONT> const& cfgStr)
{
this->SetArray(key, cfgStr.Default);
for (auto const& item : cfgStr.Config) {
this->SetArray(cmStrCat(key, '_', item.first), item.second);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x45fa06
movq %rax, %rdi
movq %r15, %rsi
callq 0x38f32e
movq 0x28(%r15), %r13
testq %r13, %r13
je 0x38d3f3
leaq 0x68(%rsp), %rbp
movl $0x1, %r12d
leaq 0x8(%rsp), %r15
movq (%rbx), %ra... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cm::uv_handle_ptr_base_<uv_signal_s>::~uv_handle_ptr_base_() | ~uv_handle_ptr_base_() { this->reset(); } | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x8(%rdi), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x394ca9
callq 0x944ea
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x394ca9
popq %rbx
jmp 0x944ea
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/cmUVHandlePtr.h |
cm::uv_handle_ptr_base_<uv_process_s>::~uv_handle_ptr_base_() | ~uv_handle_ptr_base_() { this->reset(); } | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x8(%rdi), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x39501b
callq 0x944ea
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x39501b
popq %rbx
jmp 0x944ea
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/cmUVHandlePtr.h |
cmXMLWriter::Doctype(char const*) | void cmXMLWriter::Doctype(const char* doctype)
{
this->CloseStartElement();
this->ConditionalLineBreak(!this->IsContent);
this->Output << "<!DOCTYPE " << doctype << ">";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x39755c
movzbl 0x52(%rbx), %esi
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x397592
movq (%rbx), %rbx
leaq 0x24d01d(%rip), %rsi # 0x5e487b
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3b4d0
testq %r14, %r14
je 0x397888
movq %r14, %rdi
callq 0x39d50
movq %... | /JKorbelRA[P]CMake/Source/cmXMLWriter.cxx |
cmConditionEvaluator::HandleLevel2(cmConditionEvaluator::cmArgumentList&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, MessageType&) | bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs,
std::string& errorString,
MessageType& status)
{
for (auto args = newArgs.make3ArgsIterator(); args.current != newArgs.end();
args.advance(newArgs)) {
int matchN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rcx, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rsi, %r15
movq %rdi, %rbp
movq (%rsi), %r12
movq %r12, %r13
cmpq %rsi, %r12
je 0x398440
movq (%r12), %r13
movq %r13, 0x28(%rsp)
cmpq %r15, %r13
je 0x398453
movq ... | /JKorbelRA[P]CMake/Source/cmConditionEvaluator.cxx |
cmConditionEvaluator::GetBooleanValue(cmExpandedCommandArgument&) const | bool cmConditionEvaluator::GetBooleanValue(
cmExpandedCommandArgument& arg) const
{
// Check basic and named constants.
if (cmIsOn(arg.GetValue())) {
return true;
}
if (cmIsOff(arg.GetValue())) {
return false;
}
// Check for numbers.
if (!arg.empty()) {
char* end;
const double d = std::... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1593cc
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0xbc518
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x399efb
movq %rbx, %rdi
callq 0x1593cc
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0xbc5b0
testb %al, ... | /JKorbelRA[P]CMake/Source/cmConditionEvaluator.cxx |
void cmConditionEvaluator::cmArgumentList::ReduceOneArg<cmConditionEvaluator::cmArgumentList::CurrentAndNextIter>(bool, cmConditionEvaluator::cmArgumentList::CurrentAndNextIter) | void ReduceOneArg(const bool value, Iter args)
{
*args.current = cmExpandedCommandArgument(bool2string(value), true);
this->erase(args.next);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leal 0x30(%rsi), %edx
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdi
callq 0x3a490
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1593... | /JKorbelRA[P]CMake/Source/cmConditionEvaluator.cxx |
cmCoreTryCompile::ParseArgs(cmRange<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std:... | Arguments cmCoreTryCompile::ParseArgs(
const cmRange<std::vector<std::string>::const_iterator>& args,
const cmArgumentParser<Arguments>& parser,
std::vector<std::string>& unparsedArguments)
{
auto arguments = parser.Parse(args, &unparsedArguments, 0);
if (!arguments.MaybeReportError(*(this->Makefile)) &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rsi
movq %r8, %rcx
xorl %r8d, %r8d
callq 0x3a10a2
movq 0x68(%r14), %rsi
movq %rbx, %rdi
callq 0x23c89e
testb %al, %al
jne 0x39aa33
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0x39a... | /JKorbelRA[P]CMake/Source/cmCoreTryCompile.cxx |
cmCoreTryCompile::WriteSource(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&, char const*) const | std::string cmCoreTryCompile::WriteSource(std::string const& filename,
std::string const& content,
char const* command) const
{
if (!cmSystemTools::GetFilenamePath(filename).empty()) {
const auto& msg =
cmStrCat(command, " g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x3f777a
movq (%rbp), %rdi
movq 0x8(%rbp), %rbp
leaq 0x98(%rsp), %rax
cm... | /JKorbelRA[P]CMake/Source/cmCoreTryCompile.cxx |
cmFindBase::ParseArguments(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 cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
{
if (argsIn.size() < 2) {
this->SetError("called with incorrect number of arguments");
return false;
}
// copy argsIn into args so it can be modified,
// in the process extract the DOC "documentation"
// and handle options NO_CA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movq 0x8(%rsi), %r12
subq (%rsi), %r12
sarq $0x5, %r12
cmpq $0x1, %r12
ja 0x3a22e5
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x214b1a(%rip), %rsi # 0x5b6dbf
leaq 0x214b3c(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmFindBase.cxx |
cmFindBase::NormalizeFindResult() | void cmFindBase::NormalizeFindResult()
{
if (this->Makefile->GetPolicyStatus(cmPolicies::CMP0125) ==
cmPolicies::NEW) {
// ensure the path returned by find_* command is absolute
const auto& existingValue =
this->Makefile->GetDefinition(this->VariableName);
std::string value;
if (!existingV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movq 0x178(%rdi), %rdi
movl $0x7d, %esi
xorl %edx, %edx
callq 0x9ccf8
cmpl $0x2, %eax
jne 0x3a484c
movq 0x178(%rbx), %rdi
leaq 0x1d0(%rbx), %r14
movq %r14, %rsi
callq 0x9d080
movq %rax, %r15
leaq... | /JKorbelRA[P]CMake/Source/cmFindBase.cxx |
cmFindCommon::GetIgnoredPrefixPaths(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>>>>&) | void cmFindCommon::GetIgnoredPrefixPaths(std::set<std::string>& ignore)
{
std::vector<std::string> ignoreVec;
this->GetIgnoredPrefixPaths(ignoreVec);
ignore.insert(ignoreVec.begin(), ignoreVec.end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x3a72ca
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r13
movq %rbx, 0x8(%rsp)
cmpq %r13, %r14
je 0x3a73ed
leaq 0x8(%rbx), %r15
leaq 0x8(%rsp), %r1... | /JKorbelRA[P]CMake/Source/cmFindCommon.cxx |
cmFindCommon::CheckCommonArgument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{
if (arg == "NO_DEFAULT_PATH") {
this->NoDefaultPath = true;
} else if (arg == "NO_PACKAGE_ROOT_PATH") {
this->NoPackageRootPath = true;
} else if (arg == "NO_CMAKE_PATH") {
this->NoCMakePath = true;
} else if (arg == "NO_CMAKE_ENVIRONM... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23ffe7(%rip), %rsi # 0x5e7414
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x3a74f8
leaq 0x23ffe0(%rip), %rsi # 0x5e7424
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x3a74fe
leaq 0x23ffde(%rip), %rsi # 0x5e7439
movq %r14, %rdi
c... | /JKorbelRA[P]CMake/Source/cmFindCommon.cxx |
cmFindCommon::PathGroup::PathGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | PathGroup(const std::string& label)
: cmPathLabel(label)
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b7c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c4c00
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3a782c... | /JKorbelRA[P]CMake/Source/cmFindCommon.h |
cm::IntoString<char*>::into_string(char const*) | String IntoString<char*>::into_string(const char* s)
{
if (!s) {
return String();
}
return std::string(s);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3a827c
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x39d50
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b4c6
movq %rbx, %rdi
movq %r15, %rsi
c... | /JKorbelRA[P]CMake/Source/cmString.cxx |
EncodeFilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static Json::Value EncodeFilename(std::string const& path)
{
std::string data;
data.reserve(path.size());
for (auto const& byte : path) {
if (std::iscntrl(byte)) {
// Control characters.
data.append("\\u");
char buf[5];
std::snprintf(buf, sizeof(buf), "%04x", byte);
data.append(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3ae20
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x3ab057
movq (%r... | /JKorbelRA[P]CMake/Source/cmScanDepFormat.cxx |
RelativeMonth | static time_t
RelativeMonth(time_t Start, time_t Timezone, time_t RelMonth)
{
struct tm *tm;
time_t Month;
time_t Year;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE__LOCALTIME64_S)
struct tm tmbuf;
#endif
#if defined(HAVE__LOCALTIME64_S)
errno_t terr;
__time64_t tmptime;
#endif
if (RelMonth == 0)
return 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x3ac3d7
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3a730
movq %rax, %r9
movl 0x14(%rax), %eax
leal (%rax,%rax,2), %eax
leal 0x5910(,%rax,4), %eax
movslq 0x10(%r9), %rdi
cltq
addq %r15, %rdi
addq... | /JKorbelRA[P]CMake/Source/../Utilities/cmlibarchive/libarchive/archive_getdate.c |
cm_utf8_decode_character | const char* cm_utf8_decode_character(const char* first, const char* last,
unsigned int* pc)
{
/* We need at least one byte. */
if (first == last) {
return 0;
}
/* Count leading ones in the first byte. */
unsigned char c = (unsigned char)*first++;
unsigned char con... | pushq %rbx
cmpq %rsi, %rdi
je 0x3ac59f
movzbl (%rdi), %ecx
leaq 0x23b5bc(%rip), %rax # 0x5e7ae0
movzbl (%rcx,%rax), %r8d
xorl %eax, %eax
leal -0x7(%r8), %r9d
cmpl $0x2, %r9d
jb 0x3ac5a1
cmpl $0x1, %r8d
je 0x3ac5a1
incq %rdi
testl %r8d, %r8d
jne 0x3ac54a
movl %ecx, (%rdx)
movq %rdi, %rax
jmp 0x3ac5a1
cmpq %rsi, %rdi
... | /JKorbelRA[P]CMake/Source/cm_utf8.c |
cmCommandArgument_yylex_init_extra(cmCommandArgumentParserHelper*, void**) | 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 0x3ad843
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x90, %esi
callq 0x3bed8
movq %rax, (%r14)
testq %rax, %rax
je 0x3ad850
movq %rbx, (%rax)
xorl %eax, %eax
jmp 0x3ad860
callq 0x3b610
movl $0x16, (%rax)
jmp 0x3ad85b
callq 0x3b610
movl $0xc, (%rax)
movl $0... | /JKorbelRA[P]CMake/Source/LexerParser/cmCommandArgumentLexer.cxx |
cmCommandArgument_yyrealloc(void*, unsigned long, void*) | void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latt... | jmp 0x3be88
| /JKorbelRA[P]CMake/Source/LexerParser/cmCommandArgumentLexer.cxx |
cmExpr_yy_delete_buffer(yy_buffer_state*, void*) | void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yyfree( (void *) b->yy_... | testq %rdi, %rdi
je 0x3aeb2e
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x3aeb2f
movq 0x18(%rsi), %rcx
movq (%rax,%rcx,8), %rcx
jmp 0x3aeb31
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x3aeb42
movq 0x18(%rsi), %rcx
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x3aeb51
movq 0x8(%rbx), %rdi
c... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.cxx |
cmExpr_yy_scan_bytes(char const*, int, void*) | 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 0x3bee0
testq %rax, %rax
je 0x3aee08
movq %rax, %r12
testl %r15d, %r15d
jle 0x3aedda
movl %r15d, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x39260
movslq ... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.cxx |
cmExpr_yylex_destroy(void*) | int yylex_destroy (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state(yyscanner);
}
/* Destroy... | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x3aefaa
movq 0x18(%rbx), %rax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x3aefac
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3aeb12
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
movq %rbx, %rdi
callq 0x3aec65
movq 0x28(%rbx), %r... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.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.