name string | code string | asm string | file string |
|---|---|---|---|
cmSubcommandTable::cmSubcommandTable(std::initializer_list<std::pair<cm::static_string_view, bool (*)(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmExecutionStatus&)>>) | cmSubcommandTable::cmSubcommandTable(std::initializer_list<InitElem> init)
: Impl(init.begin(), init.end())
{
std::sort(this->Impl.begin(), this->Impl.end(),
[](Elem const& left, Elem const& right) {
return left.first < right.first;
});
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %rdx
leaq 0xf(%rsp), %rcx
callq 0x1d9628
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x1d8e9e
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # ... | /JKorbelRA[P]CMake/Source/cmSubcommandTable.cxx |
cmSubcommandTable::operator()(std::basic_string_view<char, std::char_traits<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>>>> const&, cmExecutionStatus&) const | bool cmSubcommandTable::operator()(cm::string_view key,
std::vector<std::string> const& args,
cmExecutionStatus& status) const
{
auto const it = std::lower_bound(
this->Impl.begin(), this->Impl.end(), key,
[](Elem const& elem, cm::string_vi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq (%rdi), %rbp
movq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
subq %rbp, %rax
testq %rax, %rax
jle 0x1d8f6a
shrq $0x3, %rax
movabsq $-0x5555555555555555, %rbx... | /JKorbelRA[P]CMake/Source/cmSubcommandTable.cxx |
cmTargetCompileDefinitionsCommand(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 cmTargetCompileDefinitionsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
return TargetCompileDefinitionsImpl(status).HandleArguments(
args, "COMPILE_DEFINITIONS");
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1de72c
leaq 0x59e6c2(%rip), %rax # 0x778350
movq %rax, (%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3fb4b1(%rip), %rsi # 0x5d5152
leaq 0x3fb4bd(%rip), %rdx # 0x5d5165
leaq 0x8(%rsp), %rdi
callq 0x... | /JKorbelRA[P]CMake/Source/cmTargetCompileDefinitionsCommand.cxx |
(anonymous namespace)::TargetCompileDefinitionsImpl::HandleMissingTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void HandleMissingTarget(const std::string& name) override
{
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
cmStrCat("Cannot specify compile definitions for target \"", name,
"\" which is not built by this project."));
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x30(%rdi), %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x28(%rsp), %rsi
movq $0x2f, (%rsi)
leaq 0x3e728e(%rip), %rdx # 0x5c104f
movq %rdx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq $0x25, 0x20(%rsi)
leaq 0x3d9177(%rip), %rax # 0x5b2f53
movq %rax, ... | /JKorbelRA[P]CMake/Source/cmTargetCompileDefinitionsCommand.cxx |
(anonymous namespace)::TargetCompileDefinitionsImpl::HandleDirectContent(cmTarget*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool, bool) | bool HandleDirectContent(cmTarget* tgt,
const std::vector<std::string>& content,
bool /*prepend*/, bool /*system*/) override
{
tgt->AppendProperty("COMPILE_DEFINITIONS", this->Join(content),
this->Makefile->GetBacktrace());
return t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3fb2e1(%rip), %rsi # 0x5d5152
leaq 0x3fb2ed(%rip), %rdx # 0x5d5165
leaq 0x28(%rsp), %rdi
callq 0x5b4c6
movq (%r14), %rax
leaq 0x48(%rsp), %rdi
movq %r14,... | /JKorbelRA[P]CMake/Source/cmTargetCompileDefinitionsCommand.cxx |
(anonymous namespace)::TargetCompileDefinitionsImpl::Join(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 Join(const std::vector<std::string>& content) override
{
std::string defs;
std::string sep;
for (std::string const& it : content) {
if (cmHasLiteralPrefix(it, "-D")) {
defs += sep + it.substr(2);
} else {
defs += sep + it;
}
sep = ";";
}
return d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq %rax, -0x8(%rsi)
movb %al, (%rsi)
movq (%rdx), %r14
movq 0x8(%rdx), %rbp
... | /JKorbelRA[P]CMake/Source/cmTargetCompileDefinitionsCommand.cxx |
cmTargetPropCommandBase::~cmTargetPropCommandBase() | virtual ~cmTargetPropCommandBase() = default; | leaq 0x59e3e3(%rip), %rax # 0x7785f8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x1da237
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x39320
retq
| /JKorbelRA[P]CMake/Source/cmTargetPropCommandBase.h |
(anonymous namespace)::TargetCompileFeaturesImpl::HandleMissingTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void HandleMissingTarget(const std::string& name) override
{
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
cmStrCat("Cannot specify compile features for target \"", name,
"\" which is not built by this project."));
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x30(%rdi), %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x28(%rsp), %rsi
movq $0x2c, (%rsi)
leaq 0x3e6d25(%rip), %rdx # 0x5c10ae
movq %rdx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq $0x25, 0x20(%rsi)
leaq 0x3d8baf(%rip), %rax # 0x5b2f53
movq %rax, ... | /JKorbelRA[P]CMake/Source/cmTargetCompileFeaturesCommand.cxx |
cmCMakePresetsGraphInternal::AnyAllOfCondition::Evaluate(std::vector<std::function<cmCMakePresetsGraphInternal::ExpandMacroResult (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::b... | bool cmCMakePresetsGraphInternal::AnyAllOfCondition::Evaluate(
const std::vector<MacroExpander>& expanders, int version,
cm::optional<bool>& out) const
{
for (auto const& condition : this->Conditions) {
cm::optional<bool> result;
if (!condition->Evaluate(expanders, version, result)) {
out.reset();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbx
cmpq %rbx, %r13
je 0x241bbe
movl %edx, %ebp
movq %rsi, %r15
leaq 0xe(%rsp), %r12
movb $0x0, 0xf(%rsp)
movq (%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
mo... | /JKorbelRA[P]CMake/Source/cmCMakePresetsGraph.cxx |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::BuildPreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::BuildPreset>::Bind<cmCMakePresetsGraph::Preset, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<ch... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0xc02(%rip), %rcx # 0x257e26
movq %rcx, 0x18(%rax)
leaq 0xc09(%rip), %rcx # 0x257e38
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x257a5a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x257258... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::BuildPreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::BuildPreset>::Bind<cmCMakePresetsGraph::BuildPreset, std::optional<int>, cmCMakePresetsGraph::ReadFileResult (*)(std::optional<int>&, ... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0xa8c(%rip), %rcx # 0x258054
movq %rcx, 0x18(%rax)
leaq 0xa93(%rip), %rcx # 0x258066
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x257a5a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2575fc... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::ConfigurePreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::ConfigurePreset>::Bind<cmCMakePresetsGraph::Preset, bool, cmCMakePresetsGraph::ReadFileResult (*)(bool&, Json::Value const*)>(std:... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1dbe(%rip), %rcx # 0x25b31e
movq %rcx, 0x18(%rax)
leaq 0x1dc5(%rip), %rcx # 0x25b330
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x259c9e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x259594... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::ConfigurePreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::ConfigurePreset>::Bind<cmCMakePresetsGraph::Preset, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocat... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1c90(%rip), %rcx # 0x25b6c0
movq %rcx, 0x18(%rax)
leaq 0x1c97(%rip), %rcx # 0x25b6d2
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x259c9e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x259a64... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::PackagePreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::PackagePreset>::Bind<cmCMakePresetsGraph::Preset, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocato... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1030(%rip), %rcx # 0x25d29e
movq %rcx, 0x18(%rax)
leaq 0x1037(%rip), %rcx # 0x25d2b0
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x25cae0
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x25c2a2... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::PackagePreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::PackagePreset>::Bind<std::nullptr_t, std::function<cmCMakePresetsGraph::ReadFileResult (std::nullptr_t&, Json::Value const*)>>(std::... | Object& Bind(const cm::string_view& name, std::nullptr_t, F func,
bool required = true)
{
return this->BindPrivate(name,
[func](T& /*out*/, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %r8d, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movq %rcx, %rsi
callq 0x2553a6
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x20, %edi
callq 0x39460
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%rs... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::PackagePreset>::operator()(cmCMakePresetsGraph::PackagePreset&, 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 0x25d808
movq %r14, %rdi
callq 0x45eb46
testb %al, %al
je 0x25d80e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::OutputOptions>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::OutputOptions>::Bind<cmCMakePresetsGraph::TestPreset::OutputOptions, std::optional<bool>, cmCMakePresetsGrap... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x3662(%rip), %rcx # 0x2622e4
movq %rcx, 0x18(%rax)
leaq 0x3669(%rip), %rcx # 0x2622f6
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x261f52
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x25ecb6... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::OutputOptions>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::OutputOptions>::Bind<cmCMakePresetsGraph::TestPreset::OutputOptions, std::__cxx11::basic_string<char, std::c... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x369c(%rip), %rcx # 0x2624e0
movq %rcx, 0x18(%rax)
leaq 0x36a3(%rip), %rcx # 0x2624f2
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x261f52
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x25ee78... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::IncludeOptions>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::IncludeOptions>::Bind<cmCMakePresetsGraph::TestPreset::IncludeOptions, std::optional<bool>, cmCMakePresetsG... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x41a8(%rip), %rcx # 0x2634f0
movq %rcx, 0x18(%rax)
leaq 0x41af(%rip), %rcx # 0x263502
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x2630ea
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x25f37c... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset>& cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset>::Bind<cmCMakePresetsGraph::TestPreset, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<... | Object& Bind(const cm::string_view& name, M U::*member, F func,
bool required = true)
{
return this->BindPrivate(name,
[func, member](T& out, const Json::Value* value,
CallState&&... state) -> E {
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x68d4(%rip), %rcx # 0x266f96
movq %rcx, 0x18(%rax)
leaq 0x68db(%rip), %rcx # 0x266fa8
movq %rcx, 0x10(%rax)
movq %rax, %rdx
movl %r8d, %ecx
callq 0x26699c
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2606f6... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::ExcludeOptions>::operator()(cmCMakePresetsGraph::TestPreset::ExcludeOptions&, 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 0x26473c
movq %r14, %rdi
callq 0x45eb46
testb %al, %al
je 0x264742
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::TestPreset::FilterOptions>::operator()(cmCMakePresetsGraph::TestPreset::FilterOptions&, 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 0x266738
movq %r14, %rdi
callq 0x45eb46
testb %al, %al
je 0x26673e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
std::function<cmCMakePresetsGraph::ReadFileResult (std::vector<cmCMakePresetsGraph::TestPreset, std::allocator<cmCMakePresetsGraph::TestPreset>>&, Json::Value const*)> cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::VectorFilter<cmCMakePresetsGraph::TestPreset, cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFil... | static cmJSONHelper<std::vector<T>, E, CallState...> VectorFilter(
E success, E fail, F func, Filter filter)
{
return [success, fail, func, filter](std::vector<T>& out,
const Json::Value* value,
CallState&&... state) -> E {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movl %esi, -0x8(%rbx)
movl %edx, -0x4(%rbx)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x261ce0
movq 0x18(%r15), %rax
movq 0x1d(%r15), %rcx
movq %rcx, 0x1d(%rbx)
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmJSONHelperBuilder<cmCMakePresetsGraph::ReadFileResult>::Object<cmCMakePresetsGraph::WorkflowPreset>::operator()(cmCMakePresetsGraph::WorkflowPreset&, 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 0x26a5be
movq %r14, %rdi
callq 0x45eb46
testb %al, %al
je 0x26a5c4
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %... | /JKorbelRA[P]CMake/Source/cmJSONHelpers.h |
cmCommandArgumentParserHelper::CombineUnions(char const*, char const*) | const char* cmCommandArgumentParserHelper::CombineUnions(const char* in1,
const char* in2)
{
if (!in1) {
return in2;
}
if (!in2) {
return in1;
}
size_t len = strlen(in1) + strlen(in2) + 1;
auto out = cm::make_unique<char[]>(len);
strcpy(out.... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
je 0x26b520
movq %rsi, %r15
testq %rbx, %rbx
je 0x26b51d
movq %rdi, %r14
movq %r15, %rdi
callq 0x39d50
movq %rax, %r12
movq %rbx, %rdi
callq 0x39d50
addq %rax, %r12
incq %r12
movq %r12, %rdi
callq 0x39fb0
movq %rax,... | /JKorbelRA[P]CMake/Source/cmCommandArgumentParserHelper.cxx |
cmCommonTargetGenerator::GetManifests(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmCommonTargetGenerator::GetManifests(const std::string& config)
{
std::vector<cmSourceFile const*> manifest_srcs;
this->GeneratorTarget->GetManifests(manifest_srcs, config);
std::vector<std::string> manifests;
manifests.reserve(manifest_srcs.size());
std::string lang = this->GeneratorTarget->Ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x8(%r12), %rdi
callq 0x2d412a
leaq 0x90(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0... | /JKorbelRA[P]CMake/Source/cmCommonTargetGenerator.cxx |
cmComputeLinkInformation::ComputeLinkTypeInfo() | void cmComputeLinkInformation::ComputeLinkTypeInfo()
{
// Check whether archives may actually be shared libraries.
this->ArchivesMayBeShared =
this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
"TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
// First assume we cannot do link type stuff.
this->LinkTypeE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0xd8(%rdi), %rax
movq 0x770(%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3640f8(%rip), %rsi # 0x5d3bcd
leaq 0x364113(%rip), %rdx # 0x5d3bef
leaq 0x8(%rsp), %rdi
callq 0x5b4c6
leaq 0x8(%rsp), ... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::GetRPathLinkString[abi:cxx11]() const | std::string cmComputeLinkInformation::GetRPathLinkString() const
{
// If there is no separate linker runtime search flag (-rpath-link)
// there is no reason to compute a string.
if (!this->OrderDependentRPath) {
return "";
}
// Construct the linker runtime search path. These MUST NOT contain tokens
// ... | pushq %rbx
movq %rdi, %rbx
movq 0x6c0(%rsi), %rdi
testq %rdi, %rdi
je 0x270fe6
callq 0x376400
leaq 0x3564e1(%rip), %rcx # 0x5c74af
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xec77a
jmp 0x270fff
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x39be95(%rip), %rdx # 0x60ce89... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::AddLibraryFeature(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmComputeLinkInformation::AddLibraryFeature(std::string const& feature)
{
auto it = this->LibraryFeatureDescriptors.find(feature);
if (it != this->LibraryFeatureDescriptors.end()) {
return it->second.Supported;
}
auto featureName =
cmStrCat("CMAKE_", this->LinkLanguage, "_LINK_LIBRARY_USING_", fea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6e0(%rdi), %r14
movq %r14, %rdi
callq 0x27bba4
leaq 0x6e8(%rbx), %rcx
cmpq %rcx, %rax
je 0x272966
movb 0x60(%rax), %bl
jmp 0x273ad8
movq %r14, 0x50(%rsp)
movq 0x100(%rbx), ... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::SetCurrentLinkType(cmComputeLinkInformation::LinkType) | void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
{
// If we are changing the current link type add the flag to tell the
// linker about it.
if (this->CurrentLinkType != lt) {
this->CurrentLinkType = lt;
if (this->LinkTypeEnabled) {
switch (this->CurrentLinkType) {
case LinkSta... | pushq %rax
cmpl %esi, 0x230(%rdi)
je 0x274cc7
movl %esi, 0x230(%rdi)
cmpb $0x1, 0x6d6(%rdi)
jne 0x274cc7
cmpl $0x2, %esi
je 0x274cb2
cmpl $0x1, %esi
jne 0x274cc7
leaq 0x238(%rdi), %rsi
leaq 0x4(%rsp), %rdx
jmp 0x274cbc
leaq 0x258(%rdi), %rsi
movq %rsp, %rdx
movl $0x0, (%rdx)
callq 0x27aa28
popq %rax
retq
nop
| /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::AddLibraryRuntimeInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget const*) | void cmComputeLinkInformation::AddLibraryRuntimeInfo(
std::string const& fullPath, cmGeneratorTarget const* target)
{
// Ignore targets on Apple where install_name is not @rpath.
// The dependenty library can be found with other means such as
// @loader_path or full paths.
if (this->Makefile->IsOn("CMAKE_PLAT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc8(%rdi), %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x35d4f6(%rip), %rsi # 0x5d40e6
leaq 0x35d50d(%rip), %rdx # 0x5d4104
leaq 0x8(%rsp), %rdi
callq 0x5b4c6
leaq 0x... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::AddLibraryRuntimeInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmComputeLinkInformation::AddLibraryRuntimeInfo(
std::string const& fullPath)
{
// Get the name of the library from the file name.
bool is_shared_library = false;
std::string file = cmSystemTools::GetFilenameName(fullPath);
if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
// Check that ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
callq 0x3f7718
movq 0xc8(%r14), %r15
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x35ca26(%rip), %rsi # 0x5d40e6
leaq 0x35ca3d(%rip), %rdx # 0x5d4104
leaq 0x20(%rsp), %rdi
callq... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmComputeLinkInformation::GetRPathString[abi:cxx11](bool) const | std::string cmComputeLinkInformation::GetRPathString(bool for_install) const
{
// Get the directories to use.
std::vector<std::string> runtimeDirs;
this->GetRPath(runtimeDirs, for_install);
// Concatenate the paths.
std::string rpath = cmJoin(runtimeDirs, this->GetRuntimeSep());
// If the rpath will be re... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x279406
movq 0x1c8(%r14), %rcx
movq 0x1d0(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9... | /JKorbelRA[P]CMake/Source/cmComputeLinkInformation.cxx |
cmGlobalGenerator::FrameworkDescriptor::GetLinkName[abi:cxx11]() const | std::string GetLinkName() const
{
return this->Suffix.empty() ? this->Name
: cmStrCat(this->Name, ',', this->Suffix);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %rcx
testq %rcx, %rcx
je 0x27ab08
movq 0x20(%rsi), %rdx
movq 0x28(%rsi), %rdi
leaq 0x10(%rsp), %r8
movl $0x1, %r9d
movq %r9, -0x10(%r8)
movq %r8, -0x8(%r8)
movb $0x2c, (%r8)
leaq 0x30(%rsp), %rax
movq %rdi, (%rax)
movq %rdx, 0x8(%rax)
movq %r9, 0x10(%rax)
mov... | /JKorbelRA[P]CMake/Source/cmGlobalGenerator.h |
cmCustomCommand::SetOutputs(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 cmCustomCommand::SetOutputs(std::vector<std::string> outputs)
{
this->Outputs = std::move(outputs);
} | subq $0x18, %rsp
movq 0x10(%rdi), %rax
movups (%rsi), %xmm0
movups (%rdi), %xmm1
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x5b438
addq $0x18, %rsp
retq
nop
| /JKorbelRA[P]CMake/Source/cmCustomCommand.cxx |
CxxModuleUsage::AddReference(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&, LookupMethod) | bool CxxModuleUsage::AddReference(std::string const& logical,
std::string const& loc, LookupMethod method)
{
auto r = this->Reference.find(logical);
if (r != this->Reference.end()) {
auto& ref = r->second;
if (ref.Path == loc && ref.Method == method) {
return true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x282abc
addq $0x38, %r13
cmpq %r13, %rax
je 0x281bae
movq %rax, %r14
movq 0x48(%rax), %r15
movq 0x8(%rbx), %r13
cmpq %r13, %r15
... | /JKorbelRA[P]CMake/Source/cmCxxModuleMapper.cxx |
cm::String::String<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | String(T&& s)
: String(IntoString<T>::into_string(std::forward<T>(s)), Private())
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x5b7c4
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /JKorbelRA[P]CMake/Source/cmString.hxx |
cmELFInternalImpl<cmELFTypes32>::cmELFInternalImpl(cmELF*, std::unique_ptr<std::istream, std::default_delete<std::istream>>, cmELFInternal::ByteOrderType) | cmELFInternalImpl<Types>::cmELFInternalImpl(cmELF* external,
std::unique_ptr<std::istream> fin,
ByteOrderType order)
: cmELFInternal(external, std::move(fin), order)
{
// Read the main header.
if (!this->Read(this->ELFHeader))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq (%rdx), %rax
xorl %edi, %edi
movq %rdi, (%rdx)
movq %rsi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl %ecx, 0x18(%rbx)
movl %edi, 0x1c(%rbx)
leaq 0x30(%rbx), %rax
movl %edi, 0x30(%rbx)
movq %rdi, 0... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::LoadDynamicSection() | bool cmELFInternalImpl<Types>::LoadDynamicSection()
{
// If there is no dynamic section we are done.
if (this->DynamicSectionIndex < 0) {
return false;
}
// If the section was already loaded we are done.
if (!this->DynamicSectionEntries.empty()) {
return true;
}
// If there are no entries we are... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x24(%rdi), %rax
testq %rax, %rax
js 0x285c7b
movq %rdi, %r14
movq 0xa8(%rdi), %rcx
movb $0x1, %bl
cmpq 0xb0(%rdi), %rcx
jne 0x285c7d
movq 0x90(%r14), %rdx
leaq (%rax,%rax,4), %rax
movl 0x24(%rdx,%rax,8), %ecx
testl %ecx, %ecx
je 0x285c... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::EncodeDynamicEntries(std::vector<std::pair<long, unsigned long>, std::allocator<std::pair<long, unsigned long>>> const&) | std::vector<char> cmELFInternalImpl<Types>::EncodeDynamicEntries(
const cmELF::DynamicEntryList& entries)
{
std::vector<char> result;
result.reserve(sizeof(ELF_Dyn) * entries.size());
for (auto const& entry : entries) {
// Store the entry in an ELF_Dyn, byteswap it, then serialize to chars
ELF_Dyn dyn;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
movq %rdi, 0x18(%rsp)
callq 0x28625c
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r15, %... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::PrintInfo(std::ostream&) const | void PrintInfo(std::ostream& os) const override
{
os << "ELF " << Types::GetName();
if (this->ByteOrder == ByteOrderMSB) {
os << " MSB";
} else if (this->ByteOrder == ByteOrderLSB) {
os << " LSB";
}
switch (this->ELFType) {
case cmELF::FileTypeInvalid:
os << " invalid fil... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x34ddad(%rip), %rsi # 0x5d4d0e
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3b4d0
leaq 0x3859e3(%rip), %rsi # 0x60c958
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3b4d0
movl 0x18(%r14), %eax
testl %eax, %eax
je 0x286f98
cmpl $0x1, %eax
jne 0x286fac
lea... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::LoadDynamicSection() | bool cmELFInternalImpl<Types>::LoadDynamicSection()
{
// If there is no dynamic section we are done.
if (this->DynamicSectionIndex < 0) {
return false;
}
// If the section was already loaded we are done.
if (!this->DynamicSectionEntries.empty()) {
return true;
}
// If there are no entries we are... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x24(%rdi), %rax
testq %rax, %rax
js 0x2874bb
movq %rdi, %r14
movq 0xb0(%rdi), %rcx
movb $0x1, %bl
cmpq 0xb8(%rdi), %rcx
jne 0x2874bd
movq 0x98(%r14), %r13
shlq $0x6, %rax
movq 0x38(%r13,%rax), %rcx
testq %rcx, %rcx
je 0x2874bb
leaq 0xb... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmExportFileGenerator::~cmExportFileGenerator() | virtual ~cmExportFileGenerator() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x4f1879(%rip), %rax # 0x77a880
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x100, %rdi # imm = 0x100
callq 0x5b438
leaq 0xd0(%rbx), %rdi
callq 0x208ebc
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x289044
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq 0x88(... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.h |
cmExportBuildFileGenerator::GenerateMainFile(std::ostream&) | bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
{
{
std::string expectedTargets;
std::string sep;
std::vector<std::string> targets;
bool generatedInterfaceRequired = false;
this->GetTargets(targets);
for (std::string const& tei : targets) {
cmGeneratorTarget* te = thi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x88(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::GetFileSetDirectories[abi:cxx11](cmGeneratorTarget*, cmFileSet*, cmTargetExport*) | std::string cmExportBuildFileGenerator::GetFileSetDirectories(
cmGeneratorTarget* gte, cmFileSet* fileSet, cmTargetExport* /*te*/)
{
std::vector<std::string> resultVector;
auto configs =
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
auto directoryEntries = fileSet->CompileDirectoryEnt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rcx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqa %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x8(%rdx), %rsi
leaq 0x90(%rsp), %rdi
xorl %edx, %edx
callq 0xa3ab8
mov... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportFileGenerator::cmExportFileGenerator() | cmExportFileGenerator::cmExportFileGenerator()
{
this->AppendMode = false;
this->ExportOld = false;
} | leaq 0x4ee481(%rip), %rax # 0x77a890
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::SetImportLinkInterface(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&, cmGeneratorExpression::PreprocessContext, cmGeneratorTarget const*, std::map<std::__cxx11::basic_str... | void cmExportFileGenerator::SetImportLinkInterface(
const std::string& config, std::string const& suffix,
cmGeneratorExpression::PreprocessContext preprocessRule,
cmGeneratorTarget const* target, ImportPropertyMap& properties)
{
// Add the transitive link dependencies for this configuration.
cmLinkInterface c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r12
movq %r8, %rdi
movq %r8, %rdx
callq 0x2f1ec6
testq %rax, %rax
je 0x28fc87
movq %rax, %r13
cmpb $0x1, 0xf0(%rax)
jne 0x28fadf
leaq 0x4... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GeneratePolicyHeaderCode(std::ostream&) | void cmExportFileGenerator::GeneratePolicyHeaderCode(std::ostream& os)
{
// Protect that file against use with older CMake versions.
/* clang-format off */
os << "# Generated by CMake\n\n";
os << "if(\"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}\" LESS 2.8)\n"
<< " message(FATAL_ERROR \"CMake >= 2.8.0 ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x322fcc(%rip), %rsi # 0x5b3432
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3b4d0
leaq 0x3457c3(%rip), %rsi # 0x5d5c3d
movl $0x3d, %edx
movq %rbx, %rdi
callq 0x3b4d0
leaq 0x3457ed(%rip), %rsi # 0x5d5c7b
movl $0x32, %edx
movq %rbx, %rdi
callq 0x3b4d0
leaq 0x309... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExternalMakefileProjectGeneratorFactory::GetName[abi:cxx11]() const | std::string cmExternalMakefileProjectGeneratorFactory::GetName() const
{
return this->Name;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5b7c4
movq %rbx, %rax
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.cxx |
cmExtraCodeBlocksGenerator::BuildMakeCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::... | std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
const std::string& make, const std::string& makefile,
const std::string& target, const std::string& makeFlags)
{
std::string command = make;
if (!makeFlags.empty()) {
command += " ";
command += makeFlags;
}
std::string generator = this->Glob... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x5b7c4
cmpq $0x0, 0x8(%r13)
je 0x297227
leaq 0x32c5ab(%ri... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
void cmXMLWriter::Attribute<char [13]>(char const*, char const (&) [13]) | void Attribute(const char* name, T const& value)
{
this->PreAttribute();
this->Output << name << "=\"" << SafeAttribute(value) << '"';
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3979fc
movq (%r14), %r14
testq %r15, %r15
je 0x297675
movq %r15, %rdi
callq 0x39d50
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3b4d0
jmp 0x29768d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%ra... | /JKorbelRA[P]CMake/Source/cmXMLWriter.h |
cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraCodeBlocksGenerator>::CreateExternalMakefileProjectGenerator() const | std::unique_ptr<cmExternalMakefileProjectGenerator>
CreateExternalMakefileProjectGenerator() const override
{
std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
p->SetName(this->GetName());
return p;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x48, %edi
callq 0x39460
movq %rax, %r14
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movq %rax, 0x28(%r14)
movq $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
leaq 0x4e2ed3(%rip), %rax # 0x77a9f0
... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.h |
cmExtraCodeLiteGenerator::cmExtraCodeLiteGenerator() | cmExtraCodeLiteGenerator::cmExtraCodeLiteGenerator()
: ConfigName("NoConfig")
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
leaq 0x4e257b(%rip), %rax # 0x77aa88
movq %rax, (%rdi)
addq $0x48, %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%r... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::GetConfigurationName[abi:cxx11](cmMakefile const*) const | std::string cmExtraCodeLiteGenerator::GetConfigurationName(
const cmMakefile* mf) const
{
std::string confName = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
// Trim the configuration name from whitespaces (left and right)
confName.erase(0, confName.find_first_not_of(" \t\r\v\n"));
confName.erase(confName.find_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x304a58(%rip), %rsi # 0x59d90e
leaq 0x304a61(%rip), %rdx # 0x59d91e
leaq 0x8(%rsp), %rdi
callq 0x5b4c6
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9cb42
leaq 0x10(%rbx),... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::CreateProjectFile(std::vector<cmLocalGenerator*, std::allocator<cmLocalGenerator*>> const&) | void cmExtraCodeLiteGenerator::CreateProjectFile(
const std::vector<cmLocalGenerator*>& lgs)
{
std::string const& outputDir = lgs[0]->GetCurrentBinaryDirectory();
std::string projectName = lgs[0]->GetProjectName();
std::string filename = outputDir + "/";
filename += projectName + ".project";
this->CreateNe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rdi
callq 0x86326
movq %rax, %r15
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
callq 0x8da04
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq ... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream&, char const*, cmLocalGenerator&) | void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
const char* envVar,
cmLocalGenerator& lg)
{
cmMakefile* mf = lg.GetMakefile();
// get the variables from the environment and from the cache and then
// figure out... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdx), %r12
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x3f4f74
movl %eax, %ebp
movq %r14, %r... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::WriteGroups(std::vector<cmSourceGroup, std::allocator<cmSourceGroup>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cmXMLWriter&) | void cmExtraEclipseCDT4Generator::WriteGroups(
std::vector<cmSourceGroup> const& sourceGroups, std::string& linkName,
cmXMLWriter& xml)
{
for (cmSourceGroup const& sg : sourceGroups) {
std::string linkName3 = cmStrCat(linkName, '/', sg.GetFullName());
std::replace(linkName3.begin(), linkName3.end(), '\\'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, 0x8(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0xa0(%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %rax
movq %rax, 0xa8(%rsp)
cmpq %rax, %r15
je 0x2a366d
leaq 0x20(%rsp), %rbp
leaq 0x48(%rsp), %r13
movq 0x40(%rs... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
void cmXMLWriter::Attribute<char [24]>(char const*, char const (&) [24]) | void Attribute(const char* name, T const& value)
{
this->PreAttribute();
this->Output << name << "=\"" << SafeAttribute(value) << '"';
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3979fc
movq (%r14), %r14
testq %r15, %r15
je 0x2a56e9
movq %r15, %rdi
callq 0x39d50
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3b4d0
jmp 0x2a5701
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%ra... | /JKorbelRA[P]CMake/Source/cmXMLWriter.h |
cmExtraSublimeTextGenerator::AppendAllTargets(std::vector<cmLocalGenerator*, std::allocator<cmLocalGenerator*>> const&, cmMakefile const*, cmGeneratedFileStream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>,... | void cmExtraSublimeTextGenerator::AppendAllTargets(
const std::vector<cmLocalGenerator*>& lgs, const cmMakefile* mf,
cmGeneratedFileStream& fout, MapSourceFileFlags& sourceFileFlags)
{
const std::string& make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
std::string compiler;
if (!lgs.empty()) {
this... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, 0x40(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x31afcb(%rip), %rsi # 0x5c378d
leaq 0x31afd6(%rip), %rdx # 0x5c379f
leaq 0x20(%rsp)... | /JKorbelRA[P]CMake/Source/cmExtraSublimeTextGenerator.cxx |
cmFileAPI::WriteReplies() | void cmFileAPI::WriteReplies()
{
if (this->QueryExists) {
cmSystemTools::MakeDirectory(this->APIv1 + "/reply");
this->WriteJsonFile(this->BuildReplyIndex(), "index", ComputeSuffixTime);
}
this->RemoveOldReplyFiles();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2abd9b
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5b7c4
leaq 0x32d353(%rip), %rsi # 0x5d903b
movq %r14, %rdi
callq 0x... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ObjectName[abi:cxx11](cmFileAPI::Object const&) | std::string cmFileAPI::ObjectName(Object const& o)
{
std::string name = cmStrCat(ObjectKindName(o.Kind), "-v", o.Version);
return name;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rax
leaq 0x4cd88b(%rip), %rcx # 0x77ace0
movq (%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x39d50
leaq 0x38(%rsp), %r12
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq $0x2, 0x10(%r12)
leaq 0x31659d(%rip), %rax ... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildInternalTest(cmFileAPI::Object const&) | Json::Value cmFileAPI::BuildInternalTest(Object const& object)
{
Json::Value test = Json::objectValue;
test["kind"] = this->ObjectKindName(object.Kind);
Json::Value& version = test["version"];
if (object.Version == 2) {
version = BuildVersion(2, InternalTestV2Minor);
} else {
version = BuildVersion(1,... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl $0x7, %esi
callq 0x45d0b8
movslq (%r14), %rax
leaq 0x4cd0cd(%rip), %rcx # 0x77ace0
movq (%rcx,%rax,8), %rsi
leaq 0x8(%rsp), %rdi
callq 0x45d264
leaq 0x32a89b(%rip), %rsi # 0x5d84c3
movq %rbx, %rdi
callq 0x45f9de
leaq 0x8(%rsp),... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
(anonymous namespace)::Target::DumpSource(cmGeneratorTarget::SourceAndKind const&, unsigned int) | Json::Value Target::DumpSource(cmGeneratorTarget::SourceAndKind const& sk,
Json::ArrayIndex si)
{
Json::Value source = Json::objectValue;
std::string const path = sk.Source.Value->ResolveFullPath();
source["path"] = RelativeIfUnder(this->TopSource, path);
if (sk.Source.Value->Get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movl %ecx, 0x16c(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl $0x7, %esi
callq 0x45d0b8
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd72f6
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
cmFileAPIToolchainsDump(cmFileAPI&, unsigned long) | Json::Value cmFileAPIToolchainsDump(cmFileAPI& fileAPI, unsigned long version)
{
Toolchains toolchains(fileAPI, version);
return toolchains.Dump();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r12
movq %rdi, %r14
movl $0x7, %esi
callq 0x45d0b8
leaq 0x178(%rsp), %rdi
movl $0x6, %esi
callq 0x45d0b8
movq %r14, (%rsp)
movq (%r12), %rax
movq 0x770(%rax), %rsi
leaq 0x160(%rsp), %rdi
callq 0xdfa6... | /JKorbelRA[P]CMake/Source/cmFileAPIToolchains.cxx |
cmFileCopier::SetPermissions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) | bool cmFileCopier::SetPermissions(const std::string& toFile,
mode_t permissions)
{
if (permissions) {
#ifdef _WIN32
if (Makefile->IsOn("CMAKE_CROSSCOMPILING")) {
// Store the mode in an NTFS alternate stream.
std::string mode_t_adt_filename = toFile + ":cmake_mode_t";... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movb $0x1, %bpl
testl %edx, %edx
je 0x2c3373
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x3f78c4
testl %eax, %eax
je 0x2c3373
leaq 0x20(%rsp), %rdi
callq 0x3b3d0
movq 0x18(%rbx), %r15
testq ... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::GetDefaultDirectoryPermissions(unsigned int**) | bool cmFileCopier::GetDefaultDirectoryPermissions(mode_t** mode)
{
// check if default dir creation permissions were set
cmValue default_dir_install_permissions = this->Makefile->GetDefinition(
"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS");
if (cmNonempty(default_dir_install_permissions)) {
std::vector<s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2d627f(%rip), %rsi # 0x599bd2
leaq 0x2d62a3(%rip), %rdx # 0x599bfd
leaq 0x8(%rsp), %rdi
callq 0x5b4c6
leaq 0x8(%rsp), %rsi
movq %r15, %r... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::CheckKeyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFileCopier::CheckKeyword(std::string const& arg)
{
if (arg == "DESTINATION") {
if (this->CurrentMatchRule) {
this->NotAfterMatch(arg);
} else {
this->Doing = DoingDestination;
}
} else if (arg == "FILES_FROM_DIR") {
if (this->CurrentMatchRule) {
this->NotAfterMatch(arg);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2f7e24(%rip), %rsi # 0x5bbb47
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x2c3e37
leaq 0x315c88(%rip), %rsi # 0x5d99c2
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x2c3e50
leaq 0x2f8706(%rip), %rsi # 0x5bc457
movq %r14, %rdi
c... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::CheckValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFileCopier::CheckValue(std::string const& arg)
{
switch (this->Doing) {
case DoingFiles:
this->Files.push_back(arg);
break;
case DoingDestination:
if (arg.empty() || cmSystemTools::FileIsFullPath(arg)) {
this->Destination = arg;
} else {
this->Destination =
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movl 0xf0(%rdi), %eax
addl $-0x2, %eax
cmpl $0x7, %eax
ja 0x2c4213
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x31590b(%rip), %rcx # 0x5d98c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x8(%r14)
je 0x2c3... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileInstaller::ReportCopy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmFileCopier::Type, bool) | void cmFileInstaller::ReportCopy(const std::string& toFile, Type type,
bool copy)
{
if (!this->MessageNever && (copy || !this->MessageLazy)) {
std::string message =
cmStrCat((copy ? "Installing: " : "Up-to-date: "), toFile);
this->Makefile->DisplayStatus(message, -1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0xff(%rdi)
jne 0x2c6823
testb %cl, %cl
je 0x2c67b2
leaq 0x3133ef(%rip), %rax # 0x5d9b9f
jmp 0x2c67c3
cmpb $0x0, 0xfe(%r14)
jne 0x2c6823
leaq 0x3133e9(%rip), %rax # 0x5d9bac
movq (%rbx), %rcx
mov... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
cmFileInstaller::HandleInstallDestination() | bool cmFileInstaller::HandleInstallDestination()
{
std::string& destination = this->Destination;
// allow for / to be a valid destination
if (destination.size() < 2 && destination != "/") {
this->Status.SetError("called with inappropriate arguments. "
"No DESTINATION provided or .")... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
cmpq $0x1, 0xa0(%rdi)
ja 0x2c7391
leaq 0x33f201(%rip), %rsi # 0x606532
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x2c7391
movq 0x8(%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
cmFileInstaller::GetTargetTypeFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFileInstaller::GetTargetTypeFromString(const std::string& stype)
{
if (stype == "EXECUTABLE") {
this->InstallType = cmInstallType_EXECUTABLE;
} else if (stype == "FILE") {
this->InstallType = cmInstallType_FILES;
} else if (stype == "PROGRAM") {
this->InstallType = cmInstallType_PROGRAMS;
} e... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2e0942(%rip), %rsi # 0x5a854f
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x2c7d4e
leaq 0x2e4b7f(%rip), %rsi # 0x5ac7a3
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x2c7d5a
leaq 0x2fbb5d(... | /JKorbelRA[P]CMake/Source/cmFileInstaller.cxx |
cmFileLockPool::Release(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmFileLockResult cmFileLockPool::Release(const std::string& filename)
{
for (auto& funcScope : this->FunctionScopes) {
const cmFileLockResult result = funcScope.Release(filename);
if (!result.IsOk()) {
return result;
}
}
for (auto& fileScope : this->FileScopes) {
const cmFileLockResult resu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r13
cmpq %r13, %r15
je 0x2c88a7
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2c8906
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x2c8fa2
testb %al, %al
je 0x2c88f2
ad... | /JKorbelRA[P]CMake/Source/cmFileLockPool.cxx |
cmReadGccDepfile(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, GccDepfilePrependPaths) | cm::optional<cmGccDepfileContent> cmReadGccDepfile(
const char* filePath, const std::string& prefix,
GccDepfilePrependPaths prependPaths)
{
cmGccDepfileLexerHelper helper;
if (!helper.readFile(filePath)) {
return cm::nullopt;
}
auto deps = cm::make_optional(std::move(helper).extractContent());
for (a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movups %xmm0, 0xc(%rdi)
movaps %xmm0, (%rdi)
callq 0x3d0cfc
testb %al, %al
je 0x2cb235
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r15
movq 0x60(%r... | /JKorbelRA[P]CMake/Source/cmGccDepfileReader.cxx |
cmGeneratorExpressionEvaluationFile::GetOutputFileName(cmLocalGenerator*, cmGeneratorTarget*, 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 cmGeneratorExpressionEvaluationFile::GetOutputFileName(
cmLocalGenerator* lg, cmGeneratorTarget* target, const std::string& config,
const std::string& lang)
{
std::string outputFileName =
this->OutputFileExpr->Evaluate(lg, config, target, nullptr, nullptr, lang);
if (cmSystemTools::FileIsFullPa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
movq %r9, (%rsp)
movq %rdx, %rsi
movq %r8, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2ccd16
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionEvaluationFile.cxx |
cmGeneratorExpressionEvaluationFile::CreateOutputFile(cmLocalGenerator*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
cmLocalGenerator* lg, std::string const& config)
{
std::vector<std::string> enabledLanguages;
cmGlobalGenerator* gg = lg->GetGlobalGenerator();
cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(this->Target);
gg->GetEnabledLanguages(enabledLan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x88(%rsi), %rbx
leaq 0x20(%rdi), %rsi
movq %r14, %rdi
callq 0x85cde
movq %rax, 0x28(%rsp)
movq %rsp, %rsi
movq %rbx... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionEvaluationFile.cxx |
cmGeneratorTarget::~cmGeneratorTarget() | cmGeneratorTarget::~cmGeneratorTarget() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x890, %rdi # imm = 0x890
callq 0x6d310
leaq 0x860(%rbx), %rdi
callq 0x108a66
leaq 0x7e8(%rbx), %rdi
callq 0x3010de
leaq 0x7b8(%rbx), %rdi
callq 0x301166
leaq 0x788(%rbx), %rdi
callq 0x3011f8
leaq 0x758(%rbx), %rdi
callq 0x3012a0
leaq 0x728(%rbx), %rdi
callq 0x301362
leaq 0x6... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetFilePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | std::string cmGeneratorTarget::GetFilePrefix(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
if (this->IsImported()) {
cmValue prefix = this->GetFilePrefixInternal(config, artifact);
return prefix ? *prefix : std::string();
}
std::string prefix;
std::string suffix;
std::str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0xf68be
testb %al, %al
je 0x2d0fcc
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x33bf1d(%rip), %rdx # 0x60ce89
leaq 0x8(%rsp), %rdi
movq %rd... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeObjectMapping() | void cmGeneratorTarget::ComputeObjectMapping()
{
auto const& configs =
this->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
std::set<std::string> configSet(configs.begin(), configs.end());
if (configSet == this->VisitedConfigsForObjects) {
return;
}
for (std::string const& c : configs... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xa3ab8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x38(%rsp), %rdi
callq 0x1b6e5e
movq 0x60(%rsp), %rax
cmpq 0xf0(%rbx), %rax
jne 0x2d3025
leaq 0x40(%rsp), %rsi... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetAllConfigSources() const | std::vector<cmGeneratorTarget::AllConfigSource> const&
cmGeneratorTarget::GetAllConfigSources() const
{
if (this->AllConfigSources.empty()) {
this->ComputeAllConfigSources();
}
return this->AllConfigSources;
} | pushq %rbx
leaq 0x3f0(%rdi), %rbx
movq 0x3f0(%rdi), %rax
cmpq 0x3f8(%rdi), %rax
jne 0x2d480d
callq 0x2d8e8c
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::BuildBundleDirectory(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&, cmGeneratorTarget::BundleDirectoryLevel) const | std::string cmGeneratorTarget::BuildBundleDirectory(
const std::string& base, const std::string& config,
BundleDirectoryLevel level) const
{
std::string fpath = base;
if (this->IsAppBundleOnApple()) {
fpath += this->GetAppBundleDirectory(config, level);
}
if (this->IsFrameworkOnApple()) {
fpath += t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x5b7c4
movq %r15, %rdi
callq 0x2d209a
testb %al, %al
je 0x2d5074
movq %rsp, %rdi
m... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetSourceFilePaths(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<BT<std::string>> cmGeneratorTarget::GetSourceFilePaths(
std::string const& config) const
{
std::vector<BT<std::string>> files;
if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) {
// At configure-time, this method can be called as part of getting the
// LOCATION prope... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x88(%rax), %rax
cmpb $0x0, 0x6e9(%rax)
movq %rdi, 0x10(%rsp)
je 0x2d6937
movq %rdi,... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::DetermineHasMacOSXRpathInstallNameDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmGeneratorTarget::DetermineHasMacOSXRpathInstallNameDir(
const std::string& config) const
{
bool install_name_is_rpath = false;
bool macosx_rpath = false;
if (!this->IsImported()) {
if (this->GetType() != cmStateEnums::SHARED_LIBRARY) {
return false;
}
cmValue install_name = this->GetPr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xf68be
testb %al, %al
je 0x2da23b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d44be
testq %rax, %rax
je 0x2da4da
cmpb $0x0, (%rax)
jne 0x2da2d0
movq 0x38(%rax), %rcx
te... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::IsWin32Executable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmGeneratorTarget::IsWin32Executable(const std::string& config) const
{
return cmIsOn(cmGeneratorExpression::Evaluate(
this->GetSafeProperty("WIN32_EXECUTABLE"), this->LocalGenerator, config));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2cce7e(%rip), %rsi # 0x5a8549
leaq 0x2cce87(%rip), %rdx # 0x5a8559
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x5b4c6
movq %r14, %rdi
movq %r15, %rsi
callq 0... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetFullNameInternal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | std::string cmGeneratorTarget::GetFullNameInternal(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
std::string prefix;
std::string base;
std::string suffix;
this->GetFullNameInternal(config, artifact, prefix, base, suffix);
return prefix + base + suffix;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetInstallNameDirForInstallTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGeneratorTarget::GetInstallNameDirForInstallTree(
const std::string& config, const std::string& installPrefix) const
{
if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
std::string dir;
cmValue install_name_dir = this->GetProperty("INSTALL_NAME_DIR");
if (this->CanGenerateInst... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, 0x30(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r13
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2f7e1b(%rip), %rsi # 0x5d40e6
leaq 0x2f7e32(%rip), %rdx # 0x5d4104
movq %rsp, %rdi
callq... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeLinkClosure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget::LinkClosure&, bool) const | bool cmGeneratorTarget::ComputeLinkClosure(const std::string& config,
LinkClosure& lc,
bool secondPass) const
{
// Get languages built in this target.
std::unordered_set<std::string> languages;
cmLinkImplementation const* impl =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xb0(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
m... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetMacContentDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmStateEnums::ArtifactType) const | std::string cmGeneratorTarget::GetMacContentDirectory(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
// Start with the output directory for the target.
std::string fpath = cmStrCat(this->GetDirectory(config, artifact), '/');
BundleDirectoryLevel level = ContentLevel;
if (this->IsFram... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2d4e82
movq (%r12), %rax
movq 0x8(%r12), %rcx
leaq 0x38(%rsp), %r12
movl $0x1, %edx
movq %rdx, -0x10(%r12)
movq %r12, -0x8(%r12)
movb $0x2f, (%r12)
leaq 0x58(%rsp), %... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeModuleDefinitionInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget::ModuleDefinitionInfo&) const | void cmGeneratorTarget::ComputeModuleDefinitionInfo(
std::string const& config, ModuleDefinitionInfo& info) const
{
this->GetModuleDefinitionSources(info.Sources, config);
info.WindowsExportAllSymbols =
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") &&
this->GetPropertyAsBool("WINDOWS_EX... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdx), %rsi
movq %r14, %rdx
callq 0x2d3f90
movq 0x8(%r15), %r12
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2fce23(%rip), %rsi # 0x5dae79
leaq 0x2fce44(%rip), %rdx # 0x5daea1
l... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmTargetTraceDependencies::CheckCustomCommands(std::vector<cmCustomCommand, std::allocator<cmCustomCommand>> const&) | cmValue cmGeneratorTarget::GetLanguageStandard(std::string const& lang,
std::string const& config) const
{
BTs<std::string> const* languageStandard =
this->GetLanguageStandardProperty(lang, config);
if (languageStandard) {
return cmValue(languageStandard->Valu... | pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x2deac5
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2def32
addq $0x138, %r14 # imm = 0x138
cmpq %r15, %r14
jne 0x2deaae
popq %rbx
popq %r14
popq %r15
retq
nop
| /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetIncludeDirectories(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<BT<std::string>> cmGeneratorTarget::GetIncludeDirectories(
const std::string& config, const std::string& lang) const
{
std::vector<BT<std::string>> includes;
std::unordered_set<std::string> uniqueIncludes;
cmGeneratorExpressionDAGChecker dagChecker(this, "INCLUDE_DIRECTORIES",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp # imm = 0x378
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x58(%rsp)
movq $0x0, 0x10(%rdi)
leaq 0x2f0(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xm... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetCompileFeatures(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<BT<std::string>> cmGeneratorTarget::GetCompileFeatures(
std::string const& config) const
{
std::vector<BT<std::string>> result;
std::unordered_set<std::string> uniqueFeatures;
cmGeneratorExpressionDAGChecker dagChecker(this, "COMPILE_FEATURES", nullptr,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0xd0(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetCompileDefinitions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<BT<std::string>> cmGeneratorTarget::GetCompileDefinitions(
std::string const& config, std::string const& language) const
{
std::vector<BT<std::string>> list;
std::unordered_set<std::string> uniqueOptions;
cmGeneratorExpressionDAGChecker dagChecker(this, "COMPILE_DEFINITIONS",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x48(%rsp)
movq $0x0, 0x10(%rdi)
leaq 0x140(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xm... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeVersionedName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_strin... | void cmGeneratorTarget::ComputeVersionedName(
std::string& vName, std::string const& prefix, std::string const& base,
std::string const& suffix, std::string const& name, cmValue version) const
{
vName = this->Makefile->IsOn("APPLE") ? (prefix + base) : name;
if (version) {
vName += ".";
vName += *versio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, 0x40(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2ad3ca(%rip), %rsi # 0x59a1d8
leaq 0x2ad3c8(%rip), %rdx # ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
char const* getTypedProperty<char const*>(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorExpressionInterpreter*) | const char* getTypedProperty<const char*>(
cmGeneratorTarget const* tgt, const std::string& prop,
cmGeneratorExpressionInterpreter* genexInterpreter)
{
cmValue value = tgt->GetProperty(prop);
if (genexInterpreter == nullptr) {
return value.GetCStr();
}
return genexInterpreter->Evaluate(value ? *value ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
callq 0x2d0626
movq %rax, %rbx
testq %r15, %r15
je 0x2ef0c4
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
testq %rbx, %rbx
je 0x2ef0ce
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5b7c4
jmp... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetLinkInformation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | cmComputeLinkInformation* cmGeneratorTarget::GetLinkInformation(
const std::string& config) const
{
// Lookup any existing information for this configuration.
std::string key(cmSystemTools::UpperCase(config));
auto i = this->LinkInformation.find(key);
if (i == this->LinkInformation.end()) {
// Compute inf... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3f6026
leaq 0x2d0(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3094b8
movq %rax, %r12
leaq 0x2d8(%r14), %rax
cmpq %rax, %r12
jne 0x2ef456
movl $0x740, %edi # imm = ... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetTargetVersion(int&, int&) const | void cmGeneratorTarget::GetTargetVersion(int& major, int& minor) const
{
int patch;
this->GetTargetVersion("VERSION", major, minor, patch);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x306a8c(%rip), %rsi # 0x5f688a
leaq 0x306a8c(%rip), %rdx # 0x5f6891
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x5b4c6
leaq 0xc(%rsp), %r8
mov... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::GetRuntimeLinkLibrary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGeneratorTarget::GetRuntimeLinkLibrary(
std::string const& lang, std::string const& config) const
{
// This is activated by the presence of a default selection whether or
// not it is overridden by a property.
cmValue runtimeLibraryDefault = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", la... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
leaq 0x48(%rsp), %rsi
movq $0x6, (%rsi)
leaq 0x2b435e(%rip), %rdx # 0x5a4306
movq %rdx, 0x8(%rsi)
movq %... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::CreateFortranModuleDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmGeneratorTarget::CreateFortranModuleDirectory(
std::string const& working_dir) const
{
std::string mod_dir;
std::string target_mod_dir;
if (cmValue prop = this->GetProperty("Fortran_MODULE_DIRECTORY")) {
target_mod_dir = *prop;
} else {
std::string const& default_mod_dir =
this->Lo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ExpandLinkItems(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmRange<__gnu_cxx::__normal_iterator<BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<BT<std::__cxx11::basic_string<char, std::char_traits<char>... | void cmGeneratorTarget::ExpandLinkItems(
std::string const& prop, cmBTStringRange entries, std::string const& config,
cmGeneratorTarget const* headTarget, LinkInterfaceFor interfaceFor,
LinkInterfaceField field, cmLinkInterface& iface) const
{
if (entries.empty()) {
return;
}
// Keep this logic in sync ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %r9, 0x18(%rsp)
movq %r8, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
cmpq %rcx, %rdx
je 0x2f1da7
movq %rdx, %r12
movq %rdi, %r13
leaq 0x178(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
ad... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGeneratorTarget::ComputeLinkInterfaceRuntimeLibraries(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmOptionalLinkInterface&) const | void cmGeneratorTarget::ComputeLinkInterfaceRuntimeLibraries(
const std::string& config, cmOptionalLinkInterface& iface) const
{
for (std::string const& lang : iface.Languages) {
if ((lang == "CUDA" || lang == "HIP") &&
iface.LanguageRuntimeLibraries.find(lang) ==
iface.LanguageRuntimeLibrarie... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, 0xf8(%rsp)
movq %rdi, 0xf0(%rsp)
movq 0x68(%rdx), %r12
movq %rdx, (%rsp)
movq 0x70(%rdx), %rax
movq %rax, 0x100(%rsp)
cmpq %rax, %r12
je 0x2f38ce
subq $-0x80, (%rsp)
leaq 0x8(%rsp), %r14
leaq 0x90(%rs... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.