name string | code string | asm string | file string |
|---|---|---|---|
CxxModuleMapExtension(std::optional<CxxModuleMapFormat>) | cm::static_string_view CxxModuleMapExtension(
cm::optional<CxxModuleMapFormat> format)
{
if (format) {
switch (*format) {
case CxxModuleMapFormat::Gcc:
return ".gcm"_s;
case CxxModuleMapFormat::Msvc:
return ".ifc"_s;
}
}
return ".bmi"_s;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4d99b0
testb $0x1, %al
jne 0x58963b
jmp 0x589691
leaq -0x18(%rbp), %rdi
callq 0x4d9a60
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x589659
jmp 0x58964f
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x589674
j... | /JKorbelRA[P]CMake/Source/cmCxxModuleMapper.cxx |
CxxModuleUsageSeed[abi:cxx11](CxxModuleLocations const&, std::vector<cmScanDepInfo, std::allocator<cmScanDepInfo>> const&, CxxModuleUsage&) | std::set<std::string> CxxModuleUsageSeed(
CxxModuleLocations const& loc, std::vector<cmScanDepInfo> const& objects,
CxxModuleUsage& usages)
{
// Track inner usages to populate usages from internal bits.
//
// This is a map of modules that required some other module that was not
// found to those that were n... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4d73a0
movq -0x268(%rbp), %rdi
movb $0x0, -0x51(%rbp)
callq 0xde... | /JKorbelRA[P]CMake/Source/cmCxxModuleMapper.cxx |
CxxModuleMapContent[abi:cxx11](CxxModuleMapFormat, CxxModuleLocations const&, cmScanDepInfo const&, CxxModuleUsage const&) | std::string CxxModuleMapContent(CxxModuleMapFormat format,
CxxModuleLocations const& loc,
cmScanDepInfo const& obj,
CxxModuleUsage const& usages)
{
switch (format) {
case CxxModuleMapFormat::Gcc:
return CxxModule... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x58a09c
jmp 0x58a092
movl -0x2c(%rbp... | /JKorbelRA[P]CMake/Source/cmCxxModuleMapper.cxx |
(anonymous namespace)::CxxModuleMapContentMsvc[abi:cxx11](CxxModuleLocations const&, cmScanDepInfo const&, CxxModuleUsage const&) | std::string CxxModuleMapContentMsvc(CxxModuleLocations const& loc,
cmScanDepInfo const& obj,
CxxModuleUsage const& usages)
{
std::stringstream mm;
// A response file of `-reference NAME=PATH` arguments.
// MSVC's command line only supports ... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x360(%rbp)
movq %rdi, %rax
movq %rax, -0x358(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3ba20
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x4df4b0
cm... | /JKorbelRA[P]CMake/Source/cmCxxModuleMapper.cxx |
cmDefinitions::GetInternal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmLinkedTree<cmDefinitions>::iterator, cmLinkedTree<cmDefinitions>::iterator, bool) | cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key,
StackIter begin,
StackIter end, bool raise)
{
assert(begin != end);
{
auto it = begin->Map.find(cm::String::borrow(key));
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %r9b, %al
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x4... | /JKorbelRA[P]CMake/Source/cmDefinitions.cxx |
cmDefinitions::HasKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmLinkedTree<cmDefinitions>::iterator, cmLinkedTree<cmDefinitions>::iterator) | bool cmDefinitions::HasKey(const std::string& key, StackIter begin,
StackIter end)
{
for (StackIter it = begin; it != end; ++it) {
if (it->Map.find(cm::String::borrow(key)) != it->Map.end()) {
return true;
}
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
m... | /JKorbelRA[P]CMake/Source/cmDefinitions.cxx |
cmDefinitions::MakeClosure(cmLinkedTree<cmDefinitions>::iterator, cmLinkedTree<cmDefinitions>::iterator) | cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end)
{
cmDefinitions closure;
std::unordered_set<cm::string_view> undefined;
for (StackIter it = begin; it != end; ++it) {
// Consider local definitions.
for (auto const& mi : it->Map) {
// Use this key if it is not already set or u... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x2bd250
leaq -0x68(%rbp), %rdi
callq 0x3493... | /JKorbelRA[P]CMake/Source/cmDefinitions.cxx |
cmDefinitions::ClosureKeys[abi:cxx11](cmLinkedTree<cmDefinitions>::iterator, cmLinkedTree<cmDefinitions>::iterator) | std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin,
StackIter end)
{
std::vector<std::string> defined;
std::unordered_set<cm::string_view> bound;
for (StackIter it = begin; it != end; ++it) {
defined.reserve(defined.size() + it->Map.size())... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x60530
leaq -0x68(%rbp), %rdi
callq 0x349350... | /JKorbelRA[P]CMake/Source/cmDefinitions.cxx |
(anonymous namespace)::cmDynamicLoaderCache::GetCacheFile(char const*, void*&) | bool cmDynamicLoaderCache::GetCacheFile(const char* path,
cmsys::DynamicLoader::LibraryHandle& p)
{
auto it = this->CacheMap.find(path);
if (it != this->CacheMap.end()) {
p = it->second;
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3c460
movq -0x78(%rbp), %rsi
movq -0x7... | /JKorbelRA[P]CMake/Source/cmDynamicLoader.cxx |
(anonymous namespace)::cmDynamicLoaderCache::CacheFile(char const*, void*) | void cmDynamicLoaderCache::CacheFile(const char* path,
cmsys::DynamicLoader::LibraryHandle p)
{
cmsys::DynamicLoader::LibraryHandle h;
if (this->GetCacheFile(path, h)) {
this->FlushCache(path);
}
this->CacheMap[path] = p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x58f110
testb $0x1, %al
jne 0x58f252
jmp 0x58f25f
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58f3b0... | /JKorbelRA[P]CMake/Source/cmDynamicLoader.cxx |
(anonymous namespace)::cmDynamicLoaderCache::FlushCache(char const*) | bool cmDynamicLoaderCache::FlushCache(const char* path)
{
auto it = this->CacheMap.find(path);
bool ret = false;
if (it != this->CacheMap.end()) {
cmsys::DynamicLoader::CloseLibrary(it->second);
this->CacheMap.erase(it);
ret = true;
}
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3c460
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x38(... | /JKorbelRA[P]CMake/Source/cmDynamicLoader.cxx |
cmELF::cmELF(char const*) | cmELF::cmELF(const char* fname)
{
// Try to open the file.
auto fin = cm::make_unique<cmsys::ifstream>(fname, std::ios::binary);
// Quit now if the file could not be opened.
if (!fin || !*fin) {
this->ErrorMessage = "Error opening input file.";
return;
}
// Read the ELF identification block.
cha... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x5913b0
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3d1f0
movq 0x9694c0(%rip), %rdx # 0xef9f28
leaq -0x18(%rbp)... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELF::GetRunPath() | cmELF::StringEntry const* cmELF::GetRunPath()
{
if (this->Valid() &&
(this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) {
return this->Internal->GetRunPath();
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x590dc0
testb $0x1, %al
jne 0x59118f
jmp 0x5911d2
movq -0x18(%rbp), %rdi
callq 0x591910
movq %rax, %rdi
callq 0x591930
cmpl $0x2, %eax
je 0x5911bb
movq -0x18(%rbp), %rdi
callq 0x591910
movq %rax, %rdi... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFByteSwap(char*, cmELFByteSwapSize<8ul>) | static void cmELFByteSwap(char* data, cmELFByteSwapSize<8> /*unused*/)
{
char one_byte;
one_byte = data[0];
data[0] = data[7];
data[7] = one_byte;
one_byte = data[1];
data[1] = data[6];
data[6] = one_byte;
one_byte = data[2];
data[2] = data[5];
data[5] = one_byte;
one_byte = data[3];
data[3] = d... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::GetDynamicEntries() | cmELF::DynamicEntryList cmELFInternalImpl<Types>::GetDynamicEntries()
{
cmELF::DynamicEntryList result;
// Ensure entries have been read from file
if (!this->LoadDynamicSection()) {
return result;
}
// Copy into public array
result.reserve(this->DynamicSectionEntries.size());
for (ELF_Dyn& dyn : thi... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x591970
movq -0x58(%rbp), %rdi
callq 0x594c60
movb %al, -0x49(%rbp)
jmp 0x592cea
movb -0x49(%... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::PrintInfo(std::ostream&) const | void PrintInfo(std::ostream& os) const override
{
os << "ELF " << Types::GetName();
if (this->ByteOrder == ByteOrderMSB) {
os << " MSB";
} else if (this->ByteOrder == ByteOrderLSB) {
os << " LSB";
}
switch (this->ELFType) {
case cmELF::FileTypeInvalid:
os << " invalid fil... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5f19bb(%rip), %rsi # 0xb84d1e
callq 0x3d690
movq %rax, -0x20(%rbp)
callq 0x5977a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3d690
movq -0x18(%rbp), ... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::FileTypeValid(unsigned short) | bool FileTypeValid(ELF_Half et)
{
unsigned int eti = static_cast<unsigned int>(et);
if (eti == ET_NONE || eti == ET_REL || eti == ET_EXEC || eti == ET_DYN ||
eti == ET_CORE) {
return true;
}
if (eti >= ET_LOOS && eti <= ET_HIOS) {
return true;
}
if (eti >= ET_LOPROC && eti ... | pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x5938e4
cmpl $0x1, -0x18(%rbp)
je 0x5938e4
cmpl $0x2, -0x18(%rbp)
je 0x5938e4
cmpl $0x3, -0x18(%rbp)
je 0x5938e4
cmpl $0x4, -0x18(%rbp)
jne 0x5938ea
movb $0x1,... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::ByteSwap(Elf32_Ehdr&) | void ByteSwap(ELF_Ehdr& elf_header)
{
cmELFByteSwap(elf_header.e_type);
cmELFByteSwap(elf_header.e_machine);
cmELFByteSwap(elf_header.e_version);
cmELFByteSwap(elf_header.e_entry);
cmELFByteSwap(elf_header.e_phoff);
cmELFByteSwap(elf_header.e_shoff);
cmELFByteSwap(elf_header.e_flags);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x593890
movq -0x10(%rbp), %rdi
addq $0x12, %rdi
callq 0x593890
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
callq 0x593ab0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x593ab0
movq -0x10(... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes32>::LoadDynamicSection() | bool cmELFInternalImpl<Types>::LoadDynamicSection()
{
// If there is no dynamic section we are done.
if (this->DynamicSectionIndex < 0) {
return false;
}
// If the section was already loaded we are done.
if (!this->DynamicSectionEntries.empty()) {
return true;
}
// If there are no entries we are... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x24(%rax)
jge 0x594c83
movb $0x0, -0x1(%rbp)
jmp 0x594da9
movq -0x40(%rbp), %rdi
addq $0xa8, %rdi
callq 0x594de0
testb $0x1, %al
jne 0x594ca0
movb $0x1, -0x1(%rbp)
jmp 0x594da9
movq -0x40(%rbp), ... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::cmELFInternalImpl(cmELF*, std::unique_ptr<std::istream, std::default_delete<std::istream>>, cmELFInternal::ByteOrderType) | cmELFInternalImpl<Types>::cmELFInternalImpl(cmELF* external,
std::unique_ptr<std::istream> fin,
ByteOrderType order)
: cmELFInternal(external, std::move(fin), order)
{
// Read the main header.
if (!this->Read(this->ELFHeader))... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdx, -0x210(%rbp)
movq %rsi, %rax
movq -0x210(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
le... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::Read(Elf64_Ehdr&) | bool Read(ELF_Ehdr& x)
{
// Read the header from the file.
if (!this->Stream->read(reinterpret_cast<char*>(&x), sizeof(x))) {
return false;
}
// The byte order of ELF header fields may not match that of the
// processor-specific data. The header fields are ordered to
// match the targe... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0x593870
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x3d330
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3cc00
testb $0x1,... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::EncodeDynamicEntries(std::vector<std::pair<long, unsigned long>, std::allocator<std::pair<long, unsigned long>>> const&) | std::vector<char> cmELFInternalImpl<Types>::EncodeDynamicEntries(
const cmELF::DynamicEntryList& entries)
{
std::vector<char> result;
result.reserve(sizeof(ELF_Dyn) * entries.size());
for (auto const& entry : entries) {
// Store the entry in an ELF_Dyn, byteswap it, then serialize to chars
ELF_Dyn dyn;... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2dd450
movq -0x18(%rbp), %rdi
callq 0x595c00
movq -0x70(%rbp), %rdi
m... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::GetDynamicSectionString(unsigned int) | cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString(
unsigned int tag)
{
// Short-circuit if already checked.
auto dssi = this->DynamicSectionStrings.find(tag);
if (dssi != this->DynamicSectionStrings.end()) {
if (dssi->second.Position > 0) {
return &dssi->second;
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x28, %rdi
leaq -0x14(%rbp), %rsi
callq 0x596600
movq -0x98(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x596660
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq ... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::PrintInfo(std::ostream&) const | void PrintInfo(std::ostream& os) const override
{
os << "ELF " << Types::GetName();
if (this->ByteOrder == ByteOrderMSB) {
os << " MSB";
} else if (this->ByteOrder == ByteOrderLSB) {
os << " LSB";
}
switch (this->ELFType) {
case cmELF::FileTypeInvalid:
os << " invalid fil... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5ec1cb(%rip), %rsi # 0xb84d1e
callq 0x3d690
movq %rax, -0x20(%rbp)
callq 0x59ae80
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3d690
movq -0x18(%rbp), ... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmELFInternalImpl<cmELFTypes64>::ByteSwap(Elf64_Ehdr&) | void ByteSwap(ELF_Ehdr& elf_header)
{
cmELFByteSwap(elf_header.e_type);
cmELFByteSwap(elf_header.e_machine);
cmELFByteSwap(elf_header.e_version);
cmELFByteSwap(elf_header.e_entry);
cmELFByteSwap(elf_header.e_phoff);
cmELFByteSwap(elf_header.e_shoff);
cmELFByteSwap(elf_header.e_flags);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x593890
movq -0x10(%rbp), %rdi
addq $0x12, %rdi
callq 0x593890
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
callq 0x593ab0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x598f00
movq -0x10(... | /JKorbelRA[P]CMake/Source/cmELF.cxx |
cmExprParserHelper::ParseString(char const*, int) | int cmExprParserHelper::ParseString(const char* str, int verb)
{
if (!str) {
return 0;
}
// printf("Do some parsing: %s\n", str);
this->Verbose = verb;
this->InputBuffer = str;
this->InputBufferPos = 0;
this->CurrentLine = 0;
this->Result = 0;
yyscan_t yyscanner;
cmExpr_yylex_init(&yyscanner)... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x270(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x59b354
movl $0x0, -0x4(%rbp)
jmp 0x59b881
movq -0x270(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x44(... | /JKorbelRA[P]CMake/Source/cmExprParserHelper.cxx |
cmExprParserHelper::Error(char const*) | void cmExprParserHelper::Error(const char* str)
{
unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
std::ostringstream ostr;
ostr << str << " (" << pos << ")";
this->ErrorString = ostr.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x3c530
movq -0x1d0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3... | /JKorbelRA[P]CMake/Source/cmExprParserHelper.cxx |
cmExportBuildFileGenerator::GetTargets(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) const | void cmExportBuildFileGenerator::GetTargets(
std::vector<std::string>& targets) const
{
if (this->ExportSet) {
for (std::unique_ptr<cmTargetExport> const& te :
this->ExportSet->GetTargetExports()) {
if (te->NamelinkOnly) {
continue;
}
targets.push_back(te->TargetName);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x130(%rax)
je 0x59e542
movq -0x38(%rbp), %rax
movq 0x130(%rax), %rdi
callq 0x4443e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4443f0
movq %rax, -0x20(%rbp)
movq -... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::SetImportLocationProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | void cmExportBuildFileGenerator::SetImportLocationProperty(
const std::string& config, std::string const& suffix,
cmGeneratorTarget* target, ImportPropertyMap& properties)
{
// Get the makefile in which to lookup target information.
cmMakefile* mf = target->Makefile;
if (target->GetType() == cmStateEnums::OB... | pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6263f0
cmpl $0x4, %eax
jne 0x59ee90
lea... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::FindBuildExportInfo(cmGlobalGenerator*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::pair<std::vector<std::string>, std::string>
cmExportBuildFileGenerator::FindBuildExportInfo(cmGlobalGenerator* gg,
const std::string& name)
{
std::vector<std::string> exportFiles;
std::string ns;
auto& exportSets = gg->GetBuildExportSets();
for (auto const&... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x60530
leaq -0x58(%rbp), %rdi
callq 0x3d1f0
movq -0x18(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::InstallNameDir(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmExportBuildFileGenerator::InstallNameDir(
cmGeneratorTarget const* target, const std::string& config)
{
std::string install_name_dir;
cmMakefile* mf = target->Target->GetMakefile();
if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
install_name_dir = target->GetInstallNameDirForBuildTree(conf... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x3d1f0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2e3ca0
movq %rax, -0x90(%rbp)
jmp 0x5... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::GetFileSetDirectories[abi:cxx11](cmGeneratorTarget*, cmFileSet*, cmTargetExport*) | std::string cmExportBuildFileGenerator::GetFileSetDirectories(
cmGeneratorTarget* gte, cmFileSet* fileSet, cmTargetExport* /*te*/)
{
std::vector<std::string> resultVector;
auto configs =
gte->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
auto directoryEntries = fileSet->CompileDirectoryEnt... | pushq %rbp
movq %rsp, %rbp
subq $0x510, %rsp # imm = 0x510
movq %rdi, -0x470(%rbp)
movq %rdi, %rax
movq %rax, -0x468(%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, -0x460(%rbp)
leaq -0x40(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportBuildFileGenerator::GetFileSetFiles[abi:cxx11](cmGeneratorTarget*, cmFileSet*, cmTargetExport*) | std::string cmExportBuildFileGenerator::GetFileSetFiles(cmGeneratorTarget* gte,
cmFileSet* fileSet,
cmTargetExport* /*te*/)
{
std::vector<std::string> resultVector;
auto configs =
gte->Makefile->GetG... | pushq %rbp
movq %rsp, %rbp
subq $0x5d0, %rsp # imm = 0x5D0
movq %rdi, -0x508(%rbp)
movq %rdi, %rax
movq %rax, -0x500(%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, -0x4f8(%rbp)
leaq -0x40(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmExportBuildFileGenerator.cxx |
cmExportFileGenerator::GenerateImportConfig(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmExportFileGenerator::GenerateImportConfig(std::ostream& os,
const std::string& config)
{
// Construct the property configuration suffix.
std::string suffix = "_";
if (!config.empty()) {
suffix += cmSystemTools::UpperCase(config);
} else {
suffix +=... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3c460
movq -0x78(%rbp), %rdx
leaq 0x61d24e(%rip), %rsi # 0xbbf205
leaq -0x38(%rbp), %rdi
callq 0x606e0
jmp... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream&, char const*) | void cmExportFileGenerator::GenerateRequiredCMakeVersion(
std::ostream& os, const char* versionString)
{
/* clang-format off */
os << "if(CMAKE_VERSION VERSION_LESS " << versionString << ")\n"
" message(FATAL_ERROR \"This file relies on consumers using "
"CMake " << versionString << " or greater.... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5e3091(%rip), %rsi # 0xb85500
callq 0x3d690
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d690
movq %rax, %rdi
leaq 0x5e3095(%rip), %rsi # 0xb8551f
callq 0x3d690
movq %ra... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(cmGeneratorTarget const*, cmGeneratorExpression::PreprocessContext, 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::__cxx1... | bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
cmGeneratorTarget const* target,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap& properties)
{
if (!target->IsLinkable()) {
return false;
}
static const std::array<std::string, 3> linkIfaceProps = {
{ "IN... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x65a940
testb $0x1, %al
jne 0x5a24eb
movb $0x0, -0x1(%rbp)
jmp 0x5a27dc
cmpb $0x0, 0x960cae(%rip) # 0xf03... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateSourcesInterface(cmGeneratorTarget const*, cmGeneratorExpression::PreprocessContext, 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_strin... | void cmExportFileGenerator::PopulateSourcesInterface(
cmGeneratorTarget const* gt,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap& properties)
{
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char* propName = "INTERFACE_SOURCES";
cmValue input = gt->Get... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x5a282d
jmp 0x5a284c
leaq 0x5e2d48(%rip), %rdi # 0xb8557c
leaq 0x5e2d7b(%rip), %rs... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
checkInterfaceDirs(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&) | static bool checkInterfaceDirs(const std::string& prepro,
cmGeneratorTarget const* target,
const std::string& prop)
{
std::string const& installDir =
target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
std::string const& topSourceDir =
t... | pushq %rbp
movq %rsp, %rbp
subq $0x620, %rsp # imm = 0x620
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x498(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x490(%rbp)
callq 0x3c460
movq -0x490(%rbp), %rdx
leaq 0x5f1782(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateIncludeDirectoriesInterface(cmGeneratorTarget const*, cmGeneratorExpression::PreprocessContext, 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::... | void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
cmGeneratorTarget const* target,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap& properties, cmTargetExport const& te)
{
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char* propName = "INTE... | pushq %rbp
movq %rsp, %rbp
subq $0x530, %rsp # imm = 0x530
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x428(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x5a3861
jmp 0x5a3880
leaq 0x5e1d14(%rip), %rdi # 0xb8557c
le... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateLinkDependsInterface(cmGeneratorTarget const*, cmGeneratorExpression::PreprocessContext, 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_s... | void cmExportFileGenerator::PopulateLinkDependsInterface(
cmGeneratorTarget const* gt,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap& properties)
{
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char* propName = "INTERFACE_LINK_DEPENDS";
cmValue input ... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x5a441d
jmp 0x5a443c
leaq 0x5e1158(%rip), %rdi # 0xb8557c
leaq 0x5e118b(%rip), %rs... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateLinkDirectoriesInterface(cmGeneratorTarget const*, cmGeneratorExpression::PreprocessContext, 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::bas... | void cmExportFileGenerator::PopulateLinkDirectoriesInterface(
cmGeneratorTarget const* gt,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap& properties)
{
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char* propName = "INTERFACE_LINK_DIRECTORIES";
cmValu... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x5a484d
jmp 0x5a486c
leaq 0x5e0d28(%rip), %rdi # 0xb8557c
leaq 0x5e0d5b(%rip), %rs... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::PopulateCompatibleInterfaceProperties(cmGeneratorTarget const*, 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::char_traits<char... | void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
cmGeneratorTarget const* gtarget, ImportPropertyMap& properties)
{
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL", gtarget,
properties);
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING", ... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x3c460
movq -0x218(%rbp), %rdx
leaq 0x5e0c9a(%rip), %rsi # 0xb8596a
leaq -0x38(... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
getCompatibleInterfaceProperties(cmGeneratorTarget const*, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | static void getCompatibleInterfaceProperties(
cmGeneratorTarget const* target, std::set<std::string>& ifaceProperties,
const std::string& config)
{
if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
// object libraries have no link information, so nothing to compute
return;
}
cmComputeLinkInfor... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6263f0
cmpl $0x4, %eax
jne 0x5a54aa
jmp 0x5a5944
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64ebd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rb... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::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::char_traits... | void cmExportFileGenerator::GenerateInterfaceProperties(
const cmGeneratorTarget* target, std::ostream& os,
const ImportPropertyMap& properties)
{
if (!properties.empty()) {
std::string targetName =
cmStrCat(this->Namespace, target->GetExportName());
os << "set_target_properties(" << targetName << "... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a4110
testb $0x1, %al
jne 0x5a5bd4
movq -0x118(%rbp), %rsi
addq $0x8, %rsi
leaq -... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::SetImportDetailProperties(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::alloca... | void cmExportFileGenerator::SetImportDetailProperties(
const std::string& config, std::string const& suffix,
cmGeneratorTarget* target, ImportPropertyMap& properties)
{
// Get the makefile in which to lookup target information.
cmMakefile* mf = target->Makefile;
// Add the soname for unix shared libraries.
... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
c... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GeneratePolicyHeaderCode(std::ostream&) | void cmExportFileGenerator::GeneratePolicyHeaderCode(std::ostream& os)
{
// Protect that file against use with older CMake versions.
/* clang-format off */
os << "# Generated by CMake\n\n";
os << "if(\"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}\" LESS 2.8)\n"
<< " message(FATAL_ERROR \"CMake >= 2.8.0 ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5c4cc5(%rip), %rsi # 0xb6bf10
callq 0x3d690
movq -0x10(%rbp), %rdi
leaq 0x5de9ff(%rip), %rsi # 0xb85c5a
callq 0x3d690
movq %rax, %rdi
leaq 0x5dea2e(%rip), %rsi # 0xb85c98
callq 0x3d690
movq %r... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GenerateImportHeaderCode(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
const std::string& config)
{
os << "#----------------------------------------------------------------\n"
<< "# Generated CMake target import file";
if (!config.empty()) {
os << " for ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5dea4a(%rip), %rsi # 0xb85d71
callq 0x3d690
movq %rax, %rdi
leaq 0x5dea7e(%rip), %rsi # 0xb85db4
callq 0x3d690
movq -0x18(%rbp)... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GenerateImportVersionCode(std::ostream&) | void cmExportFileGenerator::GenerateImportVersionCode(std::ostream& os)
{
// Store an import file format version. This will let us change the
// format later while still allowing old import files to work.
/* clang-format off */
os << "# Commands may need to know the format version.\n"
<< "set(CMAKE_IMPORT... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5dea61(%rip), %rsi # 0xb85e3c
callq 0x3d690
movq %rax, %rdi
leaq 0x5dea83(%rip), %rsi # 0xb85e6d
callq 0x3d690
movq %rax, %rdi
leaq 0x5defbc(%rip), %rsi # 0xb863b5
callq 0x3d690
addq $0x10, %r... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmExportFileGenerator::GenerateExpectedTargetsCode(
std::ostream& os, const std::string& expectedTargets)
{
/* clang-format off */
os << "# Protect against multiple inclusion, which would fail when already "
"imported targets are added once more.\n"
"set(_cmake_targets_defined \"\")\n"
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5dea20(%rip), %rsi # 0xb85e8f
callq 0x3d690
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3d3d0
movq %rax, %rdi
leaq 0x5deafa(%rip), %rsi # 0xb85f84
callq 0x3d690
addq $0x... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream&) | void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os)
{
if (this->MissingTargets.empty()) {
/* clang-format off */
os << "# This file does not depend on other imported targets which have\n"
"# been exported from the same project but in a separate "
"export set.\n\... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x100, %rdi # imm = 0x100
callq 0x61d70
testb $0x1, %al
jne 0x5a8060
jmp 0x5a8075
movq -0x10(%rbp), %rdi
leaq 0x5de537(%rip), %rsi # 0xb865a2
callq 0x3d690
jmp 0x5a81... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
void cmExportFileGenerator::SetImportLinkProperty<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&, cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>... | void cmExportFileGenerator::SetImportLinkProperty(
std::string const& suffix, cmGeneratorTarget const* target,
const std::string& propName, std::vector<T> const& entries,
ImportPropertyMap& properties, ImportLinkPropertyTargetNames targetNames)
{
// Skip the property if there are no entries.
if (entries.empty... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x28(%rbp), %rdi
callq 0x61d70
testb $0x1... | /JKorbelRA[P]CMake/Source/cmExportFileGenerator.cxx |
cmExportSetMap::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmExportSet& cmExportSetMap::operator[](const std::string& name)
{
auto it = this->find(name);
if (it == this->end()) // Export set not found
{
auto tup_name = std::make_tuple(name);
it = this->emplace(std::piecewise_construct, tup_name, tup_name).first;
}
return it->second;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3ab8b0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3ab910
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3ab8e0
tes... | /JKorbelRA[P]CMake/Source/cmExportSet.cxx |
cmExternalMakefileProjectGenerator::CreateFullGeneratorName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
const std::string& globalGenerator, const std::string& extraGenerator)
{
std::string fullName;
if (!globalGenerator.empty()) {
if (!extraGenerator.empty()) {
fullName = cmStrCat(extraGenerator, " - ");
}
fullName += globalG... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3d1f0
movq -0x10(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x5acbd2
movq -0x18(%rbp), %rdi
callq 0x3b870
testb ... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.cxx |
cmExtraCodeBlocksGenerator::GetFactory() | cmExternalMakefileProjectGeneratorFactory*
cmExtraCodeBlocksGenerator::GetFactory()
{
static cmExternalMakefileProjectGeneratorSimpleFactory<
cmExtraCodeBlocksGenerator>
factory("CodeBlocks", "Generates CodeBlocks project files.");
if (factory.GetSupportedGlobalGenerators().empty()) {
#if defined(_WIN32)
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
cmpb $0x0, 0x9563be(%rip) # 0xf03250
jne 0x5acf5f
leaq 0x9563b1(%rip), %rdi # 0xf03250
callq 0x3d080
cmpl $0x0, %eax
je 0x5acf5f
leaq -0x21(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3c460
movq -0xd0(%rbp), %rdx
leaq 0x5da336(%rip), %rsi # 0xb87201
leaq -0x20(%rbp), ... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExtraCodeBlocksGenerator::CreateProjectFile(std::vector<cmLocalGenerator*, std::allocator<cmLocalGenerator*>> const&) | void cmExtraCodeBlocksGenerator::CreateProjectFile(
const std::vector<cmLocalGenerator*>& lgs)
{
std::string outputDir = lgs[0]->GetCurrentBinaryDirectory();
std::string projectName = lgs[0]->GetProjectName();
std::string filename = cmStrCat(outputDir, '/', projectName, ".cbp");
std::string sessionFilename =... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x168(%rbp)
callq 0x533600
movq (%rax), %rdi
callq 0x1ee380
movq %rax, %rsi
leaq -0x30(%rbp)... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExtraCodeBlocksGenerator::CreateNewProjectFile(std::vector<cmLocalGenerator*, std::allocator<cmLocalGenerator*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
const std::vector<cmLocalGenerator*>& lgs, const std::string& filename)
{
const cmMakefile* mf = lgs[0]->GetMakefile();
cmGeneratedFileStream fout(filename);
if (!fout) {
return;
}
Tree tree;
// build tree of virtual folders
for (auto const& i... | pushq %rbp
movq %rsp, %rbp
subq $0xe00, %rsp # imm = 0xE00
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xbd8(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, -0xbd0(%rbp)
movl %eax, %esi
callq 0x533600
movq (%rax), %rdi
callq 0x1a29c0
movl -0xb... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
Tree::BuildUnit(cmXMLWriter&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
{
for (std::string const& f : this->files) {
xml.StartElement("Unit");
xml.Attribute("filename", fsPath + f);
xml.StartElement("Option");
xml.Attribute("virtualFolder", "CMake Files\\");
xml.EndElement();
xml.EndElement(... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdf060
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9f4c0... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
Tree::BuildUnitImpl(cmXMLWriter&, 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 | void Tree::BuildUnitImpl(cmXMLWriter& xml,
const std::string& virtualFolderPath,
const std::string& fsPath) const
{
for (std::string const& f : this->files) {
xml.StartElement("Unit");
xml.Attribute("filename", cmStrCat(fsPath, this->path, "/", f));
xml.S... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2c8(%rbp)
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdf060
movq %rax, -0x30(%rbp)
movq -0x28(%r... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExtraCodeBlocksGenerator::GetCBCompilerId[abi:cxx11](cmMakefile const*) | std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf)
{
// allow the user to overwrite the detected compiler
std::string userCompiler =
mf->GetSafeDefinition("CMAKE_CODEBLOCKS_COMPILER_ID");
if (!userCompiler.empty()) {
return userCompiler;
}
// figure out which language to us... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x59(%rbp), %rdi
m... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmLocalGenerator const*, std::__cxx11::basic_string<char, std::char_tra... | void cmExtraCodeBlocksGenerator::AppendTarget(
cmXMLWriter& xml, const std::string& targetName, cmGeneratorTarget* target,
const std::string& make, const cmLocalGenerator* lg,
const std::string& compiler, const std::string& makeFlags)
{
cmMakefile const* makefile = lg->GetMakefile();
std::string makefileName ... | pushq %rbp
movq %rsp, %rbp
subq $0x9a0, %rsp # imm = 0x9A0
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x758(%rbp)
movq -0x30(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExtraCodeBlocksGenerator::BuildMakeCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::... | std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
const std::string& make, const std::string& makefile,
const std::string& target, const std::string& makeFlags)
{
std::string command = make;
if (!makeFlags.empty()) {
command += " ";
command += makeFlags;
}
std::string generator = this->Glob... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x18... | /JKorbelRA[P]CMake/Source/cmExtraCodeBlocksGenerator.cxx |
cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraCodeBlocksGenerator>::CreateExternalMakefileProjectGenerator() const | std::unique_ptr<cmExternalMakefileProjectGenerator>
CreateExternalMakefileProjectGenerator() const override
{
std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
p->SetName(this->GetName());
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x48, %edi
callq 0x3cbd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5ace40... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.h |
cmExtraCodeLiteGenerator::GetFactory() | cmExternalMakefileProjectGeneratorFactory*
cmExtraCodeLiteGenerator::GetFactory()
{
static cmExternalMakefileProjectGeneratorSimpleFactory<
cmExtraCodeLiteGenerator>
factory("CodeLite", "Generates CodeLite project files.");
if (factory.GetSupportedGlobalGenerators().empty()) {
#if defined(_WIN32)
facto... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
cmpb $0x0, 0x94c476(%rip) # 0xf032f8
jne 0x5b6f4f
leaq 0x94c469(%rip), %rdi # 0xf032f8
callq 0x3d080
cmpl $0x0, %eax
je 0x5b6f4f
leaq -0x21(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3c460
movq -0xd0(%rbp), %rdx
leaq 0x5d0721(%rip), %rsi # 0xb875dc
leaq -0x20(%rbp), ... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::Generate() | void cmExtraCodeLiteGenerator::Generate()
{
// Hold root tree information for creating the workspace
std::string workspaceProjectName;
std::string workspaceOutputDir;
std::string workspaceFileName;
std::string workspaceSourcePath;
const std::map<std::string, std::vector<cmLocalGenerator*>>& projectMap =
... | pushq %rbp
movq %rsp, %rbp
subq $0x610, %rsp # imm = 0x610
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x590(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3d1f0
leaq -0x48(%rbp), %rdi
callq 0x3d1f0
leaq -0x68(%rbp), %rdi
callq 0x3d1f0
leaq -0x88(%rbp), %rdi
callq 0x3d1f0
movq -0x590(%rbp), %rax
movq 0x20(... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::GetConfigurationName[abi:cxx11](cmMakefile const*) const | std::string cmExtraCodeLiteGenerator::GetConfigurationName(
const cmMakefile* mf) const
{
std::string confName = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
// Trim the configuration name from whitespaces (left and right)
confName.erase(0, confName.find_first_not_of(" \t\r\v\n"));
confName.erase(confName.find_... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3c460
movq -0x60(%rbp),... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::CreateProjectsByTarget[abi:cxx11](cmXMLWriter*) | std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByTarget(
cmXMLWriter* xml)
{
std::vector<std::string> retval;
// for each target in the workspace create a codelite project
const auto& lgs = this->GlobalGenerator->GetLocalGenerators();
for (const auto& lg : lgs) {
for (const auto& lt : lg... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x60530
movq -0x220(%rbp), %rax
movq 0x20(... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps[abi:cxx11](cmXMLWriter*) | std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps(
cmXMLWriter* xml)
{
std::vector<std::string> retval;
// for each sub project in the workspace create a codelite project
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
std::string const& outputDir = it.second[0]... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x60530
movq -0x150(%rbp), %rax
movq 0x20(... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::CreateNewProjectFile(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmExtraCodeLiteGenerator::CreateNewProjectFile(
const cmGeneratorTarget* gt, const std::string& filename)
{
const cmMakefile* mf = gt->Makefile;
cmGeneratedFileStream fout(filename);
if (!fout) {
return;
}
cmXMLWriter xml(fout);
////////////////////////////////////
xml.StartDocument("utf-8");
... | pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x288(%rbp), %rdi
xorl %ecx, %ecx
movl %... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::CollectSourceFiles(cmMakefile const*, cmGeneratorTarget const*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmSourceFile*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx... | std::string cmExtraCodeLiteGenerator::CollectSourceFiles(
const cmMakefile* makefile, const cmGeneratorTarget* gt,
std::map<std::string, cmSourceFile*>& cFiles,
std::set<std::string>& otherFiles)
{
std::string projectType;
switch (gt->GetType()) {
case cmStateEnums::EXECUTABLE: {
projectType = "Exec... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x118(%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 %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x3d1f0
movq -0x20(%rb... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::GetCodeLiteCompilerName[abi:cxx11](cmMakefile const*) const | std::string cmExtraCodeLiteGenerator::GetCodeLiteCompilerName(
const cmMakefile* mf) const
{
// figure out which language to use
// for now care only for C and C++
std::string compilerIdVar = "CMAKE_CXX_COMPILER_ID";
if (!this->GlobalGenerator->GetLanguageEnabled("CXX")) {
compilerIdVar = "CMAKE_C_COMPILE... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3c460
movq -0x90(%rbp), %rdx
leaq 0x59810c(%ri... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExtraCodeLiteGenerator::GetBuildCommand(cmMakefile const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmExtraCodeLiteGenerator::GetBuildCommand(
const cmMakefile* mf, const std::string& targetName) const
{
const std::string& generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
const std::string& make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
std::string buildCommand = make; // Default
st... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x250(%rbp)
movq %rdi, %rax
movq %rax, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x238(%rbp)
l... | /JKorbelRA[P]CMake/Source/cmExtraCodeLiteGenerator.cxx |
cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraCodeLiteGenerator>::CreateExternalMakefileProjectGenerator() const | std::unique_ptr<cmExternalMakefileProjectGenerator>
CreateExternalMakefileProjectGenerator() const override
{
std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
p->SetName(this->GetName());
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x90, %edi
callq 0x3cbd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5b6dc0... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.h |
cmExtraEclipseCDT4Generator::cmExtraEclipseCDT4Generator() | cmExtraEclipseCDT4Generator::cmExtraEclipseCDT4Generator()
{
this->IsOutOfSourceBuild = false;
this->GenerateSourceProject = false;
this->SupportsVirtualFolders = true;
this->GenerateLinkedResources = true;
this->SupportsGmakeErrorParser = true;
this->SupportsMachO64Parser = true;
this->CEnabled = false;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5b33a0
movq -0x10(%rbp), %rdi
leaq 0x9316e4(%rip), %rax # 0xeef3d8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x48, %rdi
callq 0x60530
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xdefc0
movq -0x10(... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::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&, cmMakefile*, bool) | void cmExtraEclipseCDT4Generator::EnableLanguage(
std::vector<std::string> const& languages, cmMakefile* /*unused*/,
bool /*optional*/)
{
for (std::string const& l : languages) {
if (l == "CXX") {
this->Natures.insert("org.eclipse.cdt.core.ccnature");
this->Natures.insert("org.eclipse.cdt.core.cna... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
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), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62f40
mo... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::CreateSourceProjectFile() | void cmExtraEclipseCDT4Generator::CreateSourceProjectFile()
{
assert(this->HomeDirectory != this->HomeOutputDirectory);
// set up the project name: <project>-Source@<baseSourcePathName>
const auto& lg = this->GlobalGenerator->GetLocalGenerators()[0];
std::string name = cmExtraEclipseCDT4Generator::GenerateProj... | pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp # imm = 0x500
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x4b0(%rbp)
movq %rsi, %rdi
addq $0x90, %rdi
addq $0xb0, %rsi
callq 0xdefe0
testb $0x1, %al
jne 0x5bec66
jmp 0x5bec68
jmp 0x5bec87
leaq 0x5c9125(%rip), %rdi # 0xb87d94
leaq 0x5c914f(%rip), %r... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::CreateProjectFile() | void cmExtraEclipseCDT4Generator::CreateProjectFile()
{
const auto& lg = this->GlobalGenerator->GetLocalGenerators()[0];
cmMakefile* mf = lg->GetMakefile();
const std::string filename = this->HomeOutputDirectory + "/.project";
cmGeneratedFileStream fout(filename);
if (!fout) {
return;
}
std::string... | pushq %rbp
movq %rsp, %rbp
subq $0xd50, %rsp # imm = 0xD50
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xbc8(%rbp)
movq 0x20(%rax), %rdi
callq 0x1a2ee0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, -0xbb4(%rbp)
movl %eax, %esi
callq 0x4d6f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a11... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::CreateSettingsResourcePrefsFile() | void cmExtraEclipseCDT4Generator::CreateSettingsResourcePrefsFile()
{
const auto& lg = this->GlobalGenerator->GetLocalGenerators()[0];
cmMakefile* mf = lg->GetMakefile();
const std::string filename =
this->HomeOutputDirectory + "/.settings/org.eclipse.core.resources.prefs";
cmGeneratedFileStream fout(file... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq 0x20(%rax), %rdi
callq 0x1a2ee0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, -0x2e0(%rbp)
movl %eax, %esi
callq 0x4d6f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a11... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::AppendLinkedResource(cmXMLWriter&, 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&, cmExtraEclipseCDT4Generator::LinkType) | void cmExtraEclipseCDT4Generator::AppendLinkedResource(cmXMLWriter& xml,
const std::string& name,
const std::string& path,
LinkType linkType)
{
const cha... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x5c41a7(%rip), %rax # 0xb89b38
movq %rax, -0x28(%rbp)
movl $0x2, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5c59ad
leaq 0x5c30fd(%rip), %rax # 0xb88a... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter&) | void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
{
std::string linkName = "[Targets]";
cmExtraEclipseCDT4Generator::AppendLinkedResource(
xml, linkName, "virtual:/virtual", VirtualFolder);
for (const auto& lg : this->GlobalGenerator->GetLocalGenerators()) {
cmMakefile* makefile =... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x3c460
movq -0x200(%rbp), %rdx
leaq 0x5c282d(%rip), %rsi # 0xb884b9
leaq -0x30(%rbp), %rdi
callq 0x606... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::WriteGroups(std::vector<cmSourceGroup, std::allocator<cmSourceGroup>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cmXMLWriter&) | void cmExtraEclipseCDT4Generator::WriteGroups(
std::vector<cmSourceGroup> const& sourceGroups, std::string& linkName,
cmXMLWriter& xml)
{
for (cmSourceGroup const& sg : sourceGroups) {
std::string linkName3 = cmStrCat(linkName, '/', sg.GetFullName());
std::replace(linkName3.begin(), linkName3.end(), '\\'... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23ee50
movq %rax, -0x30(%rbp)
movq -... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
AppendAttribute(cmXMLWriter&, char const*) | static void AppendAttribute(cmXMLWriter& xml, const char* keyval)
{
xml.StartElement("attribute");
xml.Attribute("key", keyval);
xml.Attribute("value", keyval);
xml.EndElement();
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3c460
movq -0x50(%rbp), %rdx
leaq 0x5f7658(%rip), %rsi # 0xbbe1a8
leaq -0x30(%rbp), %rdi
callq 0x606e0
jmp 0x5c6b5b
movq -0x58(%r... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::AppendTarget(cmXMLWriter&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std... | void cmExtraEclipseCDT4Generator::AppendTarget(
cmXMLWriter& xml, const std::string& target, const std::string& make,
const std::string& makeArgs, const std::string& path, const char* prefix,
const char* makeTarget)
{
xml.StartElement("target");
xml.Attribute("name", prefix + target);
xml.Attribute("path", ... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x180(%rbp)
... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraEclipseCDT4Generator::AppendStorageScanners(cmXMLWriter&, cmMakefile const&) | void cmExtraEclipseCDT4Generator::AppendStorageScanners(
cmXMLWriter& xml, const cmMakefile& makefile)
{
// we need the "make" and the C (or C++) compiler which are used, Alex
const std::string& make =
makefile.GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
std::string compiler = makefile.GetSafeDefinition("C... | pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp # imm = 0x3F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2f0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x3c460
movq -0x2e8(%rbp), %rdx
leaq 0x5890c5(%rip), %rsi # 0xb501f1
leaq -0x38(%rbp), %rdi
callq 0x60... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
void AppendDictionary<char [6]>(cmXMLWriter&, char const*, char const (&) [6]) | void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
{
xml.StartElement("dictionary");
xml.Element("key", key);
xml.Element("value", value);
xml.EndElement();
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3c460
movq -0xa8(%rbp), %rdx
leaq 0x61e46d(%rip), %rsi # 0xbe681d
leaq -0x38(%rbp), %rdi
callq 0x606e0
jmp... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
void AppendDictionary<char [4]>(cmXMLWriter&, char const*, char const (&) [4]) | void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
{
xml.StartElement("dictionary");
xml.Element("key", key);
xml.Element("value", value);
xml.EndElement();
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3c460
movq -0xa8(%rbp), %rdx
leaq 0x61dced(%rip), %rsi # 0xbe681d
leaq -0x38(%rbp), %rdi
callq 0x606e0
jmp... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
void AppendDictionary<char [1]>(cmXMLWriter&, char const*, char const (&) [1]) | void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
{
xml.StartElement("dictionary");
xml.Element("key", key);
xml.Element("value", value);
xml.EndElement();
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3c460
movq -0xa8(%rbp), %rdx
leaq 0x61db0d(%rip), %rsi # 0xbe681d
leaq -0x38(%rbp), %rdi
callq 0x606e0
jmp... | /JKorbelRA[P]CMake/Source/cmExtraEclipseCDT4Generator.cxx |
cmExtraKateGenerator::GetFactory() | cmExternalMakefileProjectGeneratorFactory* cmExtraKateGenerator::GetFactory()
{
static cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraKateGenerator>
factory("Kate", "Generates Kate project files.");
if (factory.GetSupportedGlobalGenerators().empty()) {
#if defined(_WIN32)
factory.AddSupportedGlobal... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
cmpb $0x0, 0x939226(%rip) # 0xf03428
jne 0x5ca2cf
leaq 0x939219(%rip), %rdi # 0xf03428
callq 0x3d080
cmpl $0x0, %eax
je 0x5ca2cf
leaq -0x21(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3c460
movq -0xd0(%rbp), %rdx
leaq 0x5be8c8(%rip), %rsi # 0xb88b03
leaq -0x20(%rbp), ... | /JKorbelRA[P]CMake/Source/cmExtraKateGenerator.cxx |
cmExtraKateGenerator::CreateKateProjectFile(cmLocalGenerator const&) const | void cmExtraKateGenerator::CreateKateProjectFile(
const cmLocalGenerator& lg) const
{
std::string filename = cmStrCat(lg.GetBinaryDirectory(), "/.kateproject");
cmGeneratedFileStream fout(filename);
if (!fout) {
return;
}
/* clang-format off */
fout <<
"{\n"
"\t\"name\": \"" << this->ProjectN... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x348(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ee3b0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x340(%rbp)
callq 0x61ca0
leaq 0x5be145(%rip), %rsi # 0xb88b26
leaq... | /JKorbelRA[P]CMake/Source/cmExtraKateGenerator.cxx |
cmExtraKateGenerator::WriteTargets(cmLocalGenerator const&, cmGeneratedFileStream&) const | void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator& lg,
cmGeneratedFileStream& fout) const
{
cmMakefile const* mf = lg.GetMakefile();
const std::string& make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
const std::string& makeArgs =
mf->GetSafeDefiniti... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x298(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b3ff0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x49(%rbp), %rdi
movq ... | /JKorbelRA[P]CMake/Source/cmExtraKateGenerator.cxx |
cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraKateGenerator>::CreateExternalMakefileProjectGenerator() const | std::unique_ptr<cmExternalMakefileProjectGenerator>
CreateExternalMakefileProjectGenerator() const override
{
std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
p->SetName(this->GetName());
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x70, %edi
callq 0x3cbd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5ca1b0... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.h |
cmExtraSublimeTextGenerator::CreateProjectFile(std::vector<cmLocalGenerator*, std::allocator<cmLocalGenerator*>> const&) | void cmExtraSublimeTextGenerator::CreateProjectFile(
const std::vector<cmLocalGenerator*>& lgs)
{
std::string outputDir = lgs[0]->GetCurrentBinaryDirectory();
std::string projectName = lgs[0]->GetProjectName();
const std::string filename =
outputDir + "/" + projectName + ".sublime-project";
this->Create... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xc8(%rbp)
callq 0x533600
movq (%rax), %rdi
callq 0x1ee380
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3b400
movq -0... | /JKorbelRA[P]CMake/Source/cmExtraSublimeTextGenerator.cxx |
cmExtraSublimeTextGenerator::AppendTarget(cmGeneratedFileStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmLocalGenerator*, cmGeneratorTarget*, char const*, cmMakefile const*, char const*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<ch... | void cmExtraSublimeTextGenerator::AppendTarget(
cmGeneratedFileStream& fout, const std::string& targetName,
cmLocalGenerator* lg, cmGeneratorTarget* target, const char* make,
const cmMakefile* makefile, const char* /*compiler*/,
MapSourceFileFlags& sourceFileFlags, bool firstTarget)
{
if (target != nullptr) ... | pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp # imm = 0x4D0
movb 0x28(%rbp), %al
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x... | /JKorbelRA[P]CMake/Source/cmExtraSublimeTextGenerator.cxx |
cmExternalMakefileProjectGeneratorSimpleFactory<cmExtraSublimeTextGenerator>::CreateExternalMakefileProjectGenerator() const | std::unique_ptr<cmExternalMakefileProjectGenerator>
CreateExternalMakefileProjectGenerator() const override
{
std::unique_ptr<cmExternalMakefileProjectGenerator> p(new T);
p->SetName(this->GetName());
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x70, %edi
callq 0x3cbd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5cc750... | /JKorbelRA[P]CMake/Source/cmExternalMakefileProjectGenerator.h |
cmFileAPI::cmFileAPI(cmake*) | cmFileAPI::cmFileAPI(cmake* cm)
: CMakeInstance(cm)
{
this->APIv1 =
this->CMakeInstance->GetHomeOutputDirectory() + "/.cmake/api/v1";
Json::CharReaderBuilder rbuilder;
rbuilder["collectComments"] = false;
rbuilder["failIfExtra"] = true;
rbuilder["rejectDupKeys"] = false;
rbuilder["strictRoot"] = true... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x288(%rbp)
callq 0x3d1f0
movq -0x250(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x280(%rbp)... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ReadQueries() | void cmFileAPI::ReadQueries()
{
std::string const query_dir = this->APIv1 + "/query";
this->QueryExists = cmSystemTools::FileIsDirectory(query_dir);
if (!this->QueryExists) {
return;
}
// Load queries at the top level.
std::vector<std::string> queries = cmFileAPI::LoadDir(query_dir);
// Read the que... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
addq $0x8, %rsi
leaq 0x5b7e9f(%rip), %rdx # 0xb89074
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x83c40
movq -0x90(%rbp), %rdi
callq 0x7f8880
movb %al, -0x81(%rbp)
jmp 0x5d11f9
movq -0x98(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ReadQuery(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<cmFileAPI::Object, std::allocator<cmFileAPI::Object>>&) | bool cmFileAPI::ReadQuery(std::string const& query,
std::vector<Object>& objects)
{
// Parse the "<kind>-" syntax.
std::string::size_type sep_pos = query.find('-');
if (sep_pos == std::string::npos) {
return false;
}
std::string kindName = query.substr(0, sep_pos);
std::string ... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e350
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x5d17d9
movb $0x0, -0x1(%rbp)
jmp 0x5d1c15
movq -0x10(%rbp), %rsi
... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::WriteReplies() | void cmFileAPI::WriteReplies()
{
if (this->QueryExists) {
cmSystemTools::MakeDirectory(this->APIv1 + "/reply");
this->WriteJsonFile(this->BuildReplyIndex(), "index", ComputeSuffixTime);
}
this->RemoveOldReplyFiles();
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
testb $0x1, 0x60(%rax)
je 0x5d1d92
movq -0xb8(%rbp), %rsi
addq $0x8, %rsi
leaq 0x5b741d(%rip), %rdx # 0xb89083
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x83c40
movq -0xc8(%rbp), %rdi
xorl %eax, %... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ObjectKindName(cmFileAPI::ObjectKind) | const char* cmFileAPI::ObjectKindName(ObjectKind kind)
{
// Keep in sync with ObjectKind enum.
static const char* objectKindNames[] = {
"codemodel", //
"cache", //
"cmakeFiles", //
"toolchains", //
"__test" //
};
return objectKindNames[static_cast<size_t>(kind)];
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x92902e(%rip), %rax # 0xefc0c0
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildClientRequests(Json::Value const&) | cmFileAPI::ClientRequests cmFileAPI::BuildClientRequests(
Json::Value const& requests)
{
ClientRequests result;
if (requests.isNull()) {
result.Error = "'requests' member missing";
return result;
}
if (!requests.isArray()) {
result.Error = "'requests' member is not an array";
return result;
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5d6cd0
movq -0x18(%rbp), %rdi
callq 0x8d896... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildCMake() | Json::Value cmFileAPI::BuildCMake()
{
Json::Value cmake = Json::objectValue;
cmake["version"] = this->CMakeInstance->ReportVersionJson();
Json::Value& cmake_paths = cmake["paths"] = Json::objectValue;
cmake_paths["cmake"] = cmSystemTools::GetCMakeCommand();
cmake_paths["ctest"] = cmSystemTools::GetCTestComman... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x150(%rbp), %rax
movq (%rax), %rs... | /JKorbelRA[P]CMake/Source/cmFileAPI.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.