name string | code string | asm string | file string |
|---|---|---|---|
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmAppendPathSegmentGenerator&>(cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<char, std::... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f94e0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3f9520
leaq -0x40(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x1, %al
jne 0x3fa329
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmCaseInsensitiveDirectoryListGenerator>(cmFindPackageCommand::SearchAppBundlePrefix(std::__cxx11::basic_string<c... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fa600
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3f88d0
leaq -0x40(%rbp), %rdi
callq 0x3b870
xorb $-0x1, %al
testb $0x1, %al
jne 0x3fa669
mov... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
cmMakefile::SetGlobalTargetImportScope::SetGlobalTargetImportScope(cmMakefile*, cmMakefile::ImportedTargetScope) | SetGlobalTargetImportScope(cmMakefile* mk, ImportedTargetScope const scope)
: Makefile(mk)
{
if (scope == ImportedTargetScope::Global &&
!this->Makefile->IsImportedTargetGlobalScope()) {
this->Makefile->CurrentImportedTargetScope = scope;
this->Set = true;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
cmpl $0x1, -0x14(%rbp)
jne 0x3fbcce
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x221e90
testb $0x1, %al
jne 0x3fbcce
m... | /JKorbelRA[P]CMake/Source/cmMakefile.h |
cmFindPathCommand::FindFrameworkHeader[abi:cxx11](cmFindBaseDebugState&) | std::string cmFindPathCommand::FindFrameworkHeader(cmFindBaseDebugState& debug)
{
for (std::string const& n : this->Names) {
for (std::string const& sp : this->SearchPaths) {
std::string fwPath = this->FindHeaderInFramework(n, sp, debug);
if (!fwPath.empty()) {
return fwPath;
}
}
}... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x1f0, %rax # imm = 0x1F0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x622... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindPathCommand::FindHeaderInFramework(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&, cmFindBaseDebugState&) const | std::string cmFindPathCommand::FindHeaderInFramework(
std::string const& file, std::string const& dir,
cmFindBaseDebugState& debug) const
{
std::string fileName = file;
std::string frameWorkName;
std::string::size_type pos = fileName.find('/');
// if there is a / in the name try to find the header as a fram... | pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp # imm = 0x3C0
movq %rdi, -0x340(%rbp)
movq %rdi, %rax
movq %rax, -0x338(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x330(%rbp)
movq -0x18(%rbp), %rsi
lea... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindProgramCommand::cmFindProgramCommand(cmExecutionStatus&) | cmFindProgramCommand::cmFindProgramCommand(cmExecutionStatus& status)
: cmFindBase("find_program", status)
{
this->NamesPerDirAllowed = true;
this->VariableDocumentation = "Path to a program.";
this->VariableType = cmStateEnums::FILEPATH;
// Windows Registry views
// When policy CMP0134 is not NEW, rely on ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3c460
movq -0x90(%rbp), %rdx
leaq 0x75ca88(%rip), %rsi # 0xb65b74
leaq -0x30(%rbp), %rdi
callq 0x606e0
jmp 0x4090f7
movq -0x98(%r... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::InitialPass(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
{
this->CMakePathName = "PROGRAM";
// call cmFindBase::ParseArguments
if (!this->ParseArguments(argsIn)) {
return false;
}
this->DebugMode = this->ComputeIfDebugModeWanted(this->VariableName);
if (this->AlreadyDefined) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
leaq 0x746ee5(%rip), %rsi # 0xb501fc
callq 0x3b9f0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindProgram[abi:cxx11]() | std::string cmFindProgramCommand::FindProgram()
{
std::string program;
if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
program = this->FindAppBundle();
}
if (program.empty() && !this->SearchAppBundleOnly) {
program = this->FindNormalProgram();
}
if (program.empty() && this->SearchAp... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3d1f0
movq -0x90(%rbp), %rax
testb $0x1, 0x173(%rax)
jne 0x409428
movq -0x90(%rbp), %rax
tes... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindAppBundle[abi:cxx11]() | std::string cmFindProgramCommand::FindAppBundle()
{
for (std::string const& name : this->Names) {
std::string appName = name + std::string(".app");
std::string appPath =
cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
if (!appPath.empty()) {
std::string executable = this->Get... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
addq $0x1f0, %rax # imm = 0x1F0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindNormalProgramDirsPerName[abi:cxx11]() | std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
{
// Search the entire path for each name.
cmFindProgramHelper helper(this->FindCommandName, this->Makefile, this);
for (std::string const& n : this->Names) {
// Switch to searching for this name.
helper.SetName(n);
// Check for the nam... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x1c0(%rbp)
addq $0x188, %rsi # imm = 0x188
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
cal... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::GetBundleExecutable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmFindProgramCommand::GetBundleExecutable(
std::string const& bundlePath)
{
std::string executable;
(void)bundlePath;
#if defined(__APPLE__)
// Started with an example on developer.apple.com about finding bundles
// and modified from that.
// Get a CFString of the app bundle path
// XXX - Is ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3d1f0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x409e9b
movq -0x30(%rbp), %rdi
callq 0x3e568
movq -0x28(%... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::cmFindProgramHelper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmMakefile*, cmFindBase const*) | cmFindProgramHelper(std::string debugName, cmMakefile* makefile,
cmFindBase const* base)
: DebugSearches(std::move(debugName), base)
, Makefile(makefile)
, FindBase(base)
, PolicyCMP0109(makefile->GetPolicyStatus(cmPolicies::CMP0109))
{
#if defined(_WIN32) || defined(__CYGWIN__) ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x60530
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x90(%rbp)
c... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::CheckCompoundNames() | bool CheckCompoundNames()
{
return std::any_of(this->Names.begin(), this->Names.end(),
[this](std::string const& n) -> bool {
// Only perform search relative to current directory
// if the file name contains a directory separator.
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
callq 0x62290
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x38, %rdi
callq 0x622c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp)... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::CheckDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool CheckDirectory(std::string const& path)
{
return std::any_of(this->Names.begin(), this->Names.end(),
[this, &path](std::string const& n) -> bool {
// Only perform search relative to current directory
// if the file name contains a direc... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
callq 0x62290
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
callq 0x622c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rax, -0x30... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::~cmFindProgramHelper() | cmFindProgramHelper(std::string debugName, cmMakefile* makefile,
cmFindBase const* base)
: DebugSearches(std::move(debugName), base)
, Makefile(makefile)
, FindBase(base)
, PolicyCMP0109(makefile->GetPolicyStatus(cmPolicies::CMP0109))
{
#if defined(_WIN32) || defined(__CYGWIN__) ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x90, %rdi
callq 0x74af60
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x3e568
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x3e568
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x62750
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::CheckDirectoryForName(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 CheckDirectoryForName(std::string const& path, std::string const& name)
{
return std::any_of(this->Extensions.begin(), this->Extensions.end(),
[this, &path, &name](std::string const& ext) -> bool {
if (!ext.empty() && cmHasSuffix(name, ext)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x62290
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x622c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x40(%rbp)
movq... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::FileIsExecutableCMP0109(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool FileIsExecutableCMP0109(std::string const& file) const
{
switch (this->PolicyCMP0109) {
case cmPolicies::OLD:
return cmSystemTools::FileExists(file, true);
case cmPolicies::NEW:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::REQUIRED_IF_USED:
return cmSystemTools::... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movl 0x120(%rax), %eax
movl %eax, -0x174(%rbp)
testl %eax, %eax
je 0x40b020
jmp 0x40b010
movl -0x174(%rbp), %eax
addl $-0x2, %eax
subl $0x3, %eax
jb 0x40b038... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
(anonymous namespace)::TryParseInteger(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) | bool TryParseInteger(cmExecutionStatus& status, const std::string& str, int& i)
{
try {
i = std::stoi(str);
} catch (std::invalid_argument&) {
std::ostringstream e;
e << "Invalid integer: '" << str << "'";
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccurred();
return false;
} ca... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xd33b0
movl %eax, -0x374(%rbp)
jmp 0x40cbd1
movl -0x374(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
(anonymous namespace)::cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile*) | cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf)
: Makefile(mf)
{
this->Makefile->PushLoopBlock();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x40ee20
movq -0x28(%rbp), %rdi
leaq 0xadee68(%rip), %rax # 0xeebe70
movq %rax, (%rdi)
addq $0x98, %rdi
movq %rdi, -0x30(%rbp)
callq 0x60530
movq -0x28(%rbp), %rax
movq -0x10(%r... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
(anonymous namespace)::cmForEachFunctionBlocker::ReplayZipLists(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>> const&, cmExecutionStatus&) | bool cmForEachFunctionBlocker::ReplayZipLists(
std::vector<cmListFileFunction> const& functions,
cmExecutionStatus& inStatus)
{
assert("Unexpected number of iteration variables" &&
this->IterationVarsCount >= 1);
auto& mf = inStatus.GetMakefile();
// Expand the list of list-variables into a list of... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
cmpq $0x1, 0xb8(%rax)
jb 0x40d31e
jmp 0x40d33d
leaq 0x7659a5(%rip), %rdi # 0xb72cca
leaq 0x7657e4(%rip), %rsi # 0xb72b10
movl $0x9... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
(anonymous namespace)::cmForEachFunctionBlocker::invoke(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>> const&, cmExecutionStatus&, cmMakefile&) | auto cmForEachFunctionBlocker::invoke(
std::vector<cmListFileFunction> const& functions,
cmExecutionStatus& inStatus, cmMakefile& mf) -> InvokeResult
{
InvokeResult result = { true, false };
// Invoke all the functions that were collected in the block.
for (cmListFileFunction const& func : functions) {
cm... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movw 0x764bfa(%rip), %ax # 0xb72efc
movw %ax, -0x2(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x410ab0
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
bool cmArgumentParser<cmBlockCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmExecutionStatus&)::Arguments>::Parse<std::vector<std::__cxx11::basic_string<char, std... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4126c0
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
(anonymous namespace)::BlockScopePushPop::BlockScopePushPop(cmMakefile*, cm::enum_set<(anonymous namespace)::ScopeType, 0> const&) | BlockScopePushPop::BlockScopePushPop(cmMakefile* mf, const ScopeSet& scopes)
{
if (scopes.contains(ScopeType::POLICIES)) {
this->PolicyScope = cm::make_unique<cmMakefile::PolicyPushPop>(mf);
}
if (scopes.contains(ScopeType::VARIABLES)) {
this->VariableScope = cm::make_unique<cmMakefile::VariablePushPop>(m... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x413680
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x4136b0
movq -0x18(%rbp), %rdi
movl $0x1... | /JKorbelRA[P]CMake/Source/cmBlockCommand.cxx |
(anonymous namespace)::cmBlockFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmBlockFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
cmExecutionStatus& inStatus)
{
auto& mf = inStatus.GetMakefile();
// Invoke all the functions that were collected in the block.
for (cmListFileFunction const& fn : functions) {
cmExecutionStatus... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rsi, -0xf0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2bfb20
movq -0xf0(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d72d0
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmBlockCommand.cxx |
(anonymous namespace)::cmFunctionHelperCommand::operator()(std::vector<cmListFileArgument, std::allocator<cmListFileArgument>> const&, cmExecutionStatus&) const | bool cmFunctionHelperCommand::operator()(
std::vector<cmListFileArgument> const& args,
cmExecutionStatus& inStatus) const
{
cmMakefile& makefile = inStatus.GetMakefile();
// Expand the argument list to the function.
std::vector<std::string> expandedArgs;
makefile.ExpandArguments(args, expandedArgs);
// ... | pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3c8(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2bfb20
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x3c0(%rbp)
callq 0x60530
movq -0x3c0(... | /JKorbelRA[P]CMake/Source/cmFunctionCommand.cxx |
cmGetDirectoryPropertyCommand(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 cmGetDirectoryPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
auto i = args.begin();
std::string const& variable = *i;
++i;
... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x4173c8
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x3c460
movq -0x1b0(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmGetDirectoryPropertyCommand.cxx |
cmGetFilenameComponentCommand(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 cmGetFilenameComponentCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("called with incorrect number of arguments");
cmSystemTools::SetFatalErrorOccurred();
return false;
}
// Check and see if the... | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x417cad
movq -0x18(%rbp), %rax
movq %rax, -0x360(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x358(%rbp)
callq 0x3c460
movq -0x358(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmGetFilenameComponentCommand.cxx |
cmGetPropertyCommand(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 cmGetPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
OutType infoType = OutValue;
if (args.size() < 3) {
status.SetError("called with incorrect number of arguments");
return false;
}
// The cmake variable in which to store the result.
... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x418b7f
movq -0x18(%rbp), %rax
movq %rax, -0x2e0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x3c460
movq -0... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
(anonymous namespace)::HandleGlobalMode(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (anonymous namespace)::OutType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char... | bool HandleGlobalMode(cmExecutionStatus& status, const std::string& name,
OutType infoType, const std::string& variable,
const std::string& propertyName)
{
if (!name.empty()) {
status.SetError("given name for GLOBAL scope.");
return false;
}
// Get the property... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x419b9b
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
call... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
(anonymous namespace)::HandleDirectoryMode(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (anonymous namespace)::OutType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<c... | bool HandleDirectoryMode(cmExecutionStatus& status, const std::string& name,
OutType infoType, const std::string& variable,
const std::string& propertyName)
{
// Default to the current directory.
cmMakefile* mf = &status.GetMakefile();
// Lookup the directory if ... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2bfb20
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x419dd1
movq -0x1... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
(anonymous namespace)::HandleCacheMode(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (anonymous namespace)::OutType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>... | bool HandleCacheMode(cmExecutionStatus& status, const std::string& name,
OutType infoType, const std::string& variable,
const std::string& propertyName)
{
if (name.empty()) {
status.SetError("not given name for CACHE scope.");
return false;
}
cmValue value = null... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x41a930
jmp 0x41a9c2
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
bool (anonymous namespace)::StoreResult<cmValue>((anonymous namespace)::OutType, cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmValue) | bool StoreResult(OutType infoType, cmMakefile& makefile,
const std::string& variable, ValueType value)
{
if (infoType == OutSet) {
makefile.AddDefinition(variable, value ? "1" : "0");
} else // if(infoType == OutValue)
{
if (value) {
makefile.AddDefinition(variable, value);
} el... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x4, -0xc(%rbp)
jne 0x41adaa
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x62230
testb $0x1, %al
jne 0x4... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
bool (anonymous namespace)::StoreResult<char const*>((anonymous namespace)::OutType, cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool StoreResult(OutType infoType, cmMakefile& makefile,
const std::string& variable, ValueType value)
{
if (infoType == OutSet) {
makefile.AddDefinition(variable, value ? "1" : "0");
} else // if(infoType == OutValue)
{
if (value) {
makefile.AddDefinition(variable, value);
} el... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0x41ae62
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41ae31
leaq 0x7b6e3d(%rip), %r... | /JKorbelRA[P]CMake/Source/cmGetPropertyCommand.cxx |
cmGetSourceFilePropertyCommand(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 cmGetSourceFilePropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
std::vector<std::string>::size_type args_size = args.size();
if (args_size != 3 && args_size != 5) {
status.SetError("called with incorrect number of arguments");
return... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
movq %rax, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
je 0x41b0e8
cmpq $0x5, -0x20(%rbp)
je 0x41b0e8
movq -0x18(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x41(%rbp), %rdi
movq... | /JKorbelRA[P]CMake/Source/cmGetSourceFilePropertyCommand.cxx |
cmGetTargetPropertyCommand(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 cmGetTargetPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("called with incorrect number of arguments");
return false;
}
std::string const& var = args[0];
std::string const& targetName = args[... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x41b678
movq -0x18(%rbp), %rax
movq %rax, -0x2d0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x3c460
movq -0x2c8(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmGetTargetPropertyCommand.cxx |
cmGetTestPropertyCommand(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 cmGetTestPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("called with incorrect number of arguments");
return false;
}
std::string const& testName = args[0];
std::string const& var = args[2];
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x41bdc8
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3c460
movq -0xa8(%rbp), %rdx
leaq 0x753c1d(%rip), %rsi # 0xb6... | /JKorbelRA[P]CMake/Source/cmGetTestPropertyCommand.cxx |
cmHexFileConverter::DetermineFileType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmHexFileConverter::FileType cmHexFileConverter::DetermineFileType(
const std::string& inFileName)
{
char buf[1024];
FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb");
if (inFile == nullptr) {
return Binary;
}
if (!fgets(buf, 1024, inFile)) {
buf[0] = 0;
}
fclose(inFile);
FileType ty... | pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp # imm = 0x430
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x752a6c(%rip), %rsi # 0xb6e9c6
callq 0x7f8520
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
jne 0x41bf7c
movl $0x0, -0x4(%rbp)
jmp 0x41c0bd
leaq -0x410(%rbp), %rdi
movq -0x418(%rbp), %rdx
movl ... | /JKorbelRA[P]CMake/Source/cmHexFileConverter.cxx |
ChompStrlen(char const*) | static unsigned int ChompStrlen(const char* line)
{
if (line == nullptr) {
return 0;
}
unsigned int length = static_cast<unsigned int>(strlen(line));
if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
length--;
}
if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
length... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41c0ec
movl $0x0, -0x4(%rbp)
jmp 0x41c164
movq -0x10(%rbp), %rdi
callq 0x3b8f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je ... | /JKorbelRA[P]CMake/Source/cmHexFileConverter.cxx |
cmHexFileConverter::TryConvert(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 cmHexFileConverter::TryConvert(const std::string& inFileName,
const std::string& outFileName)
{
FileType type = DetermineFileType(inFileName);
if (type == Binary) {
return false;
}
// try to open the file
FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb");... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41bf40
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x41c19e
movb $0x0, -0x1(%rbp)
jmp 0x41c277
movq -0x10(%rbp), %rdi
leaq 0x75281d(%rip), %rsi # 0xb6e9c6
callq 0x7... | /JKorbelRA[P]CMake/Source/cmHexFileConverter.cxx |
ConvertMotorolaSrecLine(char const*, _IO_FILE*) | static bool ConvertMotorolaSrecLine(const char* buf, FILE* outFile)
{
unsigned int slen = ChompStrlen(buf);
if ((slen < MOTOROLA_SREC_MIN_LINE_LENGTH) ||
(slen > MOTOROLA_SREC_MAX_LINE_LENGTH)) {
return false;
}
// line length must be even
if (slen % 2 == 1) {
return false;
}
if (buf[0] !=... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41c0d0
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jb 0x41c2bb
cmpl $0x20e, -0x1c(%rbp) # imm = 0x20E
jbe 0x41c2c4
movb $0x0, -0x1(%rbp)
jmp 0x41c395
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl... | /JKorbelRA[P]CMake/Source/cmHexFileConverter.cxx |
(anonymous namespace)::HandleDirectoryMode(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 HandleDirectoryMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
Helper helper(status);
enum Doing
{
DoingNone,
DoingDirs,
DoingDestination,
DoingPattern,
DoingRegex,
DoingPermsFile,
DoingPermsDir,
DoingPermsMatch,
DoingConfi... | pushq %rbp
movq %rsp, %rbp
subq $0xe60, %rsp # imm = 0xE60
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4302f0
movl $0x1, -0x4c(%rbp)
movb $0x0, -0x4d(%rbp)
movb $0x0, -0x4e(%rbp)
movb $0x0, -0x4f(%rbp)
movb $0x0, -0x50(%rbp)
leaq -0x68(%rbp), %rdi
callq... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::HandleExportMode(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 HandleExportMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
Helper helper(status);
// This is the EXPORT mode.
cmInstallCommandArguments ica(helper.DefaultComponentName);
std::string exp;
std::string name_space;
bool exportOld = false;
std::string filen... | pushq %rbp
movq %rsp, %rbp
subq $0x900, %rsp # imm = 0x900
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4302f0
leaq -0x38(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x3b400
jmp 0x42dc62
leaq -0x200(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x4450e0
jmp 0x... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::HandleRuntimeDependencySetMode(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 HandleRuntimeDependencySetMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
Helper helper(status);
auto system = helper.Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME");
if (!cmRuntimeDependencyArchive::PlatformSupportsRuntimeDependencies(
... | pushq %rbp
movq %rsp, %rbp
subq $0xdc0, %rsp # imm = 0xDC0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4302f0
movq -0x40(%rbp), %rax
movq %rax, -0xcc0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xcb8(%rbp)
callq 0x3c460
movq -0xcb8(%rbp), %rdx
leaq 0x72fb... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::Helper(cmExecutionStatus&) | Helper(cmExecutionStatus& status)
: Status(status)
, Makefile(&status.GetMakefile())
{
this->DefaultComponentName = this->Makefile->GetSafeDefinition(
"CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
if (this->DefaultComponentName.empty()) {
this->DefaultComponentName = "Unspecified";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2bfb20
movq -0x60(%rbp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3d1f0
movq -0x6... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
bool cmArgumentParser<(anonymous namespace)::RuntimeDependenciesArgs>::Parse<ArgumentParser::MaybeEmpty<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>((anonymous namespace)::Run... | bool Parse(Result& result, Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
using ArgumentParser::AsParseResultPtr;
ParseResult* parseResultPtr = AsParseResultPtr(result);
Instance instance(this->Bindings, parseResultPtr, unparsedArgume... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4334d0
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
(anonymous namespace)::Helper::MakeFilesFullPath(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::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | bool Helper::MakeFilesFullPath(const char* modeName,
const std::string& basePath,
const std::vector<std::string>& relFiles,
std::vector<std::string>& absFiles)
{
for (std::string const& relFile : relFiles) {
std::string f... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62f40
movq %... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::GetDestinationForType(cmInstallCommandArguments const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string Helper::GetDestinationForType(
const cmInstallCommandArguments* args, const std::string& type) const
{
if (args && !args->GetDestination().empty()) {
return args->GetDestination();
}
if (type == "BIN") {
return this->GetRuntimeDestination(nullptr);
}
if (type == "SBIN") {
return this... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4360e1
movq -0x18(%rbp), %rdi
callq 0x4456e0
movq... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
cmInstallCommandArguments::GetComponent[abi:cxx11]() const | const std::string& cmInstallCommandArguments::GetComponent() const
{
if (!this->Component.empty()) {
return this->Component;
}
if (this->GenericArguments != nullptr) {
return this->GenericArguments->GetComponent();
}
if (!this->DefaultComponentName.empty()) {
return this->DefaultComponentName;
}... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x90, %rdi
callq 0x3b870
testb $0x1, %al
jne 0x445787
movq -0x30(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x8(%rbp)
jmp 0x445874
movq -0x30(%rbp), %rax
cmpq $0x0, 0x190(%rax)
je 0x4457ae
movq -0x30(%rb... | /JKorbelRA[P]CMake/Source/cmInstallCommandArguments.cxx |
cmInstallCommandArguments::CheckPermissions(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 cmInstallCommandArguments::CheckPermissions(
const std::string& onePermission, std::string& permissions)
{
// Check the permission against the table.
for (const char** valid = cmInstallCommandArguments::PermissionsTable;
*valid; ++valid) {
if (onePermission == *valid) {
// This is a valid pe... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xab6029(%rip), %rax # 0xefbdc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x445dee
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x85b10
testb $0x1, %al
jne 0x445dbb
jmp 0x4... | /JKorbelRA[P]CMake/Source/cmInstallCommandArguments.cxx |
cmInstallCommandFileSetArguments::cmInstallCommandFileSetArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | cmInstallCommandFileSetArguments::cmInstallCommandFileSetArguments(
std::string defaultComponent)
: cmInstallCommandArguments(std::move(defaultComponent))
{
this->Bind("FILE_SET"_s, this->FileSet);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3c420
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x4450e0
jmp 0x445f77
leaq -0x30(%rbp), %rdi
callq 0x3e568
movq -0x60(%rbp... | /JKorbelRA[P]CMake/Source/cmInstallCommandArguments.cxx |
cmInstallCxxModuleBmiGenerator::GenerateScriptForConfig(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmScriptGeneratorIndent) | void cmInstallCxxModuleBmiGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
auto const& loc = this->GetScriptLocation(config);
if (loc.empty()) {
return;
}
os << indent << "include(\""
<< cmOutputConverter::EscapeForCMake(
loc, cmOutputConvert... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x446810
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jn... | /JKorbelRA[P]CMake/Source/cmInstallCxxModuleBmiGenerator.cxx |
FindInstallSource[abi:cxx11](cmMakefile&, char const*) | static std::string FindInstallSource(cmMakefile& makefile, const char* name)
{
if (cmSystemTools::FileIsFullPath(name) ||
cmGeneratorExpression::Find(name) == 0) {
// This is a full path.
return name;
}
// This is a relative path.
std::string tb = cmStrCat(makefile.GetCurrentBinaryDirectory(), '/... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x801040
movb %al, %cl
movb $0x0, -0x3a(%rbp)
movb $0x0, -0x4d(%rbp)
movb $0x1, %al
testb... | /JKorbelRA[P]CMake/Source/cmInstallFilesCommand.cxx |
FinalAction(cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static void FinalAction(cmMakefile& makefile, std::string const& dest,
std::vector<std::string> const& args)
{
std::string testf;
std::string const& ext = args[0];
std::vector<std::string> installFiles;
// two different options
if (args.size() > 1) {
// now put the files into the ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d1f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d540
movq %rax, -0x40(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x60530
movq -0x18(%rbp)... | /JKorbelRA[P]CMake/Source/cmInstallFilesCommand.cxx |
FinalAction(cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static void FinalAction(cmMakefile& makefile, std::string const& dest,
std::vector<std::string> const& args)
{
bool files_mode = false;
if (!args.empty() && args[0] == "FILES") {
files_mode = true;
}
std::vector<std::string> files;
// two different options
if (args.size() > 1 |... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x448b3e
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d540
movq %rax, %rdi
leaq 0x7... | /JKorbelRA[P]CMake/Source/cmInstallProgramsCommand.cxx |
FindInstallSource[abi:cxx11](cmMakefile&, char const*) | static std::string FindInstallSource(cmMakefile& makefile, const char* name)
{
if (cmSystemTools::FileIsFullPath(name) ||
cmGeneratorExpression::Find(name) == 0) {
// This is a full path.
return name;
}
// This is a relative path.
std::string tb = cmStrCat(makefile.GetCurrentBinaryDirectory(), '/... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x801040
movb %al, %cl
movb $0x0, -0x3a(%rbp)
movb $0x0, -0x4d(%rbp)
movb $0x1, %al
testb... | /JKorbelRA[P]CMake/Source/cmInstallProgramsCommand.cxx |
(anonymous namespace)::HandleLengthCommand(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 HandleLengthCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command LENGTH requires two arguments.");
return false;
}
const std::string& listName = args[1];
const std::string& variableName = args.back(... | pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x44b318
movq -0x18(%rbp), %rax
movq %rax, -0x4a0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x498(%rbp)
callq 0x3c460
movq -0x498(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandleAppendCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmExecutionStatus&) | bool HandleAppendCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
assert(args.size() >= 2);
// Skip if nothing to append.
if (args.size() < 3) {
return true;
}
cmMakefile& makefile = status.GetMakefile();
std::string const& listName = args[1];
// ex... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jb 0x44ba54
jmp 0x44ba73
leaq 0x72a903(%rip), %rdi # 0xb7635e
leaq 0x72a90d(%rip), %rsi # 0xb7636f
movl $0xd8, %edx
leaq 0x72a963(%rip), %rcx ... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandlePrependCommand(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 HandlePrependCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
assert(args.size() >= 2);
// Skip if nothing to prepend.
if (args.size() < 3) {
return true;
}
cmMakefile& makefile = status.GetMakefile();
std::string const& listName = args[1];
//... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jb 0x44bd04
jmp 0x44bd23
leaq 0x72a653(%rip), %rdi # 0xb7635e
leaq 0x72a65d(%rip), %rsi # 0xb7636f
movl $0xf2, %edx
leaq 0x72a71a(%rip), %rcx ... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandlePopBackCommand(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 HandlePopBackCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
assert(args.size() >= 2);
cmMakefile& makefile = status.GetMakefile();
auto ai = args.cbegin();
++ai; // Skip subcommand name
std::string const& listName = *ai++;
std::vector<std::string> ... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jb 0x44bfa4
jmp 0x44bfc3
leaq 0x72a3b3(%rip), %rdi # 0xb7635e
leaq 0x72a3bd(%rip), %rsi # 0xb7636f
movl $0x10d, %edx # imm = 0x10D
lea... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandleJoinCommand(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 HandleJoinCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 4) {
status.SetError(cmStrCat("sub-command JOIN requires three arguments (",
args.size() - 1, " found)."));
return false;
}
const std::string& l... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
je 0x44d386
movq -0x18(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq 0x72930c(%rip), %rsi # 0xb765f4
leaq -0x68(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::HandleSortCommand(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 HandleSortCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
assert(args.size() >= 2);
if (args.size() > 8) {
status.SetError("sub-command SORT only takes up to six arguments.");
return false;
}
auto sortCompare = cmStringSorter::Compare::UNINITIALIZE... | pushq %rbp
movq %rsp, %rbp
subq $0x770, %rsp # imm = 0x770
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jb 0x4507c4
jmp 0x4507e3
leaq 0x725b93(%rip), %rdi # 0xb7635e
leaq 0x725b9d(%rip), %rsi # 0xb7636f
movl $0x4a4, %edx # imm = 0x4A4
lea... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::GetIndexArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*, cmMakefile&) | bool GetIndexArg(const std::string& arg, int* idx, cmMakefile& mf)
{
long value;
if (!cmStrToLong(arg, &value)) {
switch (mf.GetPolicyStatus(cmPolicies::CMP0121)) {
case cmPolicies::WARN: {
// Default is to warn and use old behavior OLD behavior is to allow
// compatibility, so issue a war... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2cd1d0
testb $0x1, %al
jne 0x452bb8
movq -0x20(%rbp), %rdi
movl $0x79, %esi
xorl %edx, %edx
callq 0x220000
movl %eax, %ecx
movq... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::TransformReplace::~TransformReplace() | TransformReplace(const std::vector<std::string>& arguments,
cmMakefile* makefile)
: ReplaceHelper(arguments[0], arguments[1], makefile)
{
makefile->ClearMatches();
if (!this->ReplaceHelper.IsRegularExpressionValid()) {
throw transform_error(
cmStrCat("sub-command TRANSFOR... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xa947b5(%rip), %rax # 0xeec240
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x45ed10
movq -0x10(%rbp), %rdi
callq 0x457c80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::TransformSelectorAt::Validate(unsigned long) | bool Validate(std::size_t count) override
{
decltype(this->Indexes) indexes;
for (auto index : this->Indexes) {
indexes.push_back(this->NormalizeIndex(index, count));
}
this->Indexes = std::move(indexes);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x151b60
movq -0x60(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfa170
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::TransformSelectorIndexes::NormalizeIndex(int, unsigned long) | int NormalizeIndex(int index, std::size_t count)
{
if (index < 0) {
index = static_cast<int>(count) + index;
}
if (index < 0 || count <= static_cast<std::size_t>(index)) {
throw transform_error(cmStrCat(
"sub-command TRANSFORM, selector ", this->Tag, ", index: ", index,
" out o... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x458be1
movq -0x18(%rbp), %rax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x458bf8
movq -0x18(%rbp), %rax
movsl... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::cmStringSorter::ApplyFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string ApplyFilter(const std::string& argument)
{
std::string result = argument;
for (auto filter : this->filters) {
if (filter != nullptr) {
result = filter(result);
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3b400
movq -0x78(%rbp), %rax
movq %rax, -0x28(... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
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_iterator cmRemoveIndices<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::all... | typename Range::const_iterator cmRemoveIndices(Range& r, InputRange const& rem)
{
typename InputRange::const_iterator remIt = rem.begin();
typename InputRange::const_iterator remEnd = rem.end();
const auto rangeEnd = r.end();
if (remIt == remEnd) {
return rangeEnd;
}
auto writer = r.begin();
std::adv... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45e100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45e120
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x622c0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
ca... | /JKorbelRA[P]CMake/Source/cmAlgorithms.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<cmRange<std::reverse_iterator<__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::string cmJoin(Range const& rng, cm::string_view separator)
{
if (rng.empty()) {
return std::string();
}
std::ostringstream os;
auto it = rng.begin();
auto const end = rng.end();
os << *it;
while (++it != end) {
os << separator << *it;
}
return os.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x460320
testb $0x1, %al
jne 0x4601bb
jmp 0x4601cc
movq -0x1e0(%rb... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmLoadCacheCommand(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 cmLoadCacheCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with wrong number of arguments.");
return false;
}
if (args.size() >= 2 && args[1] == "READ_WITH_PREFIX") {
return ReadWithPrefix(args, status... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x4603e5
jmp 0x460477
movq -0x18(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x3c460
movq -0x170(%rbp)... | /JKorbelRA[P]CMake/Source/cmLoadCacheCommand.cxx |
cmAddCustomCommand(void*, char const*, char const*, int, char const**, int, char const**, int, char const**, char const*) | static void CCONV cmAddCustomCommand(void* arg, const char* source,
const char* command, int numArgs,
const char** args, int numDepends,
const char** depends, int numOutputs,
... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmAddExecutable(void*, char const*, int, char const**, int) | static void CCONV cmAddExecutable(void* arg, const char* exename, int numSrcs,
const char** srcs, int win32)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
std::vector<std::string> srcs2;
int i;
for (i = 0; i < numSrcs; ++i) {
srcs2.emplace_back(srcs[i]);
}
cmTarget*... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x60530
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x463a9... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmAddLinkDirectoryForTarget(void*, char const*, char const*) | static void CCONV cmAddLinkDirectoryForTarget(void* arg, const char* tgt,
const char* d)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
cmTarget* t = mf->FindLocalNonAliasTarget(tgt);
if (!t) {
cmSystemTools::Error(
"Attempt to add link directories to non... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x180(%r... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmAddUtilityCommand(void*, char const*, char const*, char const*, int, int, char const**, int, char const**) | static void CCONV cmAddUtilityCommand(void* arg, const char* utilityName,
const char* command,
const char* arguments, int all,
int numDepends, const char** depends,
int... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
le... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmExpandSourceListArguments(void*, int, char const**, int*, char***, unsigned int) | static void CCONV cmExpandSourceListArguments(void* arg, int numArgs,
const char** args, int* resArgc,
char*** resArgv,
unsigned int startArgumentIndex)
{
(void)arg;
(void)startA... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x60530
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x464d25
movq -0x18(%rbp), %rax
... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmGetSource(void*, char const*) | static void CCONV* cmGetSource(void* arg, const char* name)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
if (cmSourceFile* rsf = mf->GetSource(name)) {
// Lookup the proxy source file object for this source.
auto i = cmCPluginAPISourceFiles.find(rsf);
if (i == cmCPluginAPISourceFiles.end()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3c460
movq -... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileAddDepend(void*, char const*) | static void CCONV cmSourceFileAddDepend(void* arg, const char* depend)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
rsf->AddDepend(depend);
} else {
sf->Depends.emplace_back(depend);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46598f
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileGetProperty(void*, char const*) | static const char* CCONV cmSourceFileGetProperty(void* arg, const char* prop)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
return rsf->GetProperty(prop).GetCStr();
}
if (!strcmp(prop, "LOCATION")) {
return sf->FullPath.c_str();
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x465a99
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileSetName(void*, char const*, char const*, int, char const**, int, char const**) | static void CCONV cmSourceFileSetName(void* arg, const char* name,
const char* dir, int numSourceExtensions,
const char** sourceExtensions,
int numHeaderExtensions,
con... | pushq %rbp
movq %rsp, %rbp
subq $0x590, %rsp # imm = 0x590
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileSetProperty(void*, char const*, char const*) | static void CCONV cmSourceFileSetProperty(void* arg, const char* prop,
const char* value)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
rsf->SetProperty(prop, value);
} else if (prop) {
if (... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4669f2
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
DefineSourceFileProperty(void*, char const*, char const*, char const*, int) | static void CCONV DefineSourceFileProperty(void* arg, const char* name,
const char* briefDocs,
const char* longDocs, int chained)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
mf->GetState()->DefineProperty(name, cmProperty::S... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x221e60
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movq %r... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
(anonymous namespace)::cmMacroFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmMacroFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
cmExecutionStatus& status)
{
cmMakefile& mf = status.GetMakefile();
mf.AppendProperty("MACROS", this->Args[0]);
// create a new command and add it to cmake
cmMacroHelperCommand f;
f.Args = this->... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rsi, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bfb20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq... | /JKorbelRA[P]CMake/Source/cmMacroCommand.cxx |
cmMakeDirectoryCommand(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 cmMakeDirectoryCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 1) {
status.SetError("called with incorrect number of arguments");
return false;
}
if (!status.GetMakefile().CanIWriteThisFile(args[0])) {
std::string e = "atte... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x1, %rax
je 0x46d948
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3c460
movq -0xa0(%rbp), %rdx
leaq 0x70209d(%rip), %rsi # 0xb6f... | /JKorbelRA[P]CMake/Source/cmMakeDirectoryCommand.cxx |
(anonymous namespace)::HandleExprCommand(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 HandleExprCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if ((args.size() != 3) && (args.size() != 5)) {
status.SetError("EXPR called with incorrect arguments.");
return false;
}
enum class NumericFormat
{
UNINITIALIZED,
DECIMAL,
HEXAD... | pushq %rbp
movq %rsp, %rbp
subq $0x7c0, %rsp # imm = 0x7C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x46e46b
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
je 0x46e46b
movq -0x18(%rbp), %rax
movq %rax, -0x720(%rbp)
leaq -0x39(%rbp), %rdi
movq... | /JKorbelRA[P]CMake/Source/cmMathCommand.cxx |
cmMessageCommand(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 cmMessageCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
auto& mf = status.GetMakefile();
auto i = args.cbegin();
auto type = MessageType::MESSAGE;... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x46ed35
jmp 0x46edc7
movq -0x18(%rbp), %rax
movq %rax, -0x380(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x378(%rbp)
callq 0x3c460
movq -0x378(%rbp)... | /JKorbelRA[P]CMake/Source/cmMessageCommand.cxx |
(anonymous namespace)::IndentText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmMakefile&) | std::string IndentText(std::string text, cmMakefile& mf)
{
auto indent =
cmJoin(cmExpandedList(mf.GetSafeDefinition("CMAKE_MESSAGE_INDENT")), "");
const auto showContext = mf.GetCMakeInstance()->GetShowLogContext() ||
mf.IsOn("CMAKE_MESSAGE_CONTEXT_SHOW");
if (showContext) {
auto context = cmJoin(
... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rsi, -0x2a0(%rbp)
movq %rdi, -0x298(%rbp)
movq %rdi, %rax
movq %rax, -0x290(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x288(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0x280(%rbp)
... | /JKorbelRA[P]CMake/Source/cmMessageCommand.cxx |
(anonymous namespace)::cmLBDepend::GetDependInformation(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&) | cmDependInformation* GetDependInformation(const std::string& file,
const std::string& extraPath)
{
// Get the full path for the file so that lookup is unambiguous.
std::string fullPath = this->FullPath(file, extraPath);
// Try to find the file's instance of cmD... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4736b0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x... | /JKorbelRA[P]CMake/Source/cmOutputRequiredFilesCommand.cxx |
void (anonymous namespace)::UserArgumentParser::Bind<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmParseArgumentsCommand(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>,... | void Bind(std::vector<std::string> const& names,
std::map<std::string, T>& ref, H duplicateKey)
{
for (std::string const& key : names) {
auto const it = ref.emplace(key, T{}).first;
bool const inserted = this->cmArgumentParser<void>::Bind(
cm::string_view(it->first), it->second);
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62f40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62... | /JKorbelRA[P]CMake/Source/cmParseArgumentsCommand.cxx |
TopLevelCMakeVarCondSet(cmMakefile&, 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&) | static void TopLevelCMakeVarCondSet(cmMakefile& mf, std::string const& name,
std::string const& value)
{
// Set the CMAKE_PROJECT_XXX variable to be the highest-level
// project name in the tree. If there are two project commands
// in the same CMakeLists.txt file, and it is th... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x220440
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x62230
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x480e2c
jmp 0x48... | /JKorbelRA[P]CMake/Source/cmProjectCommand.cxx |
cmQTWrapUICommand(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 cmQTWrapUICommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
// Get the uic and moc executables to run in the ... | pushq %rbp
movq %rsp, %rbp
subq $0x810, %rsp # imm = 0x810
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x4, %rax
jae 0x4832f8
movq -0x18(%rbp), %rax
movq %rax, -0x658(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x650(%rbp)
callq 0x3c460
movq -0x650(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmQTWrapUICommand.cxx |
cmSearchPath::AddCMakePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmSearchPath::AddCMakePath(const std::string& variable)
{
assert(this->FC != nullptr);
// Get a path from a CMake variable.
if (cmValue value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(*value);
for (std::string const& p : expanded) {
th... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, (%rax)
je 0x485636
jmp 0x485655
leaq 0x6f2e4b(%rip), %rdi # 0xb78488
leaq 0x6f2e58(%rip), %rsi # 0xb7849c
movl $0x46, %edx
leaq 0x6f2ee1(%rip), %rcx # 0xb78531
callq ... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSetDirectoryPropertiesCommand(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 cmSetDirectoryPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
// PROPERTIES followed by prop value pairs
if (args.size() % 2 !... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x48a0f5
jmp 0x48a187
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3c460
movq -0xf8(%rbp), ... | /JKorbelRA[P]CMake/Source/cmSetDirectoryPropertiesCommand.cxx |
SetPropertyCommand::MakeSourceFilePathAbsoluteIfNeeded(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string MakeSourceFilePathAbsoluteIfNeeded(
cmExecutionStatus& status, const std::string& source_file_path,
const bool needed)
{
if (!needed) {
return source_file_path;
}
std::string absolute_file_path = cmSystemTools::CollapseFullPath(
source_file_path, status.GetMakefile().GetCurrentSourceDirect... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x48ad5b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b40... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
SetPropertyCommand::HandleAndValidateSourceFilePropertyGENERATED(cmSourceFile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, SetPropertyCommand::PropertyOp) | bool HandleAndValidateSourceFilePropertyGENERATED(
cmSourceFile* sf, std::string const& propertyValue, PropertyOp op)
{
const auto& mf = *sf->GetLocation().GetMakefile();
auto policyStatus = mf.GetPolicyStatus(cmPolicies::CMP0118);
const bool policyWARN = policyStatus == cmPolicies::WARN;
const bool policyNE... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29d750
movq %rax, %rdi
callq 0x29e930
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x76, %esi
xorl %edx, %edx
callq 0x220000
movl %eax, -0x2c(%... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleSourceMode(cmExecutionStatus&, 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::all... | bool HandleSourceMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove,
const s... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movl %r9d, -0x18c(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x18c(%rbp), %ecx
movq %r8, -0x188(%rbp)
movq %rdx, %r8
movq %rsi, %r9
movq %rdi, %r10
movq -0x188(%rbp), %rdi
movb %cl, %dl
movb %al, %sil
movb 0x20(%rbp), %al
movq 0x18(%rbp), %rcx
movb 0... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleCacheMode(cmExecutionStatus&, 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::allo... | bool HandleCacheMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
if (propertyName == "ADVANCED"... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movl %r9d, -0x2a4(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x2a4(%rbp), %ecx
movq %r8, -0x2a0(%rbp)
movq %rdx, -0x298(%rbp)
movq %rsi, %r8
movq -0x2a0(%rbp), %rsi
movq %rdi, %r9
movq -0x298(%rbp), %rdi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleTarget(cmTarget*, cmMakefile&, 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, bool, bool) | bool HandleTarget(cmTarget* target, cmMakefile& makefile,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
// Set or append the property.
if (appendMode) {
target->AppendProperty(property... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %r9d, -0x74(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x74(%rbp), %ecx
movq %r8, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rsi, %r8
movq -0x70(%rbp), %rsi
movq %rdi, %r9
movq -0x68(%rbp), %rdi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movq %r8, -0x10(%rbp)
... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleTest(cmTest*, 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, bool, bool) | bool HandleTest(cmTest* test, const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
// Set or append the property.
if (appendMode) {
test->AppendProperty(propertyName, propertyValue, appendAsString);
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x38(%rbp)
movl %ecx, %eax
movl -0x38(%rbp), %ecx
movl %eax, -0x34(%rbp)
movq %rdx, %rax
movl -0x34(%rbp), %edx
movq %rax, -0x30(%rbp)
movq %rsi, %rax
movq -0x30(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq %rdi, %r8
movq -0x28(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleInstall(cmInstalledFile*, cmMakefile&, 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, bool, bool) | bool HandleInstall(cmInstalledFile* file, cmMakefile& makefile,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
// Set or append the property.
if (remove) {
file->RemoveProperty(prope... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r9d, -0x3c(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x3c(%rbp), %ecx
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r8
movq -0x38(%rbp), %rsi
movq %rdi, %r9
movq -0x30(%rbp), %rdi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movq %r8, -0x10(%rbp)
... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
RunCommandForScope(cmMakefile*, __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::all... | static bool RunCommandForScope(
cmMakefile* mf, std::vector<std::string>::const_iterator file_begin,
std::vector<std::string>::const_iterator file_end,
std::vector<std::string>::const_iterator prop_begin,
std::vector<std::string>::const_iterator prop_end, std::string& errors)
{
std::vector<std::string> proper... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x60530
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x... | /JKorbelRA[P]CMake/Source/cmSetSourceFilesPropertiesCommand.cxx |
cmSetTestsPropertiesCommand(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 cmSetTestsPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
// first identify the properties arguments
auto propsIter = std::find(ar... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x491ad5
jmp 0x491b67
movq -0x18(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x3c460
movq -0x1c8(%rbp)... | /JKorbelRA[P]CMake/Source/cmSetTestsPropertiesCommand.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.