name string | code string | asm string | file string |
|---|---|---|---|
cmLocalGenerator::AddLanguageFlags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cmGeneratorTarget const*, cmBuildStep, 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>>... | void cmLocalGenerator::AddLanguageFlags(std::string& flags,
cmGeneratorTarget const* target,
cmBuildStep compileOrLink,
const std::string& lang,
const std::stri... | pushq %rbp
movq %rsp, %rbp
subq $0xfa0, %rsp # imm = 0xFA0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xbc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xbc0(%rbp)
leaq 0x973df5(%rip), %... | /JKorbelRA[P]CMake/Source/cmLocalGenerator.cxx |
cmMakefile::ParseDefineFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
{
// Create a regular expression to match valid definitions.
static cmsys::RegularExpression valid("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=.*)?$");
// Make sure the definition matches.
if (!valid.find(def)) {
return false;
}
// Definitions w... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
cmpb $0x0, 0xcd72ec(%rip) # 0xefeee8
jne 0x227c4a
leaq 0xcd72e3(%rip), %rdi # 0xefeee8
callq 0x3d080... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::PushFunctionScope(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmPolicies::PolicyMap const&) | void cmMakefile::PushFunctionScope(std::string const& fileName,
const cmPolicies::PolicyMap& pm)
{
this->StateSnapshot = this->GetState()->CreateFunctionCallSnapshot(
this->StateSnapshot, fileName);
assert(this->StateSnapshot.IsValid());
this->PushLoopBlockBarrier();
#if !... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x221e60
movq -0x38(%rbp), %rdx
movq %rax, %rsi
addq $0x2d0, %rdx # imm = 0x2D0
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x2b1700
movq ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::PopFunctionScope(bool) | void cmMakefile::PopFunctionScope(bool reportError)
{
this->PopPolicy();
this->PopSnapshot(reportError);
this->PopFunctionBlockerBarrier(reportError);
#if !defined(CMAKE_BOOTSTRAP)
this->GetGlobalGenerator()->GetFileLockPool().PopFunctionScope();
#endif
this->PopLoopBlockBarrier();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x222240
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x222770
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::MaybeWarnUninitialized(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) const | void cmMakefile::MaybeWarnUninitialized(std::string const& variable,
const char* sourceFilename) const
{
// check to see if we need to print a warning
// if strict mode is on and the variable has
// not been "cleared"/initialized with a set(foo ) call
if (this->GetCMakeIn... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x21f780
movq %rax, %rdi
callq 0x23ed50
testb $0x1, %al
jne 0x22cf88
jmp 0x22d0b9
movq -0x1c8(%rbp), %rdi
movq -0x10(%rbp), %rsi
c... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::AddGlobalLinkInformation(cmTarget&) | void cmMakefile::AddGlobalLinkInformation(cmTarget& target)
{
// for these targets do not add anything
switch (target.GetType()) {
case cmStateEnums::UTILITY:
case cmStateEnums::GLOBAL_TARGET:
case cmStateEnums::INTERFACE_LIBRARY:
return;
default:;
}
if (cmValue linkLibsProp = this->GetPr... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ebc90
addl $-0x5, %eax
subl $0x2, %eax
ja 0x22d576
jmp 0x22d571
jmp 0x22d901
jmp 0x22d578
leaq -0x39(%rbp), %rdi
movq %rdi, -0x... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::AddExecutable(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&, bool) | cmTarget* cmMakefile::AddExecutable(const std::string& exeName,
const std::vector<std::string>& srcs,
bool excludeFromAll)
{
cmTarget* target = this->AddNewTarget(cmStateEnums::EXECUTABLE, exeName);
if (excludeFromAll) {
target->SetProperty... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x22db00
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x22dc12... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::GetAppleSDKType() const | cmMakefile::AppleSDK cmMakefile::GetAppleSDKType() const
{
std::string sdkRoot;
sdkRoot = this->GetSafeDefinition("CMAKE_OSX_SYSROOT");
sdkRoot = cmSystemTools::LowerCase(sdkRoot);
struct
{
std::string name;
AppleSDK sdk;
} const sdkDatabase[]{
{ "appletvos", AppleSDK::AppleTVOS },
{ "apple... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
leaq -0x51(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x3c460
movq -0x220(%rbp), %rdx
leaq 0x924390(%rip), %rsi # 0xb53711
leaq -0x50(%rbp), ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::GetSONameFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const char* cmMakefile::GetSONameFlag(const std::string& language) const
{
std::string name = "CMAKE_SHARED_LIBRARY_SONAME";
if (!language.empty()) {
name += "_";
name += language;
}
name += "_FLAG";
return this->GetDefinition(name).GetCStr();
} | 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 -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3c460
movq -0x58(%rbp), %rdx
leaq 0x92694e(%rip), %rsi # 0xb5646e
leaq -0x30(%rbp), %rdi
callq 0x606e0
jmp 0x22fb2b
leaq -0x31(%r... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::ExpandArguments(std::vector<cmListFileArgument, std::allocator<cmListFileArgument>> 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 | bool cmMakefile::ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<std::string>& outArgs) const
{
std::string const& filename = this->GetBacktrace().Top().FilePath;
std::string value;
outArgs.reserve(inArgs.size());
for (cmListFileArgument const& i : inA... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x220710
movq -0xa0(%rbp), %rdi
callq 0x1d7740
movq %rax, -0x98(%rbp)
jmp 0x232df7
movq -0x98(%rbp), %rax
addq ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::GetSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmSourceFileLocationKind) const | cmSourceFile* cmMakefile::GetSource(const std::string& sourceName,
cmSourceFileLocationKind kind) const
{
// First check "Known" paths (avoids the creation of cmSourceFileLocation)
if (kind == cmSourceFileLocationKind::Known) {
auto sfsi = this->KnownFileSearchIndex.find(sour... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x2337e4
movq -0xf0(%rbp), %rdi
addq $0x150, %rdi # imm = 0x150
movq -0x18(%rbp), %rsi
callq 0x23... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::CreateSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, cmSourceFileLocationKind) | cmSourceFile* cmMakefile::CreateSource(const std::string& sourceName,
bool generated,
cmSourceFileLocationKind kind)
{
auto sf = cm::make_unique<cmSourceFile>(this, sourceName, generated, kind);
auto name =
this->GetCMakeInstance()->S... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x11(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::EnableLanguage(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) | void cmMakefile::EnableLanguage(std::vector<std::string> const& languages,
bool optional)
{
if (this->DeferRunning) {
this->IssueMessage(
MessageType::FATAL_ERROR,
"Languages may not be enabled during deferred execution.");
return;
}
if (const char* def = this->... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
testb $0x1, 0x308(%rax)
je 0x233e0a
leaq -0x39(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x3c460
movq -0x208... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::TryCompile(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::basic_string<char, std... | int cmMakefile::TryCompile(const std::string& srcdir,
const std::string& bindir,
const std::string& projectName,
const std::string& targetName, bool fast, int jobs,
const std::vector<std::string>* cmakeArgs,
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd28, %rsp # imm = 0xD28
movb %r9b, %al
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movl 0x10(%rbp), %r9d
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x1... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::ConfigureFile(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, unsigned int, cmNewLineStyle) | int cmMakefile::ConfigureFile(const std::string& infile,
const std::string& outfile, bool copyonly,
bool atOnly, bool escapeQuotes,
mode_t permissions, cmNewLineStyle newLine)
{
int res = 1;
if (!this->CanIWriteThisFile(outfil... | pushq %rbp
movq %rsp, %rbp
subq $0x990, %rsp # imm = 0x990
movl %r8d, -0x8e8(%rbp)
movl %ecx, %eax
movl -0x8e8(%rbp), %ecx
movl %eax, -0x8e4(%rbp)
movq %rdx, %rax
movl -0x8e4(%rbp), %edx
movq %rax, -0x8e0(%rbp)
movq %rsi, %rax
movq -0x8e0(%rbp), %rsi
movq %rax, -0x8d8(%rbp)
movq %rdi, %r8
movq -0x8d8(%rbp), ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::FormatListFileStack[abi:cxx11]() const | std::string cmMakefile::FormatListFileStack() const
{
std::vector<std::string> listFiles;
cmStateSnapshot snp = this->StateSnapshot;
while (snp.IsValid()) {
listFiles.push_back(snp.GetExecutionListFile());
snp = snp.GetCallStackParent();
}
std::reverse(listFiles.begin(), listFiles.end());
std::ostri... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x60530
movq -0x210(%rbp), %rax
movq 0x2d0(%rax), %rcx
movq %rcx,... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::PushScope() | void cmMakefile::PushScope()
{
this->StateSnapshot =
this->GetState()->CreateVariableScopeSnapshot(this->StateSnapshot);
this->PushLoopBlockBarrier();
#if !defined(CMAKE_BOOTSTRAP)
this->GetGlobalGenerator()->GetFileLockPool().PushFunctionScope();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x221e60
movq -0x28(%rbp), %rdx
movq %rax, %rsi
addq $0x2d0, %rdx # imm = 0x2D0
leaq -0x20(%rbp), %rdi
callq 0x2b1ff0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x2d0(%rdi)
movq ... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::EnforceUniqueName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool) const | bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
bool isCustom) const
{
if (this->IsAlias(name)) {
std::ostringstream e;
e << "cannot create target \"" << name
<< "\" because an alias with the same name already exists.";
msg = e.str();
... | pushq %rbp
movq %rsp, %rbp
subq $0x640, %rsp # imm = 0x640
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x580(%rbp)
movq -0x18(%rbp), %rsi
callq 0x237bc0
testb $0x1, %al
jne 0x237c5b
jmp 0x237d21
lea... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
cmMakefile::SetPolicy(cmPolicies::PolicyID, cmPolicies::PolicyStatus) | bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
cmPolicies::PolicyStatus status)
{
// A REQUIRED_ALWAYS policy may be set only to NEW.
if (status != cmPolicies::NEW &&
cmPolicies::GetPolicyStatus(id) == cmPolicies::REQUIRED_ALWAYS) {
std::string msg = cmPolicies::GetRequired... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x2, -0x18(%rbp)
je 0x2387bc
movl -0x14(%rbp), %edi
callq 0x266360
cmpl $0x4, %eax
jne 0x2387bc
movl -0x14(%rbp), %esi
leaq -0x38... | /JKorbelRA[P]CMake/Source/cmMakefile.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<cmRange<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cx... | 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 $0x200, %rsp # imm = 0x200
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 0x24cbe0
testb $0x1, %al
jne 0x23dacb
jmp 0x23dadc
movq -0x1e0(%rb... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmMakefileProfilingData::cmMakefileProfilingData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmMakefileProfilingData::cmMakefileProfilingData(
const std::string& profileStream)
{
std::ios::openmode omode = std::ios::out | std::ios::trunc;
this->ProfileStream.open(profileStream.c_str(), omode);
Json::StreamWriterBuilder wbuilder;
this->JsonWriter =
std::unique_ptr<Json::StreamWriter>(wbuilder.newS... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
callq 0x3cf40
movq -0xb8(%rbp), %rdi
addq $0x200, %rdi # imm = 0x200
movq %rdi, -0xb0(%rbp)
callq 0x25cd10
movl $0x10, %edi
movl $0x20, ... | /JKorbelRA[P]CMake/Source/cmMakefileProfilingData.cxx |
cmMakefileProfilingData::StartEntry(cmListFileFunction const&, cmListFileContext const&) | void cmMakefileProfilingData::StartEntry(const cmListFileFunction& lff,
cmListFileContext const& lfc)
{
cm::optional<Json::Value> argsValue(cm::in_place, Json::objectValue);
if (!lff.Arguments().empty()) {
std::string args;
for (auto const& a : lff.Arguments()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
movl $0x7, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x25cd70
movq -0x10(%rbp), %rdi
callq 0x23c3d0
movq %rax, %rd... | /JKorbelRA[P]CMake/Source/cmMakefileProfilingData.cxx |
cmMessenger::ConvertMessageType(MessageType) const | MessageType cmMessenger::ConvertMessageType(MessageType t) const
{
bool warningsAsErrors;
if (t == MessageType::AUTHOR_WARNING || t == MessageType::AUTHOR_ERROR) {
warningsAsErrors = this->GetDevWarningsAsErrors();
if (warningsAsErrors && t == MessageType::AUTHOR_WARNING) {
t = MessageType::AUTHOR_ER... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x25d583
cmpl $0x1, -0xc(%rbp)
jne 0x25d5bd
movq -0x18(%rbp), %rdi
callq 0x25e090
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x25d5a6
cmpl $0x0... | /JKorbelRA[P]CMake/Source/cmMessenger.cxx |
displayMessage(MessageType, std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&) | static void displayMessage(MessageType t, std::ostringstream& msg)
{
// Add a note about warning suppression.
if (t == MessageType::AUTHOR_WARNING) {
msg << "This warning is for project developers. Use -Wno-dev to suppress "
"it.";
} else if (t == MessageType::AUTHOR_ERROR) {
msg << "This erro... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x25ddba
movq -0x10(%rbp), %rdi
leaq 0x8f975b(%rip), %rsi # 0xb5750e
callq 0x3d690
jmp 0x25ddd2
cmpl $0x1, -0x4(%rbp)
jne 0x25ddd0
movq -0x10(%rbp), %rdi
leaq 0x8f9789(%rip), %... | /JKorbelRA[P]CMake/Source/cmMessenger.cxx |
getMessageColor(MessageType) | static int getMessageColor(MessageType t)
{
switch (t) {
case MessageType::INTERNAL_ERROR:
case MessageType::FATAL_ERROR:
case MessageType::AUTHOR_ERROR:
return cmsysTerminal_Color_ForegroundRed;
case MessageType::AUTHOR_WARNING:
case MessageType::WARNING:
return cmsysTerminal_Color_Fo... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x25e072
jmp 0x25e053
movl -0xc(%rbp), %eax
decl %eax
subl $0x3, %eax
jb 0x25e069
jmp 0x25e05f
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x25e072
jmp 0x25e07b
movl $0x2, -0x4(%rbp)
jmp 0x25e082
movl $0x4, -0x... | /JKorbelRA[P]CMake/Source/cmMessenger.cxx |
cmOutputConverter::Shell_SkipMakeVariables(char const*, char const*) | cm::string_view::iterator cmOutputConverter::Shell_SkipMakeVariables(
cm::string_view::iterator c, cm::string_view::iterator end)
{
while ((c != end && (c + 1) != end) && (*c == '$' && *(c + 1) == '(')) {
cm::string_view::iterator skip = c + 2;
while ((skip != end) && Shell_CharIsMakeVariableName(*skip)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x25fdea
movq -0x8(%rbp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x25fdea
movq -0x8(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Source/cmOutputConverter.cxx |
cmNewLineStyle::GetCharacters[abi:cxx11]() const | std::string cmNewLineStyle::GetCharacters() const
{
switch (this->NewLineStyle) {
case Invalid:
return "";
case LF:
return "\n";
case CRLF:
return "\r\n";
}
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x2617e5
jmp 0x2617ca
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x261830
jmp 0x2617d4... | /JKorbelRA[P]CMake/Source/cmNewLineStyle.cxx |
cmPolicies::ApplyPolicyVersion(cmMakefile*, unsigned int, unsigned int, unsigned int, cmPolicies::WarnCompat) | bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, unsigned int majorVer,
unsigned int minorVer,
unsigned int patchVer,
WarnCompat warnCompat)
{
// Warn about policy versions for which support will be removed.... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movb $0x0, -0x49(%rbp)
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x122(%rbp)
jne 0x262329
cmpl $0x2, -0x14(%rbp... | /JKorbelRA[P]CMake/Source/cmPolicies.cxx |
DiagnoseAncientPolicies(std::vector<cmPolicies::PolicyID, std::allocator<cmPolicies::PolicyID>> const&, unsigned int, unsigned int, unsigned int, cmMakefile*) | static void DiagnoseAncientPolicies(
std::vector<cmPolicies::PolicyID> const& ancient, unsigned int majorVer,
unsigned int minorVer, unsigned int patchVer, cmMakefile* mf)
{
std::ostringstream e;
e << "The project requests behavior compatible with CMake version \""
<< majorVer << "." << minorVer << "." << p... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3c530
movq -0x1f8(%rbp), %rdi
leaq 0x8f1dec(%rip), %rsi # 0xb58ce9
callq 0x3d69... | /JKorbelRA[P]CMake/Source/cmPolicies.cxx |
idToShortDescription(cmPolicies::PolicyID) | static const char* idToShortDescription(cmPolicies::PolicyID id)
{
switch (id) {
#define POLICY_CASE(ID, SHORT_DESCRIPTION) \
case cmPolicies::ID: \
return SHORT_DESCRIPTION;
CM_FOR_EACH_POLICY_ID_DOC(POLICY_CASE)
#und... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x8f, %rax
ja 0x267dfd
movq -0x18(%rbp), %rax
leaq 0x8f06c7(%rip), %rcx # 0xb57bdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8f1947(%rip), %rax # 0xb58e6c
movq %rax, -0x8(%rbp)
jmp 0x267e05
leaq ... | /JKorbelRA[P]CMake/Source/cmPolicies.cxx |
cmPolicies::GetPolicyDeprecatedWarning[abi:cxx11](cmPolicies::PolicyID) | std::string cmPolicies::GetPolicyDeprecatedWarning(cmPolicies::PolicyID id)
{
std::ostringstream msg;
/* clang-format off */
msg <<
"The OLD behavior for policy " << idToString(id) << " "
"will be removed from a future version of CMake.\n"
"The cmake-policies(7) manual explains that the OLD behaviors ... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x3c530
movq -0x1a8(%rbp), %rdi
leaq 0x8f0655(%rip), %rsi # 0xb584a9
callq 0x3d690
mo... | /JKorbelRA[P]CMake/Source/cmPolicies.cxx |
cmQtAutoGenGlobalInitializer::GetCompilerFeatures(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>>&) | cmQtAutoGen::CompilerFeaturesHandle
cmQtAutoGenGlobalInitializer::GetCompilerFeatures(
std::string const& generator, std::string const& executable,
std::string& error)
{
// Check if we have cached features
{
auto it = this->CompilerFeatures_.find(executable);
if (it != this->CompilerFeatures_.end()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x258(%rbp)
addq $0x78, %rdi
movq -0x2... | /JKorbelRA[P]CMake/Source/cmQtAutoGenGlobalInitializer.cxx |
cmQtAutoGenInitializer::InitCustomTargets() | bool cmQtAutoGenInitializer::InitCustomTargets()
{
// Configurations
this->MultiConfig = this->GlobalGen->IsMultiConfig();
this->ConfigDefault = this->Makefile->GetDefaultConfiguration();
this->ConfigsList =
this->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
// Verbosity
{
std::st... | pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp # imm = 0xB90
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x930(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x130(%rax), %rax
callq *%rax
movb %al, %cl
movq -0x930(%rbp), %rax
movb %cl, 0x134(%rax)
movq 0x20(%rax), %rsi
leaq -0x30(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmQtAutoGenInitializer::InitUic() | bool cmQtAutoGenInitializer::InitUic()
{
// Uic search paths
{
std::string const& usp =
this->GenTarget->GetSafeProperty("AUTOUIC_SEARCH_PATHS");
if (!usp.empty()) {
this->Uic.SearchPaths =
SearchPathSanitizer(this->Makefile)(cmExpandedList(usp));
}
}
// Uic target options
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x158(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x3c460
movq -0x150(%rbp), %rdx
leaq 0x8e4e34(%rip), %rsi # 0xb5b507
leaq -0x38... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmQtAutoGenInitializer::InitRcc() | bool cmQtAutoGenInitializer::InitRcc()
{
// Rcc executable
{
if (!this->GetQtExecutable(this->Rcc, "rcc", false)) {
return false;
}
// Evaluate test output on demand
CompilerFeatures& features = *this->Rcc.ExecutableFeatures;
if (!features.Evaluated) {
// Look for list options
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x8b8, %rax # imm = 0x8B8
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3c460
movq -0x58(%rbp), %rdx
leaq 0x8e4954(%rip), %rsi # 0xb5b81a
leaq -0x30(%rbp), ... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmQtAutoGenInitializer::GetQtExecutable(cmQtAutoGenInitializer::GenVarsT&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | bool cmQtAutoGenInitializer::GetQtExecutable(GenVarsT& genVars,
const std::string& executable,
bool ignoreMissingTarget) const
{
auto print_err = [this, &genVars](std::string const& err) {
cmSystemTools::Error(cmStrCat(genVa... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3e0(%rbp)
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rb... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
(anonymous namespace)::StaticLibraryCycle(cmGeneratorTarget const*, cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool StaticLibraryCycle(cmGeneratorTarget const* targetOrigin,
cmGeneratorTarget const* targetDepend,
std::string const& config)
{
bool cycle = false;
if ((targetOrigin->GetType() == cmStateEnums::STATIC_LIBRARY) &&
(targetDepend->GetType() == cmStateEnums::STAT... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6263f0
cmpl $0x1, %eax
jne 0x27ebb3
movq -0x10(%rbp), %rdi
callq 0x6263f0
cmpl $0x1, %eax
jne 0x27ebb3
leaq -0x50(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmQtAutoGenInitializer::SetupWriteAutogenInfo() | bool cmQtAutoGenInitializer::SetupWriteAutogenInfo()
{
// Utility lambdas
auto MfDef = [this](std::string const& key) {
return this->Makefile->GetSafeDefinition(key);
};
// Filtered headers and sources
std::set<std::string> moc_skip;
std::set<std::string> uic_skip;
std::vector<MUFile const*> headers;... | pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp # imm = 0xA80
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8c0(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdefc0
leaq -0x70(%rbp), %rdi
callq 0xdefc0
leaq -0x88(%rbp), %rdi
movq %rdi, -0x8b8(%rbp)
callq 0x289a70
leaq -0xa0(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
void (anonymous namespace)::InfoWriter::SetConfigArray<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::allocato... | void InfoWriter::SetConfigArray(
std::string const& key,
cmQtAutoGenInitializer::ConfigStrings<CONT> const& cfgStr)
{
this->SetArray(key, cfgStr.Default);
for (auto const& item : cfgStr.Config) {
this->SetArray(cmStrCat(key, '_', item.first), item.second);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x282620
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x297230
m... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
void (anonymous namespace)::InfoWriter::SetArrayArray<std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, s... | void InfoWriter::SetArrayArray(std::string const& key, CONT const& container,
FUNC func)
{
Json::Value& jval = this->Value_[key];
if (MakeArray(jval, container)) {
Json::ArrayIndex ii = 0;
for (auto const& citem : container) {
Json::Value& aval = jval[ii++];
aval =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8da160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x287590
testb $0x1, %al
jne 0x2828fe
jmp 0x2829a1
movl $0x0, -0x2c(%rb... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmQtAutoGenInitializer::handleSkipPch(cmSourceFile*) | void cmQtAutoGenInitializer::handleSkipPch(cmSourceFile* sf)
{
bool skipPch = true;
for (auto const& pair : this->AutogenTarget.Sources) {
if (!pair.first->GetIsGenerated() &&
!pair.first->GetProperty("SKIP_PRECOMPILE_HEADERS")) {
skipPch = false;
}
}
if (skipPch) {
sf->SetProperty("S... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, -0x11(%rbp)
addq $0x290, %rax # imm = 0x290
addq $0x1d8, %rax # imm = 0x1D8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2884a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp)... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
parseMocVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | static cmQtAutoGen::IntegerVersion parseMocVersion(std::string str)
{
cmQtAutoGen::IntegerVersion result;
static const std::string prelude = "moc ";
size_t pos = str.find(prelude);
if (pos == std::string::npos) {
return result;
}
str.erase(0, prelude.size() + pos);
std::istringstream iss(str);
std... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x200(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x28a040
cmpb $0x0, 0xc7a7aa(%rip) # 0xeff2f0
jne 0x284bb4
leaq 0xc7a7a1(%rip), %rdi # 0xeff2f0
callq 0x3d080
cmpl $0x0, %eax
je 0x284bb4
leaq -0x11(%rbp), %rdi
movq %rd... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
bool (anonymous namespace)::InfoWriter::MakeArray<std::vector<cmQtAutoGenInitializer::MUFile const*, std::allocator<cmQtAutoGenInitializer::MUFile const*>>>(Json::Value&, std::vector<cmQtAutoGenInitializer::MUFile const*, std::allocator<cmQtAutoGenInitializer::MUFile const*>> const&) | bool InfoWriter::MakeArray(Json::Value& jval, CONT const& container)
{
jval = Json::arrayValue;
std::size_t const listSize = cm::size(container);
if (listSize == 0) {
return false;
}
jval.resize(static_cast<unsigned int>(listSize));
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x6, %esi
callq 0x8d5360
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8d60a0
leaq -0x40(%rbp), %rdi
callq 0x8d5f30
movq -0x18(%rbp), %rdi
callq 0x2971a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48... | /JKorbelRA[P]CMake/Source/cmQtAutoGenInitializer.cxx |
cmRST::ProcessFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool cmRST::ProcessFile(std::string const& fname, bool isModule)
{
cmsys::ifstream fin(fname.c_str());
if (fin) {
this->DocDir = cmSystemTools::GetFilenamePath(fname);
if (isModule) {
this->ProcessModule(fin);
} else {
this->ProcessRST(fin);
}
this->OutputLinePending = true;
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3cc60
movq %rax, %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x3b2a0... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ProcessModule(std::istream&) | void cmRST::ProcessModule(std::istream& is)
{
std::string line;
std::string rst;
while (cmSystemTools::GetLineFromStream(is, line)) {
if (!rst.empty() && rst != "#") {
// Bracket mode: check for end bracket
std::string::size_type pos = line.find(rst);
if (pos == std::string::npos) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
leaq -0x50(%rbp), %rdi
callq 0x3d1f0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rsi
movq $-... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ProcessRST(std::istream&) | void cmRST::ProcessRST(std::istream& is)
{
std::string line;
while (cmSystemTools::GetLineFromStream(is, line)) {
this->ProcessLine(line);
}
this->Reset();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d1f0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rsi
movq $-0x1, %rcx
callq 0x7fb800
movb %al, -0x49(%rbp)
jmp 0x298aae
movb... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ProcessInclude(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmRST::IncludeType) | bool cmRST::ProcessInclude(std::string file, IncludeType type)
{
bool found = false;
if (this->IncludeDepth < 10) {
cmRST r(this->OS, this->DocRoot);
r.IncludeDepth = this->IncludeDepth + 1;
r.OutputLinePending = this->OutputLinePending;
if (type != IncludeTocTree) {
r.Replace = this->Replace;... | pushq %rbp
movq %rsp, %rbp
subq $0xed0, %rsp # imm = 0xED0
movq %rsi, -0xea8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xea0(%rbp)
movb $0x0, -0x15(%rbp)
cmpl $0xa, 0x28(%rax)
jge 0x299f7f
movq -0xea0(%rbp), %rsi
movq (%rsi), %rax
movq %rax, -... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmRST::ReplaceSubstitutions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmRST::ReplaceSubstitutions(std::string const& line)
{
std::string out;
std::string::size_type pos = 0;
while (this->Substitution.find(line.c_str() + pos)) {
std::string::size_type start = this->Substitution.start(2);
std::string::size_type end = this->Substitution.end(2);
std::string subs... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3d1f0
movq $0x0, -0x28(%rbp)
movq -0x110... | /JKorbelRA[P]CMake/Source/cmRST.cxx |
cmScriptGenerator::GenerateScriptActionsOnce(std::ostream&, cmScriptGeneratorIndent) | void cmScriptGenerator::GenerateScriptActionsOnce(std::ostream& os,
Indent indent)
{
if (this->Configurations.empty()) {
// This rule is for all configurations.
this->GenerateScriptActions(os, indent);
} else {
// Generate a per-configuration block.
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x28, %rdi
callq 0x61d70
testb $0x1, %al
jne 0x29c5ed
jmp 0x29c609
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp... | /JKorbelRA[P]CMake/Source/cmScriptGenerator.cxx |
cmState::cmState(cmState::Mode, cmState::ProjectKind) | cmState::cmState(Mode mode, ProjectKind projectKind)
: StateMode(mode)
, StateProjectKind(projectKind)
{
this->CacheManager = cm::make_unique<cmCacheManager>();
this->GlobVerificationManager = cm::make_unique<cmGlobVerificationManager>();
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x2b4510
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x60530
movq -0x38(%rbp), %rdi
addq $0x48... | /JKorbelRA[P]CMake/Source/cmState.cxx |
cmState::ModeToString[abi:cxx11](cmState::Mode) | std::string cmState::ModeToString(cmState::Mode mode)
{
switch (mode) {
case Project:
return "PROJECT";
case Script:
return "SCRIPT";
case FindPackage:
return "FIND_PACKAGE";
case CTest:
return "CTEST";
case CPack:
return "CPACK";
case Help:
return "HELP";
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x2b0a39
movq -0x30(%rbp), %rax
leaq 0x8ac59f(%rip), %rcx # 0xb5cdc8
movslq (%rcx,%rax,4), %rax
addq %r... | /JKorbelRA[P]CMake/Source/cmState.cxx |
cmState::CreateFunctionCallSnapshot(cmStateSnapshot const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmStateSnapshot cmState::CreateFunctionCallSnapshot(
cmStateSnapshot const& originSnapshot, std::string const& fileName)
{
cmStateDetail::PositionType pos =
this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
pos->ScopeParent = originSnapshot.Position;
pos->SnapshotType = cmStateEnum... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %rdi, -0x200(%rbp)
movq %rdi, -0x1f8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
addq $0x1c8, %rax # imm = 0x1C8
movq %rax, -0x1e0(%rbp)
movq -0x10(%rbp), %ra... | /JKorbelRA[P]CMake/Source/cmState.cxx |
cmStateSnapshot::RaiseScope(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool cmStateSnapshot::RaiseScope(std::string const& var, const char* varDef)
{
if (this->Position->ScopeParent == this->Position->DirectoryParent) {
cmStateSnapshot parentDir = this->GetBuildsystemDirectoryParent();
if (!parentDir.IsValid()) {
return false;
}
// Update the definition in the pare... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x8, %rdi
callq 0x2b5610
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
addq $0x8, %rdi
callq 0x2b5610
movq -0x90(%rbp), %rdi
movq 0x10(%rax), %rcx
movq %rc... | /JKorbelRA[P]CMake/Source/cmStateSnapshot.cxx |
cmSystemTools::ParseWindowsCommandLine(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>>>>&) | void cmSystemTools::ParseWindowsCommandLine(const char* command,
std::vector<std::string>& args)
{
// See the MSDN document "Parsing C Command-Line Arguments" at
// http://msdn2.microsoft.com/en-us/library/a1y7w461.aspx for rules
// of parsing the windows command line.
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d1f0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2cf22b
movq -0x40(%rbp), %rax
movs... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::SaveRestoreEnvironment::~SaveRestoreEnvironment() | cmSystemTools::SaveRestoreEnvironment::~SaveRestoreEnvironment()
{
// First clear everything in the current environment:
std::vector<std::string> currentEnv = GetEnvironmentVariables();
for (std::string var : currentEnv) {
std::string::size_type pos = var.find('=');
if (pos != std::string::npos) {
v... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2d2ab0
jmp 0x2d4195
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62290
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x622c0
movq %rax, -0x3... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::EnableVSConsoleOutput() | void cmSystemTools::EnableVSConsoleOutput()
{
#ifdef _WIN32
// Visual Studio tools like devenv may not
// display output to the console unless this environment variable is
// set. We need it to capture the output of these build tools.
// Note for future work that one could pass "/out \\.\pipe\NAME" to
// eit... | pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::ExtractTar(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&, cmSystemToo... | bool cmSystemTools::ExtractTar(const std::string& outFileName,
const std::vector<std::string>& files,
cmTarExtractTimestamps extractTimestamps,
bool verbose)
{
#if !defined(CMAKE_BOOTSTRAP)
return extract_tar(outFileName, fil... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x15(%rbp), %al
movl -0x14(%rbp), %ecx
movl $0x1, %r8d
andb $0x1, %al
movzbl %al, %edx
callq 0x2d4a60
andb... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
(anonymous namespace)::extract_tar(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&, bo... | bool extract_tar(const std::string& outFileName,
const std::vector<std::string>& files, bool verbose,
cmSystemTools::cmTarExtractTimestamps extractTimestamps,
bool extract)
{
cmLocaleRAII localeRAII;
static_cast<void>(localeRAII);
struct archive* a = archive_read... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xe7680
callq 0x8f2690
movq %rax, -0x290(%rbp)
jmp 0x2d4a9b
mov... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
SetRPathELF(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>>*, bool*) | static cm::optional<bool> SetRPathELF(std::string const& file,
std::string const& newRPath,
std::string* emsg, bool* changed)
{
auto adjustCallback = [newRPath](cm::optional<std::string>& outRPath,
const std... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3b400
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2da160
jmp 0x2d75d2
leaq... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
RemoveRPathXCOFF(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*) | static cm::optional<bool> RemoveRPathXCOFF(std::string const& file,
std::string* emsg, bool* removed)
{
if (removed) {
*removed = false;
}
#if !defined(CMake_USE_XCOFF_PARSER)
(void)file;
(void)emsg;
return cm::nullopt; // Cannot handle XCOFF files.
#else
cmXCO... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2d84b2
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
leaq -0x2(%rbp), %rdi
callq 0x2de090
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::GetSystemName() | cm::string_view cmSystemTools::GetSystemName()
{
#if defined(_WIN32)
return "Windows";
#elif defined(__ANDROID__)
return "Android";
#else
static struct utsname uts_name;
static bool initialized = false;
static cm::string_view systemName;
if (initialized) {
return systemName;
}
if (uname(&uts_name) >... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
testb $0x1, 0xc273fc(%rip) # 0xf000be
je 0x2d8cdf
movq 0xc273f5(%rip), %rax # 0xf000c0
movq %rax, -0x10(%rbp)
movq 0xc273f2(%rip), %rax # 0xf000c8
movq %rax, -0x8(%rbp)
jmp 0x2d8f4b
leaq 0xc27252(%rip), %rdi # 0xefff38
callq 0x3b1d0
cmpl ... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
(anonymous namespace)::copy_data(archive*, archive*) | bool copy_data(struct archive* ar, struct archive* aw)
{
long r;
const void* buff;
size_t size;
# if defined(ARCHIVE_VERSION_NUMBER) && ARCHIVE_VERSION_NUMBER >= 3000000
__LA_INT64_T offset;
# else
off_t offset;
# endif
for (;;) {
// See archive.h definition of ARCHIVE_OK for return values.
r = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x940c10
cltq
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x2d95c8
movb $0x1, -0x1(%rbp)
jmp 0x2d9611
movq -0x10(%rbp), %rdi
m... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
Mkdir(char const*, unsigned int const*) | inline int Mkdir(const char* dir, const mode_t* mode)
{
#if defined(_WIN32)
int ret = _wmkdir(cmSystemTools::ConvertToWindowsExtendedPath(dir).c_str());
if (ret == 0 && mode)
cmSystemTools::SystemTools::SetPermissions(dir, *mode);
return ret;
#else
return mkdir(dir, mode ? *mode : 0777);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2dd72a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2dd734
movl $0x1ff, %eax # imm = 0x1FF
movl %eax, -0x1c(%rbp)
jmp 0x2d... | /JKorbelRA[P]CMake/Source/cmSystemTools.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cmTargetPropertyComputer::ComputeLocation<cmTarget>(cmTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const std::string& cmTargetPropertyComputer::ComputeLocation<cmTarget>(
cmTarget const* tgt, const std::string& config)
{
static std::string loc;
if (tgt->IsImported()) {
loc =
tgt->ImportedGetFullPath(config, cmStateEnums::RuntimeBinaryArtifact);
return loc;
}
cmGlobalGenerator* gg = tgt->GetG... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0xc1cee9(%rip) # 0xf00220
jne 0x2e337c
leaq 0xc1cee0(%rip), %rdi # 0xf00220
callq 0x3d080
cmpl $0x0, %eax
je 0x2e337c
leaq 0xc1ceaf(%rip), %rdi # 0xf00200
callq 0x3d1f0
movq 0xc16c5b(%rip), %rdi # 0xef9fb8
l... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::SetLanguageStandardProperty(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&) | void cmTarget::SetLanguageStandardProperty(std::string const& lang,
std::string const& value,
const std::string& feature)
{
cmListFileBacktrace featureBacktrace;
for (auto const& entry : this->impl->CompileFeaturesEntries) {
i... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1a28a0
movq -0xf0(%rbp), %rdi
callq 0x2f8d20
addq $0x258, %rax # imm = 0... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::AddUtility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, cmMakefile*) | void cmTarget::AddUtility(std::string const& name, bool cross, cmMakefile* mf)
{
this->impl->Utilities.insert(BT<std::pair<std::string, bool>>(
{ name, cross }, mf ? mf->GetBacktrace() : cmListFileBacktrace()));
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f8d20
addq $0xf0, %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2f9... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::AddSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | cmSourceFile* cmTarget::AddSource(const std::string& src, bool before)
{
cmSourceFileLocation sfl(this->impl->Makefile, src,
cmSourceFileLocationKind::Known);
if (std::find_if(
this->impl->SourceEntries.begin(), this->impl->SourceEntries.end(),
TargetPropertyEntryFinder(sf... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x2f8d20
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x140(%rbp)
... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::AddLinkLibrary(cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmTargetLinkLibraryType) | void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& lib,
cmTargetLinkLibraryType llt)
{
cmTarget* tgt = mf.FindTargetToUse(lib);
{
const bool isNonImportedTarget = tgt && !tgt->IsImported();
const std::string libName =
(isNonImportedTarget && llt != GENERAL_... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x226450
movq %rax, -0x28(%rbp)
xorl %eax, %e... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetSuffixVariableInternal(cmStateEnums::ArtifactType) const | const char* cmTarget::GetSuffixVariableInternal(
cmStateEnums::ArtifactType artifact) const
{
switch (this->GetType()) {
case cmStateEnums::STATIC_LIBRARY:
return "CMAKE_STATIC_LIBRARY_SUFFIX";
case cmStateEnums::SHARED_LIBRARY:
switch (artifact) {
case cmStateEnums::RuntimeBinaryArtifac... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2ebc90
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x2f4c17
movq -0x20(%rbp), %rax
leaq 0x86bb9e(%rip), %rcx # 0xb606c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetPrefixVariableInternal(cmStateEnums::ArtifactType) const | const char* cmTarget::GetPrefixVariableInternal(
cmStateEnums::ArtifactType artifact) const
{
switch (this->GetType()) {
case cmStateEnums::STATIC_LIBRARY:
return "CMAKE_STATIC_LIBRARY_PREFIX";
case cmStateEnums::SHARED_LIBRARY:
switch (artifact) {
case cmStateEnums::RuntimeBinaryArtifac... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2ebc90
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x2f4d57
movq -0x20(%rbp), %rax
leaq 0x86ba6e(%rip), %rcx # 0xb606d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetMappedConfig(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmValue&, cmValue&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | bool cmTarget::GetMappedConfig(std::string const& desired_config, cmValue& loc,
cmValue& imp, std::string& suffix) const
{
std::string config_upper;
if (!desired_config.empty()) {
config_upper = cmSystemTools::UpperCase(desired_config);
}
std::string locPropBase;
if (this->... | pushq %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp # imm = 0x7E0
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, -0x740(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3d1f0
movq -0x18(%rbp), %rdi
callq 0x3b870
testb $0x1, %al... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetOrCreateFileSet(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&, cmFileSetVisibility) | std::pair<cmFileSet*, bool> cmTarget::GetOrCreateFileSet(
const std::string& name, const std::string& type, cmFileSetVisibility vis)
{
auto result = this->impl->FileSets.emplace(
std::make_pair(name, cmFileSet(name, type, vis)));
if (result.second) {
auto bt = this->impl->Makefile->GetBacktrace();
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x2f8d20
addq $0x360, %rax # imm = 0x360
movq %rax, -0x278(%rbp)
movq -0x20(%rbp), %rsi
movq %... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetFileSetsPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmTarget::GetFileSetsPropertyName(const std::string& type)
{
if (type == "HEADERS") {
return "HEADER_SETS";
}
if (type == "CXX_MODULES") {
return "CXX_MODULE_SETS";
}
if (type == "CXX_MODULE_HEADER_UNITS") {
return "CXX_MODULE_HEADER_UNIT_SETS";
}
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8b3f13(%rip), %rsi # 0xbaa389
callq 0x85b10
testb $0x1, %al
jne 0x2f6481
jmp 0x2f64cc
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
call... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTarget::GetInterfaceFileSetsPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmTarget::GetInterfaceFileSetsPropertyName(const std::string& type)
{
if (type == "HEADERS") {
return "INTERFACE_HEADER_SETS";
}
if (type == "CXX_MODULES") {
return "INTERFACE_CXX_MODULE_SETS";
}
if (type == "CXX_MODULE_HEADER_UNITS") {
return "INTERFACE_CXX_MODULE_HEADER_UNIT_SETS";
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8b3d83(%rip), %rsi # 0xbaa389
callq 0x85b10
testb $0x1, %al
jne 0x2f6611
jmp 0x2f665c
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
call... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmTargetInternals::CheckImportedLibName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool cmTargetInternals::CheckImportedLibName(std::string const& prop,
std::string const& value) const
{
if (this->TargetType != cmStateEnums::INTERFACE_LIBRARY ||
!this->IsImportedTarget) {
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
prop ... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
cmpl $0x7, (%rax)
jne 0x2f6aa7
movq -0x180(%rbp), %rax
testb $0x1, 0xe5(%rax)
jne 0x2f6b1a
movq -0x180(%rbp), %rax
movq 0x8(%rax), %ra... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
bool (anonymous namespace)::FileSetType::WriteProperties<char const*>(cmTarget*, cmTargetInternals*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, bool) | bool FileSetType::WriteProperties(cmTarget* tgt, cmTargetInternals* impl,
const std::string& prop, ValueType value,
bool clear)
{
if (prop == this->DefaultDirectoryProperty) {
impl->AddDirectoryToFileSet(tgt, std::string(this->TypeName), value,
... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x588(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3e200
... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
void cmTarget::StoreProperty<char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | void cmTarget::StoreProperty(const std::string& prop, ValueType value)
{
if (prop == propMANUALLY_ADDED_DEPENDENCIES) {
this->impl->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
"MANUALLY_ADDED_DEPENDENCIES property is read-only\n");
return;
}
if (prop == propNAME) {
this->impl->Makefi... | pushq %rbp
movq %rsp, %rbp
subq $0xfd0, %rsp # imm = 0xFD0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd98(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc06883(%rip), %rsi # 0xf004b0
callq 0x6d150
testb $0x1, %al
jne 0x2f9c3b
jmp 0x2f9cda
movq -0xd98(%rbp)... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmValue cmTargetPropertyComputer::GetProperty<cmTarget>(cmTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmMakefile const&) | static cmValue GetProperty(Target const* tgt, const std::string& prop,
cmMakefile const& mf)
{
if (cmValue loc = GetLocation(tgt, prop, mf)) {
return loc;
}
if (cmSystemTools::GetFatalErrorOccurred()) {
return nullptr;
}
if (prop == "SOURCES") {
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x30cb20
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x62230
testb $0x1, %al
jne 0x2fdbb8
jmp 0x2fdbba
jmp 0x2fdc0a
callq 0x1a... | /JKorbelRA[P]CMake/Source/cmTargetPropertyComputer.h |
TargetPropertyEntryFinder::operator()(BT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | bool operator()(BT<std::string> const& entry)
{
std::vector<std::string> files = cmExpandedList(entry.Value);
std::vector<cmSourceFileLocation> locations;
locations.reserve(files.size());
std::transform(files.begin(), files.end(), std::back_inserter(locations),
CreateLocation(this->... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e200
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
movq %rd... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
void cmTargetInternals::AddDirectoryToFileSet<cmValue>(cmTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmValue, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, bool) | void cmTargetInternals::AddDirectoryToFileSet(
cmTarget* self, std::string const& fileSetName, ValueType value,
cm::string_view fileSetType, cm::string_view description, bool clear)
{
auto* fileSet = self->GetFileSet(fileSetName);
if (!fileSet) {
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movb 0x20(%rbp), %al
leaq 0x10(%rbp), %r10
movq %r10, -0x1f0(%rbp)
movq %rcx, -0x8(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
void cmTargetInternals::AddPathToFileSet<cmValue>(cmTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmValue, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, bool) | void cmTargetInternals::AddPathToFileSet(
cmTarget* self, std::string const& fileSetName, ValueType value,
cm::string_view fileSetType, cm::string_view description, bool clear)
{
auto* fileSet = self->GetFileSet(fileSetName);
if (!fileSet) {
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movb 0x20(%rbp), %al
leaq 0x10(%rbp), %r10
movq %r10, -0x1f0(%rbp)
movq %rcx, -0x8(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(... | /JKorbelRA[P]CMake/Source/cmTarget.cxx |
cmValue cmTargetPropertyComputer::GetLocation<cmTarget>(cmTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmMakefile const&) | static cmValue GetLocation(Target const* tgt, std::string const& prop,
cmMakefile const& mf)
{
// Watch for special "computed" properties that are dependent on
// other properties or variables. Always recompute them.
if (tgt->GetType() == cmStateEnums::EXECUTABLE ||
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ebc90
cmpl $0x0, %eax
je 0x30cb81
movq -0x10(%rbp), %rdi
callq 0x2ebc90
cmpl $0x1, %eax
je 0x30cb81
movq -0x10(%rbp), %rdi
callq 0x2ebc90
cmpl $0x2, %eax
je 0x30cb81
movq -0x1... | /JKorbelRA[P]CMake/Source/cmTargetPropertyComputer.h |
cmTargetPropertyComputer::HandleLocationPropertyPolicy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmMakefile const&) | bool cmTargetPropertyComputer::HandleLocationPropertyPolicy(
std::string const& tgtName, cmMakefile const& mf)
{
std::ostringstream e;
const char* modal = nullptr;
MessageType messageType = MessageType::AUTHOR_WARNING;
switch (mf.GetPolicyStatus(cmPolicies::CMP0026)) {
case cmPolicies::WARN:
e << cm... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3c530
movq $0x0, -0x190(%rbp)
movl $0x0, -0x194(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %edx, %edx
callq 0x220000
movl %eax, -0x1ec(%rbp)
jmp 0x30dd8c
movl -0x1ec... | /JKorbelRA[P]CMake/Source/cmTargetPropertyComputer.cxx |
(anonymous namespace)::countMaxConsecutiveEqualSigns(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::size_t countMaxConsecutiveEqualSigns(const std::string& name)
{
std::size_t max = 0;
auto startIt = find(name.begin(), name.end(), '=');
auto endIt = startIt;
for (; startIt != name.end(); startIt = find(endIt, name.end(), '=')) {
endIt =
find_if_not(startIt + 1, name.end(), [](char c) { return c... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b640
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3e220
movq %rax, -0x28(%rbp)
movb $0x3d, -0x29(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x311aa0
movq ... | /JKorbelRA[P]CMake/Source/cmTestGenerator.cxx |
cmTestGenerator::EvaluateCommandLineArguments(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&, cmGeneratorExpression&, std::__cxx11::basic_string<char, std::char_traits<char... | std::vector<std::string> cmTestGenerator::EvaluateCommandLineArguments(
const std::vector<std::string>& argv, cmGeneratorExpression& ge,
const std::string& config) const
{
// Evaluate executable name and arguments
auto evaluatedRange =
cmMakeRange(argv).transform([&](const std::string& arg) {
return g... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%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, -0x108(%rbp)
movq -0x18(%rbp), %rdi
call... | /JKorbelRA[P]CMake/Source/cmTestGenerator.cxx |
cmTestGenerator::GenerateInternalProperties(std::ostream&) | void cmTestGenerator::GenerateInternalProperties(std::ostream& os)
{
cmListFileBacktrace bt = this->Test->GetBacktrace();
if (bt.Empty()) {
return;
}
os << " "
<< "_BACKTRACE_TRIPLES"
<< " \"";
bool prependTripleSeparator = false;
while (!bt.Empty()) {
const auto& entry = bt.Top();
i... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x30e0c0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1d1690
movq -0x60(%rbp), %rdi
callq 0x1d7790
movb %al, -0x51(%rbp)
jmp 0x3104ae
movb -0x51(%rbp), %al
... | /JKorbelRA[P]CMake/Source/cmTestGenerator.cxx |
cmVariableWatch::RemoveWatch(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&, int, void*, char const*, cmMakefile const*), void*) | void cmVariableWatch::RemoveWatch(const std::string& variable,
WatchMethod method, void* client_data /*=0*/)
{
if (!this->WatchMap.count(variable)) {
return;
}
cmVariableWatch::VectorOfPairs* vp = &this->WatchMap[variable];
cmVariableWatch::VectorOfPairs::iterator it;
for... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3129c0
cmpq $0x0, %rax
jne 0x312344
jmp 0x312412
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3127b0... | /JKorbelRA[P]CMake/Source/cmVariableWatch.cxx |
cmVariableWatch::VariableAccessed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, char const*, cmMakefile const*) const | bool cmVariableWatch::VariableAccessed(const std::string& variable,
int access_type, const char* newValue,
const cmMakefile* mf) const
{
auto mit = this->WatchMap.find(variable);
if (mit != this->WatchMap.end()) {
// The strategy here... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x18(%rbp), %rsi
callq 0x312af0
movq -0xb8(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x312b50
movq %rax, -0x40(... | /JKorbelRA[P]CMake/Source/cmVariableWatch.cxx |
cmXMLParser::ParseFile(char const*) | int cmXMLParser::ParseFile(const char* file)
{
if (!file) {
return 0;
}
cmsys::ifstream ifs(file);
if (!ifs) {
return 0;
}
std::ostringstream str;
str << ifs.rdbuf();
return this->Parse(str.str().c_str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp # imm = 0x3F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3d0(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x316c41
movl $0x0, -0x4(%rbp)
jmp 0x316dac
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3b2a0
movq -0x2... | /JKorbelRA[P]CMake/Source/cmXMLParser.cxx |
cmXMLParser::CleanupParser() | int cmXMLParser::CleanupParser()
{
if (!this->Parser) {
std::cerr << "Parser not initialized" << std::endl;
this->ParseError = 1;
return 0;
}
int result = !this->ParseError;
if (result) {
// Tell the expat XML parser about the end-of-input.
if (!XML_Parse(static_cast<XML_Parser>(this->Parser... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x3170f1
movq 0xbe2e46(%rip), %rdi # 0xef9f08
leaq 0x84b1c3(%rip), %rsi # 0xb6228c
callq 0x3d690
movq %rax, %rdi
movq 0xbe2e40(%rip), %rsi # 0xef9f18
callq 0x3e080
movq -0x... | /JKorbelRA[P]CMake/Source/cmXMLParser.cxx |
cmXMLParser::ParseBuffer(char const*, unsigned long) | int cmXMLParser::ParseBuffer(const char* buffer, std::string::size_type count)
{
// Pass the buffer to the expat XML parser.
if (!XML_Parse(static_cast<XML_Parser>(this->Parser), buffer,
static_cast<int>(count), 0)) {
this->ReportXmlParseError();
return 0;
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x8a1aa0
cmpl $0x0, %eax
jne 0x3171b9
movq -0x28(%rbp),... | /JKorbelRA[P]CMake/Source/cmXMLParser.cxx |
cmXMLParser::FindAttribute(char const**, char const*) | const char* cmXMLParser::FindAttribute(const char** atts,
const char* attribute)
{
if (atts && attribute) {
for (const char** a = atts; *a && *(a + 1); a += 2) {
if (strcmp(*a, attribute) == 0) {
return *(a + 1);
}
}
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x317382
cmpq $0x0, -0x18(%rbp)
je 0x317382
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x317344
movq -0x20(%rbp), %rax
... | /JKorbelRA[P]CMake/Source/cmXMLParser.cxx |
operator<<(std::ostream&, cmXMLSafe const&) | std::ostream& operator<<(std::ostream& os, cmXMLSafe const& self)
{
char const* first = self.Data;
char const* last = self.Data + self.Size;
while (first != last) {
unsigned int ch;
if (const char* next = cm_utf8_decode_character(first, last, &ch)) {
// http://www.w3.org/TR/REC-xml/#NT-Char
if... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x31781f
m... | /JKorbelRA[P]CMake/Source/cmXMLSafe.cxx |
cmXMLWriter::ConditionalLineBreak(bool) | void cmXMLWriter::ConditionalLineBreak(bool condition)
{
if (condition) {
this->Output << '\n';
for (std::size_t i = 0; i < this->Indent + this->Level; ++i) {
this->Output << this->IndentationElement;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x317b40
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x3be10
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq -... | /JKorbelRA[P]CMake/Source/cmXMLWriter.cxx |
cmXMLWriter::EndElement() | void cmXMLWriter::EndElement()
{
assert(this->Indent > 0);
--this->Indent;
if (this->ElementOpen) {
this->Output << "/>";
} else {
this->ConditionalLineBreak(!this->IsContent);
this->IsContent = false;
this->Output << "</" << this->Elements.top() << '>';
}
this->Elements.pop();
this->Eleme... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x48(%rax)
jbe 0x317b6d
jmp 0x317b8c
leaq 0x84a95b(%rip), %rdi # 0xb624cf
leaq 0x84a895(%rip), %rsi # 0xb62410
movl $0x2d, %edx
leaq 0x84a959(%rip), %rcx # 0xb624e0
callq 0x3b440
movq -0x10... | /JKorbelRA[P]CMake/Source/cmXMLWriter.cxx |
cmake::cmake(cmake::Role, cmState::Mode, cmState::ProjectKind) | cmake::cmake(Role role, cmState::Mode mode, cmState::ProjectKind projectKind)
: CMakeWorkingDirectory(cmSystemTools::GetCurrentWorkingDirectory())
, FileTimeCache(cm::make_unique<cmFileTimeCache>())
#ifndef CMAKE_BOOTSTRAP
, VariableWatch(cm::make_unique<cmVariableWatch>())
#endif
, State(cm::make_unique<cmStat... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
movq %rdi, %rax
movq %rax, -0x2e0(%rbp)
callq 0x344300
movq -0x2b0(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x2d8(... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::AddDefaultExtraGenerators() | void cmake::AddDefaultExtraGenerators()
{
#if !defined(CMAKE_BOOTSTRAP)
this->ExtraGenerators.push_back(cmExtraCodeBlocksGenerator::GetFactory());
this->ExtraGenerators.push_back(cmExtraCodeLiteGenerator::GetFactory());
this->ExtraGenerators.push_back(cmExtraEclipseCDT4Generator::GetFactory());
this->ExtraGener... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rax
movq %rax, -0x60(%rbp)
callq 0x5ace80
movq -0x60(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x346490
movq -0x40(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
callq 0... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::LoadEnvironmentPresets() | void cmake::LoadEnvironmentPresets()
{
std::string envGenVar;
bool hasEnvironmentGenerator = false;
if (cmSystemTools::GetEnv("CMAKE_GENERATOR", envGenVar)) {
hasEnvironmentGenerator = true;
this->EnvironmentGenerator = envGenVar;
}
auto readGeneratorVar = [&](std::string const& name, std::string& ke... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3d1f0
movq -0xd0(%rbp), %rsi
movb $0x0, -0x29(%rbp)
leaq 0x827b67(%rip), %rdi # 0xb40a03
callq 0x7f8000
movb %al, -0xc2(%rbp)
jmp 0x318ea9
movb -0xc2(%r... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmake::ProcessPresetVariables() | void cmake::ProcessPresetVariables()
{
for (auto const& var : this->UnprocessedPresetVariables) {
if (!var.second) {
continue;
}
cmStateEnums::CacheEntryType type = cmStateEnums::UNINITIALIZED;
if (!var.second->Type.empty()) {
type = cmState::StringToCacheEntryType(var.second->Type);
}... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x700, %rax # imm = 0x700
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x100e90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x100ec0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rd... | /JKorbelRA[P]CMake/Source/cmake.cxx |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmake*)>::cmCommandLineArgument<cmake::SetCacheArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_tra... | cmCommandLineArgument(std::string n, std::string failedMsg, Values t,
FunctionType&& func)
: InvalidSyntaxMessage(cmStrCat(" is invalid syntax for ", n))
, InvalidValueMessage(std::move(failedMsg))
, Name(std::move(n))
, Type(t)
, SeparatorNeeded(RequiresSeparator::Yes)
,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x823871(%rip), %rsi # 0xb3fab3
callq 0x6... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.