name string | code string | asm string | file string |
|---|---|---|---|
llvm::SmallVectorTemplateBase<std::tuple<llvm::BasicBlock const*, llvm::SuccIterator<llvm::Instruction const, llvm::BasicBlock const>, llvm::SuccIterator<llvm::Instruction const, llvm::BasicBlock const>>, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r8
movl $0x28, %ecx
movq %r14, %rsi
callq 0x1cba3de
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x1abb6c7
movq (%rbx), %rax
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rcx
xorl %edx, %... | /llvm/ADT/SmallVector.h |
llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*>>::po_iterator(llvm::BasicBlock const*) | po_iterator(NodeRef BB) {
this->insertEdge(std::optional<NodeRef>(), BB);
VisitStack.emplace_back(BB, GT::child_begin(BB), GT::child_end(BB));
traverseChild();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
leaq 0x60(%rdi), %r14
leaq 0x70(%rdi), %rax
movq %rax, 0x60(%rdi)
movabsq $0x800000000, %rax # imm = 0x8000000... | /llvm/ADT/PostOrderIterator.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
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, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*>>::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 0x1abdb0e
decl %eax
je 0x1abdb12
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x1abdb17
xorl %ebp, %ebp
jmp 0x1abdb2d
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
llvm::df_iterator<llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>> const*, llvm::df_iterator_default_set<llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>> const*, 8u>, false, llvm::GraphTraits<llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>> const*>>::begin(llvm::GenericCycle<llvm::Gener... | static df_iterator begin(const GraphT &G) {
return df_iterator(GT::getEntryNode(G));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movq $0x0, 0x70(%rdi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %... | /llvm/ADT/DepthFirstIterator.h |
llvm::lto::LTO::addThinLTO(llvm::BitcodeModule, llvm::ArrayRef<llvm::lto::InputFile::Symbol>, llvm::lto::SymbolResolution const*&, llvm::lto::SymbolResolution const*) | Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
const SymbolResolution *&ResI,
const SymbolResolution *ResE) {
const SymbolResolution *ResITmp = ResI;
for (const InputFile::Symbol &Sym : Syms) {
assert(ResITmp != ResE);
SymbolResolution R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, 0x18(%rsp)
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
je 0x1ac40e7
movq 0x18(%rsp), %rax
movq (%rax), %r12
movq (%rsp), %rax
addq $0x848, %rax # imm = 0x848
movq %ra... | /LTO/LTO.cpp |
llvm::Error llvm::make_error<llvm::StringError, char const (&) [53], std::error_code>(char const (&) [53], std::error_code&&) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x40, %edi
callq 0x751940
movq %rax, %r14
movw $0x101, 0x20(%rsp) # imm = 0x101
cmpb $0x0, (%r12)
je 0x1ac5677
movq %r12, (%rsp)
movb $0x3, %al
jmp 0x1ac5679
movb $0x1, %al
movq %rsp, %rsi
movb %al, 0... | /llvm/Support/Error.h |
llvm::Error llvm::make_error<llvm::StringError, char const (&) [66], std::error_code>(char const (&) [66], std::error_code&&) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x40, %edi
callq 0x751940
movq %rax, %r14
movw $0x101, 0x20(%rsp) # imm = 0x101
cmpb $0x0, (%r12)
je 0x1ac5922
movq %r12, (%rsp)
movb $0x3, %al
jmp 0x1ac5924
movb $0x1, %al
movq %rsp, %rsi
movb %al, 0... | /llvm/Support/Error.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void>>, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::DenseSet<llvm::ValueInfo, llvm::DenseMapInfo<llvm::ValueInfo, void>>>>, llvm::StringRef, llvm::... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %r15d
testl %r15d, %r15d
je 0x1ac8a8a
movq %rsi, %r14
movq (%rdi), %r13
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1cc3dfe
movl %eax, %ebp
decl %r15d
movl %r15d, 0x14(%rsp)
andl %r15d, %ebp
movl $0x1,... | /llvm/ADT/DenseMap.h |
llvm::MCAsmInfo::MCAsmInfo() | MCAsmInfo::MCAsmInfo() {
SeparatorString = ";";
CommentString = "#";
LabelSuffix = ":";
PrivateGlobalPrefix = "L";
PrivateLabelPrefix = PrivateGlobalPrefix;
LinkerPrivateGlobalPrefix = "";
InlineAsmStart = "APP";
InlineAsmEnd = "NO_APP";
Code16Directive = ".code16";
Code32Directive = ".code32";
Co... | leaq 0x3d38e37(%rip), %rax # 0x5810d90
addq $0x10, %rax
movq %rax, (%rdi)
movabsq $0x400000004, %rax # imm = 0x400000004
movq %rax, 0x8(%rdi)
movb $0x1, %cl
movb %cl, 0x10(%rdi)
xorl %eax, %eax
movl %eax, 0x11(%rdi)
movl %eax, 0x14(%rdi)
movabsq $0x100000004, %rdx # imm = 0x100000004
movq %rdx, 0x18(%rdi)
m... | /MC/MCAsmInfo.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCCVFunctionInfo::LineInfo>>, unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<u... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1add764
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movl (%rdi,%rbx), %ebx
cmpl %ebx, %esi
jne 0x1add72f
movq... | /llvm/ADT/DenseMap.h |
llvm::StringMap<llvm::MCSectionMachO*, llvm::MallocAllocator>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x1adf047
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1adf047
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x1adf03f
testq %rdi, %rdi
je 0x1adf03f
movq (%rdi), %rsi
addq $0x11, %rsi
movl $0x8, %edx
callq 0x1cac6... | /llvm/ADT/StringMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::MCLabel*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCLabel*>>, unsigned int, llvm::MCLabel*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCLabel*>>::clear() | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1adfccf
cmpl $0x0, 0xc(%rdi)
je 0x1adfe07
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1ae4b9e
testq %rcx, %rcx
je 0x1adfdff
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::StringMap<llvm::MCSectionELF*, llvm::MallocAllocator>::clear() | bool empty() const { return NumItems == 0; } | cmpl $0x0, 0xc(%rdi)
je 0x1adfecf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
testq %r14, %r14
je 0x1adfebc
xorl %r15d, %r15d
movq (%rbx), %r12
movq (%r12,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x1adfeac
testq %rdi, %rdi
je 0x1adfeac
movq (%rdi), %rsi
addq $0x11, %rsi
movl $0... | /llvm/ADT/StringMap.h |
llvm::MCContext::getOrCreateSymbol(llvm::Twine const&) | MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
SmallString<128> NameSV;
StringRef NameRef = Name.toStringRef(NameSV);
assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
MCSymbolTableEntry &Entry = getSymbolTableEntry(NameRef);
if (!Entry.second.Symbol) {
bool IsRenamable = Nam... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x80, -0x8(%r13)
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x8ccafa
movq %rax, %r15
movq %rdx, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x... | /MC/MCContext.cpp |
llvm::MCContext::recordELFMergeableSectionInfo(llvm::StringRef, unsigned int, unsigned int, unsigned int) | void MCContext::recordELFMergeableSectionInfo(StringRef SectionName,
unsigned Flags, unsigned UniqueID,
unsigned EntrySize) {
bool IsMergeable = Flags & ELF::SHF_MERGE;
if (UniqueID == GenericSectionID) {
ELFSeenGenericM... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $-0x1, %r8d
je 0x1ae1da9
movl %r15d, %eax
shrb $0x4, %al
jmp 0x1ae1dc4
leaq 0x968(%rbx), %rsi
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
leaq 0x30(%rsp), ... | /MC/MCContext.cpp |
llvm::MCSymbolCOFF* llvm::MCContext::getOrCreateSectionSymbol<llvm::MCSymbolCOFF>(llvm::StringRef) | Symbol *MCContext::getOrCreateSectionSymbol(StringRef Section) {
Symbol *R;
auto &SymEntry = getSymbolTableEntry(Section);
MCSymbol *Sym = SymEntry.second.Symbol;
// A section symbol can not redefine regular symbols. There may be multiple
// sections with the same name, in which case the first such section wi... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
callq 0x1ae00d8
movq %rax, %r14
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x1ae2401
movq %rbx, %rdi
movl $0x1, %esi
callq 0x817c20
testq %rax, %rax
je 0x1ae23ef
movq %rbx, %rdi
callq 0x88840a
testb %al, %al
je 0x1ae23d0
movq %rbx, %rdi
movl $0x1, %esi
cal... | /MC/MCContext.cpp |
llvm::MCContext::setGenDwarfRootFile(llvm::StringRef, llvm::StringRef) | void MCContext::setGenDwarfRootFile(StringRef InputFileName, StringRef Buffer) {
// MCDwarf needs the root file as well as the compilation directory.
// If we find a '.file 0' directive that will supersede these values.
std::optional<MD5::MD5Result> Cksum;
if (getDwarfVersion() >= 5) {
MD5 Hash;
MD5::MD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpw $0x5, 0x758(%rdi)
jb 0x1ae3463
movq %r8, %r12
movq %rcx, %r13
leaq 0xf0(%rsp), %rbp
movq %rbp, %rdi
callq 0x1cae520
movq %rbp, %rdi
movq %r13, %rsi
movq %r12,... | /MC/MCContext.cpp |
llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::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 %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0x7c6c14
testl %ebp, %ebp
je 0x1ae504f
decl %ebp
je 0x1ae5053
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1ae5058
xorl %ebp, %ebp
jmp 0x1ae506e
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>>, std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1ae571c
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl 0x4(%rsi), %eax
leal (%r8,%r8,8), %r9d
leal (%r8,%r9,4), %r9d
leal (%rax,%rax,8), %r10d
leal (%rax,%r10,4), %eax
shlq $0x20, %r9
orq %r9, %rax
movabsq $-0x40a7b892e31b1a47, %r10 # imm = 0xBF5847... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>* llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*... | 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, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x1ae5779
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>>, std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::... | 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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1ae59ba
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx... | /llvm/ADT/DenseMap.h |
llvm::MCContext::WasmSectionKey::operator<(llvm::MCContext::WasmSectionKey const&) const | bool operator<(const WasmSectionKey &Other) const {
if (SectionName != Other.SectionName)
return SectionName < Other.SectionName;
if (GroupName != Other.GroupName)
return GroupName < Other.GroupName;
return UniqueID < Other.UniqueID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x1ae6720
testq %rdx, %rdx
je 0x1ae672d
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x751d10
testl %eax, %eax
je 0x1ae672d
movq %r14, %rdi
movq %rbx, %rsi
callq ... | /llvm/MC/MCContext.h |
llvm::MCDwarfLineStr::getFinalizedData() | SmallString<0> MCDwarfLineStr::getFinalizedData() {
// Emit the strings without perturbing the offsets we used.
if (!LineStrings.isFinalized())
LineStrings.finalizeInOrder();
SmallString<0> Data;
Data.resize(LineStrings.getSize());
LineStrings.write((uint8_t *)Data.data());
return Data;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rsi), %r14
cmpb $0x0, 0x95(%rsi)
jne 0x1ae7b1a
movq %r14, %rdi
callq 0x1b17de8
leaq 0x18(%rbx), %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x88(%r15), %rsi
movq %rbx, %rdi
callq 0x1a8c0ec
movq (%rbx), %rsi
movq %r14,... | /MC/MCDwarf.cpp |
llvm::MCDwarfLineTableHeader::emitV5FileDirTables(llvm::MCStreamer*, std::optional<llvm::MCDwarfLineStr>&) const | void MCDwarfLineTableHeader::emitV5FileDirTables(
MCStreamer *MCOS, std::optional<MCDwarfLineStr> &LineStr) const {
// The directory format, which is just a list of the directory paths. In a
// non-split object, these are references to .debug_line_str; in a split
// object, they are inline strings.
MCOS->e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movl $0x1, %esi
movq %r14, %rdi
movl $0x1, %edx
callq *0x208(%rax)
movl $0x1, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1b04ef4
cmpb $0x0, 0xa... | /MC/MCDwarf.cpp |
llvm::MapVector<llvm::MCSection*, std::vector<llvm::MCDwarfLineEntry, std::allocator<llvm::MCDwarfLineEntry>>, llvm::DenseMap<llvm::MCSection*, unsigned int, llvm::DenseMapInfo<llvm::MCSection*, void>, llvm::detail::DenseMapPair<llvm::MCSection*, unsigned int>>, llvm::SmallVector<std::pair<llvm::MCSection*, std::vector... | ValueT &operator[](const KeyT &Key) {
std::pair<KeyT, typename MapType::mapped_type> Pair = std::make_pair(Key, 0);
std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
auto &I = Result.first->second;
if (Result.second) {
Vector.push_back(std::make_pair(Key, ValueT()));
I =... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x30(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ad71e0
movq (%r15), %r12
cmpb $0x1, 0x10(%r15)
jne 0x1aea96f
leaq 0x1... | /llvm/ADT/MapVector.h |
llvm::SmallVectorImpl<llvm::MCDwarfFile>::truncate(unsigned long) | void truncate(size_type N) {
assert(this->size() >= N && "Cannot increase size with truncate");
this->destroy_range(this->begin() + N, this->end());
this->set_size(N);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x1aeb607
movq (%r14), %rcx
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax), %r15
addq $-0x40, %r15
movq %rbx, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %r12
subq %rax, %r12
movq -0x10... | /llvm/ADT/SmallVector.h |
llvm::MCELFStreamer::emitBundleAlignMode(llvm::Align) | inline bool operator>(Align Lhs, uint64_t Rhs) {
ALIGN_CHECK_ISPOSITIVE(Rhs);
return Lhs.value() > Rhs;
} | testb %sil, %sil
je 0x1aef5c8
movzbl %sil, %ecx
movq 0x120(%rdi), %rax
movl 0x170(%rax), %edx
testl %edx, %edx
sete %sil
movl %edx, %edi
movl $0x1, %edx
movl $0x1, %r8d
shlq %cl, %r8
cmpq %rdi, %r8
sete %dil
orb %sil, %dil
cmpb $0x1, %dil
jne 0x1aef5c8
shlq %cl, %rdx
movl %edx, 0x170(%rax)
retq
pushq %rax
leaq 0x33cf71... | /llvm/Support/Alignment.h |
llvm::MCELFStreamer::setAttributeItem(unsigned int, llvm::StringRef, bool) | void MCELFStreamer::setAttributeItem(unsigned Attribute, StringRef Value,
bool OverwriteExisting) {
// Look for existing attribute item
if (AttributeItem *Item = getAttributeItem(Attribute)) {
if (!OverwriteExisting)
return;
Item->Type = AttributeItem::TextAttribut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1b0(%rdi), %ecx
testq %rcx, %rcx
je 0x1aef9ec
movq 0x1a8(%rbx), %rax
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl %ebp, 0x4(%rax)
cmoveq %rax, %r13
je 0x1aef9ef
addq... | /MC/MCELFStreamer.cpp |
llvm::MCObjectWriter::CGProfileEntry const* llvm::SmallVectorTemplateCommon<llvm::MCObjectWriter::CGProfileEntry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::MCObjectWriter::CGProfileEntry, true>>(llvm::SmallVectorTemplateBase<llvm::MCObjectWriter::CGProfileEntry, true>*, llvm::MCObjectW... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x1aefe5c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpq %rbx, %rax
setbe %sil... | /llvm/ADT/SmallVector.h |
llvm::MCSymbolRefExpr::create(llvm::StringRef, llvm::MCSymbolRefExpr::VariantKind, llvm::MCContext&) | const MCSymbolRefExpr *MCSymbolRefExpr::create(StringRef Name, VariantKind Kind,
MCContext &Ctx) {
return create(Ctx.getOrCreateSymbol(Name), Kind, Ctx);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsp, %rax
movw $0x105, 0x20(%rax) # imm = 0x105
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rcx, %rdi
movq %rax, %rsi
callq 0x1adffe4
movq %rax, %r14
leaq 0xc0(%rbx), %rdi
movl $0x18, %esi
movl $0x3, %edx
callq 0x8c... | /MC/MCExpr.cpp |
llvm::MCObjectStreamer::emitTPRel32Value(llvm::MCExpr const*) | void MCObjectStreamer::emitTPRel32Value(const MCExpr *Value) {
MCDataFragment *DF = getOrCreateDataFragment();
DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
Value, FK_TPRel_4));
DF->getContents().resize(DF->getContents().size() + 4, 0);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
xorl %esi, %esi
callq 0x1afa77c
movq %rax, %rbx
leaq 0x60(%rax), %rdi
movl 0x30(%rax), %eax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, (%rsi)
movl %eax, 0x8(%rsi)
movl $0x10, 0xc(%rsi)
movl $0x1, %edx
callq 0x154e8be
mo... | /MC/MCObjectStreamer.cpp |
llvm::MCPseudoProbeDecoder::printProbeForAddress(llvm::raw_ostream&, unsigned long) | void MCPseudoProbeDecoder::printProbeForAddress(raw_ostream &OS,
uint64_t Address) {
auto It = Address2ProbesMap.find(Address);
if (It != Address2ProbesMap.end()) {
for (auto &Probe : It->second) {
OS << " [Probe]:\t";
Probe.print(OS, GUID2FuncDescMap,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rsi
leaq 0x40(%rdi), %rax
movq %rax, %rcx
testq %rsi, %rsi
je 0x1afeeac
movq %rax, %rcx
xorl %edi, %edi
cmpq %rdx, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rcx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rs... | /MC/MCPseudoProbe.cpp |
void llvm::cl::apply<llvm::cl::opt<llvm::EmitDwarfUnwindType, false, llvm::cl::parser<llvm::EmitDwarfUnwindType>>, char [18], llvm::cl::desc, llvm::cl::initializer<llvm::EmitDwarfUnwindType>, llvm::cl::ValuesClass>(llvm::cl::opt<llvm::EmitDwarfUnwindType, false, llvm::cl::parser<llvm::EmitDwarfUnwindType>>*, char const... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7512e0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movq (%r14), %rax
movl (%rax), %ecx
movl %ecx... | /llvm/Support/CommandLine.h |
llvm::MapVector<llvm::MCSymbol*, long, llvm::DenseMap<llvm::MCSymbol*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, unsigned int>>, llvm::SmallVector<std::pair<llvm::MCSymbol*, long>, 0u>>::operator[](llvm::MCSymbol* const&) | ValueT &operator[](const KeyT &Key) {
std::pair<KeyT, typename MapType::mapped_type> Pair = std::make_pair(Key, 0);
std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
auto &I = Result.first->second;
if (Result.second) {
Vector.push_back(std::make_pair(Key, ValueT()));
I =... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x10(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x153af2e
movq (%r15), %r12
cmpb $0x1, 0x10(%r15)
jne 0x1b0f660
leaq 0x1... | /llvm/ADT/MapVector.h |
llvm::SmallVectorImpl<std::pair<llvm::MCSymbol*, llvm::WinEH::FrameInfo::Epilog>>::erase(std::pair<llvm::MCSymbol*, llvm::WinEH::FrameInfo::Epilog> const*) | iterator erase(const_iterator CI) {
// Just cast away constness because this is a non-const member function.
iterator I = const_cast<iterator>(CI);
assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
iterator N = I;
// Shift all elts down one.
std::move(I+1, this->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%rdi), %rax
movq %rsi, %r14
subq %rsi, %rax
addq $-0x30, %rax
testq %rax, %rax
jle 0x1b10323
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r15
... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, unsigned long, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, unsigned long>>, llvm::MCSection const*, unsigned long, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSecti... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1b12651
cmpl $0x0, 0xc(%rdi)
je 0x1b1272a
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1b16028
testq %rcx, %rcx
je 0x1b12722
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, unsigned char, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, unsigned char>>, llvm::MCSection const*, unsigned char, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSecti... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1b166d0
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1b166c6
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1b16762
movq (%rbx), %rcx
movq %rcx, (%rax)
movb $... | /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 0x1b1ab23
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::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... | 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 0x1b1b7bd
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::wasm::WasmSignature, unsigned int, llvm::DenseMapInfo<llvm::wasm::WasmSignature, void>, llvm::detail::DenseMapPair<llvm::wasm::WasmSignature, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::wasm::WasmSignature, unsigned int, llvm::DenseMapInfo<llvm::wasm::Wasm... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x1b209b0
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1b2092a
xorl %ecx, %ecx
jmp 0x1b2093d
movq %r... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::WasmObjectWriter::startSection((anonymous namespace)::SectionBookkeeping&, unsigned int) | void WasmObjectWriter::startSection(SectionBookkeeping &Section,
unsigned SectionId) {
LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
W->OS << char(SectionId);
Section.SizeOffset = W->OS.tell();
// The section size. We don't know the size yet, so reserve enough... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rax
movq (%rax), %rdi
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x1b22358
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movb %dl, (%rax)
jmp 0x1b22360
movzbl %dl, %esi
callq 0x1cea3ee
movq 0x68(%r14), %rax
movq (... | /MC/WasmObjectWriter.cpp |
llvm::WinCOFFObjectWriter::WinCOFFObjectWriter(std::unique_ptr<llvm::MCWinCOFFObjectTargetWriter, std::default_delete<llvm::MCWinCOFFObjectTargetWriter>>, llvm::raw_pwrite_stream&, llvm::raw_pwrite_stream&) | WinCOFFObjectWriter::WinCOFFObjectWriter(
std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS,
raw_pwrite_stream &DwoOS)
: TargetObjectWriter(std::move(MOTW)),
ObjWriter(std::make_unique<WinCOFFWriter>(*this, OS,
WinCOFFWriter::NonDw... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %r13, 0x20(%rdi)
movb %r13b, 0x28(%rdi)
leaq 0x68(%rdi), %rax
xorps %xmm0, %xmm0
movu... | /MC/WinCOFFObjectWriter.cpp |
llvm::detail::DenseMapPair<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*>>, llv... | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x1b27a57
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x1b27a59
incl 0... | /llvm/ADT/DenseMap.h |
bool 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<... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1b27e87
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r14d
shlq $0x4, %r14
leaq (%rdi,%r14), %r11
movq... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbolELF const*, llvm::MCSymbolELF const*, llvm::DenseMapInfo<llvm::MCSymbolELF const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbolELF const*, llvm::MCSymbolELF const*>>, llvm::MCSymbolELF const*, llvm::MCSymbolELF const*, llvm::DenseMapInfo<llvm::MCSymbolELF const*,... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1b32641
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::MCAsmStreamer::emitExplicitComments() | void MCAsmStreamer::emitExplicitComments() {
StringRef Comments = ExplicitCommentToEmit;
if (!Comments.empty())
OS << Comments;
ExplicitCommentToEmit.clear();
} | pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdx
testq %rdx, %rdx
je 0x1b34365
movq 0x128(%rbx), %rdi
movq 0x148(%rbx), %rsi
callq 0x7c4562
movq $0x0, 0x150(%rbx)
popq %rbx
retq
| /MC/MCAsmStreamer.cpp |
(anonymous namespace)::MCAsmStreamer::emitLabel(llvm::MCSymbol*, llvm::SMLoc) | void MCAsmStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
MCStreamer::emitLabel(Symbol, Loc);
Symbol->print(OS, MAI);
OS << MAI->getLabelSuffix();
EmitEOL();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1b058fa
movq 0x128(%r14), %rsi
movq 0x130(%r14), %rdx
movq %rbx, %rdi
callq 0x1b09d68
movq 0x128(%r14), %rdi
movq 0x130(%r14), %rax
movq 0x48(%rax), %rsi
callq 0x7c4532
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b399f8
nop
| /MC/MCAsmStreamer.cpp |
(anonymous namespace)::MCAsmStreamer::emitWeakReference(llvm::MCSymbol*, llvm::MCSymbol const*) | void MCAsmStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
OS << ".weakref ";
Alias->print(OS, MAI);
OS << ", ";
Symbol->print(OS, MAI);
EmitEOL();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
leaq 0x338f0ab(%rip), %rsi # 0x4ec3ab9
movl $0x9, %edx
callq 0x7c4562
movq 0x128(%rbx), %rsi
movq 0x130(%rbx), %rdx
movq %r15, %rdi
callq 0x1b09d68
movq 0x128(%rbx), %rdi
leaq 0x23f2ca1(%rip), %rsi # 0x3f276dd
mo... | /MC/MCAsmStreamer.cpp |
(anonymous namespace)::MCAsmStreamer::emitLocalCommonSymbol(llvm::MCSymbol*, unsigned long, llvm::Align) | void MCAsmStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
Align ByteAlign) {
OS << "\t.lcomm\t";
Symbol->print(OS, MAI);
OS << ',' << Size;
if (ByteAlign > 1) {
switch (MAI->getLCOMMDirectiveAlignmentType()) {
case LCOMM::NoAlignment:
llv... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
leaq 0x338e018(%rip), %rsi # 0x4ec3c50
movl $0x8, %edx
callq 0x7c4562
movq 0x128(%rbx), %rsi
movq 0x130(%rbx), %rdx
movq %r15, %rdi
callq 0x1b09d68
movq 0x128(%rbx), %rdi
movq ... | /MC/MCAsmStreamer.cpp |
llvm::MCLOHDirective::getEmitSize(llvm::MCAssembler const&, llvm::MachObjectWriter const&) const | uint64_t MCLOHDirective::getEmitSize(const MCAssembler &Asm,
const MachObjectWriter &ObjWriter) const {
class raw_counting_ostream : public raw_ostream {
uint64_t Count = 0;
void write_impl(const char *, size_t size) override { Count += size; }
uint64_t current_pos()... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsp, %rbx
movl $0x0, 0x8(%rbx)
movb $0x0, 0x28(%rbx)
movl $0x1, 0x2c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
leaq 0x3cda9bb(%rip), %rdx # 0x5815700
movq %rdx, (%rbx)
movq %rax, 0x30(%rbx)
movq %rbx, %rdx
callq... | /MC/MCLinkerOptimizationHint.cpp |
llvm::MCSPIRVStreamer::MCSPIRVStreamer(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>>) | MCSPIRVStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
std::unique_ptr<MCObjectWriter> OW,
std::unique_ptr<MCCodeEmitter> Emitter)
: MCObjectStreamer(Context, std::move(TAB), std::move(OW),
std::move(Emitter)) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
xorl %edi, %edi
movq %rdi, (%rdx)
movq (%rcx), %rdx
movq %rsp, %r9
movq %rdx, (%r9)
movq %rdi, (%rcx)
movq (%r8), %rcx
leaq 0x10(%rsp), %r14
movq %rcx, (%r14)
movq %rdi, (%r8)
movq %rbx, %rdi
movq %rax, %rdx
... | /llvm/MC/MCSPIRVStreamer.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::object::getSecIndexForError<llvm::object::ELFType<(llvm::endianness)1, false>>(llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)1, false>> const&, llvm::object::ELFType<(llvm::endianness)1, false>::Shdr const&) | std::string getSecIndexForError(const ELFFile<ELFT> &Obj,
const typename ELFT::Shdr &Sec) {
auto TableOrErr = Obj.sections();
if (TableOrErr)
return "[index " + std::to_string(&Sec - &TableOrErr->front()) + "]";
// To make this helper be more convenient for error reporting purp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b401d2
testb $0x1, 0x10(%r14)
je 0x1b3f95e
movq (%rsp), %rax
movq $0x0, (%rsp)
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0... | /llvm/Object/ELF.h |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getVersionDefinitions(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, true>> const&) const | Expected<std::vector<VerDef>>
ELFFile<ELFT>::getVersionDefinitions(const Elf_Shdr &Sec) const {
Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Sec);
if (!StrTabOrErr)
return StrTabOrErr.takeError();
Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
if (!ContentsOrErr)
return creat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x170(%rsp), %r14
movq %r14, %rdi
callq 0x1b58f68
testb $0x1, 0x10(%r14)
je 0x1b58324
movq 0x170(%rsp), %rax
movq $0x0, 0x170(%rsp)
orb $0x1, 0x18(%r12)
movq ... | /llvm/Object/ELF.h |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getSHNDXTable(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, true>> const&, llvm::ArrayRef<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, true>>>) const | Expected<ArrayRef<typename ELFT::Word>>
ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section,
Elf_Shdr_Range Sections) const {
assert(Section.sh_type == ELF::SHT_SYMTAB_SHNDX);
auto VOrErr = getSectionContentsAsArray<Elf_Word>(Section);
if (!VOrErr)
return VOrErr.takeError();
Ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x1b5bc72
testb $0x1, 0x10(%rbp)
je 0x1b5ba87
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
orb $0x1, 0x10(%rbx)
movq %... | /llvm/Object/ELF.h |
llvm::Expected<llvm::ArrayRef<llvm::object::Elf_Dyn_Impl<llvm::object::ELFType<(llvm::endianness)1, true>>>> llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getSectionContentsAsArray<llvm::object::Elf_Dyn_Impl<llvm::object::ELFType<(llvm::endianness)1, true>>>(llvm::object::Elf_Shdr_Impl<llvm::... | Expected<ArrayRef<T>>
ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr &Sec) const {
if (Sec.sh_entsize != sizeof(T) && sizeof(T) != 1)
return createError("section " + getSecIndexForError(*this, Sec) +
" has invalid sh_entsize: expected " + Twine(sizeof(T)) +
"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x10, 0x38(%rdx)
jne 0x1b5efa1
movq 0x18(%r14), %rax
movq %rax, 0xf0(%rsp)
movq 0x20(%r14), %rcx
movq %rcx, (%rsp)
testb $0xf, %cl
je 0x1b5eff5
leaq 0x58(%rs... | /llvm/Object/ELF.h |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)0, true>>::decodeBBAddrMap(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const&, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, std::vector<llvm::object::PGOAnalysisMap, std::allocator<ll... | Expected<std::vector<BBAddrMap>>
ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec,
std::vector<PGOAnalysisMap> *PGOAnalyses) const {
size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0;
auto AddrMapsOrErr = decodeBBAddrMapImpl(*this, Sec, RelaSec,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdx, 0x148(%rsp)
testq %r8, %r8
movq %rsi, 0x180(%rsp)
je 0x1b71ea7
movq 0x8(%r8), %rax
subq (%r8), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movq ... | /Object/ELF.cpp |
std::pair<llvm::DenseMapIterator<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, unsigned int, llvm::DenseMapInfo<llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, void>, llvm::detail::DenseMapPair<llvm::object::Elf_Shdr_Impl<llvm::object::ELFTyp... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x1b7d914
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1b7d8ce
xorl %ecx, %ecx
jmp 0x1b7d8ee
movq %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol const*, std::vector<llvm::StringRef, std::allocator<llvm::StringRef>>, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, std::vector<llvm::StringRef, std::allocator<llvm::StringRef>>>>, llvm::MCSymbol const*, std::vec... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1b84999
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x5, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::Error llvm::make_error<llvm::object::GenericBinaryError, char const (&) [35], llvm::object::object_error>(char const (&) [35], llvm::object::object_error&&) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x38, %edi
callq 0x751940
movq %rax, %r15
movw $0x101, 0x20(%rsp) # imm = 0x101
cmpb $0x0, (%r12)
je 0x1b87de2
movq %r12, (%rsp)
movb $0x3, %al
jmp 0x1b87de4
movb $0x1, %al
movq %rsp, %rsi
movb %al, 0... | /llvm/Support/Error.h |
llvm::object::WasmObjectFile::parseLinkingSectionComdat(llvm::object::WasmObjectFile::ReadContext&) | Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
uint32_t ComdatCount = readVaruint32(Ctx);
StringSet<> ComdatSet;
for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
StringRef Name = readString(Ctx);
if (Name.empty() || !ComdatSet.insert(Name).second)
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
callq 0x1b87a13
movl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x60(%rsp)
testl %ebp, %ebp
j... | /Object/WasmObjectFile.cpp |
llvm::object::WasmObjectFile::getRelocationTypeName(llvm::object::DataRefImpl, llvm::SmallVectorImpl<char>&) const | void WasmObjectFile::getRelocationTypeName(
DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
StringRef Res = "Unknown";
#define WASM_RELOC(name, value) \
case wasm::name: ... | movq %rdx, %rax
movl %esi, %ecx
shrq $0x20, %rsi
movq 0x48(%rdi), %rdx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
movq 0x30(%rdx,%rcx), %rcx
leaq (%rsi,%rsi,2), %rdx
movzbl (%rcx,%rdx,8), %ecx
cmpq $0x1a, %rcx
ja 0x1b8cbab
leaq 0x3342019(%rip), %rdx # 0x4ecebb0
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
leaq 0x334207b(... | /Object/WasmObjectFile.cpp |
llvm::object::COFFObjectFile::getRelocationSymbol(llvm::object::DataRefImpl) const | [[nodiscard]] inline value_type read(const void *memory, endianness endian) {
value_type ret;
memcpy(&ret,
LLVM_ASSUME_ALIGNED(
memory, (detail::PickAlignment<value_type, alignment>::value)),
sizeof(value_type));
return byte_swap<value_type>(ret, endian);
} | movl 0x4(%rsi), %eax
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdx
xorl %esi, %esi
movq %rcx, %r8
orq %rdx, %r8
je 0x1b9ada9
movq 0x30(%rdi), %r8
testq %r8, %r8
je 0x1b9ad9e
cmpw $-0x1, 0x2(%r8)
je 0x1b9ada9
addq $0xc, %r8
jmp 0x1b9ada6
movq 0x38(%rdi), %r8
addq $0x34, %r8
movl (%r8), %esi
cmpl %esi, %eax
jae 0x1b9adc6
t... | /llvm/Support/Endian.h |
llvm::object::ELFObjectFileBase::getNVPTXCPUName() const | StringRef ELFObjectFileBase::getNVPTXCPUName() const {
assert(getEMachine() == ELF::EM_CUDA);
unsigned SM = getPlatformFlags() & ELF::EF_CUDA_SM;
switch (SM) {
// Fermi architecture.
case ELF::EF_CUDA_SM20:
return "sm_20";
case ELF::EF_CUDA_SM21:
return "sm_21";
// Kepler architecture.
case EL... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x218(%rax)
movzbl %al, %eax
movl $0x5, %edx
cmpl $0x45, %eax
jg 0x1b9e2bd
cmpl $0x31, %eax
jg 0x1b9e2e1
leal -0x1e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x1b9e316
leaq 0x3331d28(%rip), %rax # 0x4ecffd0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1f28e04(%... | /Object/ELFObjectFile.cpp |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>::getSectionSize(llvm::object::DataRefImpl) const | [[nodiscard]] inline value_type read(const void *memory, endianness endian) {
value_type ret;
memcpy(&ret,
LLVM_ASSUME_ALIGNED(
memory, (detail::PickAlignment<value_type, alignment>::value)),
sizeof(value_type));
return byte_swap<value_type>(ret, endian);
} | movl 0x14(%rsi), %eax
retq
| /llvm/Support/Endian.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>::getRela(llvm::object::DataRefImpl) const | const typename ELFObjectFile<ELFT>::Elf_Rela *
ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
if (!Ret)
report_fatal_error(Twine(errorToErrorCode(Ret.takeError()).message()));
return... | pushq %rbx
subq $0x60, %rsp
movq %rsi, %rdx
movq %rsi, %rcx
shrq $0x20, %rcx
leaq 0x38(%rdi), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1ba67ec
testb $0x1, 0x8(%rbx)
jne 0x1ba6568
movq (%rsp), %rax
addq $0x60, %rsp
popq %rbx
retq
movq (%rsp), %rax
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x1ca... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>::ELFObjectFile(llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>&&) | ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
: ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
Other.DotSymtabSec, Other.DotSymtabShndxSec) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movups 0x10(%rsi), %xmm0
movups 0x20(%rsi), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movups 0x38(%rsi), %xmm0
leaq 0x50(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
addq $0x48, %rsi
callq 0x1ba5a0c
leaq 0x80(%rsp), %r15
movq %r15,... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, false>>::create(llvm::MemoryBufferRef, bool) | Expected<ELFObjectFile<ELFT>>
ELFObjectFile<ELFT>::create(MemoryBufferRef Object, bool InitContent) {
auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
if (Error E = EFOrErr.takeError())
return std::move(E);
ELFObjectFile<ELFT> Obj = {Object, std::move(*EFOrErr), nullptr, nullptr,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1b512ae
testb $0x1, 0x40(%r14)
je 0x1ba6e18
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rsp)
jmp 0x1ba6e1a
xorl %e... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, false>>::section_rel_end(llvm::object::DataRefImpl) const | relocation_iterator
ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
relocation_iterator Begin = section_rel_begin(Sec);
DataRefImpl RelData = Begin->getRawDataRefImpl();
if (S->sh_type == ELF::SHT_CREL) {
RelData.d.b = Crels[RelDat... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x110(%rax)
movq %rax, %r14
movl 0x4(%r15), %eax
cmpl $0x14000040, %eax # imm = 0x14000040
jne 0x1ba85f9
movl %r14d, %eax
movq 0x90(%rbx), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movl 0x8(%rcx,%rdx),... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, false>>::getSectionType(llvm::object::DataRefImpl) const | [[nodiscard]] inline value_type read(const void *memory, endianness endian) {
value_type ret;
memcpy(&ret,
LLVM_ASSUME_ALIGNED(
memory, (detail::PickAlignment<value_type, alignment>::value)),
sizeof(value_type));
return byte_swap<value_type>(ret, endian);
} | movl 0x4(%rsi), %eax
bswapl %eax
retq
| /llvm/Support/Endian.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getRelocationOffset(llvm::object::DataRefImpl) const | uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
const Elf_Shdr *sec = getRelSection(Rel);
if (sec->sh_type == ELF::SHT_CREL)
return getCrel(Rel).r_offset;
if (sec->sh_type == ELF::SHT_REL)
return getRel(Rel)->r_offset;
return getRela(Rel)->r_offset;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1bad476
movl 0x4(%rax), %eax
cmpl $0x40000014, %eax # imm = 0x40000014
jne 0x1babcd3
movq %rbx, %rax
shrq $0x20, %rax
movl %ebx, %ecx
movq 0x90(%r14), %rdx
shlq $0x4, %rcx
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq (%rdx,%rcx), %rax
jmp 0... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getFileFormatName() const | iterator begin() const { return Data; } | movq 0x38(%rdi), %rax
movzbl 0x4(%rax), %ecx
cmpl $0x2, %ecx
je 0x1bac111
cmpl $0x1, %ecx
jne 0x1bac394
movzwl 0x12(%rax), %eax
movl $0xa, %edx
cmpl $0x52, %eax
jg 0x1bac189
cmpl $0x11, %eax
jg 0x1bac220
addl $-0x2, %eax
cmpl $0x6, %eax
ja 0x1bac387
leaq 0x3324178(%rip), %rcx # 0x4ed0278
movslq (%rcx,%rax,4), %rax
ad... | /llvm/ADT/StringRef.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getRelocationAddend(llvm::object::DataRefImpl) const | Expected<int64_t>
ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
if (getRelSection(Rel)->sh_type == ELF::SHT_RELA)
return (int64_t)getRela(Rel)->r_addend;
if (getRelSection(Rel)->sh_type == ELF::SHT_CREL)
return (int64_t)getCrel(Rel).r_addend;
return createError("Relocation section does... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1bad476
cmpl $0x4, 0x4(%rax)
jne 0x1bac7f6
movq %r14, %rdi
movq %r15, %rsi
callq 0x1bad554
movq 0x10(%rax), %rax
jmp 0x1bac82c
movq %r14, %rdi
movq %r15, %rsi
callq 0x1bad476
cmpl $0... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getSymbolELFType(llvm::object::DataRefImpl) const | uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
if (!SymOrErr)
report_fatal_error(SymOrErr.takeError());
return (*SymOrErr)->getType();
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rsi, %rcx
shrq $0x20, %rcx
leaq 0x38(%rdi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1bb05f0
testb $0x1, 0x8(%rbx)
jne 0x1bb0268
movq 0x8(%rsp), %rax
movb 0x4(%rax), %al
andb $0xf, %al
addq $0x20, %rsp
popq %rbx
retq
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
le... | /llvm/Object/ELFObjectFile.h |
llvm::object::MachOObjectFile::getStringTableData() const | StringRef MachOObjectFile::getStringTableData() const {
MachO::symtab_command S = getSymtabLoadCommand();
return getData().substr(S.stroff, S.strsize);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x110(%rdi), %rdx
testq %rdx, %rdx
je 0x1bc08c9
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1bbfecc
jmp 0x1bc08e0
movabsq $0x1800000002, %rax # imm = 0x1800000002
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1b952da
movl 0... | /Object/MachOObjectFile.cpp |
llvm::object::MachOObjectFile::getNValue(llvm::object::DataRefImpl) const | uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
if (is64Bit()) {
MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
return Entry.n_value;
}
MachO::nlist Entry = getSymbolTableEntry(Sym);
return Entry.n_value;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x40(%rax)
movq %r14, %rdi
movq %rbx, %rsi
testb %al, %al
je 0x1bc0ab2
callq 0x1bc061e
movq %rdx, %rax
jmp 0x1bc0ab9
callq 0x1bc06aa
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /Object/MachOObjectFile.cpp |
llvm::object::MachOObjectFile::isSectionBitcode(llvm::object::DataRefImpl) const | bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
StringRef SegmentName = getSectionFinalSegmentName(Sec);
if (Expected<StringRef> NameOrErr = getSectionName(Sec))
return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movl %ebx, %eax
movq 0x50(%rdi), %rcx
movq (%rcx,%rax,8), %rax
leaq 0x10(%rax), %r14
movl $0x10, %r15d
cmpb $0x0, 0x1f(%rax)
jne 0x1bc18db
movq %r14, %rdi
callq 0x7512e0
movq %rax, %r15
movq (%r12), %rax
m... | /Object/MachOObjectFile.cpp |
createMemberHeaderParseError(llvm::object::AbstractArchiveMemberHeader const*, char const*, unsigned long) | static Error
createMemberHeaderParseError(const AbstractArchiveMemberHeader *ArMemHeader,
const char *RawHeaderPtr, uint64_t Size) {
StringRef Msg("remaining size of archive too small for next archive "
"member header ");
Expected<StringRef> NameOrErr = ArMemHeader->get... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rdx
callq *0x40(%rax)
testb $0x1, 0x10(%r12)
je 0x1bd896f
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rsp)
leaq 0x70(%rsp), %r12
movq %ra... | /Object/Archive.cpp |
llvm::NewArchiveMember::detectKindFromObject() const | static bool isDarwin(object::Archive::Kind Kind) {
return Kind == object::Archive::K_DARWIN ||
Kind == object::Archive::K_DARWIN64;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq (%rdi), %rsi
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x1cad8fa
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1b839c8
testb $0x1, 0x8(%rbx... | /Object/ArchiveWriter.cpp |
llvm::computeArchiveRelativePath[abi:cxx11](llvm::StringRef, llvm::StringRef) | Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To) {
ErrorOr<SmallString<128>> PathToOrErr = canonicalizePath(To);
ErrorOr<SmallString<128>> DirFromOrErr = canonicalizePath(From);
if (!PathToOrErr || !DirFromOrErr)
return errorCodeToError(errnoAsErrorCode());
const SmallString<1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x2d0(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x1bdeab8
leaq 0x3a8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1bdeab8
testb ... | /Object/ArchiveWriter.cpp |
std::enable_if<!std::is_same_v<llvm::BlockExtractorPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::BlockExtractorPass>(llvm::BlockExtractorPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x751940
movq (%r14), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%r14), %rdx
movq %rdx, 0x18(%rsp)
movq 0x10(%r14), %rsi
movq %rsi, 0x20(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%r14)
movups %xmm0, (%r14)
movb 0x18(%r14), %dil
m... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::StripSymbolsPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::StripSymbolsPass>(llvm::StripSymbolsPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c295ba(%rip), %rcx # 0x581be18
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab0ac8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bf2884
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::SyntheticCountsPropagation, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::SyntheticCountsPropagation>(llvm::SyntheticCountsPropagation&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c295a2(%rip), %rcx # 0x581bf98
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab0ac8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bf2a1c
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::DominatorTreeAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<llvm::DominatorTreeAnalysis>>(ll... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c17eb4(%rip), %rcx # 0x581f998
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab2b52
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c07b0a
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::VerifierAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<llvm::VerifierAnalysis>>(llvm::Invali... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c17e04(%rip), %rcx # 0x5820498
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab2b52
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c086ba
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::RequireAnalysisPass<llvm::TypeBasedAA, llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::RequireAnalys... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c17de0(%rip), %rcx # 0x58206d8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab2b52
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c0891e
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::CorrelatedValuePropagationPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::CorrelatedValuePropagationPass>(llvm::CorrelatedValuePropagationPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c13bd4(%rip), %rcx # 0x581c9d8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab2b52
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c08e2a
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::IRCEPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::IRCEPass>(llvm::IRCEPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3c13a24(%rip), %rcx # 0x581d198
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab2b52
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c0979a
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::DependenceAnalysisPrinterPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::DependenceAnalysisPrinterPass>(llvm::DependenceAnalysisPrinterPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x751940
movq (%rbx), %rcx
movb 0x8(%rbx), %dl
leaq 0x3c1386f(%rip), %rsi # 0x581dcd8
addq $0x10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movb %dl, 0x10(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::DemandedBitsPrinterPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::DemandedBitsPrinterPass>(llvm::DemandedBitsPrinterPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x751940
movq (%rbx), %rcx
leaq 0x3c13842(%rip), %rdx # 0x581dd98
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xab2b52
movq (%rbx), %rdi
test... | /llvm/IR/PassManager.h |
llvm::StringMap<std::unique_ptr<llvm::GCStrategy, std::default_delete<llvm::GCStrategy>>, llvm::MallocAllocator>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x1c288a0
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1c288a0
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x1c28898
testq %rdi, %rdi
je 0x1c28898
movq %rbx, %rsi
callq 0x1c288ae
incq %r15
cmpq %r15, %r14
jne 0x... | /llvm/ADT/StringMap.h |
llvm::detail::AnalysisPassModel<llvm::Module, llvm::GlobalsAA, llvm::AnalysisManager<llvm::Module>::Invalidator>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x28bfa5a
movl $0x158, %edi # imm = 0x158
callq 0x751940
movq %rax, %r15
leaq 0x158(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x28bf700
lea... | /llvm/IR/PassManagerInternal.h |
llvm::detail::AnalysisPassModel<llvm::Function, llvm::DebugAssignmentTrackingAnalysis, llvm::AnalysisManager<llvm::Function>::Invalidator>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x19658ce
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c2c2d3
movq (%r15), %rax
xorl %ecx, %ecx
movq %rcx, (%r15)
movq %rax, (%rbx)
movq %rcx, (%r15)
movq 0x70(%r14), %rdi
movl 0x80(%... | /llvm/IR/PassManagerInternal.h |
llvm::detail::AnalysisPassModel<llvm::Function, llvm::BasicAA, llvm::AnalysisManager<llvm::Function>::Invalidator>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x286697c
movl $0xd0, %edi
callq 0x751940
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x118(%rsp), %rsi
movq %rcx, -0x48(%rsi)
movq %rdx, -0x40(%rsi)
movq 0x10(%r14), %rdi
movq %rd... | /llvm/IR/PassManagerInternal.h |
llvm::PreservedAnalyses llvm::InvalidateAnalysisPass<llvm::ModuleSummaryIndexAnalysis>::run<llvm::Module, llvm::AnalysisManager<llvm::Module>>(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
auto PA = PreservedAnalyses::all();
PA.abandon<AnalysisT>();
return PA;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2, %eax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x50(%rdi), %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %e... | /llvm/IR/PassManager.h |
llvm::GraphWriter<llvm::DominatorTree*>::writeGraph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void writeGraph(const std::string &Title = "") {
// Output the header for the graph...
writeHeader(Title);
// Emit all of the nodes in the graph...
writeNodes();
// Output any customizations on the graph
DOTGraphTraits<GraphType>::addCustomGraphFeatures(G, *this);
// Output the end of the... | pushq %rbx
movq %rdi, %rbx
callq 0x1c39a32
movq %rbx, %rdi
callq 0x1c39c26
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x1c39a25
leaq 0x2c0ab35(%rip), %rsi # 0x484454f
movl $0x2, %edx
popq %rbx
jmp 0x1cea464
movw $0xa7d, (%rax) # imm = 0xA7D
addq $0x2, 0x2... | /llvm/Support/GraphWriter.h |
llvm::GraphWriter<llvm::PostDominatorTree*>::writeNodes() | void writeNodes() {
// Loop over the graph, printing it out...
for (const auto Node : nodes<GraphType>(G))
if (!isNodeHidden(Node))
writeNode(Node);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x1c3b9ce
leaq 0x20(%rsp), %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x1cb9ff4
leaq 0x60(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x1c3a7a6
leaq 0... | /llvm/Support/GraphWriter.h |
llvm::SmallVectorImpl<llvm::GetElementPtrInst*>::assignRemote(llvm::SmallVectorImpl<llvm::GetElementPtrInst*>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x1c3f7a3
callq 0x751980
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %... | /llvm/ADT/SmallVector.h |
llvm::PreservedAnalyses llvm::InvalidateAnalysisPass<llvm::LoopAccessAnalysis>::run<llvm::Function, llvm::AnalysisManager<llvm::Function>>(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
auto PA = PreservedAnalyses::all();
PA.abandon<AnalysisT>();
return PA;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2, %eax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x50(%rdi), %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %e... | /llvm/IR/PassManager.h |
llvm::InvalidateAnalysisPass<llvm::DominanceFrontierAnalysis>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1c206c8
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x1828639(%rip), %rsi # 0x346e7ba
movl $0xb, %edx
movq %r15, %rdi
callq 0x7c4562
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7c4... | /llvm/IR/PassManager.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.