name string | code string | asm string | file string |
|---|---|---|---|
llvm::DWARFDataExtractor::getInitialLength(unsigned long*, llvm::Error*) const | std::pair<uint64_t, dwarf::DwarfFormat>
DWARFDataExtractor::getInitialLength(uint64_t *Off, Error *Err) const {
ErrorAsOutParameter ErrAsOut(Err);
if (Err && *Err)
return {0, dwarf::DWARF32};
Cursor C(*Off);
uint64_t Length = getRelocatedValue(C, 4);
dwarf::DwarfFormat Format = dwarf::DWARF32;
if (Leng... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
je 0x121588
cmpq $0x0, (%rbx)
je 0x121588
xorl %r14d, %r14d
xorl %r12d, %r12d
jmp 0x12174b
movq (%r15), %rax
leaq 0x10(%rsp), %r13
movq %rax, -0x8(%r13)
movq $0x0, (%r13)
l... | /DebugInfo/DWARF/DWARFDataExtractor.cpp |
llvm::Error llvm::createStringError<unsigned long, unsigned char, unsigned char>(std::error_code, char const*, unsigned long const&, unsigned char const&, unsigned char const&) | inline Error createStringError(std::error_code EC, char const *Fmt,
const Ts &... Vals) {
std::string Buffer;
raw_string_ostream(Buffer) << format(Fmt, Vals...);
return make_error<StringError>(Buffer, EC);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %r15
movl $0x0, ... | /llvm/Support/Error.h |
llvm::DWARFDebugArangeSet::Descriptor::dump(llvm::raw_ostream&, unsigned int) const | void DWARFDebugArangeSet::Descriptor::dump(raw_ostream &OS,
uint32_t AddressSize) const {
OS << '[';
DWARFFormValue::dumpAddress(OS, AddressSize, Address);
OS << ", ";
DWARFFormValue::dumpAddress(OS, AddressSize, getEndAddress());
OS << ')';
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
cmpq 0x18(%rsi), %rax
jae 0x123ba7
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x5b, (%rax)
jmp 0x123bb4
movq %rbx, %rdi
movl $0x5b, %esi
callq 0xb332e
movq (%r14), %rdx
movzbl %bpl, %ebp
movq %rbx, %rdi
movl %eb... | /DebugInfo/DWARF/DWARFDebugArangeSet.cpp |
llvm::DWARFDebugAranges::extract(llvm::DWARFDataExtractor, llvm::function_ref<void (llvm::Error)>, llvm::function_ref<void (llvm::Error)>) | void DWARFDebugAranges::extract(
DWARFDataExtractor DebugArangesData,
function_ref<void(Error)> RecoverableErrorHandler,
function_ref<void(Error)> WarningHandler) {
if (!DebugArangesData.isValidOffset(0))
return;
uint64_t Offset = 0;
DWARFDebugArangeSet Set;
while (DebugArangesData.isValidOffse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x108(%rsp), %r14
testq %r14, %r14
je 0x12498e
movq %rdi, %r13
movq %rdx, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
leaq 0x70(%rsp), %rdi
movq %rax, 0x38(%rdi)
... | /DebugInfo/DWARF/DWARFDebugAranges.cpp |
llvm::Expected<std::vector<llvm::DWARFAddressRange, std::allocator<llvm::DWARFAddressRange>>>::~Expected() | ~Expected() {
assertIsChecked();
if (!HasError)
getStorage()->~storage_type();
else
getErrorStorage()->~error_type();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testb $0x1, 0x18(%rbx)
je 0x124c39
testq %rdi, %rdi
je 0x124c30
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
jmp 0x124c4b
testq %rdi, %rdi
je 0x124c4b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x8b100
popq %rbx
retq
nop
| /llvm/Support/Error.h |
printRegister(llvm::raw_ostream&, llvm::DIDumpOptions, unsigned int) | static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts,
unsigned RegNum) {
if (DumpOpts.GetNameForDWARFReg) {
auto RegName = DumpOpts.GetNameForDWARFReg(RegNum, DumpOpts.IsEH);
if (!RegName.empty()) {
OS << RegName;
return;
}
}
OS << "reg" << RegNum;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x50(%rsi)
movl %edx, %ebx
je 0x1261a6
movzbl 0x16(%rsi), %edx
addq $0x40, %rsi
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x12c7ee
testq %rdx, %rdx
je 0x1261a6
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x90d0a
leaq 0x2c5591(%rip), %rs... | /DebugInfo/DWARF/DWARFDebugFrame.cpp |
llvm::DWARFDebugLine::Prologue::hasFileAtIndex(unsigned long) const | bool DWARFDebugLine::Prologue::hasFileAtIndex(uint64_t FileIndex) const {
uint16_t DwarfVersion = getVersion();
assert(DwarfVersion != 0 &&
"line table prologue has no dwarf version information");
if (DwarfVersion >= 5)
return FileIndex < FileNames.size();
return FileIndex != 0 && FileIndex <= File... | cmpw $0x5, 0x8(%rdi)
jb 0x12e1b6
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F1
imulq %rax, %rcx
cmpq %rsi, %rcx
seta %al
retq
testq %rsi, %rsi
je 0x12e1dc
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f, %... | /DebugInfo/DWARF/DWARFDebugLine.cpp |
llvm::DWARFLocationTable::visitAbsoluteLocationList(unsigned long, std::optional<llvm::object::SectionedAddress>, std::function<std::optional<llvm::object::SectionedAddress> (unsigned int)>, llvm::function_ref<bool (llvm::Expected<llvm::DWARFLocationExpression>)>) const | Error DWARFLocationTable::visitAbsoluteLocationList(
uint64_t Offset, std::optional<SectionedAddress> BaseAddr,
std::function<std::optional<SectionedAddress>(uint32_t)> LookupAddr,
function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const {
DWARFLocationInterpreter Interp(BaseAddr, std::move(L... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0(%rsp), %rax
movq %r8, 0x30(%rsp)
movq %r9, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x10(%rcx), %rsi
testq %rsi, %... | /DebugInfo/DWARF/DWARFDebugLoc.cpp |
llvm::DWARFDebugLoc::visitLocationList(unsigned long*, llvm::function_ref<bool (llvm::DWARFLocationEntry const&)>) const | Error DWARFDebugLoc::visitLocationList(
uint64_t *Offset,
function_ref<bool(const DWARFLocationEntry &)> Callback) const {
DataExtractor::Cursor C(*Offset);
while (true) {
uint64_t SectionIndex;
uint64_t Value0 = Data.getRelocatedAddress(C);
uint64_t Value1 = Data.getRelocatedAddress(C, &Section... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rsi, %r13
movq %rdx, 0x30(%rsp)
movq (%rdx), %rax
leaq 0x28(%rsp), %rbp
movq %rax, -0x8(%rbp)
movq $0x0, (%rbp)
leaq 0x8(%rsi), %r14
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
movq %rax, 0x8(... | /DebugInfo/DWARF/DWARFDebugLoc.cpp |
llvm::DenseMap<unsigned long, llvm::DWARFUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFUnit*>>::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::DenseMapBase<llvm::DenseMap<unsigned long, llvm::DWARFUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFUnit*>>, unsigned long, llvm::DWARFUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFUnit*>>::moveFromOldBuc... | 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 0x13939c
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::SmallSet<llvm::DWARFDie, 3u, std::less<llvm::DWARFDie>>::insert(llvm::DWARFDie const&) | std::pair<const_iterator, bool> insert(const T &V) {
if (!isSmall()) {
auto [I, Inserted] = Set.insert(V);
return std::make_pair(const_iterator(I), Inserted);
}
VIterator I = vfind(V);
if (I != Vector.end()) // Don't reinsert if it already exists.
return std::make_pair(const_iterat... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x68(%rsi)
je 0x13ce97
addq $0x40, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x14088e
xorl %ecx, %ecx
jmp 0x13cf0c
movq (%r14), %rax
movl 0x8(%r14), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
leaq (%rax,%rsi), %... | /llvm/ADT/SmallSet.h |
llvm::DWARFDie::getAttributeValueAsReferencedDie(llvm::DWARFFormValue const&) const | DWARFDie
DWARFDie::getAttributeValueAsReferencedDie(const DWARFFormValue &V) const {
DWARFDie Result;
if (std::optional<uint64_t> Offset = V.getAsRelativeReference()) {
Result = const_cast<DWARFUnit *>(V.getUnit())
->getDIEForOffset(V.getUnit()->getOffset() + *Offset);
} else if (Offset = V.g... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14590a
testb $0x1, %dl
je 0x13cfcd
movq 0x20(%r14), %rbx
addq 0x18(%rbx), %rax
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x13cffd
movq %r14, %rdi
callq 0x145926
testb $0x1, %dl
je 0x13d026
movq %rax, %r14
movq (%rbx), %rax
movq 0xd8(%rax... | /DebugInfo/DWARF/DWARFDie.cpp |
llvm::DWARFFormValue::getAsCString() const | Expected<const char *> DWARFFormValue::getAsCString() const {
if (!isFormClass(FC_String))
return make_error<StringError>("Invalid form for string attribute",
inconvertibleErrorCode());
if (Form == DW_FORM_string)
return Value.cstr;
// FIXME: Add support for DW_FORM_GNU_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rsi), %ebp
movq 0x20(%rsi), %r15
testq %r15, %r15
je 0x145232
movzwl 0x20(%r15), %eax
jmp 0x145236
movw $0x3, %ax
movzwl %ax, %edx
movl %ebp, %edi
movl $0x4, %esi
callq 0... | /DebugInfo/DWARF/DWARFFormValue.cpp |
llvm::DWARFFormValue::getAsBlock() const | std::optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {
if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc) &&
Form != DW_FORM_data16)
return std::nullopt;
return ArrayRef(Value.data, Value.uval);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rsi), %eax
movq 0x20(%rsi), %r15
testq %r15, %r15
je 0x145a92
movzwl 0x20(%r15), %ecx
jmp 0x145a96
movw $0x3, %cx
movzwl %ax, %ebp
movzwl %cx, %edx
movl %ebp, %edi
movl $0x2, %esi
callq 0x143ff9
testb %al, %al
jne 0x145ad9
t... | /DebugInfo/DWARF/DWARFFormValue.cpp |
llvm::SmallVectorTemplateBase<llvm::DWARFGdbIndex::CompUnitEntry, true>::push_back(llvm::DWARFGdbIndex::CompUnitEntry) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x146884
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rs... | /llvm/ADT/SmallVector.h |
void llvm::SmallVectorImpl<llvm::DWARFGdbIndex::TypeUnitEntry>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x146adf
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x146ad4
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x146a81
leaq 0x10(%r14), %rsi
movl $0x18, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa6f56
movl 0x8(%r14), %ecx
cmpq %rbx, %rcx
je 0x146ad4
leaq (%rcx... | /llvm/ADT/SmallVector.h |
llvm::DWARFDebugNames::ValueIterator::setEnd() | void setEnd() { *this = ValueIterator(); } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rdi, %rbx
movl $0xd8, %r14d
movq %rsp, %rdi
leaq (%rdi,%r14), %r15
leaq 0xe8(%rsp), %r12
xorl %r13d, %r13d
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x8b270
movq %r12, -0x10(%r12)
movq %r13, -0... | /llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h |
llvm::DWARFTypePrinter::appendScopes(llvm::DWARFDie) | void DWARFTypePrinter::appendScopes(DWARFDie D) {
if (D.getTag() == DW_TAG_compile_unit)
return;
if (D.getTag() == DW_TAG_type_unit)
return;
if (D.getTag() == DW_TAG_skeleton_unit)
return;
if (D.getTag() == DW_TAG_subprogram)
return;
if (D.getTag() == DW_TAG_lexical_block)
return;
D = D.... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x16dfe2
movzwl 0x4(%rax), %eax
addl $-0xb, %eax
cmpl $0x3f, %eax
ja 0x16dfe2
movabsq $-0x7fbffff7ffffffbf, %rcx # imm = 0x8040000800000041
btq %rax, %rcx
jb 0x16e07e
movq %... | /DebugInfo/DWARF/DWARFTypePrinter.cpp |
llvm::object::createBinary(llvm::MemoryBufferRef, llvm::LLVMContext*, bool) | Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
LLVMContext *Context,
bool InitContent) {
file_magic Type = identify_magic(Buffer.getBuffer());
switch (Type) {
case file_ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x30e9e9
movl %eax, %ecx
leaq 0x1e0cfd(%rip), %rdx # 0x34fc50
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movups (%r15), %xmm0
movu... | /Object/Binary.cpp |
llvm::object::COFFObjectFile::getSectionAddress(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 0xc(%rsi), %ecx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x16fbb5
movl 0x1c(%rax), %eax
jmp 0x16fbc6
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x16fbc4
movq 0x18(%rax), %rax
jmp 0x16fbc6
xorl %eax, %eax
addq %rcx, %rax
retq
| /llvm/Support/Endian.h |
llvm::object::COFFObjectFile::section_rel_end(llvm::object::DataRefImpl) const | relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
const coff_relocation *I = getFirstReloc(Sec, Data, base());
if (I)
I += getNumberOfRelocations(Sec, Data, base());
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(I);
return relocatio... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movups 0x10(%rdi), %xmm0
movups 0x20(%rdi), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x16fe70
testq %rax, %rax
je 0x16ffc7
movq %rax, %r15
leaq 0x10(%rbx), %rax
movq (%rax), %rsi
movu... | /Object/COFFObjectFile.cpp |
llvm::object::MachOObjectFile::isSectionStripped(llvm::object::DataRefImpl) const | bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
if (is64Bit())
return getSection64(Sec).offset == 0;
return getSection(Sec).offset == 0;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movl %r14d, %ecx
testb %al, %al
je 0x17d920
movq 0x50(%rbx), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17e5db
movl 0x30(%r14), %eax
jmp 0x17d93c
movq 0x50(%rbx), %r... | /Object/MachOObjectFile.cpp |
llvm::MachO::section_64 getStruct<llvm::MachO::section_64>(llvm::object::MachOObjectFile const&, char const*) | static T getStruct(const MachOObjectFile &O, const char *P) {
// Don't read before the beginning or past the end of the file
if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
report_fatal_error("Malformed MachO file.");
T Cmd;
memcpy(&Cmd, P, sizeof(T));
if (O.isLittleEndian() != sys::IsL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x16ef00
cmpq %r15, %rax
ja 0x17e6a7
leaq 0x50(%r15), %r12
movq %r14, %rdi
callq 0x16ef00
addq %rax, %rdx
cmpq %rdx, %r12
ja 0x17e6a7
movl $0x50, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8b0b... | /Object/MachOObjectFile.cpp |
llvm::Expected<llvm::MachO::segment_command_64> getStructOrErr<llvm::MachO::segment_command_64>(llvm::object::MachOObjectFile const&, char const*) | static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) {
// Don't read before the beginning or past the end of the file
if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
return malformedError("Structure read out-of-range");
T Cmd;
memcpy(&Cmd, P, sizeof(T));
if (O.isLi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x16ef00
cmpq %r15, %rax
ja 0x17f53e
leaq 0x48(%r15), %r12
movq %r14, %rdi
callq 0x16ef00
addq %rax, %rdx
cmpq %rdx, %r12
jbe 0x17f56f
leaq 0x1d3964(%rip), %rax # 0x352ea9
leaq 0x10(%rsp... | /Object/MachOObjectFile.cpp |
llvm::object::resolveBPF(unsigned long, unsigned long, unsigned long, unsigned long, long) | static uint64_t resolveBPF(uint64_t Type, uint64_t Offset, uint64_t S,
uint64_t LocData, int64_t /*Addend*/) {
switch (Type) {
case ELF::R_BPF_64_ABS32:
return (S + LocData) & 0xFFFFFFFF;
case ELF::R_BPF_64_ABS64:
return S + LocData;
default:
llvm_unreachable("Invalid relo... | addq %rdx, %rcx
cmpq $0x3, %rdi
movl %ecx, %eax
cmovneq %rcx, %rax
retq
| /Object/RelocationResolver.cpp |
llvm::object::resolvePPC64(unsigned long, unsigned long, unsigned long, unsigned long, long) | static uint64_t resolvePPC64(uint64_t Type, uint64_t Offset, uint64_t S,
uint64_t /*LocData*/, int64_t Addend) {
switch (Type) {
case ELF::R_PPC64_ADDR32:
return (S + Addend) & 0xFFFFFFFF;
case ELF::R_PPC64_ADDR64:
return S + Addend;
case ELF::R_PPC64_REL32:
return (S + ... | movq %rdx, %rax
addq %r8, %rax
cmpq $0x25, %rdi
jg 0x18325e
cmpq $0x1, %rdi
jne 0x183268
movl %eax, %eax
retq
cmpq $0x26, %rdi
je 0x183267
subq %rsi, %rax
retq
subl %esi, %eax
retq
| /Object/RelocationResolver.cpp |
llvm::object::supportsAmdgpu(unsigned long) | static bool supportsAmdgpu(uint64_t Type) {
switch (Type) {
case ELF::R_AMDGPU_ABS32:
case ELF::R_AMDGPU_ABS64:
return true;
default:
return false;
}
} | cmpq $0x6, %rdi
sete %cl
cmpq $0x3, %rdi
sete %al
orb %cl, %al
retq
| /Object/RelocationResolver.cpp |
llvm::object::supportsX86(unsigned long) | static bool supportsX86(uint64_t Type) {
switch (Type) {
case ELF::R_386_NONE:
case ELF::R_386_32:
case ELF::R_386_PC32:
return true;
default:
return false;
}
} | cmpq $0x3, %rdi
setb %al
retq
| /Object/RelocationResolver.cpp |
llvm::object::resolveMips32(unsigned long, unsigned long, unsigned long, unsigned long, long) | static uint64_t resolveMips32(uint64_t Type, uint64_t Offset, uint64_t S,
uint64_t LocData, int64_t /*Addend*/) {
// FIXME: Take in account implicit addends to get correct results.
if (Type == ELF::R_MIPS_32)
return (S + LocData) & 0xFFFFFFFF;
if (Type == ELF::R_MIPS_TLS_DTPREL32... | leal (%rcx,%rdx), %eax
retq
| /Object/RelocationResolver.cpp |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)1, false>>::getSection(unsigned int) const | Expected<const typename ELFT::Shdr *>
ELFFile<ELFT>::getSection(uint32_t Index) const {
auto TableOrErr = sections();
if (!TableOrErr)
return TableOrErr.takeError();
return object::getSection<ELFT>(*TableOrErr, Index);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x183a48
testb $0x1, 0x10(%r14)
je 0x1839b5
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
orb $0x1, 0x8(%rbx)
jmp 0x1839cf
movl %ebp, %eax
cmpq %rax, 0x10(%rsp)
jbe 0x1839d4
movq 0x8(%rsp)... | /llvm/Object/ELF.h |
llvm::object::WasmObjectFile::parseCustomSection(llvm::object::WasmSection&, llvm::object::WasmObjectFile::ReadContext&) | Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
if (Sec.Name == "dylink") {
if (Error Err = parseDylinkSection(Ctx))
return Err;
} else if (Sec.Name == "dylink.0") {
if (Error Err = parseDylink0Section(Ctx))
return Err;
} else if (Sec.Name == "name") {
if (Er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %rbp
leaq -0x4(%rbp), %r14
cmpq $0xb, %r14
ja 0x1865a0
leaq 0x1ce8df(%rip), %rax # 0x354d30
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
j... | /Object/WasmObjectFile.cpp |
llvm::Error llvm::make_error<llvm::object::GenericBinaryError, char const (&) [24], llvm::object::object_error>(char const (&) [24], 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 0x8b140
movq %rax, %r15
movw $0x101, 0x20(%rsp) # imm = 0x101
cmpb $0x0, (%r12)
je 0x18a3b1
movq %r12, (%rsp)
movb $0x3, %al
jmp 0x18a3b3
movb $0x1, %al
movq %rsp, %rsi
movb %al, 0x20... | /llvm/Support/Error.h |
llvm::object::WasmObjectFile::getSymbolFlags(llvm::object::DataRefImpl) const | Expected<uint32_t> WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
uint32_t Result = SymbolRef::SF_None;
const WasmSymbol &Sym = getWasmSymbol(Symb);
LLVM_DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
if (Sym.isBindingWeak())
Result |= SymbolRef::SF_Weak;
if (!Sym.isBind... | shrq $0x20, %rdx
movq 0x218(%rsi), %rax
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
movl 0x14(%rax,%rdx), %ecx
movl %ecx, %esi
andl $0x3, %esi
xorl %r8d, %r8d
cmpl $0x1, %esi
sete %r8b
xorl %r9d, %r9d
cmpl $0x2, %esi
leal 0x2(,%r8,4), %esi
cmovel %r9d, %esi
movl %ecx, %r8d
andl $0xc, %r8d
leal 0x200(%rsi), %r9d
cmpl $0x4,... | /Object/WasmObjectFile.cpp |
llvm::object::WasmObjectFile::getSectionName(llvm::object::DataRefImpl) const | Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
const WasmSection &S = Sections[Sec.d.a];
if (S.Type == wasm::WASM_SEC_CUSTOM)
return S.Name;
if (S.Type > wasm::WASM_SEC_LAST_KNOWN)
return createStringError(object_error::invalid_section_index, "");
return wasm::sectionTypeToS... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl %edx, %ecx
movq 0x48(%rsi), %rax
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %edi
testl %edi, %edi
je 0x18cb96
cmpl $0xe, %edi
jb 0x18cba6
callq 0x9722f
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x25... | /Object/WasmObjectFile.cpp |
llvm::Expected<llvm::ArrayRef<llvm::object::XCOFFRelocation32>> llvm::object::XCOFFObjectFile::relocations<llvm::object::XCOFFSectionHeader32, llvm::object::XCOFFRelocation32>(llvm::object::XCOFFSectionHeader32 const&) const | Expected<ArrayRef<Reloc>> XCOFFObjectFile::relocations(const Shdr &Sec) const {
uintptr_t RelocAddr = getWithOffset(reinterpret_cast<uintptr_t>(FileHeader),
Sec.FileOffsetToRelocationInfo);
auto NumRelocEntriesOrErr = getNumberOfRelocationEntries(Sec);
if (Error E = NumRelocE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x18(%rdx), %r15d
bswapl %r15d
addq 0x30(%rsi), %r15
movq %rsp, %r13
movq %r13, %rdi
callq 0x190d90
testb $0x1, 0x8(%r13)
je 0x190abb
movq (%rsp), %rax
movq $... | /Object/XCOFFObjectFile.cpp |
llvm::object::XCOFFObjectFile::mapDebugSectionName(llvm::StringRef) const | StringRef XCOFFObjectFile::mapDebugSectionName(StringRef Name) const {
return StringSwitch<StringRef>(Name)
.Case("dwinfo", "debug_info")
.Case("dwline", "debug_line")
.Case("dwpbnms", "debug_pubnames")
.Case("dwpbtyp", "debug_pubtypes")
.Case("dwarnge", "debug_aranges")
.Case("dwa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x6, %rdx
jne 0x19280e
leaq 0x26c83f(%rip), %rsi # 0x3ff03a
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8b5f0
testl %eax, %eax
sete %bpl
jmp 0x192810
xorl %ebp, %ebp
cmpq $0x6, %rbx
setne %al
orb %bpl, %al
je 0x192825
leaq 0x1b2... | /Object/XCOFFObjectFile.cpp |
llvm::object::ArchiveMemberHeader::isThin() const | Expected<bool> ArchiveMemberHeader::isThin() const {
Expected<StringRef> NameOrErr = getRawName();
if (!NameOrErr)
return NameOrErr.takeError();
StringRef Name = NameOrErr.get();
return Parent->isThin() && Name != "/" && Name != "//" && Name != "/SYM64/";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
callq *0x18(%rax)
testb $0x1, 0x10(%r15)
je 0x1954bd
movq (%rsp), %rax
movq $0x0, (%rsp)
orb $0x1, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0x195546
movq 0x8(%r14), %rax
testb $0x8, 0x72... | /Object/Archive.cpp |
llvm::object::ELFObjectFileBase::getLoongArchFeatures() const | SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {
SubtargetFeatures Features;
switch (getPlatformFlags() & ELF::EF_LOONGARCH_ABI_MODIFIER_MASK) {
case ELF::EF_LOONGARCH_ABI_SOFT_FLOAT:
break;
case ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT:
Features.AddFeature("d");
// D implies F accordi... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x251d79(%rip), %rsi # 0x3eb126
xorl %edx, %edx
callq 0x3104e6
movq (%r14), %rax
movq %r14, %rdi
callq *0x218(%rax)
andl $0x7, %eax
cmpl $0x2, %eax
je 0x1993e6
cmpl $0x3, %eax
jne 0x1993ff
leaq 0x1be498(%rip), %rsi # 0x35786c
movl $0x1, %edx
mo... | /Object/ELFObjectFile.cpp |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>::getSectionContents(llvm::object::DataRefImpl) const | Expected<ArrayRef<uint8_t>>
ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const {
const Elf_Shdr *EShdr = getSection(Sec);
if (EShdr->sh_type == ELF::SHT_NOBITS)
return ArrayRef((const uint8_t *)base(), (size_t)0);
if (Error E =
checkOffset(getMemoryBufferRef(),
(uin... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x8, 0x4(%rdx)
jne 0x19b057
movq 0x10(%r15), %rax
andb $-0x2, 0x10(%rbx)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x19b0d8
movq %rdx, %r14
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x16ef14
movl 0x10(%r14), %ecx
movl 0x14(%r14),... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, false>>::getSymbolSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::endianness)1, false>> const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, false>> const*) const | Expected<section_iterator>
ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
const Elf_Shdr *SymTab) const {
ArrayRef<Elf_Word> ShndxTable;
if (DotSymtabShndxSec) {
// TODO: Test this error.
Expected<ArrayRef<Elf_Word>> ShndxTableOrErr =
EF.getSHNDXTabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rsi), %rdx
testq %rdx, %rdx
je 0x19f1e9
movq %rax, 0x40(%rsp)
movq %rcx, %r12
leaq 0x38(%r14), %rsi
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x19dfc0
movb 0x10(%r13), %bpl
tes... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, false>>::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, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1838a6
cmpl $0x4000000, 0x4(%rax) # imm = 0x4000000
jne 0x1a49c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a8186
movl 0x8(%rax), %eax
bswapl %eax
cltq
jmp 0x1a49f3
movq %r15, %rdi
m... | /llvm/Object/ELFObjectFile.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::object::getSecIndexForError<llvm::object::ELFType<(llvm::endianness)0, false>>(llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)0, false>> const&, llvm::object::ELFType<(llvm::endianness)0, 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 0x183f38
testb $0x1, 0x10(%r14)
je 0x1a5a40
movq (%rsp), %rax
movq $0x0, (%rsp)
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x9... | /llvm/Object/ELF.h |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)0, false>>::getSection(llvm::object::Elf_Sym_Impl<llvm::object::ELFType<(llvm::endianness)0, false>> const&, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>> const*, llvm::object::DataRegion<llvm::support::detail::packed_endian_... | Expected<const typename ELFT::Shdr *>
ELFFile<ELFT>::getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab,
DataRegion<Elf_Word> ShndxTable) const {
auto SymsOrErr = symbols(SymTab);
if (!SymsOrErr)
return SymsOrErr.takeError();
return getSection(Sym, *SymsOrErr, ShndxTable);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x1a6937
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x1a4f50
jmp 0x1a6944
andb $-0x2, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
testb $0x1, 0x30(%rsp)
je 0x1a6962
movq 0x20... | /llvm/Object/ELF.h |
llvm::Expected<llvm::ArrayRef<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::endianness)0, false>, true>>> llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)0, false>>::getSectionContentsAsArray<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::endianness)0, false>, true>>(llvm::object::Elf_S... | 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, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0xc000000, 0x24(%rdx) # imm = 0xC000000
jne 0x1a91bb
movl 0x14(%r15), %r14d
bswapl %r14d
movabsq $0x1555555555555556, %rcx # imm = 0x1555555555555556
movq %... | /llvm/Object/ELF.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, false>>::dynamic_symbol_begin() const | elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
if (!DotDynSymSec || DotDynSymSec->sh_size < sizeof(Elf_Sym))
// Ignore errors here where the dynsym is empty or sh_size less than the
// size of one symbol. These should be handled elsewhere.
return symbol_iterator(SymbolRef(toDRI(Do... | pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rsi
testq %rsi, %rsi
je 0x1aa45f
movl 0x14(%rsi), %eax
bswapl %eax
cmpl $0xf, %eax
ja 0x1aa466
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1aa46e
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1a5c06
movq %rbx, %rdx
popq %rbx
retq
| /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::getRelocationType(llvm::object::DataRefImpl) const | uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
const Elf_Shdr *sec = getRelSection(Rel);
if (sec->sh_type == ELF::SHT_CREL)
return getCrel(Rel).r_type;
if (sec->sh_type == ELF::SHT_REL)
return getRel(Rel)->getType(EF.isMips64EL());
else
return getRela(Rel)->getType(EF.isMip... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x18383a
movl 0x4(%rax), %eax
cmpl $0x40000014, %eax # imm = 0x40000014
jne 0x1ac1f2
movq %r14, %rax
shrq $0x20, %rax
movl %r14d, %ecx
movq 0x90(%rbx), %rdx
shlq $0x4, %rcx
movq (%rdx,%rcx), %rcx
leaq (%rax,%rax,2), %rax
movl 0xc(%rcx,%rax,8),... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)1, true>>::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
retq
| /llvm/Support/Endian.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 0x18383a
cmpl $0x4, 0x4(%rax)
jne 0x1acc08
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b0566
movq 0x10(%rax), %rax
jmp 0x1acc3e
movq %r14, %rdi
movq %r15, %rsi
callq 0x18383a
cmpl $0x4000... | /llvm/Object/ELFObjectFile.h |
llvm::SmallVectorImpl<llvm::object::Elf_Crel_Impl<true>>::operator=(llvm::SmallVectorImpl<llvm::object::Elf_Crel_Impl<true>>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1b03cb
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0x1b032f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b03da
jmp 0x1b03cb
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %r12d
cmpl %r15d, %r12d
jae 0x1b035f
cm... | /llvm/ADT/SmallVector.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getArch() const | Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
bool IsLittleEndian = ELFT::Endianness == llvm::endianness::little;
switch (EF.getHeader().e_machine) {
case ELF::EM_68K:
return Triple::m68k;
case ELF::EM_386:
case ELF::EM_IAMCU:
return Triple::x86;
case ELF::EM_X86_64:
return Triple::x86... | pushq %rax
movq 0x38(%rdi), %rcx
movzwl 0x12(%rcx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
cmpl $0x52, %eax
jle 0x1b499e
cmpl $0xdf, %eax
jle 0x1b49c9
leal -0xf3(%rax), %edx
cmpl $0x9, %edx
ja 0x1b4a44
leaq 0x1a29f0(%rip), %rax # 0x357360
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzbl 0x4(%rcx), %ecx
mov... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getSymbolOther(llvm::object::DataRefImpl) const | uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
Expected<const Elf_Sym *> SymOrErr = getSymbol(Symb);
if (!SymOrErr)
report_fatal_error(SymOrErr.takeError());
return (*SymOrErr)->st_other;
} | 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 0x1b5096
testb $0x1, 0x8(%rbx)
jne 0x1b4c9c
movq 0x8(%rsp), %rax
movb 0x5(%rax), %al
addq $0x20, %rsp
popq %rbx
retq
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
leaq 0x18(%rsp), %r... | /llvm/Object/ELFObjectFile.h |
llvm::object::ELFObjectFile<llvm::object::ELFType<(llvm::endianness)0, true>>::getRel(llvm::object::DataRefImpl) const | const typename ELFObjectFile<ELFT>::Elf_Rel *
ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
if (!Ret)
report_fatal_error(Twine(errorToErrorCode(Ret.takeError()).message()));
return *Ret;
} | 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 0x1b8142
testb $0x1, 0x8(%rbx)
jne 0x1b808c
movq (%rsp), %rax
addq $0x60, %rsp
popq %rbx
retq
movq (%rsp), %rax
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0xa5199... | /llvm/Object/ELFObjectFile.h |
llvm::SmallPtrSetImplBase::find_imp(void const*) const | const void *const * find_imp(const void * Ptr) const {
if (isSmall()) {
// Linear search for the item.
for (const void *const *APtr = SmallArray,
*const *E = SmallArray + NumNonEmpty; APtr != E; ++APtr)
if (*APtr == Ptr)
return APtr;
return EndPointer();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x1bb089
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa6be2
cmpq %rbx, (%rax)
je 0x1bb0ce
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpq (%r14), %rax
sete %cl
movl 0x10(%r14,%rcx,4), %ecx
leaq (%rax,%rcx,8),... | /llvm/ADT/SmallPtrSet.h |
llvm::RecordStreamer::begin() | iterator begin() { return iterator(TheTable, NumBuckets == 0); } | movq 0x128(%rdi), %rax
cmpl $0x0, 0x130(%rdi)
je 0x1bc6aa
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1bc6a4
cmpq $-0x8, %rcx
jne 0x1bc6aa
addq $0x8, %rax
jmp 0x1bc696
retq
nop
| /llvm/ADT/StringMap.h |
llvm::StringMap<llvm::GlobalValue const*, 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 0x1bcebb
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1bcebb
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x1bceb3
testq %rdi, %rdi
je 0x1bceb3
movq (%rdi), %rsi
addq $0x11, %rsi
movl $0x8, %edx
callq 0xa6092
inc... | /llvm/ADT/StringMap.h |
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::vector<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 0x1bd3d7
movq (%r15), %rax
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
neg... | /llvm/ADT/DenseMap.h |
llvm::utohexstr[abi:cxx11](unsigned long, bool, unsigned int) | inline std::string utohexstr(uint64_t X, bool LowerCase = false,
unsigned Width = 0) {
char Buffer[17];
char *BufPtr = std::end(Buffer);
if (X == 0) *--BufPtr = '0';
for (unsigned i = 0; Width ? (i < Width) : X; ++i) {
unsigned char Mod = static_cast<unsigned char>(X) & 15;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %eax
movq %rdi, %rbx
leaq 0x11(%rsp), %rdx
movq %rdx, %rdi
testq %rsi, %rsi
jne 0x1bef99
leaq 0x10(%rsp), %rdi
movb $0x30, (%rdi)
xorl %r8d, %r8d
testl %ecx, %ecx
setne %r8b
cmoveq %rsi, %r8
testq %r8, %r8
je 0x1beff2
shlb $0x5, %al
movl $0x1, %r9d
leaq 0x17fca5(%rip), ... | /llvm/ADT/StringExtras.h |
llvm::DenseMapBase<llvm::SmallDenseMap<unsigned int, llvm::Value*, 4u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::Value*>>, unsigned int, llvm::Value*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::Value*>>::find(unsigned int const&) | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x1c56dc
testb $0x1, (%rbx)
leaq 0x8(%rbx), %rcx
cmoveq 0x8(%rbx), %rcx
movl $0x4, %edx
cmovel 0x10(%rbx), %edx
shlq $0x4, %rdx
addq %rcx, %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
re... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::BitcodeReader::parseValueSymbolTable(unsigned long) | Error BitcodeReader::parseValueSymbolTable(uint64_t Offset) {
uint64_t CurrentBit;
// Pass in the Offset to distinguish between calling for the module-level
// VST (where we want to jump to the VST offset) and the function-level
// VST (where we don't).
if (Offset > 0) {
Expected<uint64_t> MaybeCurrentBit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1d1729
leaq 0x20(%r15), %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d4b1a
movb 0x8(%r12), %bpl
testb $... | /Bitcode/Reader/BitcodeReader.cpp |
llvm::gep_type_begin(llvm::User const*) | inline gep_type_iterator gep_type_begin(const User *GEP) {
auto *GEPOp = cast<GEPOperator>(GEP);
return gep_type_iterator::begin(
GEPOp->getSourceElementType(),
GEP->op_begin() + 1);
} | pushq %rbx
movq %rdi, %rbx
callq 0x26d7ea
movq %rax, %rdx
movl 0x4(%rbx), %eax
btl $0x1e, %eax
jb 0x1d2782
shll $0x5, %eax
subq %rax, %rbx
jmp 0x1d2786
movq -0x8(%rbx), %rbx
addq $0x20, %rbx
andq $-0x7, %rdx
orq $0x4, %rdx
movq %rbx, %rax
popq %rbx
retq
nop
| /llvm/IR/GetElementPtrTypeIterator.h |
(anonymous namespace)::BitcodeReader::getVirtualTypeID(llvm::Type*, llvm::ArrayRef<unsigned int>) | unsigned BitcodeReader::getVirtualTypeID(Type *Ty,
ArrayRef<unsigned> ChildTypeIDs) {
unsigned ChildTypeID = ChildTypeIDs.empty() ? InvalidTypeID : ChildTypeIDs[0];
auto CacheKey = std::make_pair(Ty, ChildTypeID);
auto It = VirtualTypeIDs.find(CacheKey);
if (It != Virtua... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, 0x8(%rsp)
testq %rcx, %rcx
je 0x1d2822
movl (%rbx), %ecx
jmp 0x1d2827
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movl %ecx, 0x8(%rax)
leaq 0x240(%r12), %r1... | /Bitcode/Reader/BitcodeReader.cpp |
llvm::BitstreamCursor::advanceSkippingSubblocks(unsigned int) | Expected<BitstreamEntry> advanceSkippingSubblocks(unsigned Flags = 0) {
while (true) {
// If we found a normal entry, return it.
Expected<BitstreamEntry> MaybeEntry = advance(Flags);
if (!MaybeEntry)
return MaybeEntry;
BitstreamEntry Entry = MaybeEntry.get();
if (Entry.Kind !=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x8(%rdi), %r13b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1c00e6
movb 0x10(%rsp), %al
testb $0x1, %al
je 0x1d4272
andb $0x1, %al
andb $-0x2, %r13b
o... | /llvm/Bitstream/BitstreamReader.h |
(anonymous namespace)::BitcodeReader::readBitWidthAndConstantRange(llvm::ArrayRef<unsigned long>, unsigned int&) | Expected<ConstantRange>
readBitWidthAndConstantRange(ArrayRef<uint64_t> Record, unsigned &OpNum) {
if (Record.size() - OpNum < 1)
return error("Too few records for range");
unsigned BitWidth = Record[OpNum++];
return readConstantRange(Record, OpNum, BitWidth);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl (%r8), %eax
cmpq %rcx, %rax
jne 0x1d4428
addq $0x8, %rsi
leaq 0x192c45(%rip), %rax # 0x367046
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1c4fde
orb $0x1, 0x20(%rbx)
movq (%... | /Bitcode/Reader/BitcodeReader.cpp |
llvm::TrackingMDRef::operator=(llvm::TrackingMDRef&&) | TrackingMDRef &operator=(TrackingMDRef &&X) {
if (&X == this)
return *this;
untrack();
MD = X.MD;
retrack(X);
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x1d56a9
movq %rsi, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1d5689
movq %rbx, %rdi
callq 0x263ab8
movq (%r14), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1d56a9
movq %r14, %rdi
movq %rbx, %rdx
callq 0x263b72
movq $0x0, (%r14)
m... | /llvm/IR/TrackingMDRef.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::SmallVector<unsigned int, 1u>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::SmallVector<unsigned int, 1u>>>, unsigned int, llvm::SmallVector<unsigned int, 1u>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPa... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1d3ecc
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1d5da2
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1d5dac
movl (%rbx), %ecx
movl %ecx, (%rax)
leaq 0x18... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::BasicBlock*, llvm::Value*, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x1d662a
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0xa608d
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %rax... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function*, llvm::Function*, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, llvm::Function*>>, llvm::Function*, llvm::Function*, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, llvm::Function*>>::clear(... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1dc9c7
cmpl $0x0, 0xc(%rdi)
je 0x1dcaa0
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1df6ba
testq %rcx, %rcx
je 0x1dca98
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalObject*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalObject*, void>, llvm::detail::DenseSetPair<llvm::GlobalObject*>>, llvm::GlobalObject*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalObject*, void>, llvm::detail::DenseSetPair<llvm::Glob... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1df250
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, %r11d
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%rsi)
jne 0x1df217
movq %r1... | /llvm/ADT/DenseMap.h |
llvm::MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() | Expected<bool>
MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
IndexCursor = Stream;
SmallVector<uint64_t, 64> Record;
GlobalDeclAttachmentPos = 0;
// Get the abbrevs, and preload record positions to make them lazy-loadable.
while (true) {
uint64_t SavedPos = IndexCursor.GetCurrentBitN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0xc8(%rsi), %rbx
leaq 0x148(%rsi), %r15
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, 0x148(%rsi)
movups %xmm1, 0x158(%rsi)
movl 0x20(%rbx), %eax
movl %ea... | /Bitcode/Reader/MetadataLoader.cpp |
llvm::MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(llvm::Function&, llvm::ArrayRef<llvm::Instruction*>) | Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
Function &F, ArrayRef<Instruction *> InstructionList) {
if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
return Err;
SmallVector<uint64_t, 64> Record;
PlaceholderQueue Placeholders;
while (true) {
BitstreamEntry ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0xc8(%rsi), %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x2a8a90
cmpq $0x0, (%rbx)
jne 0x1e79d3
movq %r15, 0x58(%rsp)
movq %r14, 0x50(%rsp)
le... | /Bitcode/Reader/MetadataLoader.cpp |
llvm::MetadataLoader::MetadataLoaderImpl::upgradeCUVariables() | void upgradeCUVariables() {
if (!NeedUpgradeToDIGlobalVariableExpression)
return;
// Upgrade list of variables attached to the CUs.
if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
auto *CU = cast<DI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
cmpb $0x1, 0x412(%rdi)
jne 0x1e8c7a
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rdi
leaq 0x20f943(%rip), %rax # 0x3f838c
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
callq 0x26c1... | /Bitcode/Reader/MetadataLoader.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DILocalScope*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::DILocalScope*, void>, llvm::detail::DenseSetPair<llvm::DILocalScope*>>, llvm::DILocalScope*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::DILocalScope*, void>, llvm::detail::DenseSetPair<llvm::DILocalSc... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1e9d04
testb %al, %al
je 0x1e9cf1
movq (%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x1e9cfe
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MDString*, llvm::DICompositeType*, 1u, llvm::DenseMapInfo<llvm::MDString*, void>, llvm::detail::DenseMapPair<llvm::MDString*, llvm::DICompositeType*>>, llvm::MDString*, llvm::DICompositeType*, llvm::DenseMapInfo<llvm::MDString*, void>, llvm::detail::DenseMapPair<llvm::MDStri... | 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
leaq 0x8(%rdi), %rax
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rax
movl $0x1, %ecx
cmovel 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1eb740
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MDString*, std::unique_ptr<llvm::MDTuple, llvm::TempMDNodeDeleter>, 1u, llvm::DenseMapInfo<llvm::MDString*, void>, llvm::detail::DenseMapPair<llvm::MDString*, std::unique_ptr<llvm::MDTuple, llvm::TempMDNodeDeleter>>>, llvm::MDString*, std::unique_ptr<llvm::MDTuple, llvm::Tem... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1ebaf0
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1ebae6
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1ebb8e
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0... | /llvm/ADT/DenseMap.h |
llvm::BitcodeReaderValueList::getValueFwdRef(unsigned int, llvm::Type*, unsigned int, llvm::BasicBlock*) | Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty,
unsigned TyID,
BasicBlock *ConstExprInsertBB) {
// Bail out for a clearly invalid value.
if (Idx >= RefsUpperBound)
return nullptr;
if (Idx >= size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl %esi, 0x18(%rdi)
jbe 0x1ee350
movq %r8, %r12
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %r14
movl %ecx, 0x4(%rsp)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x5, %rax
cmpl %esi, %eax
ja 0x1ee1dc
leal 0x1(%r13), %esi
movq %r14, %r... | /Bitcode/Reader/ValueList.cpp |
llvm::APFloat::Storage::Storage(llvm::APFloat::Storage&&) | Storage(Storage &&RHS) {
if (usesLayout<IEEEFloat>(*RHS.semantics)) {
new (this) IEEEFloat(std::move(RHS.IEEE));
return;
}
if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
new (this) DoubleAPFloat(std::move(RHS.Double));
return;
}
llvm_unreachable("Unexpecte... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
callq 0xc24dc
movq %r14, %rdi
movq %rbx, %rsi
cmpq %r15, %rax
je 0x1ee400
popq %rbx
popq %r14
popq %r15
jmp 0xc2de8
popq %rbx
popq %r14
popq %r15
jmp 0xc8d92
| /llvm/ADT/APFloat.h |
llvm::APFloat::Storage::Storage(llvm::APFloat::Storage const&) | Storage(const Storage &RHS) {
if (usesLayout<IEEEFloat>(*RHS.semantics)) {
new (this) IEEEFloat(RHS.IEEE);
return;
}
if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
new (this) DoubleAPFloat(RHS.Double);
return;
}
llvm_unreachable("Unexpected semantics");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
callq 0xc24dc
movq %r14, %rdi
movq %rbx, %rsi
cmpq %r15, %rax
je 0x1ee66c
popq %rbx
popq %r14
popq %r15
jmp 0xc2da8
popq %rbx
popq %r14
popq %r15
jmp 0xc8d02
| /llvm/ADT/APFloat.h |
llvm::SlotTracker::processFunction() | void SlotTracker::processFunction() {
ST_DEBUG("begin processFunction!\n");
fNext = 0;
// Process function metadata if it wasn't hit at the module-level.
if (!ShouldInitializeAllMetadata)
processFunctionMetadata(*TheFunction);
// Add all the function arguments with no names.
for(Function::const_arg_it... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0xa0(%rdi)
cmpb $0x0, 0x19(%rdi)
jne 0x1ef505
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1ef3da
movq 0x10(%rbx), %r14
testb $0x1, 0x2(%r14)
je 0x1ef518
movq %r14, %rdi
callq 0x251c92
movq 0x58(%r14), %r12
mo... | /IR/AsmWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Comdat const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseSetPair<llvm::Comdat const*>>, llvm::Comdat const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseSetPair<llvm::Comdat co... | 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 0x1f76db
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
n... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::AssemblyWriter::printMetadataAttachments(llvm::SmallVectorImpl<std::pair<unsigned int, llvm::MDNode*>> const&, llvm::StringRef) | [[nodiscard]] bool empty() const { return !Size; } | cmpl $0x0, 0x8(%rsi)
je 0x1f78c3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
cmpl $0x0, 0x138(%rdi)
jne 0x1f77b7
leaq 0x130(%r15), %rsi
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, %rdi
andq ... | /llvm/ADT/SmallVector.h |
PrintDSOLocation(llvm::GlobalValue const&, llvm::formatted_raw_ostream&) | bool isDSOLocal() const {
return IsDSOLocal;
} | movl 0x20(%rdi), %eax
btl $0xe, %eax
jae 0x1f7993
movl %eax, %ecx
andl $0xf, %ecx
leal -0x7(%rcx), %edx
cmpl $0x2, %edx
jb 0x1f7993
testb $0x30, %al
setne %al
cmpl $0x9, %ecx
setne %cl
testb %cl, %al
je 0x1f7994
retq
leaq 0x175e4b(%rip), %rax # 0x36d7e6
movl $0xa, %edx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x90d0a
| /llvm/IR/GlobalValue.h |
PrintCallingConv(unsigned int, llvm::raw_ostream&) | static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
switch (cc) {
default: Out << "cc" << cc; break;
case CallingConv::Fast: Out << "fastcc"; break;
case CallingConv::Cold: Out << "coldcc"; break;
case CallingConv::AnyReg: Out << "anyregcc"; break;
... | pushq %rbx
movl %edi, %ebx
leal -0x8(%rbx), %eax
cmpl $0x67, %eax
ja 0x1f7a51
leaq 0x175a58(%rip), %rcx # 0x36d470
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x175df2(%rip), %rax # 0x36d81a
jmp 0x1f7c83
leaq 0x176074(%rip), %rax # 0x36daa8
jmp 0x1f7c75
leaq 0x17607e(%rip), %rax # 0x36dabe
jm... | /IR/AsmWriter.cpp |
maybePrintCallAddrSpace(llvm::Value const*, llvm::Instruction const*, llvm::raw_ostream&) | static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
raw_ostream &Out) {
// We print the address space of the call if it is non-zero.
if (Operand == nullptr) {
Out << " <cannot get addrspace!>";
return;
}
unsigned CallAddrSpace = Operand->ge... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdi, %rdi
je 0x1fe3f5
movq 0x8(%rdi), %rax
movl $0xfe, %ecx
andl 0x8(%rax), %ecx
cmpl $0x12, %ecx
jne 0x1fe39e
movq 0x10(%rax), %rax
movq (%rax), %rax
movl 0x8(%rax), %r14d
cmpl $0xff, %r14d
ja 0x1fe3c1
movq %rsi, %rdi
callq 0x1f2556
testq %rax, %rax
je 0x1fe3c1
c... | /IR/AsmWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>, llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>::... | 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 0x1f95a2
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1ff39b
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1f9634
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $0x0... | /llvm/ADT/DenseMap.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::join<llvm::StringRef*>(llvm::StringRef*, llvm::StringRef*, llvm::StringRef) | inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
using tag = typename std::iterator_traits<IteratorT>::iterator_category;
return detail::join_impl(Begin, End, Separator, tag());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x203272
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdx, %rsi
subq %r13, %rsi
sarq $0x4, %rsi
decq %rsi
imulq %r8, %rsi
m... | /llvm/ADT/StringExtras.h |
llvm::AttributeSet::removeAttribute(llvm::LLVMContext&, llvm::StringRef) const | AttributeSet AttributeSet::removeAttribute(LLVMContext &C,
StringRef Kind) const {
if (!hasAttribute(Kind)) return *this;
AttrBuilder B(C, *this);
B.removeAttribute(Kind);
return get(C, B);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2037a6
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x10(%rsp), %rsi
movq %rdx, (%rsi)
movq %rcx, 0x8(%rsi)
addq $0x18, %rdi
leaq 0x8(%rsp), %rdx
callq 0x20609c
testb %al, %al
je 0x2037a6
movq (%... | /IR/Attributes.cpp |
llvm::AttrBuilder::removeAttribute(llvm::StringRef) | AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
auto It = lower_bound(Attrs, A, AttributeComparator());
if (It != Attrs.end() && It->hasAttribute(A))
Attrs.erase(It);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %ecx
leaq (%rdi,%rcx,8), %rsi
movq %rax, %rdx
callq 0x205b8e
movl 0x10(%rbx), %r14d
shlq $0x3, %r14
addq 0x8(%rbx), %r14
cmpq %r14, %rax
je 0x203826
movq %rax, %... | /IR/Attributes.cpp |
llvm::AttrBuilder::getAttribute(llvm::Attribute::AttrKind) const | Attribute AttrBuilder::getAttribute(Attribute::AttrKind A) const {
assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!");
auto It = lower_bound(Attrs, A, AttributeComparator());
if (It != Attrs.end() && It->hasAttribute(A))
return *It;
return {};
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0x205c3c
movl 0x10(%rbx), %ecx
shlq $0x3, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x205561
movl 0xc(%rsp), %esi
movq (%rax), %rdx
testq %rdx, %rdx
je 0x20553b... | /IR/Attributes.cpp |
llvm::AttrBuilder::getAttribute(llvm::StringRef) const | Attribute AttrBuilder::getAttribute(StringRef A) const {
auto It = lower_bound(Attrs, A, AttributeComparator());
if (It != Attrs.end() && It->hasAttribute(A))
return *It;
return {};
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq 0x8(%rdi), %rdi
movl 0x10(%r14), %ecx
leaq (%rdi,%rcx,8), %rsi
movq %rax, %rdx
callq 0x205c8f
movq %rax, %rbx
movl 0x10(%r14), %eax
shlq $0x3, %rax
addq 0x8(%r14), %rax
cmpq %rax, %rbx
je 0x2057ab
mov... | /IR/Attributes.cpp |
std::pair<llvm::DenseMapIterator<llvm::StringRef, llvm::Attribute, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::Attribute>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::Attribute, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapP... | 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 0x20609c
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x206050
xorl %ecx, %ecx
jmp 0x206072
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::IRBuilderBase::CreateAtomicRMW(llvm::AtomicRMWInst::BinOp, llvm::Value*, llvm::Value*, llvm::MaybeAlign, llvm::AtomicOrdering, unsigned char) | AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr,
Value *Val, MaybeAlign Align,
AtomicOrdering Ordering,
SyncScope::ID SSID = SyncScope::System) {
if (!Align) {
const DataLayout &DL = BB->getDa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0x1c(%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
btl $0x8, %r8d
jb 0x20c333
movq 0x30(%rbx), %rdi
callq 0x222372
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x1bb0d6
xorl %ecx, %ecx
te... | /llvm/IR/IRBuilder.h |
upgradeDbgIntrinsicToDbgRecord(llvm::StringRef, llvm::CallBase*) | static void upgradeDbgIntrinsicToDbgRecord(StringRef Name, CallBase *CI) {
DbgRecord *DR = nullptr;
if (Name == "label") {
DR = new DbgLabelRecord(unwrapMAVOp<DILabel>(CI, 0), CI->getDebugLoc());
} else if (Name == "assign") {
DR = new DbgVariableRecord(
unwrapMAVOp<Metadata>(CI, 0), unwrapMAVOp<D... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq -0x4(%rsi), %r12
cmpq $0x3, %r12
ja 0x216193
movq %rsi, %r14
movq %rdi, %r15
leaq 0x15a07a(%rip), %rax # 0x37014c
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1e4456(%rip), %rsi # 0x3fa538
movq ... | /IR/AutoUpgrade.cpp |
llvm::MemTransferBase<llvm::MemIntrinsic>::setSourceAlignment(llvm::MaybeAlign) | void setSourceAlignment(MaybeAlign Alignment) {
BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
if (Alignment)
BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
BaseCL::getContext(), *Alignment));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
callq 0x274dd0
movq %r14, %rdi
movq %rax, %rsi
movl $0x2, %edx
movl $0x51, %ecx
callq 0x204c68
movq %rax, 0x48(%rbx)
btl $0x8, %ebp
jae 0x216cf9
movq %rbx, %rdi
callq 0x274dd0
movq %rax, %rdi
mo... | /llvm/IR/IntrinsicInst.h |
llvm::UpgradeARCRuntime(llvm::Module&) | void llvm::UpgradeARCRuntime(Module &M) {
// This lambda converts normal function calls to ARC runtime functions to
// intrinsic calls.
auto UpgradeToIntrinsic = [&](const char *OldFunc,
llvm::Intrinsic::ID IntrinsicFunc) {
Function *Fn = M.getFunction(OldFunc);
if (!Fn)
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x15eb03(%rip), %rsi # 0x375c1d
movl $0xfb, %edx
callq 0x21776a
leaq 0x15b4fb(%rip), %rax # 0x372626
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0... | /IR/AutoUpgrade.cpp |
llvm::upgradeInstructionLoopAttachment(llvm::MDNode&) | MDNode *llvm::upgradeInstructionLoopAttachment(MDNode &N) {
auto *T = dyn_cast<MDTuple>(&N);
if (!T)
return &N;
if (none_of(T->operands(), isOldLoopArgument))
return &N;
SmallVector<Metadata *, 8> Ops;
Ops.reserve(T->getNumOperands());
for (Metadata *MD : T->operands())
Ops.push_back(upgradeLo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r14
xorl %r12d, %r12d
cmpb $0x5, (%rdi)
cmoveq %rdi, %r12
jne 0x218abf
leaq -0x10(%r12), %r15
movq -0x10(%r12), %rax
testb $0x2, %al
jne 0x218739
leal (%rax,%rax), %ecx
andl $0x78, %ecx
movq %r15, %rdi
subq %rcx, %rdi
shrl $0... | /IR/AutoUpgrade.cpp |
isOldLoopArgument(llvm::Metadata*) | static bool isOldLoopArgument(Metadata *MD) {
auto *T = dyn_cast_or_null<MDTuple>(MD);
if (!T)
return false;
if (T->getNumOperands() < 1)
return false;
auto *S = dyn_cast_or_null<MDString>(T->getOperand(0));
if (!S)
return false;
return S->getString().starts_with("llvm.vectorizer.");
} | xorl %eax, %eax
testq %rdi, %rdi
je 0x218ae2
cmpb $0x5, (%rdi)
cmoveq %rdi, %rax
testq %rax, %rax
je 0x218afb
pushq %rax
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x218afe
movl %ecx, %edx
shrl $0x6, %edx
andl $0xf, %edx
jmp 0x218b01
xorl %eax, %eax
retq
movl -0x18(%rax), %edx
testl %edx, %edx
je 0x218b3d
testb $0x2, %... | /IR/AutoUpgrade.cpp |
llvm::UpgradeDataLayoutString[abi:cxx11](llvm::StringRef, llvm::StringRef) | std::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) {
Triple T(TT);
// The only data layout upgrades needed for pre-GCN, SPIR or SPIRV are setting
// the address space of globals to 1. This does not apply to SPIRV Logical.
if (((T.isAMDGPU() && !T.isAMDGCN()) ||
(T.isSPIR() || (T.isSPIR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x48(%rsp), %rsi
movw $0x105, 0x20(%rsi) # imm = 0x105
movq %rcx, (%rsi)
movq %r8, 0x8(%rsi)
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x310... | /IR/AutoUpgrade.cpp |
upgradeArmOrAarch64IntrinsicFunction(bool, llvm::Function*, llvm::StringRef, llvm::Function*&) | static bool upgradeArmOrAarch64IntrinsicFunction(bool IsArm, Function *F,
StringRef Name,
Function *&NewFn) {
if (Name.starts_with("rbit")) {
// '(arm|aarch64).rbit'.
NewFn = Intrinsic::getDeclaration(F->getParen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x4, %rcx
jb 0x21970b
cmpl $0x74696272, (%r12) # imm = 0x74696272
je 0x219816
cmpq $0xe, %r15
jne 0x21972b
le... | /IR/AutoUpgrade.cpp |
llvm::IRBuilderBase::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const | Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
FastMathFlags FMF) const {
if (!FPMD)
FPMD = DefaultFPMathTag;
if (FPMD)
I->setMetadata(LLVMContext::MD_fpmath, FPMD);
I->setFastMathFlags(FMF);
return I;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
testq %rdx, %rdx
jne 0x21e323
movq 0x60(%rdi), %rdx
testq %rdx, %rdx
je 0x21e335
movq %rbx, %rdi
movl $0x3, %esi
callq 0x26701a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25b4e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /llvm/IR/IRBuilder.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.