name string | code string | asm string | file string |
|---|---|---|---|
cmListFileLexerSetToken | static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
int length)
{
/* Set the token line and column number. */
lexer->token.line = lexer->line;
lexer->token.column = lexer->column;
/* Use the same buffer if possible. */
if (lexer->token.text) {
... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x28(%r14), %rax
movq %rax, 0x14(%r14)
testq %rdi, %rdi
je 0x3b07bd
testq %r15, %r15
je 0x3b07a8
cmpl %ebx, 0x30(%r14)
jle 0x3b07a8
movq %r15, %rsi
callq 0x39db0
jmp 0x3b07dd
callq 0x3be90
movq $0x0, 0x8(%r14)
mov... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_yy_init_buffer | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
{
int oerrno = errno;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
yy_flush_buffer( b , yyscanner);
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3b610
movq %rax, %r14
movl (%rax), %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b0b93
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x3b0a70
movq 0x18(%r12), %rcx
movq (%ra... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_yy_switch_to_buffer | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack (yyscanner);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3b067d
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x3b0b39
movq 0x18(%rbx), %rax
movq (%rcx,%rax,8), %rdx
cmpq %r14, %rdx
je 0x3b0b39
testq %rdx, %rdx
je 0x3b0b01
movb 0x30(%rbx), %al
movq 0x40(%rbx), %rcx
movb %al, (%rcx)
movq 0x40... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmListFileLexer_SetFileName | int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name,
cmListFileLexer_BOM* bom)
{
int result = 1;
cmListFileLexerDestroy(lexer);
if (name) {
#ifdef _WIN32
wchar_t* wname = cmsysEncoding_DupToWide(name);
lexer->file = _wfopen(wname, L"rb");
free(wname... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3b11f5
movl $0x1, %ebp
testq %r15, %r15
je 0x3b11ca
leaq 0x1e8161(%rip), %rsi # 0x5991d0
movq %r15, %rdi
callq 0x3bd40
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x3b10fb
testq %r14, %r14
je 0x3b11ca
m... | /JKorbelRA[P]CMake/Source/LexerParser/cmListFileLexer.c |
cmComputeLinkDepends::AddDirectLinkEntries() | void cmComputeLinkDepends::AddDirectLinkEntries()
{
// Add direct link dependencies in this configuration.
cmLinkImplementation const* impl = this->Target->GetLinkImplementation(
this->Config, cmGeneratorTarget::LinkInterfaceFor::Link);
this->AddLinkEntries(-1, impl->Libraries);
this->AddLinkObjects(impl->O... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x40(%rbx), %rsi
movl $0x1, %edx
callq 0x2d5c00
movq %rax, %r14
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rax, %rdx
callq 0x3bae8c
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
cmpq %r12, %r15
je 0x3b... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::GetCurrentFeature(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string const& cmComputeLinkDepends::GetCurrentFeature(
std::string const& item, std::string const& defaultFeature) const
{
auto it = this->LinkLibraryOverride.find(item);
return it == this->LinkLibraryOverride.end() ? defaultFeature : it->second;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
addq $0x78, %rdi
callq 0x97aec
subq $-0x80, %r14
leaq 0x40(%rax), %rcx
cmpq %r14, %rax
cmoveq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::AddVarLinkEntries(int, char const*) | void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
const char* value)
{
// This is called to add the dependencies named by
// <item>_LIB_DEPENDS. The variable contains a semicolon-separated
// list. The list contains link-type;item pairs and just items.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movl %esi, 0x4(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
callq 0x39d50
leaq 0x90(%rsp), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xec293
xorps %xmm0, %xmm0
movaps %xmm0... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::VisitComponent(unsigned int) | void cmComputeLinkDepends::VisitComponent(unsigned int c)
{
// Check if the node has already been visited.
if (this->ComponentVisited[c]) {
return;
}
// We are now visiting this component so mark it.
this->ComponentVisited[c] = 1;
// Visit the neighbors of the component first.
// Run in reverse orde... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq 0x220(%rdi), %rax
cmpb $0x0, (%rax,%r14)
jne 0x3b8a0d
movq %rdi, %rbx
movb $0x1, (%rax,%r14)
movq 0x280(%rdi), %rax
movslq %esi, %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r15
movq 0x8(%rax,%rcx,8), %r12
cmpq %r15,... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::MakePendingComponent(unsigned int) | cmComputeLinkDepends::PendingComponent&
cmComputeLinkDepends::MakePendingComponent(unsigned int component)
{
// Create an entry (in topological order) for the component.
PendingComponent& pc =
this->PendingComponents[this->ComponentOrder[component]];
pc.Id = component;
NodeList const& nl = this->CCG->GetCom... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
addq $0x250, %rdi # imm = 0x250
movl %esi, %esi
shlq $0x2, %rsi
addq 0x238(%r15), %rsi
callq 0x3bcc48
movq %rax, %rbx
movl %ebp, (%rax)
movq 0x280(%r15), %rax
movslq %ebp, %rdx
movq 0x68(%rax), %rcx
l... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmWrap<cmGraphEdgeList>(std::basic_string_view<char, std::char_traits<char>>, cmGraphEdgeList const&, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | std::string cmWrap(cm::string_view prefix, Range const& rng,
cm::string_view suffix, cm::string_view sep)
{
if (rng.empty()) {
return std::string();
}
return cmCatViews(
{ prefix, cmJoin(rng, cmCatViews({ suffix, sep, prefix })), suffix });
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x3bcbad
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
leaq 0xd0(%rsp), %rcx
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x70(%rsp), %rax
movq %r8, (%rax)
movq %r9, 0x8(%rax)
movups (%r... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator*) | cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg)
{
this->GlobalGenerator = gg;
cmake* cm = this->GlobalGenerator->GetCMakeInstance();
this->DebugMode =
cm->GetState()->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE");
this->NoCycles =
cm->GetState()->GetGlobalPropertyAsBool("GLO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
leaq 0x30(%rdi), %rcx
movl $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
addq $0x50, %... | /JKorbelRA[P]CMake/Source/cmComputeTargetDepends.cxx |
cmComputeTargetDepends::CollectTargetDepends(int) | void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
{
// Get the depender.
cmGeneratorTarget const* depender = this->Targets[depender_index];
if (!depender->IsInBuildSystem()) {
return;
}
// Loop over all targets linked directly in all configs.
// We need to make targets depend on the... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movslq %esi, %rax
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %rbp
movq %rbp, %rdi
callq 0x2d4a78
testb %al, %al
je 0x3c2183
leaq 0xc0(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
... | /JKorbelRA[P]CMake/Source/cmComputeTargetDepends.cxx |
cmComputeTargetDepends::CollectSideEffectsForTarget(std::set<int, std::less<int>, std::allocator<int>>&, int) | void cmComputeTargetDepends::CollectSideEffectsForTarget(
std::set<int>& visited, int depender_index)
{
if (!visited.count(depender_index)) {
auto& se = this->SideEffects[depender_index];
visited.insert(depender_index);
this->Targets[depender_index]->AppendCustomCommandSideEffects(
se.CustomComman... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl %edx, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x3c2cea
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, %rcx
xorl %edi, %edi
cmpl %edx, 0x20(%rax)
setl %dil
cmovgeq %rax, %rcx
mo... | /JKorbelRA[P]CMake/Source/cmComputeTargetDepends.cxx |
cmComputeTargetDepends::OptimizeLinkDependencies(cmGeneratorTarget const*, cmGraphEdgeList&, cmGraphEdgeList const&) | void cmComputeTargetDepends::OptimizeLinkDependencies(
cmGeneratorTarget const* gt, cmGraphEdgeList& outputEdges,
cmGraphEdgeList const& inputEdges)
{
std::set<int> emitted;
for (auto const& edge : inputEdges) {
if (edge.IsStrong()) {
// Preserve strong edges
outputEdges.push_back(edge);
} e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, 0x78(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x90(%rsp), %rdx
movl $0x0, (%rdx)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rax, 0x20(%rdx)
movq (%rcx), %r12
movq 0x8(%rcx), ... | /JKorbelRA[P]CMake/Source/cmComputeTargetDepends.cxx |
cmDependsC::cmDependsC(cmLocalUnixMakefileGenerator3*, 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::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, st... | cmDependsC::cmDependsC(cmLocalUnixMakefileGenerator3* lg,
const std::string& targetDir, const std::string& lang,
const DependencyMap* validDeps)
: cmDepends(lg, targetDir)
, ValidDeps(validDeps)
{
cmMakefile* mf = lg->GetMakefile();
// Configure the include file se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r8, %r15
movq %rcx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x108(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0xf8(%rsp), %r12
movq %r12, %rdi
callq 0x5... | /JKorbelRA[P]CMake/Source/cmDependsC.cxx |
cmDependsC::Scan(std::istream&, 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 cmDependsC::Scan(std::istream& is, const std::string& directory,
const std::string& fullName)
{
cmIncludeLines& newCacheEntry = this->FileCache[fullName];
newCacheEntry.Used = true;
// Read one line at a time.
std::string line;
while (cmSystemTools::GetLineFromStream(is, line)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0x98(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdi, %r15
addq $0x4f0, %rdi # imm = 0x4F0
movq %rcx, %rsi
callq 0x3c7814
movq %rax, 0xa8(%rsp)
movb $0x1, 0x18(%rax)
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x... | /JKorbelRA[P]CMake/Source/cmDependsC.cxx |
cmExportInstallAndroidMKGenerator::GenerateInterfaceProperties(cmGeneratorTarget const*, std::ostream&, std::map<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::less<std::__cxx11::basic_string<char, std:... | void cmExportInstallAndroidMKGenerator::GenerateInterfaceProperties(
cmGeneratorTarget const* target, std::ostream& os,
const ImportPropertyMap& properties)
{
std::string config;
if (!this->Configurations.empty()) {
config = this->Configurations[0];
}
cmExportBuildAndroidMKGenerator::GenerateInterfacePr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0x3ca5f4
leaq 0x8(%rsp), %rdi
callq 0x3bad0
leaq 0x8(%rsp), %r8
movq %r15, %rdi... | /JKorbelRA[P]CMake/Source/cmExportInstallAndroidMKGenerator.cxx |
cmExportInstallFileGenerator::GenerateImportPrefix(std::ostream&) | void cmExportInstallFileGenerator::GenerateImportPrefix(std::ostream& os)
{
// Set an _IMPORT_PREFIX variable for import location properties
// to reference if they are relative to the install prefix.
std::string installPrefix =
this->IEGen->GetLocalGenerator()->GetMakefile()->GetSafeDefinition(
"CMAKE_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x118(%rdi), %rax
movq 0x158(%rax), %rax
movq 0x70(%rax), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x21b8d3(%rip), %rsi # 0x5e7494
leaq 0x21b8e0(%rip), %rdx # 0x5e74a8
leaq 0x28(%r... | /JKorbelRA[P]CMake/Source/cmExportInstallFileGenerator.cxx |
cmExportInstallFileGenerator::GetFileSetDirectories[abi:cxx11](cmGeneratorTarget*, cmFileSet*, cmTargetExport*) | std::string cmExportInstallFileGenerator::GetFileSetDirectories(
cmGeneratorTarget* gte, cmFileSet* fileSet, cmTargetExport* te)
{
std::vector<std::string> resultVector;
auto configs =
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
cmGeneratorExpression ge;
auto cge = ge.Parse(te->F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, 0xc0(%rsp)
movq %rdi, 0x8(%rsp)
movq %rcx, 0x48(%rsp)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
movq 0x8(%rdx), %rsi
leaq 0x88(%rsp), %rdi
xorl %e... | /JKorbelRA[P]CMake/Source/cmExportInstallFileGenerator.cxx |
cmExportInstallFileGenerator::GenerateCxxModuleConfigInformation(std::ostream&) const | void cmExportInstallFileGenerator::GenerateCxxModuleConfigInformation(
std::ostream& os) const
{
// Now load per-configuration properties for them.
/* clang-format off */
os << "# Load information for each installed configuration.\n"
"file(GLOB _cmake_cxx_module_includes \"${CMAKE_CURRENT_LIST_DIR}/cxx-... | movq %rsi, %rdi
leaq 0x21be46(%rip), %rsi # 0x5eaac4
movl $0x14c, %edx # imm = 0x14C
jmp 0x3b4d0
| /JKorbelRA[P]CMake/Source/cmExportInstallFileGenerator.cxx |
cmExportTryCompileFileGenerator::FindTargets(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<cmGeneratorTarget const*, std::less<cmGeneratorTarget const*>, std... | std::string cmExportTryCompileFileGenerator::FindTargets(
const std::string& propName, cmGeneratorTarget const* tgt,
std::string const& language, std::set<cmGeneratorTarget const*>& emitted)
{
cmValue prop = tgt->GetProperty(propName);
if (!prop) {
return std::string();
}
cmGeneratorExpression ge;
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9e8, %rsp # imm = 0x9E8
movq %r9, %r14
movq %r8, 0x18(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x2d0626
testq %rax, %rax
je 0x3cf9c4
movq %rax, %rbp
movq %rbx, 0x28(%rs... | /JKorbelRA[P]CMake/Source/cmExportTryCompileFileGenerator.cxx |
cmExportTryCompileFileGenerator::GetCxxModulesDirectory[abi:cxx11]() const | std::string GetCxxModulesDirectory() const override { return {}; } | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
retq
nop
| /JKorbelRA[P]CMake/Source/cmExportTryCompileFileGenerator.h |
cmFilePathChecksum::setupParentDirs(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_str... | void cmFilePathChecksum::setupParentDirs(std::string const& currentSrcDir,
std::string const& currentBinDir,
std::string const& projectSrcDir,
std::string const& projectBinDir)
{
this->parentDirs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %edx, %edx
callq 0x3f8884
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a1e0
movq (%r13), %rdi
leaq 0x18(%rsp), %rbp
cmpq %rbp, %rdi
je 0... | /JKorbelRA[P]CMake/Source/cmFilePathChecksum.cxx |
cmFilePathChecksum::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmFilePathChecksum::get(std::string const& filePath) const
{
std::string relPath;
std::string relSeed;
{
std::string const fileReal = cmSystemTools::GetRealPath(filePath);
std::string parentDir;
// Find closest project parent directory
for (auto const& pDir : this->parentDirs) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x8(%rsp), %rdi
... | /JKorbelRA[P]CMake/Source/cmFilePathChecksum.cxx |
cmGeneratorExpressionDAGChecker::Initialize() | void cmGeneratorExpressionDAGChecker::Initialize()
{
const auto* top = this->Top();
this->CheckResult = this->CheckGraph();
#define TEST_TRANSITIVE_PROPERTY_METHOD(METHOD) top->METHOD() ||
if (this->CheckResult == DAG &&
(CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
TEST_TRANSITIVE_PROPERTY_METHOD) fal... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %r14
movq (%rax), %rax
testq %rax, %rax
jne 0x3d14b8
movq %rbx, %rdi
callq 0x3d16c2
movl %eax, 0x78(%rbx)
testl %eax, %eax
je 0x3d14de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x3d... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
cmGeneratorExpressionDAGChecker::Top() const | cmGeneratorExpressionDAGChecker const* cmGeneratorExpressionDAGChecker::Top()
const
{
const cmGeneratorExpressionDAGChecker* top = this;
const cmGeneratorExpressionDAGChecker* parent = this->Parent;
while (parent) {
top = parent;
parent = parent->Parent;
}
return top;
} | movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x3d16b6
retq
| /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
cmGeneratorExpressionDAGChecker::ReportError(cmGeneratorExpressionContext*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmGeneratorExpressionDAGChecker::ReportError(
cmGeneratorExpressionContext* context, const std::string& expr)
{
if (this->CheckResult == DAG) {
return;
}
context->HadError = true;
if (context->Quiet) {
return;
}
const cmGeneratorExpressionDAGChecker* parent = this->Parent;
if (parent && ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, 0x28(%rsp)
movq %rsi, (%rsp)
cmpl $0x0, 0x78(%rdi)
je 0x3d1d05
movq (%rsp), %rax
movb $0x1, 0x159(%rax)
cmpb $0x0, 0x158(%rax)
jne 0x3d1d05
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x3d19ae
cmpq $0x0, (%... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
cmGeneratorExpressionDAGChecker::EvaluatingGenexExpression() const | bool cmGeneratorExpressionDAGChecker::EvaluatingGenexExpression() const
{
return cmHasLiteralPrefix(this->Property, "TARGET_GENEX_EVAL:") ||
cmHasLiteralPrefix(this->Property, "GENEX_EVAL:");
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rsp, %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
leaq 0x219014(%rip), %r8 # 0x5eadc5
movl $0x12, %edx
movl $0x12, %ecx
xorl %esi, %esi
callq 0x5bbfc
testl %eax, %eax
je 0x3d1df7
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
cmGeneratorExpressionDAGChecker::EvaluatingLinkOptionsExpression() const | cmGeneratorExpressionDAGChecker const* cmGeneratorExpressionDAGChecker::Top()
const
{
const cmGeneratorExpressionDAGChecker* top = this;
const cmGeneratorExpressionDAGChecker* parent = this->Parent;
while (parent) {
top = parent;
parent = parent->Parent;
}
return top;
} | movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x3d1f64
cmpq $0xc, 0x18(%rax)
jne 0x3d1f97
movq 0x10(%rax), %rax
movabsq $0x54504f5f4b4e494c, %rcx # imm = 0x54504F5F4B4E494C
xorq (%rax), %rcx
movl 0x8(%rax), %eax
xorq $0x534e4f49, %rax # imm = 0x534E4F49
orq %rcx, %rax
sete %al
retq
xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(cmGeneratorTarget const*, cmGeneratorExpressionDAGChecker::ForGenex) const | bool cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(
cmGeneratorTarget const* tgt, ForGenex genex) const
{
const auto* top = this->Top();
cm::string_view prop(top->Property);
if (tgt) {
return top->Target == tgt && prop == "LINK_LIBRARIES"_s;
}
auto result = prop == "LINK_LIBRARIES"_s ||
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x3d1fa4
movq 0x10(%rax), %rbx
movq 0x18(%rax), %r14
testq %rsi, %rsi
je 0x3d1ff3
xorq 0x8(%rax), %rsi
xorq $0xe, %r14
orq %rsi, %r14
jne 0x3d2165
movabsq $0x42494c5f4b4e494c, %rax # imm = 0x42494C5F... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionDAGChecker.cxx |
GeneratorExpressionContent::Evaluate[abi:cxx11](cmGeneratorExpressionContext*, cmGeneratorExpressionDAGChecker*) const | std::string GeneratorExpressionContent::Evaluate(
cmGeneratorExpressionContext* context,
cmGeneratorExpressionDAGChecker* dagChecker) const
{
std::string identifier;
{
for (const auto& pExprEval : this->IdentifierChildren) {
identifier += pExprEval->Evaluate(context, dagChecker);
if (context->Ha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x38(%rsp)
movq %rdx, %r14
movq %rdi, 0x30(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rbx
movq %rsi, 0x80(%rsp)
movq 0x10(%rsi), %r12
cmpq %r12, %rbx
je 0x3d295a... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionEvaluator.cxx |
BoolNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*) const | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
return !cmIsOff(parameters.front()) ? "1" : "0";
} | pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0xbc5b0
leaq 0x1dfaa9(%rip), %rcx # 0x5b9a67
leaq 0x245173(%rip), %rsi # 0x61f138
leaq 0x10(%rbx), %rdx
testb %al, %al
cmovneq %rcx, %rsi
movq %rdx, (%rbx)
leaq 0x1dfa8f(%rip), %rax # 0x5b9a68
leaq 0x245159(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
FilterNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*) con... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
if (parameters.size() != 3) {
reportError(context, content->GetOriginalExpress... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
subq %rdi, %rax
cmpq $0x60, %rax
jne 0x3da957
movq %rdx, %r12
addq $0x20, %rdi
leaq 0x1d7931(%rip), %rsi # 0x5b221d
callq ... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetExistsNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
if (parameters.size() != 1) {
reportError(context, content->GetOriginalExpress... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %rax
subq %r12, %rax
cmpq $0x20, %rax
jne 0x3dae94
cmpq $0x0, 0x8(%r12)
je 0x3daed6
movq %r12, %rdi
callq 0x2ce318
testb %al, %al
je 0x3daed6
movq 0x100(%r14), %rax
movq 0x70(%ra... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
PathNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*) const | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
static std::unordered_map<
cm::string_view,
std::function<std::string(cm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp # imm = 0x588
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movb 0x3b5cc5(%rip), %al # 0x791828
testb %al, %al
je 0x3dbd23
movq (%r12), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %rsi, 0x48(%rsp)
mo... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
CompilerVersionNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChec... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (!context->HeadTarget) {
std::ostringstream e;
e << "$<" << this->Compile... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x148(%rcx)
je 0x3dcd13
movq %r9, %r13
movq %rdx, %rbp
movq 0x8(%r12), %rsi
leaq 0x50(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
ConfigurationNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecke... | std::string Evaluate(
const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
context->HadContextSensitiveCondition = true;
return context->Config;
... | pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x15a(%rcx)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x108(%rcx), %rsi
movq 0x110(%rcx), %rdx
addq %rsi, %rdx
callq 0x5b7c4
movq %rbx, %rax
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
JoinNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*) const | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
std::vector<std::string> list = cmExpandedList(parameters.front());
retu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xec293
movq (%r14), %rax
movq 0x20(%rax), %rcx
movq 0x28(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
LinkLanguageAndIdNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGCh... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (!context->HeadTarget || !dagChecker ||
!(dagChecker->EvaluatingLinkExpressio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
testq %r9, %r9
je 0x3de6f5
cmpq $0x0, 0x148(%r14)
je 0x3de6f5
movq %r9, %r13
movq %rdx, %r12
movq %r9, %rdi
callq 0x3d1ebe
testb %al, %al
jne 0x3de5cf
movq %r13, %rdi
xorl %esi, %esi
xorl %e... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
HostLinkNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*) c... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (!context->HeadTarget || !dagChecker ||
!dagChecker->EvaluatingLinkOptionsExp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdi, %rbx
testq %r9, %r9
je 0x3e0294
cmpq $0x0, 0x148(%r14)
je 0x3e0294
movq %rdx, %r15
movq %r9, %rdi
callq 0x3d1f64
testb %al, %al
je 0x3e0294
movq 0x148(%r14), %rax
cmpb $0x1, 0x298(%rax)
je 0x3e0306
leaq 0x1c8c6e(%rip)... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetPropertyNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGCheck... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagCheckerParent) const override
{
static cmsys::RegularExpression propertyNameValidator("^[A-Za-z0-9_]+$");
cmG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %rbx
movb 0x3b1518(%rip), %al # 0x791d38
testb %al, %al
je 0x3e19d0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0x88(%rsp), %rcx
movq %... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetNameNode::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChecker*)... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
return parameters.front();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
callq 0x5b7c4
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetArtifactBase::GetTarget(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChec... | cmGeneratorTarget* GetTarget(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const
{
// Lookup the referenced target.
std::string const& name = parameters.front();
i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq (%rsi), %r13
movq %r13, %rdi
callq 0x2ce318
testb %al, %al
je 0x3e4738
movq 0x100(%rbx), %rdi
movq %r13, %rsi
callq 0x85cde
testq %rax, %rax
je 0x3e478b
movq %rax, %r15
movq %rax, %rdi
callq 0x2d0... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifact<ArtifactNameTag, ArtifactDirTag>::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionConten... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
cmGeneratorTarget* target =
this->GetTarget(parameters, context, content, dagCheck... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x3e467a
testq %rax, %rax
je 0x3e4cf3
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e4a94
leaq 0x108(%r14), %rdx
movq %rsp, %rdi
movq %r15, %rsi... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifact<ArtifactLinkerTag, ArtifactDirTag>::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionCont... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
cmGeneratorTarget* target =
this->GetTarget(parameters, context, content, dagCheck... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x3e467a
testq %rax, %rax
je 0x3e5107
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e4a94
leaq 0x8(%rsp), %rdi
movq %r... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifact<ArtifactSonameTag, ArtifactNameTag>::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionCon... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
cmGeneratorTarget* target =
this->GetTarget(parameters, context, content, dagCheck... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x3e467a
testq %rax, %rax
je 0x3e5561
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e4a94
leaq 0x8(%rsp), %rdi
movq %r... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifactResultCreator<ArtifactPdbTag>::Create[abi:cxx11](cmGeneratorTarget*, cmGeneratorExpressionContext*, GeneratorExpressionContent const*) | static std::string Create(cmGeneratorTarget* target,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content)
{
if (target->IsImported()) {
::reportError(context, content->GetOriginalExpression(),
"TARGET_PD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2d10d6
testb %al, %al
je 0x3e588f
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3d24d4
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x207564(%rip... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifact<ArtifactBundleContentDirTag, ArtifactPathTag>::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExp... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
cmGeneratorTarget* target =
this->GetTarget(parameters, context, content, dagCheck... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x3e467a
testq %rax, %rax
je 0x3e6519
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e4a94
leaq 0x8(%rsp), %rdi
movq %r... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFileArtifact<ArtifactFilePrefixTag>::Evaluate(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&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGene... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
cmGeneratorTarget* target =
this->GetTarget(parameters, context, content, dagCheck... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x3e467a
testq %rax, %rax
je 0x3e72ce
leaq 0x108(%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x2d0f36
leaq 0x10(%rbx), %rax
cmpb $0x0, 0x15... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
extendText(std::vector<std::unique_ptr<cmGeneratorExpressionEvaluator, std::default_delete<cmGeneratorExpressionEvaluator>>, std::allocator<std::unique_ptr<cmGeneratorExpressionEvaluator, std::default_delete<cmGeneratorExpressionEvaluator>>>>&, __gnu_cxx::__normal_iterator<cmGeneratorExpressionToken const*, std::vector... | static void extendText(
cmGeneratorExpressionEvaluatorVector& result,
std::vector<cmGeneratorExpressionToken>::const_iterator it)
{
if (!result.empty() &&
(*(result.end() - 1))->GetType() ==
cmGeneratorExpressionEvaluator::Text) {
cm::static_reference_cast<TextContent>(*(result.end() - 1))
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, (%rdi)
je 0x3e845e
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
je 0x3e849a
movl $0x18, %edi
callq 0x39460
movups 0x8(%r14), %xmm0
leaq 0x397d2c(%rip), %rcx # 0x7801a0
movq %rcx, (%rax)
movu... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionParser.cxx |
extendResult(std::vector<std::unique_ptr<cmGeneratorExpressionEvaluator, std::default_delete<cmGeneratorExpressionEvaluator>>, std::allocator<std::unique_ptr<cmGeneratorExpressionEvaluator, std::default_delete<cmGeneratorExpressionEvaluator>>>>&, std::vector<std::unique_ptr<cmGeneratorExpressionEvaluator, std::default_... | static void extendResult(
cmGeneratorExpressionParser::cmGeneratorExpressionEvaluatorVector& result,
cmGeneratorExpressionParser::cmGeneratorExpressionEvaluatorVector&& contents)
{
if (!result.empty() &&
(*(result.end() - 1))->GetType() ==
cmGeneratorExpressionEvaluator::Text &&
contents.front... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq %rax, (%rdi)
je 0x3e851b
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jne 0x3e851b
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jne 0x3e851b
movq 0x8(%r14)... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionParser.cxx |
cmLinkItemGraphVisitor::ItemVisited(cmLinkItem const&) | bool cmLinkItemGraphVisitor::ItemVisited(cmLinkItem const& item)
{
auto& collection = this->VisitedItems;
bool const visited = collection.find(item.AsStr()) != collection.cend();
if (!visited) {
collection.insert(item.AsStr());
}
return visited;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %rsi, %rdi
callq 0x340c26
movq %r14, %rdi
movq %rax, %rsi
callq 0x7680e
movq %rax, %r12
addq $0x10, %rbx
cmpq %rbx, %rax
jne 0x3e8c78
movq %r15, %rdi
callq 0x340c26
movq %r14, %rdi
movq %rax, %rsi
callq 0x6d... | /JKorbelRA[P]CMake/Source/cmLinkItemGraphVisitor.cxx |
cmGccDepfile_yyensure_buffer_stack(void*) | static void yyensure_buffer_stack (yyscan_t yyscanner)
{
yy_size_t num_to_alloc;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) {
/* First allocation is just for 2 elements, since we don't know if this
* scanner will even need a stack. We use 2 instead of 1 to avoid an
*... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x3eac45
movq 0x20(%rbx), %r14
leaq -0x1(%r14), %rax
cmpq %rax, 0x18(%rbx)
jb 0x3eac69
leaq 0x40(,%r14,8), %rsi
callq 0x3be88
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x3eac71
addq $0x8, %r14
movq 0x20(%rbx), %rcx
xorps %xmm0, %... | /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
cmGccDepfile_yy_create_buffer(_IO_FILE*, int, void*) | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 charac... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x48, %edi
callq 0x3bee0
testq %rax, %rax
je 0x3eacd9
movq %rax, %r15
movl %ebp, 0x18(%rax)
addl $0x2, %ebp
movslq %ebp, %rdi
callq 0x3bee0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x3eacd9
movl $0x1, 0x28(%r15)... | /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
cmGccDepfile_yy_switch_to_buffer(yy_buffer_state*, void*) | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack (yyscanner);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3eabed
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x3eaf7e
movq 0x18(%rbx), %rax
movq (%rcx,%rax,8), %rdx
cmpq %r14, %rdx
je 0x3eaf7e
testq %rdx, %rdx
je 0x3eaf44
movb 0x30(%rbx), %al
movq 0x48(%rbx), %rcx
movb %al, (%rcx)
movq 0x48... | /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
cmGccDepfile_yy_delete_buffer(yy_buffer_state*, void*) | void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yyfree( (void *) b->yy_... | testq %rdi, %rdi
je 0x3eafa7
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x3eafa8
movq 0x18(%rsi), %rcx
movq (%rax,%rcx,8), %rcx
jmp 0x3eafaa
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x3eafbb
movq 0x18(%rsi), %rcx
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x28(%rbx)
je 0x3eafca
movq 0x8(%rbx), %rdi
c... | /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
cmGccDepfile_yylex_init(void**) | int yylex_init(yyscan_t* ptr_yy_globals)
{
if (ptr_yy_globals == NULL){
errno = EINVAL;
return 1;
}
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
if (*ptr_yy_globals == NULL){
errno = ENOMEM;
return 1;
}
/* By setting to 0xAA, we exp... | pushq %rbx
testq %rdi, %rdi
je 0x3eb391
movq %rdi, %rbx
movl $0x1, %edi
movl $0x98, %esi
callq 0x3bed8
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x3eb3a2
movl $0xc, %ebx
jmp 0x3eb396
movl $0x16, %ebx
callq 0x3b610
movl %ebx, (%rax)
movl $0x1, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
cmGccDepfile_yyrealloc(void*, unsigned long, void*) | void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latt... | jmp 0x3be88
nop
| /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
Base32Encode5(unsigned char const*, char*) | static void Base32Encode5(const unsigned char src[5], char dst[8])
{
// [0]:5 bits
dst[0] = Base32EncodeChar((src[0] >> 3) & 0x1F);
// [0]:3 bits + [1]:2 bits
dst[1] = Base32EncodeChar(((src[0] << 2) & 0x1C) + ((src[1] >> 6) & 0x03));
// [1]:5 bits
dst[2] = Base32EncodeChar((src[1] >> 1) & 0x1F);
// [1]:1... | movzbl (%rdi), %ecx
shrl $0x3, %ecx
leaq 0x20440f(%rip), %rax # 0x5efa10
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movzbl (%rdi), %ecx
andl $0x7, %ecx
movzbl 0x1(%rdi), %edx
shrl $0x6, %edx
leal (%rdx,%rcx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movzbl 0x1(%rdi), %ecx
shrl %ecx
andl $0x1f, %ecx
movb (%rcx,%r... | /JKorbelRA[P]CMake/Source/cmBase32.cxx |
cmComputeComponentGraph::Tarjan() | void cmComputeComponentGraph::Tarjan()
{
int n = static_cast<int>(this->InputGraph.size());
TarjanEntry entry = { 0, 0 };
this->TarjanEntries.resize(0);
this->TarjanEntries.resize(n, entry);
this->TarjanComponents.resize(0);
this->TarjanComponents.resize(n, -1);
this->TarjanWalkId = 0;
this->TarjanVisit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r13
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
leaq 0x50(%rdi), %r12
xorl %e... | /JKorbelRA[P]CMake/Source/cmComputeComponentGraph.cxx |
cmsysProcess_Delete | void kwsysProcess_Delete(kwsysProcess* cp)
{
/* Make sure we have an instance. */
if (!cp) {
return;
}
/* If the process is executing, wait for it to finish. */
if (cp->State == kwsysProcess_State_Executing) {
if (cp->Detached) {
kwsysProcess_Disown(cp);
} else {
kwsysProcess_WaitFo... | testq %rdi, %rdi
je 0x3ed0ed
pushq %rbx
movq %rdi, %rbx
movl 0x50c(%rdi), %eax
cmpl $0x3, %eax
jne 0x3ed0f8
cmpl $0x0, 0x44c(%rbx)
je 0x3ed0ee
movq %rbx, %rdi
callq 0x3ed193
jmp 0x3ed0f8
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3ed1e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3ed701
movq 0x440(%rbx), %rdi
testq %rdi,... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_WaitForExit | int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
{
int prPipe = 0;
/* Make sure we are executing a process. */
if (!cp || cp->State != kwsysProcess_State_Executing) {
return 1;
}
/* Wait for all the pipes to close. Ignore all data. */
while ((prPipe = kwsysProcess_WaitForData(cp,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
testq %rdi, %rdi
je 0x3ed6f0
movq %rdi, %r14
movl 0x50c(%rdi), %eax
cmpl $0x3, %eax
jne 0x3ed6f0
movq %rsi, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3ef0d3
testl %eax, %eax
jle 0x3ed22f
cmpl ... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_SetWorkingDirectory | int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp, const char* dir)
{
if (!cp) {
return 0;
}
if (cp->WorkingDirectory == dir) {
return 1;
}
if (cp->WorkingDirectory && dir && strcmp(cp->WorkingDirectory, dir) == 0) {
return 1;
}
if (cp->WorkingDirectory) {
free(cp->WorkingDirectory);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3ed824
movq %rsi, %r15
movq %rdi, %r14
movq 0x440(%rdi), %r12
cmpq %rsi, %r12
je 0x3ed81f
testq %r12, %r12
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x3ed7ee
movq %r12, %rdi
movq %r15, %rsi
callq 0x3aed0
testl %eax, %... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_AddCommand | int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command)
{
int newNumberOfCommands;
char*** newCommands;
/* Make sure we have a command to add. */
if (!cp || !command || !*command) {
return 0;
}
/* Allocate a new array for command pointers. */
newNumberOfCommands = cp->NumberOfCom... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x3eda75
movq %rsi, %r15
movq (%rsi), %r12
testq %r12, %r12
je 0x3eda75
movq %rdi, %rbx
movslq 0x8(%rdi), %r13
leaq 0x8(,%r13,8), %rdi
callq 0x3bee0
testq %ra... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_SetPipeNative | void kwsysProcess_SetPipeNative(kwsysProcess* cp, int prPipe, const int p[2])
{
int* pPipeNative = 0;
if (!cp) {
return;
}
switch (prPipe) {
case kwsysProcess_Pipe_STDIN:
pPipeNative = cp->PipeNativeSTDIN;
break;
case kwsysProcess_Pipe_STDOUT:
pPipeNative = cp->PipeNativeSTDOUT;
... | testq %rdi, %rdi
je 0x3edb5e
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
leal -0x1(%r14), %r15d
cmpl $0x2, %r15d
ja 0x3edb59
movq %rdi, %rbx
movl %r15d, %eax
testq %rdx, %rdx
je 0x3edb35
movl (%rdx), %ecx
movl %ecx, 0x94c(%rbx,%rax,8)
movl 0x4(%rdx), %ecx
movl %ecx, 0x950(%rbx,%rax,8)
movq 0x928(%rbx,%r15,8), %rd... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_Execute | void kwsysProcess_Execute(kwsysProcess* cp)
{
int i;
/* Do not execute a second copy simultaneously. */
if (!cp || cp->State == kwsysProcess_State_Executing) {
return;
}
/* Make sure we have something to run. */
if (cp->NumberOfCommands < 1) {
strcpy(cp->ErrorMessage, "No command");
cp->Stat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
testq %rdi, %rdi
je 0x3ee0a9
movq %rdi, %rbx
movl 0x50c(%rdi), %eax
cmpl $0x3, %eax
je 0x3ee0a9
cmpl $0x0, 0x8(%rbx)
jle 0x3ee084
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movdqu %xmm0, 0xc(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x430(%rbx... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
kwsysProcessClosePipes | static void kwsysProcessClosePipes(kwsysProcess* cp)
{
int i;
/* Close any pipes that are still open. */
for (i = 0; i < KWSYSPE_PIPE_COUNT; ++i) {
if (cp->PipeReadEnds[i] >= 0) {
#if KWSYSPE_USE_SELECT
/* If the pipe was reported by the last call to select, we must
read from it. This is nee... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xc(%rdi), %r12
leaq 0x28(%rdi), %r14
xorl %r13d, %r13d
movl (%r12,%r13,4), %ecx
testl %ecx, %ecx
js 0x3ef0c0
leaq (%r12,%r13,4), %r15
movl %ecx, %eax
shrl $0x6, %eax
movq 0x488(%rbx,%rax,8), %rdx
movl $0x1, %esi
shlq %cl, %rsi
btq %rcx, %rdx
j... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysProcess_WaitForData | int kwsysProcess_WaitForData(kwsysProcess* cp, char** data, int* length,
double* userTimeout)
{
kwsysProcessTime userStartTime = { 0, 0 };
kwsysProcessWaitData wd = { 0, kwsysProcess_Pipe_None, 0, 0, { 0, 0 } };
wd.UserTimeout = userTimeout;
/* Make sure we are executing a process. ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq %rcx, 0x30(%rsp)
testq %rdi, %rdi
je 0x3ef127
movq %rdi, %rbx
movl 0x50c(%rdi), %eax
cmpl $0x3, %eax
jne 0x3ef127
c... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
kwsysProcessChildErrorExit | static void kwsysProcessChildErrorExit(int errorPipe)
{
/* Construct the error message. */
char buffer[KWSYSPE_PIPE_BUFFER_SIZE];
kwsysProcess_ssize_t result;
strncpy(buffer, strerror(errno), KWSYSPE_PIPE_BUFFER_SIZE);
buffer[KWSYSPE_PIPE_BUFFER_SIZE - 1] = '\0';
/* Report the error to the parent through ... | pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movl %edi, %ebx
callq 0x3b610
movl (%rax), %edi
callq 0x3ac50
movq %rsp, %r14
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
movq %rax, %rsi
callq 0x39450
movb $0x0, 0x3ff(%r14)
movq %r14, %rdi
callq 0x39d50
movl %ebx, %edi
movq %r14, %rsi
mov... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsysString_strcasecmp | int kwsysString_strcasecmp(const char* lhs, const char* rhs)
{
# if defined(KWSYS_STRING_USE_STRICMP)
return _stricmp(lhs, rhs);
# elif defined(KWSYS_STRING_USE_STRCASECMP)
return strcasecmp(lhs, rhs);
# else
const char* const lower = kwsysString_strcasecmp_tolower;
unsigned char const* us1 = (unsigned char ... | jmp 0x3adc0
| /JKorbelRA[P]CMake/Source/kwsys/String.c |
cmsys::Directory::~Directory() | Directory::~Directory()
{
delete this->Internal;
} | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x3f068b
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x3f0683
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq %rbx, %rdi
callq 0x3f0a4a
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x39320
nop
| /JKorbelRA[P]CMake/Source/kwsys/Directory.cxx |
cmsys::Directory::FileIsDirectory(unsigned long) const | bool Directory::FileIsDirectory(std::size_t i) const
{
#if defined(_WIN32) && !defined(__CYGWIN__)
auto const& data = this->Internal->Files[i].FindData;
return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
#else
std::string const& path = this->GetFilePath(i);
return kwsys::SystemTools::FileIsDirector... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3f06c8
movq %rbx, %rdi
callq 0x3f5516
movl %eax, %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f0797
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x39320
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq... | /JKorbelRA[P]CMake/Source/kwsys/Directory.cxx |
cmsys::Directory::Load(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>>*) | Status Directory::Load(std::string const& name, std::string* errorMessage)
{
this->Clear();
errno = 0;
DIR* dir = opendir(name.c_str());
if (!dir) {
if (errorMessage != nullptr) {
*errorMessage = std::string(strerror(errno));
}
return Status::POSIX_errno();
}
errno = 0;
for (kwsys_dir... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
addq $0x18, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a7b0
movq (%r15), %rdi
movq (%rdi), %rsi
callq 0x3f0aa8
callq 0x3b610
movq %rax, %r13
movl $0x0, (%rax)
movq (%r14), %rdi
ca... | /JKorbelRA[P]CMake/Source/kwsys/Directory.cxx |
cmsys::Encoding::CommandLineArguments::operator=(cmsys::Encoding::CommandLineArguments const&) | Encoding::CommandLineArguments& Encoding::CommandLineArguments::operator=(
const CommandLineArguments& other)
{
if (this != &other) {
size_t i;
for (i = 0; i < this->argv_.size(); i++) {
free(this->argv_[i]);
}
this->argv_.resize(other.argv_.size());
for (i = 0; i < this->argv_.size(); i+... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3f106c
movq %rsi, %r14
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x3f101e
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
callq 0x3be90
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
... | /JKorbelRA[P]CMake/Source/kwsys/EncodingCXX.cxx |
cmsys::Encoding::ToWide[abi:cxx11](char const*) | std::wstring Encoding::ToWide(const char* cstr)
{
std::wstring wstr;
size_t length = kwsysEncoding_mbstowcs(nullptr, cstr, 0) + 1;
if (length > 0) {
std::vector<wchar_t> wchars(length);
if (kwsysEncoding_mbstowcs(&wchars[0], cstr, length) > 0) {
wstr = &wchars[0];
}
}
return wstr;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
xorl %edi, %edi
xorl %edx, %edx
callq 0x402938
movq %rax, %r15
incq %r15
je 0x3f1226
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
... | /JKorbelRA[P]CMake/Source/kwsys/EncodingCXX.cxx |
cmsys::Encoding::ToNarrow[abi:cxx11](wchar_t const*) | std::string Encoding::ToNarrow(const wchar_t* wcstr)
{
std::string str;
size_t length = kwsysEncoding_wcstombs(nullptr, wcstr, 0) + 1;
if (length > 0) {
std::vector<char> chars(length);
if (kwsysEncoding_wcstombs(&chars[0], wcstr, length) > 0) {
str = &chars[0];
}
}
return str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %edi, %edi
xorl %edx, %edx
callq 0x4029a2
movq %rax, %r15
incq %r15
je 0x3f13fd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
... | /JKorbelRA[P]CMake/Source/kwsys/EncodingCXX.cxx |
cmsys::Glob::~Glob() | Glob::~Glob()
{
delete this->Internals;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3f1762
leaq 0x18(%r14), %rdi
callq 0x1732dc
movq %r14, %rdi
callq 0x5b438
movl $0x30, %esi
movq %r14, %rdi
callq 0x39320
leaq 0x38(%rbx), %rdi
callq 0x5b438
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x3f1797
movq (%... | /JKorbelRA[P]CMake/Source/kwsys/Glob.cxx |
cmsys::Glob::AddFile(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Glob::AddFile(std::vector<std::string>& files, const std::string& file)
{
if (!this->Relative.empty()) {
files.push_back(kwsys::SystemTools::RelativePath(this->Relative, file));
} else {
files.push_back(file);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x3f28b3
movq %rdi, %rsi
addq $0x10, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3f9736
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c672
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f28ab
movq 0x18(%rsp), %rsi
incq ... | /JKorbelRA[P]CMake/Source/kwsys/Glob.cxx |
cmsys::Glob::AddExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Glob::AddExpression(const std::string& expr)
{
this->Internals->Expressions.emplace_back(this->PatternToRegex(expr));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
addq $0x18, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3f17a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f326e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f31e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x39... | /JKorbelRA[P]CMake/Source/kwsys/Glob.cxx |
cmsys::RegularExpression::operator=(cmsys::RegularExpression const&) | RegularExpression& RegularExpression::operator=(const RegularExpression& rxp)
{
if (this == &rxp) {
return *this;
}
if (!rxp.program) {
this->program = nullptr;
return *this;
}
int ind;
this->progsize = rxp.progsize; // Copy regular expression size
delete[] this->program;
this->program = new... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3f39dc
movq %rsi, %r14
cmpq $0x0, 0xc0(%rsi)
je 0x3f39d1
movl 0xc8(%r14), %eax
movl %eax, 0xc8(%rbx)
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x3f3928
callq 0x39c80
movl 0xc8(%rbx), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x39fb0
movq %rax, 0xc... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegularExpression::deep_equal(cmsys::RegularExpression const&) const | bool RegularExpression::deep_equal(const RegularExpression& rxp) const
{
int ind = this->progsize; // Get regular expression size
if (ind != rxp.progsize) // If different size regexp
return false; // Return failure
while (ind-- != 0) ... | movslq 0xc8(%rdi), %rax
cmpl 0xc8(%rsi), %eax
jne 0x3f3a95
movq 0xc0(%rdi), %rcx
movq 0xc0(%rsi), %rdx
movq %rax, %r8
subq $0x1, %r8
jb 0x3f3a61
movb -0x1(%rcx,%rax), %r9b
cmpb -0x1(%rdx,%rax), %r9b
movq %r8, %rax
je 0x3f3a4a
jmp 0x3f3a95
movq (%rdi), %rdx
movq 0xa0(%rdi), %rax
subq %rax, %rdx
movq (%rsi), %r8
movq 0xa... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegularExpression::compile(char const*) | bool RegularExpression::compile(const char* exp)
{
const char* scan;
const char* longest;
int flags;
if (exp == nullptr) {
// RAISE Error, SYM(RegularExpression), SYM(No_Expr),
printf("RegularExpression::compile(): No expression supplied.\n");
return false;
}
// First pass: determine size, leg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x3f3b0b
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movl $0x1, 0x8(%rdi)
leaq 0x39e72b(%rip), %rax # 0x7921f2
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
leaq 0x4(%rsp), %rdx
xorl %esi, ... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::regnode(char) | char* RegExpCompile::regnode(char op)
{
char* ret;
char* ptr;
ret = regcode;
if (ret == regdummyptr) {
regsize += 3;
return (ret);
}
ptr = ret;
*ptr++ = op;
*ptr++ = '\0'; // Null "next" pointer.
*ptr++ = '\0';
regcode = ptr;
return (ret);
} | movq 0x10(%rdi), %rax
leaq 0x39e381(%rip), %rcx # 0x7921f2
cmpq %rcx, %rax
je 0x3f3e88
movb %sil, (%rax)
movw $0x0, 0x1(%rax)
leaq 0x3(%rax), %rcx
movq %rcx, 0x10(%rdi)
retq
addq $0x3, 0x18(%rdi)
retq
| /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::regatom(int*) | char* RegExpCompile::regatom(int* flagp)
{
char* ret;
int flags;
*flagp = WORST; // Tentatively.
switch (*regparse++) {
case '^':
ret = regnode(BOL);
break;
case '$':
ret = regnode(EOL);
break;
case '.':
ret = regnode(ANY);
*flagp |= HASWIDTH | SIMPLE;
bre... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rsi)
movq (%rdi), %r15
leaq 0x1(%r15), %rcx
movq %rcx, (%rdi)
movzbl (%r15), %eax
cmpl $0x3e, %eax
jg 0x3f43cb
leal -0x24(%rax), %ecx
cmpl $0xa, %ecx
ja 0x3f445d
leaq 0x1fbf21(%rip), %rax # 0x5f02c8
movslq (%rax,%rcx,4), %... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::SystemTools::GetTime() | double SystemTools::GetTime()
{
#if defined(_WIN32) && !defined(__CYGWIN__)
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
return (429.4967296 * ft.dwHighDateTime + 0.0000001 * ft.dwLowDateTime -
11644473600.0);
#else
struct timeval t;
gettimeofday(&t, nullptr);
return 1.0 * double(t.tv_sec) + 0.00000... | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a0e0
cvtsi2sdq (%rbx), %xmm1
cvtsi2sdq 0x8(%rbx), %xmm0
mulsd 0x1fae8b(%rip), %xmm0 # 0x5efc70
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FileExists(char const*) | bool SystemTools::FileExists(const char* filename)
{
if (!filename) {
return false;
}
return SystemTools::FileExists(std::string(filename));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x3f5853
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
callq 0x39d50
leaq (%rax,%rbx), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5b4c6
cmpq $0x0, 0x8(%r14)
je 0x3f5857
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x39380
... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::Touch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | Status SystemTools::Touch(std::string const& filename, bool create)
{
if (!SystemTools::FileExists(filename)) {
if (create) {
FILE* file = Fopen(filename, "a+b");
if (file) {
fclose(file);
return Status::Success();
}
return Status::POSIX_errno();
} else {
return S... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x3f5ae2
movq (%rbx), %rdi
movl $0x4, %esi
callq 0x39380
testl %eax, %eax
je 0x3f5b05
testb %bpl, %bpl
je 0x3f5b1a
movq (%rbx), %rdi
leaq 0x1fac0e(%rip), %rsi # 0x5f06ff
callq 0x3bd40
testq %rax, %rax
je 0x3f5b23
movq %rax, %rdi... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::Capitalized(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::Capitalized(const std::string& s)
{
std::string n;
if (s.empty()) {
return n;
}
n.resize(s.size());
n[0] = static_cast<std::string::value_type>(toupper(s[0]));
for (size_t i = 1; i < s.size(); i++) {
n[i] = static_cast<std::string::value_type>(tolower(s[i]));
}
return n;... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x3f5c23
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3a7b0
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x39540
movq (%rbx), %rcx
movb %... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CapitalizedWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::CapitalizedWords(const std::string& s)
{
std::string n(s);
for (size_t i = 0; i < s.size(); i++) {
#if defined(_MSC_VER) && defined(_MT) && defined(_DEBUG)
// MS has an assert that will fail if s[i] < 0; setting
// LC_CTYPE using setlocale() does *not* help. Painful.
if ((int)s[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x5b7c4
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x3f5ccf
xorl %r15d, %r15d
movq (%r14), %r13
movsbl (%r13,%r1... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::LowerCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::LowerCase(const std::string& s)
{
std::string n;
n.resize(s.size());
for (size_t i = 0; i < s.size(); i++) {
n[i] = static_cast<std::string::value_type>(tolower(s[i]));
}
return n;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
xorl %edx, %edx
callq 0x3a7b0
cmpq $0x0, 0x8(%r14)
je 0x3f5ffe
xorl %r15d, %r15d
movq (%r14), %rax
movsbl (%rax,%r15), %edi
callq 0x3b010
movq (%rbx), ... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::StringStartsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool SystemTools::StringStartsWith(const std::string& str1, const char* str2)
{
if (!str2) {
return false;
}
size_t len1 = str1.size(), len2 = strlen(str2);
return len1 >= len2 && !strncmp(str1.c_str(), str2, len2) ? true : false;
} | testq %rsi, %rsi
je 0x3f623d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x39d50
cmpq %rax, %r15
jae 0x3f6240
xorl %eax, %eax
jmp 0x3f6253
xorl %eax, %eax
retq
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x39790
testl %eax, %eax
sete %al
popq %... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FindLastString(char const*, char const*) | const char* SystemTools::FindLastString(const char* str1, const char* str2)
{
if (!str1 || !str2) {
return nullptr;
}
size_t len1 = strlen(str1), len2 = strlen(str2);
if (len1 >= len2) {
const char* ptr = str1 + len1 - len2;
do {
if (!strncmp(ptr, str2, len2)) {
return ptr;
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x3f6345
movq %rsi, %rbx
movq %rdi, %r14
callq 0x39d50
movq %rax, %r15
movq %rbx, %rdi
callq 0x39d50
subq %rax, %r15
jb 0x3f6345
movq %rax, %r12
leaq (%r14,%r15), %r13
movq %r13, %rdi
movq %rbx, %... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, bool) | std::vector<std::string> SystemTools::SplitString(const std::string& p,
char sep, bool isPath)
{
std::string path = p;
std::vector<std::string> paths;
if (path.empty()) {
return paths;
}
if (isPath && path[0] == '/') {
path.erase(path.begin());
pat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x5b7c4
xorps %xmm0, %xmm0
mo... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::EscapeChars[abi:cxx11](char const*, char const*, char) | std::string SystemTools::EscapeChars(const char* str,
const char* chars_to_escape,
char escape_char)
{
std::string n;
if (str) {
if (!chars_to_escape || !*chars_to_escape) {
n.append(str);
} else {
n.reserve(strlen(str));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x3f67f4
movq %rdx, %r15
movq %rsi, %r14
testq %rdx, %rdx
je 0x3f67e9
cmpb $0x0, (%r15)
je 0x3f67e9
movl %ecx, %ebp
movq %r1... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::ConvertToWindowsOutputPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::ConvertToWindowsOutputPath(const std::string& path)
{
std::string ret;
// make it big enough for all of path and double quotes
ret.reserve(path.size() + 3);
// put path into the string
ret = path;
std::string::size_type pos = 0;
// first convert all of the slashes
while ((pos = ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq $0x3, %rsi
callq 0x3ae20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bad0
movq %rbx, %rdi
movl $0x2f, %esi
xorl %edx, %edx
call... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CopyFileContentBlockwise(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&) | Status SystemTools::CopyFileContentBlockwise(std::string const& source,
std::string const& destination)
{
// Open files
kwsys::ifstream fin(source.c_str(), std::ios::in | std::ios::binary);
if (!fin) {
return Status::POSIX_errno();
}
// try and remove the dest... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1410, %rsp # imm = 0x1410
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x208(%rsp), %r14
movq %r14, %rdi
movl $0xc, %edx
callq 0x39110
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x228(%rsp,%rax)
je 0x3f74e9
callq 0x402888
movq %rax, %rbx
jmp 0x3f75eb
movq %rbx, %rd... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::RemoveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Status SystemTools::RemoveFile(std::string const& source)
{
#ifdef _WIN32
std::wstring const& ws = Encoding::ToWindowsExtendedPath(source);
if (DeleteFileW(ws.c_str())) {
return Status::Success();
}
DWORD err = GetLastError();
if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) {
return St... | pushq %rax
movq (%rdi), %rdi
callq 0x39770
testl %eax, %eax
je 0x3f764f
callq 0x3b610
cmpl $0x2, (%rax)
jne 0x3f7653
xorl %eax, %eax
popq %rcx
retq
popq %rax
jmp 0x402888
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CloneFileContent(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&) | Status SystemTools::CloneFileContent(std::string const& source,
std::string const& destination)
{
#if defined(__linux) && defined(FICLONE)
int in = open(source.c_str(), O_RDONLY);
if (in < 0) {
return Status::POSIX_errno();
}
SystemTools::RemoveFile(destination);
int... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x39f10
testl %eax, %eax
js 0x3f76bf
movl %eax, %ebx
movq %r14, %rdi
callq 0x3f7638
movq (%r14), %rdi
movl $0x241, %esi # imm = 0x241
movl $0x180, %edx # imm = 0x180
xorl %eax, %eax
callq 0x39f... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CopyADirectory(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) | Status SystemTools::CopyADirectory(std::string const& source,
std::string const& destination, bool always)
{
Status status;
Directory dir;
status = dir.Load(source);
if (!status.IsSuccess()) {
return status;
}
status = SystemTools::MakeDirectory(destination);
if (!st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x3f0614
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3f0858
movq %rax, %r14
testl %r14d, %r14d
je 0x3f799e
movq %r14, %rbp... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::FindFile(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) | std::string SystemTools::FindFile(const std::string& name,
const std::vector<std::string>& userPaths,
bool no_system_path)
{
std::string tryPath =
SystemToolsStatic::FindName(name, userPaths, no_system_path);
if (!tryPath.empty() && !SystemTool... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3f7f36
cmpq $0x0, 0x8(%r14)
je 0x3f811a
leaq 0x8(%rsp), %rdi
callq 0x3f5516
testb %al, %al
je 0x3f8135
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x214d61(%rip), %rdx # 0x60ce89
movq %rbx, %rdi
movq %rdx, %rsi
callq... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.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.