name string | code string | asm string | file string |
|---|---|---|---|
llvm::createMachOStreamer(llvm::MCContext&, std::unique_ptr<llvm::MCAsmBackend, std::default_delete<llvm::MCAsmBackend>>&&, std::unique_ptr<llvm::MCObjectWriter, std::default_delete<llvm::MCObjectWriter>>&&, std::unique_ptr<llvm::MCCodeEmitter, std::default_delete<llvm::MCCodeEmitter>>&&, bool, bool) | MCStreamer *llvm::createMachOStreamer(MCContext &Context,
std::unique_ptr<MCAsmBackend> &&MAB,
std::unique_ptr<MCObjectWriter> &&OW,
std::unique_ptr<MCCodeEmitter> &&CE,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x1c8, %edi # imm = 0x1C8
callq 0x6e5900
movq %rax, %rbx
movq (%r13), %rax
xorl %ecx, %ecx
movq %rcx, (%r13)
movq (%r12), %rsi
movq %rcx, (%... | /MC/MCMachOStreamer.cpp |
llvm::DenseMap<llvm::MCSymbol*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, unsigned int>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x31547aa
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl... | /llvm/ADT/DenseMap.h |
llvm::SPIRVObjectWriter::writeObject(llvm::MCAssembler&) | uint64_t SPIRVObjectWriter::writeObject(MCAssembler &Asm) {
uint64_t StartOffset = W.OS.tell();
writeHeader(Asm);
for (const MCSection &S : Asm)
Asm.writeSectionData(W.OS, &S);
return W.OS.tell() - StartOffset;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x68(%rdi), %r12
movq (%r12), %rax
movq %r12, %rdi
callq *0x50(%rax)
movq %rax, %rbx
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%r12), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x315b... | /MC/SPIRVObjectWriter.cpp |
llvm::detail::DenseMapPair<llvm::CachedHashStringRef, unsigned long>* llvm::DenseMapBase<llvm::DenseMap<llvm::CachedHashStringRef, unsigned long, llvm::DenseMapInfo<llvm::CachedHashStringRef, void>, llvm::detail::DenseMapPair<llvm::CachedHashStringRef, unsigned long>>, llvm::CachedHashStringRef, unsigned long, llvm::De... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x315ce65
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::TargetRegistry::RegisterTarget(llvm::Target&, char const*, char const*, char const*, bool (*)(llvm::Triple::ArchType), bool) | void TargetRegistry::RegisterTarget(Target &T, const char *Name,
const char *ShortDesc,
const char *BackendName,
Target::ArchMatchFnTy ArchMatchFn,
bool HasJIT) {
assert(Name... | cmpq $0x0, 0x10(%rdi)
je 0x315d64a
retq
movq 0x3465cff(%rip), %rax # 0x65c3350
movq %rax, (%rdi)
movq %rdi, 0x3465cf5(%rip) # 0x65c3350
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %r8, 0x8(%rdi)
movb %r9b, 0x28(%rdi)
retq
| /MC/TargetRegistry.cpp |
(anonymous namespace)::WasmObjectWriter::executePostLayoutBinding(llvm::MCAssembler&) | void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm) {
// Some compilation units require the indirect function table to be present
// but don't explicitly reference it. This is the case for call_indirect
// without the reference-types feature, and also function bitcasts in all
// cases. In those ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2298f2d(%rip), %rax # 0x53f72ad
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
callq 0x312c544
testq %rax, %rax
je 0x315e3a9
testb $-0x80, 0xc(... | /MC/WasmObjectWriter.cpp |
llvm::DenseMap<llvm::MCSection const*, llvm::MCSymbol const*, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, llvm::MCSymbol const*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x315ed68
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::wasm::WasmSignature, unsigned int, llvm::DenseMapInfo<llvm::wasm::WasmSignature, void>, llvm::detail::DenseMapPair<llvm::wasm::WasmSignature, unsigned int>>, llvm::wasm::WasmSignature, unsigned int, llvm::DenseMapInfo<llvm::wasm::WasmSignature, void>, llvm::detail::DenseMapPair<l... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x315f077
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x58(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, -0x8(%rdx)
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x400000000,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbolWasm const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbolWasm const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbolWasm const*, unsigned int>>, llvm::MCSymbolWasm const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbolWasm const*, void>, llvm::detail::DenseMapPair<l... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x315f155
cmpl $0x0, 0xc(%rdi)
je 0x315f22e
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x315f56a
testq %rcx, %rcx
je 0x315f226
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbolWasm const*, llvm::wasm::WasmDataReference, llvm::DenseMapInfo<llvm::MCSymbolWasm const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbolWasm const*, llvm::wasm::WasmDataReference>>, llvm::MCSymbolWasm const*, llvm::wasm::WasmDataReference, llvm::DenseMapInfo<llvm::MCSym... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x315f241
cmpl $0x0, 0xc(%rdi)
je 0x315f31a
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x315f696
testq %rcx, %rcx
je 0x315f312
movq (%rdi), %rax
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, llvm::MCSymbol const*, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, llvm::MCSymbol const*>>, llvm::MCSection const*, llvm::MCSymbol const*, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::De... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x315f48f
cmpl $0x0, 0xc(%rdi)
je 0x315f568
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x315f838
testq %rcx, %rcx
je 0x315f560
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MCSection const*, llvm::MCSymbol const*, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, llvm::MCSymbol const*>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
testl %eax, %eax
je 0x315f854
decl %eax
je 0x315f858
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x315f85d
xorl %ebp, %ebp
jmp 0x315f873
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::WasmObjectWriter::writeCustomSection((anonymous namespace)::WasmCustomSection&, llvm::MCAssembler const&) | void WasmObjectWriter::writeCustomSection(WasmCustomSection &CustomSection,
const MCAssembler &Asm) {
SectionBookkeeping Section;
auto *Sec = CustomSection.Section;
startCustomSection(Section, CustomSection.Name);
Sec->setSectionOffset(W->OS.tell() - Section.ContentsOf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rbp
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x31668d6
movq 0x68(%r14), %rax
mov... | /MC/WasmObjectWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbolWasm const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbolWasm const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbolWasm const*, unsigned int>>, llvm::MCSymbolWasm const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbolWasm const*, void>, llvm::detail::DenseMapPair<l... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x316598b
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, (anonymous namespace)::COFFSection*, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, (anonymous namespace)::COFFSection*>>, llvm::MCSection const*, (anonymous namespace)::COFFSection*, llvm::DenseMapInfo<llvm:... | void grow(unsigned AtLeast) {
static_cast<DerivedT *>(this)->grow(AtLeast);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %ea... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::XCOFFObjectWriter::reset() | void XCOFFObjectWriter::reset() {
// Clear the mappings we created.
SymbolIndexMap.clear();
SectionMap.clear();
UndefinedCsects.clear();
// Reset any sections we have written to, and empty the section header table.
for (auto *Sec : Sections)
Sec->reset();
for (auto &DwarfSec : DwarfSections)
Dwar... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xe8, %rdi
callq 0x23c72fc
leaq 0xd0(%rbx), %r14
movl 0xd8(%rbx), %eax
testl %eax, %eax
je 0x316d394
leal (,%rax,4), %ecx
movl 0xe0(%rbx), %edx
cmpl %edx, %ecx
setae %cl
cmpl $0x41, %edx
setb %sil
orb %cl, %sil
jne 0x316d3b3
decl %eax
je 0x316... | /MC/XCOFFObjectWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSectionELF const*, std::vector<llvm::ELFRelocationEntry, std::allocator<llvm::ELFRelocationEntry>>, llvm::DenseMapInfo<llvm::MCSectionELF const*, void>, llvm::detail::DenseMapPair<llvm::MCSectionELF const*, std::vector<llvm::ELFRelocationEntry, std::allocator<llvm::ELFRelocatio... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x317634b
movq (%r15), %rax
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MCSectionELF const*, std::vector<llvm::ELFRelocationEntry, std::allocator<llvm::ELFRelocationEntry>>, llvm::DenseMapInfo<llvm::MCSectionELF const*, void>, llvm::detail::DenseMapPair<llvm::MCSectionELF const*, std::vector<llvm::ELFRelocationEntry, std::allocator<llvm::ELFRelocationEntry>>>>::init(un... | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x31764da
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::MCAsmStreamer::emitZerofill(llvm::MCSection*, llvm::MCSymbol*, unsigned long, llvm::Align, llvm::SMLoc) | void MCAsmStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
uint64_t Size, Align ByteAlignment,
SMLoc Loc) {
if (Symbol)
Symbol->setFragment(&Section->getDummyFragment());
// Note: a .zerofill directive does not switch sections.
OS ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3179705
leaq 0x38(%r12), %rax
movq %rax, (%r15)
movq 0x128(%rbx), %rdi
leaq 0x27588ca(%rip), %rsi # 0x58d1fdd
movl $0xa, %edx
callq 0x... | /MC/MCAsmStreamer.cpp |
(anonymous namespace)::MCAsmStreamer::emitCVDefRangeDirective(llvm::ArrayRef<std::pair<llvm::MCSymbol const*, llvm::MCSymbol const*>>, llvm::codeview::DefRangeSubfieldRegisterHeader) | void MCAsmStreamer::emitCVDefRangeDirective(
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
codeview::DefRangeSubfieldRegisterHeader DRHdr) {
PrintCVDefRangePrefix(Ranges);
OS << ", subfield_reg, ";
OS << DRHdr.Register << ", " << DRHdr.OffsetInParent;
EmitEOL();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdi, %rbx
movq %rcx, %r14
shrq $0x20, %r14
callq 0x317e0b2
movq 0x128(%rbx), %rdi
leaq 0x2756cbd(%rip), %rsi # 0x58d21e2
movl $0x10, %edx
callq 0x757dc8
movq 0x128(%rbx), %rdi
movzwl %r15w, %esi
callq 0x79e1e0
leaq 0x1e2d8d(%rip), %rsi # 0x335e2d3
movl $0x2, %... | /MC/MCAsmStreamer.cpp |
llvm::createDXContainerStreamer(llvm::MCContext&, std::unique_ptr<llvm::MCAsmBackend, std::default_delete<llvm::MCAsmBackend>>&&, std::unique_ptr<llvm::MCObjectWriter, std::default_delete<llvm::MCObjectWriter>>&&, std::unique_ptr<llvm::MCCodeEmitter, std::default_delete<llvm::MCCodeEmitter>>&&) | MCStreamer *llvm::createDXContainerStreamer(
MCContext &Context, std::unique_ptr<MCAsmBackend> &&MAB,
std::unique_ptr<MCObjectWriter> &&OW, std::unique_ptr<MCCodeEmitter> &&CE) {
auto *S = new MCDXContainerStreamer(Context, std::move(MAB), std::move(OW),
std::move(CE));
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x1a8, %edi # imm = 0x1A8
callq 0x6e5900
movq %rax, %rbx
movq (%r12), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
xorl %eax, %eax
movq %rax, (%r12)
movq (%r15), %rsi
... | /MC/MCDXContainerStreamer.cpp |
llvm::AMDGPU::HSAMD::V3::MetadataVerifier::verifyIntegerEntry(llvm::msgpack::MapDocNode&, llvm::StringRef, bool) | bool MetadataVerifier::verifyIntegerEntry(msgpack::MapDocNode &MapNode,
StringRef Key, bool Required) {
return verifyEntry(MapNode, Key, Required, [this](msgpack::DocNode &Node) {
return verifyInteger(Node);
});
} | pushq %r15
pushq %r14
pushq %rbx
movl %r8d, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x318403a
movq 0x8(%r15), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x317f015
addq $0x38, %rax
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x317ef40
xorb $0x1, %bl
m... | /BinaryFormat/AMDGPUMetadataVerifier.cpp |
llvm::XCOFF::getRelocationTypeString(llvm::XCOFF::RelocationType) | StringRef XCOFF::getRelocationTypeString(XCOFF::RelocationType Type) {
switch (Type) {
RELOC_CASE(R_POS)
RELOC_CASE(R_RL)
RELOC_CASE(R_RLA)
RELOC_CASE(R_NEG)
RELOC_CASE(R_REL)
RELOC_CASE(R_TOC)
RELOC_CASE(R_TRL)
RELOC_CASE(R_TRLA)
RELOC_CASE(R_GL)
RELOC_CASE(R_TCL)
RELOC_CA... | cmpb $0x31, %dil
ja 0x318703c
leaq 0x2751ddb(%rip), %rax # 0x58d8e00
movzbl %dil, %ecx
movq (%rax,%rcx,8), %rdx
leaq 0x2751f5c(%rip), %rsi # 0x58d8f90
movslq (%rsi,%rcx,4), %rax
addq %rsi, %rax
retq
leaq 0x2089a6(%rip), %rax # 0x338f9e9
movl $0x7, %edx
retq
| /BinaryFormat/XCOFF.cpp |
llvm::StringRef::contains(char) const | [[nodiscard]] constexpr size_t size() const { return Length; } | movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x3192d2d
pushq %rbx
movq (%rdi), %rbx
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x6e5ad0
testq %rax, %rax
setne %cl
subq %rbx, %rax
cmpq $-0x1, %rax
setne %al
andb %cl, %al
popq %rbx
retq
xorl %eax, %eax
retq
| /llvm/ADT/StringRef.h |
llvm::codeview::CodeViewRecordIO::mapEncodedInteger(unsigned long&, llvm::Twine const&) | Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value,
const Twine &Comment) {
if (isStreaming())
emitEncodedUnsignedInteger(Value, Comment);
else if (isWriting()) {
if (auto EC = writeEncodedUnsignedInteger(Value))
return EC;
} else {
APSInt N;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rdx
testq %rdx, %rdx
setne %r8b
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdi
testq %rax, %rax
sete %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x3198fec
testq %rdi, %rdi
jne 0x3199012
movq %rsi, %rdi
movq %r14, %r... | /DebugInfo/CodeView/CodeViewRecordIO.cpp |
(anonymous namespace)::CVTypeVisitor::finishVisitation(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&) | Error CVTypeVisitor::finishVisitation(CVType &Record) {
switch (Record.kind()) {
default:
if (auto EC = Callbacks.visitUnknownType(Record))
return EC;
break;
#define TYPE_RECORD(EnumName, EnumVal, Name) \
case EnumName: { ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x4, 0x8(%rdx)
jae 0x319b0f9
movq (%r15), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movq %rbx, %rdx
callq *0x10(%rax)
cmpq $0x0, (%r14)
jne 0x319b0eb
movq (%r15), %rsi
movq (%rsi), %rax
movq %r14, ... | /DebugInfo/CodeView/CVTypeVisitor.cpp |
llvm::codeview::consume(llvm::BinaryStreamReader&, llvm::APSInt&) | Error llvm::codeview::consume(BinaryStreamReader &Reader, APSInt &Num) {
// Used to avoid overload ambiguity on APInt constructor.
bool FalseVal = false;
uint16_t Short;
if (auto EC = Reader.readInteger(Short))
return EC;
if (Short < LF_NUMERIC) {
Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x16(%rsp), %rdx
callq 0x3000608
cmpq $0x0, (%rbx)
jne 0x319c845
movswq 0x16(%rsp), %r12
testq %r12, %r12
js 0x319c854
cmpl $0x41, 0x8(%r14)
jb 0x319c82e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x319c82e
call... | /DebugInfo/CodeView/RecordSerialization.cpp |
llvm::codeview::TypeRecordMapping::visitMemberBegin(llvm::codeview::CVMemberRecord&) | Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {
assert(TypeKind && "Not in a type mapping!");
assert(!MemberKind && "Already in a member mapping!");
// The largest possible subrecord is one in which there is a record prefix,
// followed by the subrecord, followed by a continuation, and that... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsi), %r15
movabsq $0x10000fef4, %rdx # imm = 0x10000FEF4
movq %r15, %rsi
callq 0x31982a8
cmpq $0x0, (%rbx)
jne 0x319f8a1
movzwl (%r14), %eax
orl $0x10000, %eax # i... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::BinaryStreamReader::skip(unsigned long) | Error BinaryStreamReader::skip(uint64_t Amount) {
if (Amount > bytesRemaining())
return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
Offset += Amount;
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x30(%rsi)
jne 0x31ab4f6
movq 0x28(%r14), %rax
jmp 0x31ab50d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x31ab50b
movq (%rdi), %rax
callq *0x28(%rax)
subq 0x20(%r14), %rax
jmp 0x31ab50d
xorl %eax, %eax
movq 0x38(%r14), %rcx
subq ... | /Support/BinaryStreamReader.cpp |
llvm::WritableBinaryStreamRef::checkOffsetForWrite(unsigned long, unsigned long) const | Error checkOffsetForWrite(uint64_t Offset, uint64_t DataSize) const {
if (!(BorrowedImpl->getFlags() & BSF_Append))
return checkOffsetForRead(Offset, DataSize);
if (Offset > getLength())
return make_error<BinaryStreamError>(stream_error_code::invalid_offset);
return Error::success();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x2, %al
jne 0x31ab90b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x31ab96a
jmp 0x31ab95a
cmpb $0x1, 0x28(%r1... | /llvm/Support/BinaryStreamRef.h |
(anonymous namespace)::MutableArrayRefImpl::readBytes(unsigned long, unsigned long, llvm::ArrayRef<unsigned char>&) | Error readBytes(uint64_t Offset, uint64_t Size,
ArrayRef<uint8_t> &Buffer) override {
return BBS.readBytes(Offset, Size, Buffer);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
addq $0x20, %rsi
callq 0x3000554
cmpq $0x0, (%r15)
jne 0x31aba96
addq 0x30(%r13), %r12
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq... | /Support/BinaryStreamRef.cpp |
llvm::Error llvm::make_error<llvm::StringError, char const (&) [26], llvm::errc>(char const (&) [26], llvm::errc&&) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x40, %edi
callq 0x6e5900
movq %rax, %r14
movb $0x1, 0x29(%rsp)
cmpb $0x0, (%r12)
je 0x31b1866
movq %r12, 0x8(%rsp)
movb $0x3, %al
jmp 0x31b1868
movb $0x1, %al
leaq 0x8(%rsp), %r12
movb %al, 0x2... | /llvm/Support/Error.h |
llvm::IntEqClasses::grow(unsigned int) | void IntEqClasses::grow(unsigned N) {
assert(NumClasses == 0 && "grow() called after compress().");
EC.reserve(N);
while (EC.size() < N)
EC.push_back(EC.size());
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, 0xc(%rdi)
jae 0x31b1b8f
movl %ebx, %edx
leaq 0x10(%r14), %rsi
movl $0x4, %ecx
movq %r14, %rdi
callq 0x7803c4
jmp 0x31b1b8f
movq %r14, %rdi
callq 0x7bb48e
movl 0x8(%r14), %esi
cmpl %ebx, %esi
jb 0x31b1b87
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /Support/IntEqClasses.cpp |
llvm::IntEqClasses::join(unsigned int, unsigned int) | unsigned IntEqClasses::join(unsigned a, unsigned b) {
assert(NumClasses == 0 && "join() called after compress().");
unsigned eca = EC[a];
unsigned ecb = EC[b];
// Update pointers while searching for the leaders, compressing the paths
// incrementally. The larger leader will eventually be updated, joining the
... | movl %esi, %eax
movq (%rdi), %rcx
movl (%rcx,%rax,4), %eax
movl %edx, %edi
movl (%rcx,%rdi,4), %edi
cmpl %edi, %eax
je 0x31b1bd5
cmpl %edi, %eax
jae 0x31b1bc5
movl %edx, %edx
movl %eax, (%rcx,%rdx,4)
movl %edi, %r8d
movl %edi, %edx
movl (%rcx,%r8,4), %edi
jmp 0x31b1bad
movl %esi, %esi
movl %edi, (%rcx,%rsi,4)
movl %eax... | /Support/IntEqClasses.cpp |
llvm::KnownBits::avgCeilS(llvm::KnownBits const&, llvm::KnownBits const&) | KnownBits KnownBits::avgCeilS(const KnownBits &LHS, const KnownBits &RHS) {
return avgCompute(LHS, RHS, /* IsCeil */ true,
/* IsSigned */ true);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rsp)
cmpl $0x40, %eax
ja 0x31b697d
movq (%r15), %rax
movq %rax, (%rsp)
jmp 0x31b6988
movq %rsp, %rdi
movq %r15, %rsi
callq 0x7b435e
movl 0x18(%r15), %eax
addq $0x10, %r15
movl %eax, 0x1... | /Support/KnownBits.cpp |
llvm::KnownBits::blsmsk() const | KnownBits KnownBits::blsmsk() const {
unsigned BitWidth = getBitWidth();
KnownBits Known(BitWidth);
unsigned Max = countMaxTrailingZeros();
Known.Zero.setBitsFrom(std::min(Max + 1, BitWidth));
unsigned Min = countMinTrailingZeros();
Known.One.setLowBits(std::min(Min + 1, BitWidth));
return Known;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x78387a
leaq 0x10(%rbx), %r14
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x78387a
leaq 0x10(%r15), %rdi
movl 0x18(%r15), %eax
cmpl... | /Support/KnownBits.cpp |
llvm::LockFileManager::waitForUnlock(unsigned int) | LockFileManager::WaitForUnlockResult
LockFileManager::waitForUnlock(const unsigned MaxSeconds) {
if (getState() != LFS_Shared)
return Res_Success;
// Since we don't yet have an event-based method to wait for the lock file,
// use randomized exponential backoff, similar to Ethernet collision
// algorithm. T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13d8, %rsp # imm = 0x13D8
xorl %ebp, %ebp
cmpb $0x1, 0x1f0(%rdi)
jne 0x31b9add
movq %rdi, %r14
movl %esi, %eax
imulq $0x3b9aca00, %rax, %rbx # imm = 0x3B9ACA00
leaq 0x48(%rsp), %r15
movq $0x989680, -0x18(%r15) # imm = 0x989680
movq $0x... | /Support/LockFileManager.cpp |
llvm::Regex::Regex(llvm::StringRef, llvm::Regex::RegexFlags) | Regex::Regex(StringRef regex, RegexFlags Flags) {
unsigned flags = 0;
preg = new llvm_regex();
preg->re_endp = regex.end();
if (Flags & IgnoreCase)
flags |= REG_ICASE;
if (Flags & Newline)
flags |= REG_NEWLINE;
if (!(Flags & BasicRegex))
flags |= REG_EXTENDED;
error = llvm_regcomp(preg, regex.... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x6e5900
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, (%rbx)
addq %r14, %r15
movq %r15, 0x10(%rax)
movl %ebp, %ecx
andl $0x1, %ecx
movl %ebp, %edx
... | /Support/Regex.cpp |
llvm::SHA1::update(llvm::ArrayRef<unsigned char>) | void SHA1::update(ArrayRef<uint8_t> Data) {
InternalState.ByteCount += Data.size();
// Finish the current block.
if (InternalState.BufferOffset > 0) {
const size_t Remainder = std::min<size_t>(
Data.size(), BLOCK_LENGTH - InternalState.BufferOffset);
for (size_t I = 0; I < Remainder; ++I)
a... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
addl %ebx, 0x54(%rdi)
movq %rsi, %r15
movzbl 0x58(%rdi), %eax
testq %rax, %rax
je 0x31bc718
movl $0x40, %r12d
subq %rax, %r12
cmpq %rbx, %r12
cmovaeq %rbx, %r12
testq %r12, %r12
je 0x31bc712
xorl %r13d, %r13d
movb (%r15,%r13), %cl
mo... | /Support/SHA1.cpp |
llvm::SpecialCaseList::inSectionBlame(llvm::StringMap<llvm::StringMap<llvm::SpecialCaseList::Matcher, llvm::MallocAllocator>, llvm::MallocAllocator> const&, llvm::StringRef, llvm::StringRef, llvm::StringRef) const | unsigned SpecialCaseList::inSectionBlame(const SectionEntries &Entries,
StringRef Prefix, StringRef Query,
StringRef Category) const {
SectionEntries::const_iterator I = Entries.find(Prefix);
if (I == Entries.end()) return 0;
String... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x782024
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x78222e
cmpl $-0x1, %eax
je 0x31c0886
mov... | /Support/SpecialCaseList.cpp |
llvm::SpecificBumpPtrAllocator<llvm::yaml::Input::SequenceHNode>::DestroyAll() | void DestroyAll() {
auto DestroyElements = [](char *Begin, char *End) {
assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
reinterpret_cast<T *>(Ptr)->~T();
};
for (auto I = Allocator.Slabs.begin(), E = Allocator.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x31c7678
movq 0x10(%rbx), %r14
leaq (%r14,%rax,8), %r15
movl $0x1e, %ebp
movq 0x10(%rbx), %rax
movq %r14, %rcx
subq %rax, %rcx
shrq $0xa, %rcx
andl $0x1ffffff, %ecx # imm = 0x1F... | /llvm/Support/Allocator.h |
llvm::yaml::ScalarTraits<double, void>::input(llvm::StringRef, void*, double&) | StringRef ScalarTraits<double>::input(StringRef Scalar, void *, double &Val) {
if (to_float(Scalar, Val))
return StringRef();
return "invalid floating point number";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
leaq 0x40(%rsp), %rax
movw $0x105, 0x20(%rax) # imm = 0x105
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x20(%rsp), %r15
movq %r15, -0x18(%r15)
movq $0x0, -0x10(%r15)
movq $0x20, -0x8(%r15)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x788... | /Support/YAMLTraits.cpp |
llvm_regfree | void
llvm_regfree(llvm_regex_t *preg)
{
struct re_guts *g;
if (preg->re_magic != MAGIC1) /* oops */
return; /* nice to complain, but hard */
g = preg->re_g;
if (g == NULL || g->magic != MAGIC2) /* oops again */
return;
preg->re_magic = 0; /* mark it invalid */
g->magic = 0; /* mark it invalid */
if (... | pushq %rbx
cmpl $0xf265, (%rdi) # imm = 0xF265
jne 0x31ce187
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0x31ce187
cmpl $0xd245, (%rbx) # imm = 0xD245
jne 0x31ce187
xorl %eax, %eax
movl %eax, (%rdi)
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31ce154
callq 0x6e5920
movq 0x18(%rbx), %rdi
t... | /Support/regfree.c |
llvm::sys::DynamicLibrary::HandleSet::AddLibrary(void*, bool, bool, bool) | bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true,
bool AllowDuplicates = false) {
#ifdef _WIN32
assert((Handle == this ? IsProcess : !IsProcess) && "Bad Handle.");
#endif
assert((!AllowDuplicates || !CanClose) &&
"CanClose must be false if AllowDuplicates i... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
testl %edx, %edx
jne 0x31ce38f
testb %r8b, %r8b
je 0x31ce33b
movq 0x8(%r14), %rsi
jmp 0x31ce369
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x31ce438
movq 0x8(%r14)... | /Support/DynamicLibrary.cpp |
llvm_blake3_compress_xof | void blake3_compress_xof(const uint32_t cv[8],
const uint8_t block[BLAKE3_BLOCK_LEN],
uint8_t block_len, uint64_t counter, uint8_t flags,
uint8_t out[64]) {
#if defined(IS_X86)
const enum cpu_feature features = get_cpu_features();
MAYBE_UNUS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r12
callq 0x31d0308
movzbl %r13b, %edx
movzbl %bpl, %r8d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %rbx, %r9
addq $0x8, %rsp
testb $0x40, %a... | /Support/BLAKE3/blake3_dispatch.c |
llvm_blake3_hash_many | void blake3_hash_many(const uint8_t *const *inputs, size_t num_inputs,
size_t blocks, const uint32_t key[8], uint64_t counter,
bool increment_counter, uint8_t flags,
uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
#if defined(IS_X86)
const enum... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x78(%rsp), %r13
movb 0x70(%rsp), %bl
movb 0x68(%rsp), %r12b
movb 0x60(%rsp), %bpl
callq 0x31d0308
movl %eax, %ecx... | /Support/BLAKE3/blake3_dispatch.c |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseType() | Node *AbstractManglingParser<Derived, Alloc>::parseType() {
Node *Result = nullptr;
switch (look()) {
// ::= <qualified-type>
case 'r':
case 'V':
case 'K': {
unsigned AfterQuals = 0;
if (look(AfterQuals) == 'r') ++AfterQuals;
if (look(AfterQuals) == 'V') ++AfterQuals;
if (look(A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, (%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x31df1b7
movzbl (%rax), %esi
leal -0x41(%rsi), %edi
cmpl $0x39, %edi
ja 0x31df1b7
leaq 0x271213a(%rip), %r8 # 0x58f0c88
movsl... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::SaveTemplateParams::SaveTemplateParams(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::De... | SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
OldParams = std::move(Parser->TemplateParams);
OldOuterParams = std::move(Parser->OuterTemplateParams);
Parser->TemplateParams.clear();
Parser->OuterTemplateParams.clear();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
addq $0x8, %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x40(%rbx), %r14
movq %r14, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
leaq 0x58(%rbx), %rax
movq %rax, 0x40(%rbx)
movq %rax, 0x48... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [19], llvm::itanium_demangle::Node*&>(char const (&) [19], llvm... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbx
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x28, %esi
callq 0x31e05de
movq (%rbx), %rcx
movb $0x15, 0x8(%rax)
movzwl 0x9(%rax), %edx
andl $0xfffff000, %edx # imm = 0xFFFFF000
orl $0x540, %edx # imm = 0x540
movw %dx, 0x9(%rax)
leaq 0x32cbb8b(%rip), %rdx # 0x64abda8
add... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [5]>(char const (&) [5]) | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x31e05de
movq %rax, %r14
movq %rbx, %rdi
callq 0x6e5300
movb $0x8, 0x8(%r14)
movzwl 0x9(%r14), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x40(%rsp), %rbp
addq $0x330, %rdi # imm = 0x330
movl $0x40, %esi
callq 0x31e05de
movups (%r13), %xmm0
movq (%r12), %rcx
movups (%r15), %xmm1
movb (%... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::BinaryExpr, llvm::itanium_demangle::Node*&, std::basic_string_view<char, std::char_traits<c... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
addq $0x330, %rdi # imm = 0x330
movl $0x30, %esi
callq 0x31e05de
movq (%r12), %rcx
movups (%r15), %xmm0
movq (%r14), %rdx
movzwl (%rbx), %esi
movb $0x36, 0x8(%rax)
movzwl 0x9(%rax), %edi
andl... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseTemplateParamDecl(llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>*) | bool consumeIf(std::string_view S) {
if (starts_with(std::string_view(First, Last - First), S)) {
First += S.size();
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jae 0x31e427b
xorl %r12d, %r12d
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
cmpw... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseBaseUnresolvedName() | Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
if (std::isdigit(look()))
return getDerived().parseSimpleId();
if (consumeIf("dn"))
return getDerived().parseDestructorName();
consumeIf("on");
Node *Oper = getDerived().parseOperatorName(/*NameState=*/nullptr);
if (Oper == n... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x31e498a
movsbl (%rax), %esi
addl $-0x30, %esi
cmpl $0x9, %esi
ja 0x31e498a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31e48ca
cmpq $0x2, %... | /llvm/Demangle/ItaniumDemangle.h |
llvm::ms_demangle::Demangler::demangleSpecialIntrinsic(std::basic_string_view<char, std::char_traits<char>>&) | SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) {
SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName);
switch (SIK) {
case SpecialIntrinsicKind::None:
return nullptr;
case SpecialIntrinsicKind::StringLiteralSymbol:
return demangleStringLiteral(MangledName)... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq $0x3, %rax
jae 0x31e66ac
leaq 0x270ac40(%rip), %rdx # 0x58f12cb
movl $0x3, %esi
movq %r14, %rdi
callq 0x31e5fed
testb %al, %al
je 0x31e6765
movb $0x1, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %r... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleAnonymousNamespaceName(std::basic_string_view<char, std::char_traits<char>>&) | NamedIdentifierNode *
Demangler::demangleAnonymousNamespaceName(std::string_view &MangledName) {
assert(llvm::itanium_demangle::starts_with(MangledName, "?A"));
consumeFront(MangledName, "?A");
NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>();
Node->Name = "`anonymous namespace'";
size_t EndPos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x27087b9(%rip), %rdx # 0x58f1251
movl $0x2, %esi
movq %rbx, %rdi
callq 0x31e5fed
leaq 0x10(%r15), %rdi
callq 0x31e5ba0
movq %rax, %r14
movq $0x15, 0x18(%rax)
leaq 0x18bb80(%rip), %rax # 0x3374640
movq... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleUnqualifiedTypeName(std::basic_string_view<char, std::char_traits<char>>&, bool) | IdentifierNode *
Demangler::demangleUnqualifiedTypeName(std::string_view &MangledName,
bool Memorize) {
// An inner-most name can be a back-reference, because a fully-qualified name
// (e.g. Scope + Inner) can contain other fully qualified names inside of
// them (for exampl... | movq (%rsi), %rax
testq %rax, %rax
je 0x31e8d51
movq 0x8(%rsi), %rcx
movsbl (%rcx), %r8d
leal -0x30(%r8), %r9d
cmpl $0x9, %r9d
ja 0x31e8d44
movslq %r8d, %rdx
leaq -0x30(%rdx), %r8
cmpq 0xc0(%rdi), %r8
jae 0x31e8d59
incq %rcx
movq %rcx, 0x8(%rsi)
decq %rax
movq %rax, (%rsi)
movq -0x110(%rdi,%rdx,8), %rax
retq
cmpq $0x1,... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleFunctionType(std::basic_string_view<char, std::char_traits<char>>&, bool) | FunctionSignatureNode *
Demangler::demangleFunctionType(std::string_view &MangledName,
bool HasThisQuals) {
FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>();
if (HasThisQuals) {
FTy->Quals = demanglePointerExtQualifiers(MangledName);
FTy->RefQualifier = dema... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x10, %rdi
callq 0x31e980e
movq %rax, %r14
testl %ebp, %ebp
je 0x31e949f
movq %rbx, %rsi
callq 0x31e7960
movl %eax, %ebp
movb %al, 0xc(%r14)
movq (%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x31e9489
movq 0... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleCustomType(std::basic_string_view<char, std::char_traits<char>>&) | CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) {
assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
MangledName.remove_prefix(1);
CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>();
CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
if (!... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
incq 0x8(%rsi)
decq (%rsi)
addq $0x10, %rdi
callq 0x31e9a52
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x31e8d04
movq %rax, 0x10(%rbx)
movq (%r15), %rax
testq %rax, %rax
je 0x31e9573
movq 0x8(%r15), %rcx
cmpb $0x40, (%rcx)
jne 0... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demanglePrimitiveType(std::basic_string_view<char, std::char_traits<char>>&) | PrimitiveTypeNode *
Demangler::demanglePrimitiveType(std::string_view &MangledName) {
if (consumeFront(MangledName, "$$T"))
return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr);
const char F = MangledName.front();
MangledName.remove_prefix(1);
switch (F) {
case 'X':
return Arena.alloc<Primit... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19bbc7(%rip), %rdx # 0x338515c
movl $0x3, %esi
movq %r14, %rdi
callq 0x31e5fed
testb %al, %al
je 0x31e95c5
addq $0x10, %rbx
leaq 0x4(%rsp), %rsi
movl $0x14, (%rsi)
movq %rbx, %rdi
callq 0x31e9ae0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::IntegerLiteralNode* llvm::ms_demangle::ArenaAllocator::alloc<llvm::ms_demangle::IntegerLiteralNode, unsigned long&, bool&>(unsigned long&, bool&) | T *alloc(Args &&... ConstructorArgs) {
constexpr size_t Size = sizeof(T);
assert(Head && Head->Buf);
size_t P = (size_t)Head->Buf + Head->Used;
uintptr_t AlignedP =
(((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
uint8_t *PP = (uint8_t *)AlignedP;
size_t Adjustment = Aligned... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r13
movq (%r13), %rax
movq 0x8(%r13), %rcx
leaq (%rcx,%rax), %rdx
addq %rcx, %rax
addq $0x7, %rax
andq $-0x8, %rax
subq %rdx, %rcx
addq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x8(%r13)
cmpq 0x10(%r13), %rcx
jbe 0x31e9e4... | /llvm/Demangle/MicrosoftDemangle.h |
llvm::ms_demangle::Demangler::dumpBackReferences() | void Demangler::dumpBackReferences() {
std::printf("%d function parameter backreferences\n",
(int)Backrefs.FunctionParamCount);
// Create an output stream so we can render each type.
OutputBuffer OB;
for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) {
OB.setCurrentPosition(0);
Typ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x68(%rdi), %esi
leaq 0x2707358(%rip), %rdi # 0x58f1276
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x6e5880
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq $-0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
cmpq $0x0, 0x68(%rbx)
je... | /Demangle/MicrosoftDemangle.cpp |
(anonymous namespace)::Demangler::demangleConstChar() | void Demangler::demangleConstChar() {
std::string_view HexDigits;
uint64_t CodePoint = parseHexNumber(HexDigits);
if (Error || HexDigits.size() > 6) {
Error = true;
return;
}
print("'");
switch (CodePoint) {
case '\t':
print(R"(\t)");
break;
case '\r':
print(R"(\r)");
break;
c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x31eecfe
cmpb $0x0, 0x31(%rbx)
jne 0x31eebe4
movq (%rsp), %r14
cmpq $0x7, %r14
jb 0x31eebf2
movb $0x1, 0x31(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x24... | /Demangle/RustDemangle.cpp |
(anonymous namespace)::Demangler::demangleOptionalBinder() | void Demangler::demangleOptionalBinder() {
uint64_t Binder = parseOptionalBase62Number('G');
if (Error || Binder == 0)
return;
// In valid inputs each bound lifetime is referenced later. Referencing a
// lifetime requires at least one byte of input. Reject inputs that are too
// short to reference all bo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x47, %esi
callq 0x31ed6ec
testq %rax, %rax
je 0x31eeecd
cmpb $0x0, 0x31(%rbx)
jne 0x31eeecd
movq %rax, %r14
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq %rax, %r14
jae 0x31eeec9
leaq 0x2702be5(%rip), %rdx # 0x58f1a4a
movl $0x4, %esi
mov... | /Demangle/RustDemangle.cpp |
cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>::extract_single_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmCommandLineArgument<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | std::string extract_single_value(std::string const& input,
ParseMode& parseState) const
{
// parse the string to get the value
auto possible_value = cm::string_view(input).substr(this->Name.size());
if (possible_value.empty()) {
parseState = ParseMode::ValueError;
... | pushq %rbx
movq %rdx, %r8
movq 0x8(%rdx), %rax
movq 0x48(%rsi), %rdx
cmpq %rdx, %rax
jb 0x5c13c
movq %rdi, %rbx
movq (%r8), %rsi
addq %rdx, %rsi
subq %rdx, %rax
je 0x5c11a
cmpb $0x3d, (%rsi)
jne 0x5c108
incq %rsi
decq %rax
je 0x5c11a
cmpl $0x0, (%rcx)
jne 0x5c122
cmpb $0x20, (%rsi)
jne 0x5c122
incq %rsi
decq %rax
jmp 0... | /JKorbelRA[P]CMake/Source/cmCommandLineArgument.h |
(anonymous namespace)::cmTarFilesFrom(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>>>>&) | bool cmTarFilesFrom(std::string const& file, std::vector<std::string>& files)
{
if (cmSystemTools::FileIsDirectory(file)) {
std::ostringstream e;
e << "-E tar --files-from= file '" << file << "' is a directory";
cmSystemTools::Error(e.str());
return false;
}
cmsys::ifstream fin(file.c_str());
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3f5516
testb %al, %al
je 0x64277
leaq 0x1c0(%rsp), %r14
movq %r14, %rdi
callq 0x3b3d0
leaq 0x533beb(%rip), %rsi # 0x597dce
movl $0x1b, %edx
movq %r14, %rdi
callq 0x3b4d... | /JKorbelRA[P]CMake/Source/cmcmd.cxx |
(anonymous namespace)::cmQtAutoMocUicT::JobT::RunProcess(cmQtAutoGen::GenT, cmWorkerPool::ProcessResultT&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::bas... | bool cmQtAutoMocUicT::JobT::RunProcess(GenT genType,
cmWorkerPool::ProcessResultT& result,
std::vector<std::string> const& command,
std::string* infoMessage)
{
// Log command
if (this->Log().Verbose(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq 0x8(%rdi), %rax
movq (%rax), %r12
cmpl $0x0, 0x38(%r12)
je 0xc4fea
testq %r8, %r8
movq %rcx, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0xc(%rsp)
je 0xc4efc
movq (%r8), %rbx
movq 0x8(%r8), %r15
testq %r15, %r1... | /JKorbelRA[P]CMake/Source/cmQtAutoMocUic.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmProjectDirectoryListGenerator&, (anonymous namespace)::cmEnumPathSegmentsGenerator&, (anonymous namespace)::cmAppendPath... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, 0x10(%rsp)
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x9a1e8
movq 0x10(%r12), %rax
movq %rax, 0x28(%r12)
leaq 0x18(%rsp), %r13
movq %r13, %r... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
bool (anonymous namespace)::TryGeneratedPaths<cmFindPackageCommand::SearchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0&, (anonymous namespace)::cmProjectDirectoryListGenerator&, (anonymous namespace)::cmEnumPathSegmentsGenerator&, (anonymous namespace)::cmProjectDir... | bool TryGeneratedPaths(CallbackFn&& filesCollector,
const std::string& startPath, Generator&& gen,
Rest&&... tail)
{
ResetGenerator(std::forward<Generator&&>(gen));
for (auto path = gen.GetNextCandidate(startPath); !path.empty();
path = gen.GetNextCandidate(start... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, 0x10(%rsp)
leaq 0x10(%rdx), %rdi
movq 0x10(%rdx), %rsi
callq 0x9a1e8
movq 0x10(%r12), %rax
movq %rax, 0x28(%r12)
leaq 0x18(%rsp), %r13
movq %r13, %r... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
(anonymous namespace)::cmDirectoryListGenerator::TransformNameBeforeCmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | virtual std::string TransformNameBeforeCmp(std::string same) { return same; } | movq %rdi, %rax
leaq 0x10(%rdi), %rsi
movq %rsi, (%rdi)
movq (%rdx), %rdi
leaq 0x10(%rdx), %rcx
cmpq %rcx, %rdi
je 0x183ad6
movq %rdi, (%rax)
movq (%rcx), %rsi
movq %rsi, 0x10(%rax)
jmp 0x183adc
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rcx, (%rdx)
movq $0x0, 0x8(%rdx)
mo... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
(anonymous namespace)::isDirentryToIgnore(char const*) | bool isDirentryToIgnore(const char* const fname)
{
assert(fname != nullptr);
assert(fname[0] != 0);
return fname[0] == '.' &&
(fname[1] == 0 || (fname[1] == '.' && fname[2] == 0));
} | pushq %rax
testq %rdi, %rdi
je 0x184d26
movzbl (%rdi), %eax
cmpl $0x2e, %eax
je 0x184d08
testl %eax, %eax
jne 0x184d1e
leaq 0x434d6b(%rip), %rdi # 0x5b9a5b
leaq 0x43499a(%rip), %rsi # 0x5b9691
leaq 0x434d1b(%rip), %rcx # 0x5b9a19
movl $0x6e, %edx
callq 0x394c0
movzbl 0x1(%rdi), %eax
testl %eax, %eax
je 0x184d2... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
(anonymous namespace)::cmFileListGeneratorGlob::GetNextCandidate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string GetNextCandidate(const std::string& parent)
{
if (this->Files.empty()) {
// Glob the set of matching files.
std::string expr = cmStrCat(parent, this->Pattern);
cmsys::Glob g;
if (!g.FindFiles(expr)) {
return {};
}
this->Files = g.GetFiles();
this->Curr... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x1852c6
movups (%r14), %xmm0
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movq %rdx, 0x8(%rsi)
movups %xmm0, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0xec4ec
leaq 0x28(%rsp), %rdi
c... | /JKorbelRA[P]CMake/Source/cmFindPackageCommand.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [52]>(cmAlphaNum const&, cmAlphaNum const&, std::__cxx11:... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rdi, %rbx
movq 0x90(%rsp), %r13
movups (%rsi), %xmm0
movq %rsp, %r14
movups %xmm0, (%r14)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r14)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%r14)
movq %rax, 0x28... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmFindCommon::PathLabel::PathLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | PathLabel(const std::string& label)
: cmPathLabel(label)
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b7c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c4c00
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x185d9a... | /JKorbelRA[P]CMake/Source/cmFindCommon.h |
cmFindPathCommand::cmFindPathCommand(cmExecutionStatus&) | cmFindPathCommand::cmFindPathCommand(cmExecutionStatus& status)
: cmFindPathCommand("find_path", status)
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4243fa(%rip), %rsi # 0x5ad1dc
leaq 0x4243fc(%rip), %rdx # 0x5ad1e5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5b4c6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
cal... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindPathCommand::FindFrameworkHeader[abi:cxx11](cmFindBaseDebugState&) | std::string cmFindPathCommand::FindFrameworkHeader(cmFindBaseDebugState& debug)
{
for (std::string const& n : this->Names) {
for (std::string const& sp : this->SearchPaths) {
std::string fwPath = this->FindHeaderInFramework(n, sp, debug);
if (!fwPath.empty()) {
return fwPath;
}
}
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %rbx
movq 0x1f0(%rsi), %r12
movq 0x1f8(%rsi), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r12
je 0x18916a
movq %rsi, %r15
leaq 0x10(%rbx), %rbp
movq 0x128(%r15), %r13
movq 0x130(%r15), %r14
cmpq %r14, %r13
je 0... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindPathCommand::FindNormalHeader[abi:cxx11](cmFindBaseDebugState&) | std::string cmFindPathCommand::FindNormalHeader(cmFindBaseDebugState& debug)
{
std::string tryPath;
for (std::string const& n : this->Names) {
for (std::string const& sp : this->SearchPaths) {
tryPath = cmStrCat(sp, n);
if (cmSystemTools::FileExists(tryPath) &&
this->Validate(this->Include... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x1f0(%rsi), %rbx
movq %rsi, 0x8(%rsp)
movq 0x1f8(%rsi), %rax
movq %rax, 0x60(%rsp)
cmpq %rax, %rbx
je ... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindPathCommand::FindHeaderInFramework(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmFindBaseDebugState&) const | std::string cmFindPathCommand::FindHeaderInFramework(
std::string const& file, std::string const& dir,
cmFindBaseDebugState& debug) const
{
std::string fileName = file;
std::string frameWorkName;
std::string::size_type pos = fileName.find('/');
// if there is a / in the name try to find the header as a fram... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, 0x48(%rsp)
movq %rdi, %rbx
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %r14
movq... | /JKorbelRA[P]CMake/Source/cmFindPathCommand.cxx |
cmFindProgramCommand::InitialPass(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
{
this->CMakePathName = "PROGRAM";
// call cmFindBase::ParseArguments
if (!this->ParseArguments(argsIn)) {
return false;
}
this->DebugMode = this->ComputeIfDebugModeWanted(this->VariableName);
if (this->AlreadyDefined) {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %rdi
movq 0x40(%r14), %rdx
leaq 0x439a86(%rip), %rcx # 0x5c3798
movl $0x7, %r8d
xorl %esi, %esi
callq 0x3a100
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movl %eax, %ebx
testb %al, %al
je 0x189d8d
le... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindProgram[abi:cxx11]() | std::string cmFindProgramCommand::FindProgram()
{
std::string program;
if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
program = this->FindAppBundle();
}
if (program.empty() && !this->SearchAppBundleOnly) {
program = this->FindNormalProgram();
}
if (program.empty() && this->SearchAp... | pushq %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)
cmpb $0x0, 0x173(%rsi)
jne 0x189df7
cmpb $0x1, 0x174(%r14)
jne 0x189e39
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x189ef4
leaq 0x8(%rsp), %r15... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindNormalProgramNamesPerDir[abi:cxx11]() | std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
{
// Search for all names in each directory.
cmFindProgramHelper helper(this->FindCommandName, this->Makefile, this);
for (std::string const& n : this->Names) {
helper.AddName(n);
}
// Check for the names themselves if they contain a direct... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x188(%rsi), %rsi
movq 0x190(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5b7c4
movq 0x178(%r14), %rdx
leaq 0x28... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::FindNormalProgramDirsPerName[abi:cxx11]() | std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
{
// Search the entire path for each name.
cmFindProgramHelper helper(this->FindCommandName, this->Makefile, this);
for (std::string const& n : this->Names) {
// Switch to searching for this name.
helper.SetName(n);
// Check for the nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x188(%rsi), %rsi
movq 0x190(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x5b7c4
movq 0x178(%r14), %r... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramCommand::GetBundleExecutable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmFindProgramCommand::GetBundleExecutable(
std::string const& bundlePath)
{
std::string executable;
(void)bundlePath;
#if defined(__APPLE__)
// Started with an example on developer.apple.com about finding bundles
// and modified from that.
// Get a CFString of the app bundle path
// XXX - Is ... | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
retq
| /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::cmFindProgramHelper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmMakefile*, cmFindBase const*) | cmFindProgramHelper(std::string debugName, cmMakefile* makefile,
cmFindBase const* base)
: DebugSearches(std::move(debugName), base)
, Makefile(makefile)
, FindBase(base)
, PolicyCMP0109(makefile->GetPolicyStatus(cmPolicies::CMP0109))
{
#if defined(_WIN32) || defined(__CYGWIN__) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
mo... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::~cmFindProgramHelper() | cmFindProgramHelper(std::string debugName, cmMakefile* makefile,
cmFindBase const* base)
: DebugSearches(std::move(debugName), base)
, Makefile(makefile)
, FindBase(base)
, PolicyCMP0109(makefile->GetPolicyStatus(cmPolicies::CMP0109))
{
#if defined(_WIN32) || defined(__CYGWIN__) ... | pushq %rbx
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x3a4de4
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x18a757
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x18a76f
movq (%rax), %rsi
incq %rsi
callq 0x39320
leaq 0x38(%rbx), %rdi
callq 0x5b4... | /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmFindProgramHelper::FileIsValid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool FileIsValid(std::string const& file) const
{
if (!this->FileIsExecutableCMP0109(file)) {
return false;
}
#ifdef _WIN32
// Pretend the Windows "python" app installer alias does not exist.
if (cmSystemTools::LowerCase(file).find("/windowsapps/python") !=
std::string::npos) {
std... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18ac5c
testb %al, %al
je 0x18ac51
movq 0x118(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a327e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /JKorbelRA[P]CMake/Source/cmFindProgramCommand.cxx |
cmForEachCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmExecutionStatus&) | bool cmForEachCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
auto kwInIter = std::find(args.begin(), args.end(), "IN");
if (kwInIter != args.end()) {
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq 0x8(%r12), %rsi
cmpq %rsi, %rdi
je 0x18b311
leaq 0x49bea4(%rip), %rdx # 0x626f57
callq 0x66c0f
movq (%r15), %r14
cmpq 0x8(%r12), %rax
je 0x18b361
movq %rax, %r13
movl $0xc8, %edi
... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
(anonymous namespace)::TryParseInteger(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) | bool TryParseInteger(cmExecutionStatus& status, const std::string& str, int& i)
{
try {
i = std::stoi(str);
} catch (std::invalid_argument&) {
std::ostringstream e;
e << "Invalid integer: '" << str << "'";
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccurred();
return false;
} ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq (%rsi), %r13
callq 0x3b610
movq %rax, %r12
movl (%rax), %ebx
movl $0x0, (%rax)
leaq 0x30(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
call... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
(anonymous namespace)::cmForEachFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmForEachFunctionBlocker::Replay(
std::vector<cmListFileFunction> functions, cmExecutionStatus& inStatus)
{
return this->ZipLists ? this->ReplayZipLists(functions, inStatus)
: this->ReplayItems(functions, inStatus);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0xb8(%rdi), %rax
cmpb $0x1, 0xc0(%rdi)
jne 0x18c2a4
testq %rax, %rax
je 0x18c8f5
movq %r13, 0xc0(%rsp)
movq %r12, 0xb8(%rsp)
movq (%r12), %r15
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
... | /JKorbelRA[P]CMake/Source/cmForEachCommand.cxx |
cmFunctionBlocker::~cmFunctionBlocker() | virtual ~cmFunctionBlocker() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x5eaddf(%rip), %rax # 0x777b30
movq %rax, (%rdi)
addq $0x78, %rdi
callq 0xb2484
cmpb $0x1, 0x70(%rbx)
jne 0x18cd7f
movb $0x0, 0x70(%rbx)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x18cd7f
movq (%rax), %rsi
incq %rsi
callq 0x39320
movq 0x28(%rbx), %rdi
leaq 0x38(%... | /JKorbelRA[P]CMake/Source/cmFunctionBlocker.h |
ChompStrlen(char const*) | static unsigned int ChompStrlen(const char* line)
{
if (line == nullptr) {
return 0;
}
unsigned int length = static_cast<unsigned int>(strlen(line));
if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
length--;
}
if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
length... | testq %rdi, %rdi
je 0x1928fd
pushq %rbx
movq %rdi, %rbx
callq 0x39d50
leal -0x1(%rax), %ecx
movzbl (%rbx,%rcx), %edx
cmpl $0xd, %edx
je 0x1928e6
cmpl $0xa, %edx
jne 0x1928e8
movl %ecx, %eax
leal -0x1(%rax), %ecx
movzbl (%rbx,%rcx), %edx
cmpl $0xd, %edx
popq %rbx
je 0x1928fa
cmpl $0xa, %edx
jne 0x1928fc
movl %ecx, %eax
... | /JKorbelRA[P]CMake/Source/cmHexFileConverter.cxx |
cmIfFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmIfFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
cmExecutionStatus& inStatus)
{
cmMakefile& mf = inStatus.GetMakefile();
// execute the functions for the true parts of the if statement
int scopeDepth = 0;
for (cmListFileFunction const& func : functions... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdx, 0x60(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rsi), %r12
movq 0x8(%rsi), %rax
movq %rax, 0x118(%rsp)
cmpq %rax, %r12
je 0x193613
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rb... | /JKorbelRA[P]CMake/Source/cmIfCommand.cxx |
cmIfCommand(std::vector<cmListFileArgument, std::allocator<cmListFileArgument>> const&, cmExecutionStatus&) | bool cmIfCommand(std::vector<cmListFileArgument> const& args,
cmExecutionStatus& inStatus)
{
cmMakefile& makefile = inStatus.GetMakefile();
std::string errorString;
std::vector<cmExpandedCommandArgument> expandedArguments;
makefile.ExpandArguments(args, expandedArguments);
MessageType statu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x80(%rsp), %rdx
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq %rbx, %rdi
mo... | /JKorbelRA[P]CMake/Source/cmIfCommand.cxx |
NormalizeInclude(cmMakefile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | static void NormalizeInclude(cmMakefile& mf, std::string& inc)
{
std::string::size_type b = inc.find_first_not_of(" \r");
std::string::size_type e = inc.find_last_not_of(" \r");
if ((b != std::string::npos) && (e != std::string::npos)) {
inc.assign(inc, b, 1 + e - b); // copy the remaining substring
} else ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x425be5(%rip), %r12 # 0x5baf64
movl $0x2, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3ad30
movq %rax, %r15
movl $0x2, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x39630
cmpq $-0x1, %r... | /JKorbelRA[P]CMake/Source/cmIncludeDirectoryCommand.cxx |
cmIncludeGuardCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmExecutionStatus&) | bool cmIncludeGuardCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() > 1) {
status.SetError(
"given an invalid number of arguments. The command takes at "
"most 1 argument.");
return false;
}
IncludeGuardScope scope = VARIABL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq %r14, %rcx
cmpq $0x21, %rcx
jb 0x1955cf
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x425a1d(%rip), %rsi # 0x5bafac
leaq 0x425a61(%rip), %rdx # 0x5ba... | /JKorbelRA[P]CMake/Source/cmIncludeGuardCommand.cxx |
(anonymous namespace)::Helper::GetRuntimeDestination[abi:cxx11](cmInstallCommandArguments const*) const | std::string Helper::GetRuntimeDestination(
const cmInstallCommandArguments* args) const
{
return this->GetDestination(args, "CMAKE_INSTALL_BINDIR", "bin");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4196a1(%rip), %rsi # 0x5bbeac
leaq 0x4196ae(%rip), %rdx # 0x5bbec0
leaq 0x20(%rsp), %rdi
callq 0x5b4c6
leaq 0x10(%rsp), %r13
movq %r13, -0x10(... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::GetLibraryDestination[abi:cxx11](cmInstallCommandArguments const*) const | std::string Helper::GetLibraryDestination(
const cmInstallCommandArguments* args) const
{
return this->GetDestination(args, "CMAKE_INSTALL_LIBDIR", "lib");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4195a6(%rip), %rsi # 0x5bbe97
leaq 0x4195b3(%rip), %rdx # 0x5bbeab
leaq 0x20(%rsp), %rdi
callq 0x5b4c6
leaq 0x10(%rsp), %r13
movq %r13, -0x10(... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::CheckCMP0006(bool&) const | bool Helper::CheckCMP0006(bool& failure) const
{
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0006)) {
case cmPolicies::WARN:
this->Makefile->IssueMessage(
MessageType::AUTHOR_WARNING,
cmPolicies::GetPolicyWarning(cmPolicies::CMP0006));
CM_FALLTHROUGH;
case cmPolicies::OL... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x9ccf8
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1a2a28
movb $0x1, %bl
testl %eax, %eax
je 0x1a2a6c
cmpl $0x1, %eax
jne 0x1a2a6a
movq 0x8(%r14), %r14
movq %rsp, %r15
movq %r15, ... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
bool (anonymous namespace)::AddBundleExecutable<cmInstallTargetGenerator*>((anonymous namespace)::Helper&, cmInstallRuntimeDependencySet*, cmInstallTargetGenerator*&&) | bool AddBundleExecutable(Helper& helper,
cmInstallRuntimeDependencySet* runtimeDependencySet,
T&& bundleExecutable)
{
if (!runtimeDependencySet->AddBundleExecutable(bundleExecutable)) {
helper.SetError(
"A runtime dependency set may only have one bundle exec... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1a6dba
movl %eax, %ebx
testb %al, %al
jne 0x1a2b0a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4193f1(%rip), %rsi # 0x5bbec1
leaq 0x419427(%rip), %rdx # 0x5bbefe
leaq 0x8(%rsp), %r15
movq %... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
(anonymous namespace)::Helper::MakeFilesFullPath(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&, std::vector<std::__cxx11::basic_string<char, std::char_traits<... | bool Helper::MakeFilesFullPath(const char* modeName,
const std::vector<std::string>& relFiles,
std::vector<std::string>& absFiles)
{
return this->MakeFilesFullPath(
modeName, this->Makefile->GetCurrentSourceDirectory(), relFiles, absFiles);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x8(%rdi), %rdi
callq 0x9f030
movq %rax, 0x30(%rsp)
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movb $0x1, %al
cmpq %rbx, %r14
je 0x1a2cad
movq %rsp, %r13
leaq 0... | /JKorbelRA[P]CMake/Source/cmInstallCommand.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.