name string | code string | asm string | file string |
|---|---|---|---|
llvm::RegBankSelect::RepairingPlacement::switchTo(llvm::RegBankSelect::RepairingPlacement::RepairingKind) | void switchTo(RepairingKind NewKind) {
assert(NewKind != Kind && "Already of the right Kind");
Kind = NewKind;
InsertPoints.clear();
CanMaterialize = NewKind != RepairingKind::Impossible;
HasSplit = false;
assert(NewKind != RepairingKind::Insert &&
"We would need more MI... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movl 0x18(%rdi), %r14d
testq %r14, %r14
je 0x1dce0fe
movq 0x10(%rbx), %r15
shlq $0x3, %r14
movq -0x8(%r15,%r14), %rdi
testq %rdi, %rdi
je 0x1dce0ef
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%r15,%r14)
addq... | /llvm/CodeGen/GlobalISel/RegBankSelect.h |
llvm::SmallVectorTemplateBase<std::unique_ptr<llvm::RegBankSelect::InsertPoint, std::default_delete<llvm::RegBankSelect::InsertPoint>>, false>::moveElementsForGrow(std::unique_ptr<llvm::RegBankSelect::InsertPoint, std::default_delete<llvm::RegBankSelect::InsertPoint>>*) | size_t size() const { return Size; } | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %ebx
testq %rbx, %rbx
je 0x1dcf9c6
movq (%rdi), %rax
leaq (,%rbx,8), %rcx
xorl %edx, %edx
movq (%rax,%rdx), %r8
movq %r8, (%rsi,%rdx)
movq $0x0, (%rax,%rdx)
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x1dcf9ad
testq %rbx, %rbx
je 0x1dcf9f1
movq (%rdi), %r14
shlq $0x3, %rbx
movq... | /llvm/ADT/SmallVector.h |
llvm::AsmPrinter::emitModuleIdents(llvm::Module&) | void AsmPrinter::emitModuleIdents(Module &M) {
if (!MAI->hasIdentDirective())
return;
if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
for (const MDNode *N : NMD->operands()) {
assert(N->getNumOperands() == 1 &&
"llvm.ident metadata entry can have only one operand");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq 0x40(%rdi), %rax
cmpb $0x1, 0x16e(%rax)
jne 0x1ddebc5
movq %rdi, %rbx
leaq 0x203320d(%rip), %rcx # 0x3e11d56
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movw $0x103, 0x20(%rax) # imm = 0x103
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1a730ba
te... | /CodeGen/AsmPrinter/AsmPrinter.cpp |
emitGlobalConstantFP(llvm::APFloat, llvm::Type*, llvm::AsmPrinter&) | static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) {
assert(ET && "Unknown float type");
APInt API = APF.bitcastToAPInt();
// First print a comment with what we think the original floating-point value
// should have been.
if (AP.isVerbose()) {
SmallString<8> StrVal;
APF.toString(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d5bc2
cmpb $0x1, 0x138(%r14)
jne 0x1de3426
leaq 0x30(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x8, -0x8(... | /CodeGen/AsmPrinter/AsmPrinter.cpp |
llvm::SmallVectorTemplateBase<(anonymous namespace)::SectionCPs, 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x10(%rsp), %r8
movl $0x30, %ecx
movq %r14, %rsi
callq 0x1cba3de
movq %rax, 0x8(%rsp)
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x1de66d7
movq (%rbx), %r12
leaq (%rax,%rax,2), %rb... | /llvm/ADT/SmallVector.h |
std::pair<llvm::DenseMapIterator<llvm::GCStrategy*, std::unique_ptr<llvm::GCMetadataPrinter, std::default_delete<llvm::GCMetadataPrinter>>, llvm::DenseMapInfo<llvm::GCStrategy*, void>, llvm::detail::DenseMapPair<llvm::GCStrategy*, std::unique_ptr<llvm::GCMetadataPrinter, std::default_delete<llvm::GCMetadataPrinter>>>, ... | 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 0x1de7562
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1de7514
xorl %ecx, %ecx
jmp 0x1de753c
movq %r... | /llvm/ADT/DenseMap.h |
llvm::AsmPrinter::PrintSpecial(llvm::MachineInstr const*, llvm::raw_ostream&, llvm::StringRef) const | void AsmPrinter::PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
StringRef Code) const {
if (Code == "private") {
const DataLayout &DL = MF->getDataLayout();
OS << DL.getPrivateGlobalPrefix();
} else if (Code == "comment") {
OS << MAI->getCommentString();
} else if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x3, %r8
je 0x1de9a88
cmpq $0x7, %r12
jne 0x1de9b48
leaq 0x1685d6f(%rip), %rsi # 0x346f7b0
movq %r13, %rdi
movq %r12, %rdx
callq 0x751d10
testl %eax, ... | /CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp |
llvm::DIEValue::print(llvm::raw_ostream&) const | LLVM_DUMP_METHOD
void DIEValue::print(raw_ostream &O) const {
switch (Ty) {
case isNone:
llvm_unreachable("Expected valid DIEValue");
#define HANDLE_DIEVALUE(T) \
case is##T: \
getDIE##T().... | movl (%rdi), %eax
decl %eax
cmpl $0xb, %eax
ja 0x1dec6b1
leaq 0x31fa45c(%rip), %rcx # 0x4fe6a98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rdi
jmp 0x1ded1e2
movq 0x8(%rdi), %rdi
jmp 0x1ded44a
movq 0x8(%rdi), %rdi
jmp 0x1ded2e6
addq $0x8, %rdi
jmp 0x1ded3f6
addq $0x8, %rdi
jmp 0x1ded27a
addq $0x... | /CodeGen/AsmPrinter/DIE.cpp |
llvm::DIEString::sizeOf(llvm::dwarf::FormParams const&, llvm::dwarf::Form) const | unsigned DIEString::sizeOf(const dwarf::FormParams &FormParams,
dwarf::Form Form) const {
// Index of string in symbol table.
switch (Form) {
case dwarf::DW_FORM_GNU_str_index:
case dwarf::DW_FORM_strx:
case dwarf::DW_FORM_strx1:
case dwarf::DW_FORM_strx2:
case dwarf::DW_FORM_st... | pushq %rax
cmpl $0xe, %edx
jne 0x1decff0
cmpb $0x1, 0x4(%rsi)
jne 0x1ded005
movzwl %dx, %ecx
cmpl $0x6, %ecx
jle 0x1ded029
cmpl $0x17, %ecx
je 0x1decfe2
cmpl $0xe, %ecx
jne 0x1ded035
cmpb $0x0, 0x3(%rsi)
setne %al
shlb $0x2, %al
addb $0x4, %al
jmp 0x1ded037
movq (%rdi), %rax
movq %rax, %rcx
andq $-0x8, %rcx
notl %eax
a... | /CodeGen/AsmPrinter/DIE.cpp |
llvm::DIEDelta::sizeOf(llvm::dwarf::FormParams const&, llvm::dwarf::Form) const | unsigned DIEDelta::sizeOf(const dwarf::FormParams &FormParams,
dwarf::Form Form) const {
switch (Form) {
case dwarf::DW_FORM_data4:
return 4;
case dwarf::DW_FORM_data8:
return 8;
case dwarf::DW_FORM_sec_offset:
return FormParams.getDwarfOffsetByteSize();
default:
llvm... | cmpl $0x6, %edx
je 0x1ded0b5
cmpl $0x17, %edx
jne 0x1ded0bb
xorl %eax, %eax
cmpb $0x0, 0x3(%rsi)
setne %al
leal 0x4(,%rax,4), %eax
retq
movl $0x4, %eax
retq
movl $0x8, %eax
retq
nop
| /CodeGen/AsmPrinter/DIE.cpp |
llvm::DebugLocEntry& llvm::SmallVectorImpl<llvm::DebugLocEntry>::emplace_back<llvm::MCSymbol const*&, llvm::MCSymbol*, llvm::SmallVector<llvm::DbgValueLoc, 4u>&>(llvm::MCSymbol const*&, llvm::MCSymbol*&&, llvm::SmallVector<llvm::DbgValueLoc, 4u>&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x1df4690
movq (%rbx), %r8
imulq $0x70, %rax, %rax
leaq (%r8,%rax), %r14
movq (%rsi), %r9
movq (%rdx), %rdx
movq (%rcx), %rsi
movl 0x8(%rcx), %ecx
leaq 0x10(%r8,%rax), %rdi
movq %r9, -0x10(%rdi)
movq %rdx, -0x8(%rdi)
leaq 0x2... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::LexicalScope*, llvm::SmallVector<llvm::DbgLabel*, 4u>, llvm::DenseMapInfo<llvm::LexicalScope*, void>, llvm::detail::DenseMapPair<llvm::LexicalScope*, llvm::SmallVector<llvm::DbgLabel*, 4u>>>, llvm::LexicalScope*, llvm::SmallVector<llvm::DbgLabel*, 4u>, llvm::DenseMapInfo<llvm::Le... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0x1df633b
cmpl $0x0, 0xc(%rbx)
je 0x1df63a9
shll $0x2, %ecx
movl 0x10(%rbx), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
jne 0x1df635d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1e04540
testq %r... | /llvm/ADT/DenseMap.h |
llvm::DwarfDebug::initSkeletonUnit(llvm::DwarfUnit const&, llvm::DIE&, std::unique_ptr<llvm::DwarfCompileUnit, std::default_delete<llvm::DwarfCompileUnit>>) | void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
std::unique_ptr<DwarfCompileUnit> NewU) {
if (!CompilationDir.empty())
NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
addGnuPubAttributes(*NewU, Die);
SkeletonHolder.addUnit(std::move(NewU));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0xb58(%rdi)
je 0x1df91b1
movq (%rbx), %rdi
movq 0xb50(%r14), %rcx
movq 0xb58(%r14), %r8
movq %r15, %rsi
movl $0x1b, %edx
callq 0x1e0a3b8
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1e3cbcc
testb %al, %al
je 0... | /CodeGen/AsmPrinter/DwarfDebug.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MDNode const*, unsigned long, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, unsigned long>>, llvm::MDNode const*, unsigned long, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, unsigne... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x1e05bb8
testb %al, %al
je 0x1df97dc
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x15938e9(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
void finishCallSiteParams<llvm::MachineLocation>(llvm::MachineLocation, llvm::DIExpression const*, llvm::ArrayRef<FwdRegParamInfo>, llvm::SmallVector<llvm::DbgCallSiteParam, 4u>&) | static void finishCallSiteParams(ValT Val, const DIExpression *Expr,
ArrayRef<FwdRegParamInfo> DescribedParams,
ParamSet &Params) {
for (auto Param : DescribedParams) {
bool ShouldCombineExpressions = Expr && Param.Expr->getNumElements() > 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
testq %rcx, %rcx
je 0x1dfb87c
movq %rdx, %r15
movq %rsi, %r12
movq %rcx, %rax
shlq $0x4, %rax
addq %rdx, %rax
movq %rax, 0x18(%rsp)
leaq 0xc0(%rsp), %rbp
movq 0x8(%r15),... | /CodeGen/AsmPrinter/DwarfDebug.cpp |
std::pair<std::pair<unsigned int, llvm::SmallVector<FwdRegParamInfo, 2u>>*, bool> llvm::MapVector<unsigned int, llvm::SmallVector<FwdRegParamInfo, 2u>, llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>, llvm::SmallVector<std::pair<... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&...Args) {
auto [It, Inserted] = Map.insert(std::make_pair(Key, 0));
if (Inserted) {
It->second = Vector.size();
Vector.emplace_back(std::piecewise_construct,
std::forward_as_tuple(std::move(Key)),
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x4(%rsp), %rcx
movl %eax, -0x4(%rcx)
movl $0x0, (%rcx)
leaq 0x10(%rsp), %r12
movq %rsp, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa49778
leaq 0x18(%rbx), %rdi
cmpb $0x1, 0x10(%r12)
jne... | /llvm/ADT/MapVector.h |
llvm::SmallVectorImpl<FwdRegParamInfo>::operator=(llvm::SmallVectorImpl<FwdRegParamInfo> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1dfbd24
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x1dfbcc9
cmpl %r14d, 0xc(%rbx)
jae 0x1dfbce2
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x10, %ecx
movq %rbx, %rdi
movq %r14, %rdx
... | /llvm/ADT/SmallVector.h |
combineDIExpressions(llvm::DIExpression const*, llvm::DIExpression const*) | static const DIExpression *combineDIExpressions(const DIExpression *Original,
const DIExpression *Addition) {
std::vector<uint64_t> Elts = Addition->getElements().vec();
// Avoid multiple DW_OP_stack_values.
if (Original->isImplicit() && Addition->isImplicit())
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
movq 0x18(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x16aa812
movq %rbx, %rdi
callq 0x19f9a94
testb %al, %al
je 0x1dfc103
movq %r14, %rdi
callq 0x19f9a94
testb %al, %al
je 0... | /CodeGen/AsmPrinter/DwarfDebug.cpp |
llvm::SmallVectorImpl<llvm::DbgValueLocEntry>::operator=(llvm::SmallVectorImpl<llvm::DbgValueLocEntry> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1dfc469
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x1dfc3ff
cmpl %r14d, 0xc(%rbx)
jae 0x1dfc41d
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x18, %ecx
movq %rbx, %rdi
movq %r14, %rdx
... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<llvm::DbgValueLocEntry>::assignRemote(llvm::SmallVectorImpl<llvm::DbgValueLocEntry>&&) | 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 0x1dfc719
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::SmallVectorImpl<llvm::RangeSpan>::assignRemote(llvm::SmallVectorImpl<llvm::RangeSpan>&&) | 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 0x1dfcf8d
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::MapVector<llvm::MCSection const*, std::vector<llvm::DebugLocStream::Entry const*, std::allocator<llvm::DebugLocStream::Entry const*>>, llvm::DenseMap<llvm::MCSection const*, unsigned int, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, unsigned int>>, llvm::Sma... | 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 0x1dfdc3a
movq (%r15), %r12
cmpb $0x1, 0x10(%r15)
jne 0x1dfdbdd
leaq 0x1... | /llvm/ADT/MapVector.h |
std::pair<llvm::MCSection const*, std::vector<llvm::RangeSpan const*, std::allocator<llvm::RangeSpan const*>>> const* llvm::SmallVectorTemplateCommon<std::pair<llvm::MCSection const*, std::vector<llvm::RangeSpan const*, std::allocator<llvm::RangeSpan const*>>>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorT... | 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 0x1dfe138
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rbx, %rax
set... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int>>::copyFrom(llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int>> const&) | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x129ef46
movq (%rbx), %rdi
movl 0x10(%rbx), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
testq %r15, %r15
je 0x1dfe6f3
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %rdi
movl... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<llvm::DwarfDebug::MinimizeAddrInV5, false, llvm::cl::parser<llvm::DwarfDebug::MinimizeAddrInV5>>, char [20], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::ValuesClass, llvm::cl::initializer<llvm::DwarfDebug::MinimizeAddrInV5>>(llvm::cl::opt<llvm::DwarfDebug::MinimizeAddrInV5, fals... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7512e0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1c90c20
movl (%r13), %eax
movzwl 0xa(%rbx), %ecx
shll $0x5, %e... | /llvm/Support/CommandLine.h |
llvm::detail::DenseMapPair<llvm::DIGlobalVariable*, llvm::SmallVector<llvm::DwarfCompileUnit::GlobalExpr, 1u>>* llvm::DenseMapBase<llvm::DenseMap<llvm::DIGlobalVariable*, llvm::SmallVector<llvm::DwarfCompileUnit::GlobalExpr, 1u>, llvm::DenseMapInfo<llvm::DIGlobalVariable*, void>, llvm::detail::DenseMapPair<llvm::DIGlob... | 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 0x1e010b5
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::DwarfStringPool::emit(llvm::AsmPrinter&, llvm::MCSection*, llvm::MCSection*, bool) | unsigned size() const { return NumItems; } | cmpl $0x0, 0xc(%rdi)
je 0x1e097c4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %r8d, %ebp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rsi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
xorl %edx, %edx
callq *0xa8(%rax)
leaq 0x68(%rsp), %rsi
m... | /llvm/ADT/StringMap.h |
llvm::DwarfTypeUnit::DwarfTypeUnit(llvm::DwarfCompileUnit&, llvm::AsmPrinter*, llvm::DwarfDebug*, llvm::DwarfFile*, unsigned int, llvm::MCDwarfDwoLineTable*) | DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID,
MCDwarfDwoLineTable *SplitLineTable)
: DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU, UniqueID),
CU(CU), SplitLineTable... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %r15
movl $0x41, %esi
callq 0x1dec87c
leaq 0x3a4972f(%rip), %rax # 0x5853668
addq $0x10, %rax
movq %rax, (%rbx)
movl %ebp, 0x48... | /CodeGen/AsmPrinter/DwarfUnit.cpp |
llvm::DwarfUnit::addBlock(llvm::DIE&, llvm::dwarf::Attribute, llvm::dwarf::Form, llvm::DIEBlock*) | void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
DIEBlock *Block) {
Block->computeSize(Asm->getDwarfFormParams());
DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
addAttribute(Die, Attribute, Form, Block);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, (%rsp)
movq 0xb8(%rdi), %rdi
callq 0x1de1f74
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
shrq $0x20, %rax
movb %al, 0x4(%rsi)
movq %r12, %rdi
callq 0x1ded68c
movq ... | /CodeGen/AsmPrinter/DwarfUnit.cpp |
llvm::DwarfTypeUnit::getHeaderSize() const | unsigned getHeaderSize() const override {
return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature
Asm->getDwarfOffsetByteSize(); // Type DIE Offset
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
callq 0x1de1f58
movl %eax, %r14d
movq 0xd0(%rbx), %rdi
callq 0x1df137a
movl %eax, %ebp
movq 0xb8(%rbx), %rdi
callq 0x1de1f58
cmpw $0x5, %bp
sbbl $-0x1, %r14d
addl %r14d, %eax
addl $0xb, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| /CodeGen/AsmPrinter/DwarfUnit.h |
llvm::CodeViewDebug::lowerTypeFunction(llvm::DISubroutineType const*) | TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
for (const DIType *ArgType : Ty->getTypeArray())
ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgType));
// MSVC uses type none for variadic argument.
if (ReturnAndArgTypeIndices.si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x1e1edb0
leaq -0x10(%r14), %rax
addl %ecx,... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DICompositeType const*, llvm::codeview::TypeIndex, llvm::DenseMapInfo<llvm::DICompositeType const*, void>, llvm::detail::DenseMapPair<llvm::DICompositeType const*, llvm::codeview::TypeIndex>>, llvm::DICompositeType const*, llvm::codeview::TypeIndex, llvm::DenseMapInfo<llvm::DICom... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1e1f86d
cmpl $0x0, 0xc(%rdi)
je 0x1e1f946
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1e2883e
testq %rcx, %rcx
je 0x1e1f93e
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::CodeViewDebug::getTypeIndexForReferenceTo(llvm::DIType const*) | TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(const DIType *Ty) {
PointerRecord PR(getTypeIndex(Ty),
getPointerSizeInBytes() == 8 ? PointerKind::Near64
: PointerKind::Near32,
PointerMode::LValueReference, PointerOptions::None,... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x1e181ac
movl %eax, %ebp
movq 0x10(%rbx), %rax
movl $0x120, %edi # imm = 0x120
addq 0x990(%rax), %rdi
xorl %esi, %esi
callq 0x19e9984
movl 0x4(%rax), %eax
andl $-0x8, %eax
xorl %ecx, %ecx
cmpl $0x40, %eax... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::CodeViewDebug::emitLocalVariable(llvm::CodeViewDebug::FunctionInfo const&, llvm::CodeViewDebug::LocalVariable const&) | void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI,
const LocalVariable &Var) {
// LocalSym record, see SymbolRecord.h for more info.
MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL);
LocalSymFlags Flags = LocalSymFlags::None;
if (Var.DIVar->isParamete... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movl $0x113e, %esi # imm = 0x113E
callq 0x1e1bd6a
movq %rax, %r13
movq (%r12), %rax
xorl %ecx, %ecx
cmpw $0x0, 0x14(%rax)
setne %cl
leal 0x100(%rcx), %ebx
cmpl $0x0, 0x28(%r1... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
getSymbolName(llvm::codeview::SymbolKind) | static StringRef getSymbolName(SymbolKind SymKind) {
for (const EnumEntry<SymbolKind> &EE : getSymbolTypeNames())
if (EE.Value == SymKind)
return EE.Name;
return "";
} | pushq %rbx
movl %edi, %ebx
callq 0x2b3f6bb
testq %rdx, %rdx
sete %cl
je 0x1e221d9
cmpw %bx, 0x20(%rax)
jne 0x1e221ab
movq %rax, %rdi
jmp 0x1e221d0
leaq (%rdx,%rdx,4), %rcx
leaq -0x28(,%rcx,8), %rdx
testq %rdx, %rdx
sete %cl
je 0x1e221d9
leaq 0x28(%rax), %rdi
addq $-0x28, %rdx
cmpw %bx, 0x48(%rax)
movq %rdi, %rax
jne 0x... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::CodeViewDebug::emitDebugInfoForGlobal(llvm::CodeViewDebug::CVGlobalVariable const&) | void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
const DIGlobalVariable *DIGV = CVGV.DIGV;
const DIScope *Scope = DIGV->getScope();
// For static data members, get the scope from the declaration.
if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>(
DIGV->getRawStati... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, (%rsp)
leaq -0x10(%rdi), %rcx
movq -0x10(%rdi), %rdx
testb $0x2, %dl
jne 0x1e224ce
leal (%rdx,%rdx), %esi
andl $0x78, %esi
movq %rcx, %rax
subq %rsi, %rax
jmp 0x1e224d2
movq -0... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::DenseMap<std::pair<llvm::DINode const*, llvm::DIType const*>, llvm::codeview::TypeIndex, llvm::DenseMapInfo<std::pair<llvm::DINode const*, llvm::DIType const*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::DINode const*, llvm::DIType const*>, llvm::codeview::TypeIndex>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1e25cca
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ec... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::LexicalScope const*, llvm::SmallVector<llvm::CodeViewDebug::LocalVariable, 1u>, llvm::DenseMapInfo<llvm::LexicalScope const*, void>, llvm::detail::DenseMapPair<llvm::LexicalScope const*, llvm::SmallVector<llvm::CodeViewDebug::LocalVariable, 1u>>>, llvm::LexicalScope const*, ... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1e26a61
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
imulq $0x68, %r11, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, ... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<std::pair<llvm::MCSymbol const*, llvm::MCSymbol const*>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::MCSymbol const*, llvm::MCSymbol const*>> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1e2a280
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %edi
cmpl %r14d, %edi
jae 0x1e2a20b
cmpl %r14d, 0xc(%rbx)
jae 0x1e2a233
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x10, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1cba528
jmp 0x1e... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::DAGCombiner::CombineTo(llvm::SDNode*, llvm::SDValue const*, unsigned int, bool) | SDValue DAGCombiner::CombineTo(SDNode *N, const SDValue *To, unsigned NumTo,
bool AddTo) {
assert(N->getNumValues() == NumTo && "Broken CombineTo call!");
++NodesCombined;
LLVM_DEBUG(dbgs() << "\nReplacing.1 "; N->dump(&DAG); dbgs() << "\nWith: ";
To[0].dump(&DAG);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorb $0x1, %r12b
movq (%rdi), %rdi
leaq 0x3a14b6a(%rip), %r13 # 0x5853f48
addq $0x10, %r13
leaq 0x8(%rsp), %rax
movq %r13, (%rax)
movq 0x2b0(%rdi), %rcx
m... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
refineIndexType(llvm::SDValue&, llvm::ISD::MemIndexType&, llvm::EVT, llvm::SelectionDAG&) | bool refineIndexType(SDValue &Index, ISD::MemIndexType &IndexType, EVT DataVT,
SelectionDAG &DAG) {
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
// It's always safe to look through zero extends.
if (Index.getOpcode() == ISD::ZERO_EXTEND) {
if (TLI.shouldRemoveExtendFromGSInde... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%r8), %r15
movq (%rdi), %rsi
cmpl $0xd5, 0x18(%rsi)
jne 0x1e3f98d
movl 0x8(%rbx), %edx
movq (%r15), %rax
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %r8
callq *0x2b0(%rax)
testb %al, %al
je ... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
(anonymous namespace)::DAGCombiner::visitSIGN_EXTEND(llvm::SDNode*) | SDValue DAGCombiner::visitSIGN_EXTEND(SDNode *N) {
SDValue N0 = N->getOperand(0);
EVT VT = N->getValueType(0);
SDLoc DL(N);
if (VT.isVector())
if (SDValue FoldedVOp = SimplifyVCastOp(N, DL))
return FoldedVOp;
// sext(undef) = 0 because the top bit will all be the same.
if (N0.isUndef())
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, 0x40(%rsp)
movq 0x30(%rsi), %rax
movb (%rax), %cl
movq 0x8(%rax), %rax
movb %cl, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq 0x4... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
bool llvm::SDPatternMatch::TernaryOpc_match<llvm::SDPatternMatch::Value_bind, llvm::SDPatternMatch::SpecificInt_match, llvm::SDPatternMatch::CondCode_match, true, false>::match<llvm::SDPatternMatch::BasicMatchContext>(llvm::SDPatternMatch::BasicMatchContext const&, llvm::SDValue) | unsigned getOpcode() const { return (unsigned)NodeType; } | movl 0x18(%rdx), %eax
cmpl (%rdi), %eax
jne 0x1e93b42
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rdx), %rax
movq (%rax), %rcx
movl 0x8(%rax), %eax
movq 0x8(%rdi), %rdx
movq %rcx, (%rdx)
movl %eax, 0x8(%rdx)
leaq 0x10(%rdi), %r12
movq 0x28(%r14), %ra... | /llvm/CodeGen/SelectionDAGNodes.h |
llvm::SDValue& llvm::SmallVectorImpl<llvm::SDValue>::emplace_back<llvm::SDValue>(llvm::SDValue&&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x1e97ca0
movq (%rbx), %rcx
shlq $0x4, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rcx,%rax)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
movl %eax, %eax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
popq %rbx
retq
movq ... | /llvm/ADT/SmallVector.h |
mergeEltWithShuffle(llvm::SDValue&, llvm::SDValue&, llvm::ArrayRef<int>, llvm::SmallVectorImpl<int>&, llvm::SDValue, unsigned int) | static bool mergeEltWithShuffle(SDValue &X, SDValue &Y, ArrayRef<int> Mask,
SmallVectorImpl<int> &NewMask, SDValue Elt,
unsigned InsIndex) {
if (Elt.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
!isa<ConstantSDNode>(Elt.getOperand(1)))
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r10
movq 0x170(%rsp), %rsi
cmpl $0x9d, 0x18(%rsi)
jne 0x1ec1921
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq 0x28(%rax), %rdi
movl 0x18(%rdi), %edi
cmpl $0x23, %edi
je 0x1ec1752
cmpl $0xb, %edi
jne 0x1... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
std::pair<int, llvm::SDValue>& llvm::SmallVectorImpl<std::pair<int, llvm::SDValue>>::emplace_back<int&, llvm::SDValue&>(int&, llvm::SDValue&) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x1ec1ce2
movq (%rdi), %rcx
leaq (%rax,%rax,2), %rax
movl (%rsi), %esi
movl %esi, (%rcx,%rax,8)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rcx,%rax,8)
movl 0x8(%rdi), %eax
incl %eax
movl %eax, 0x8(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
addq $... | /llvm/ADT/SmallVector.h |
std::pair<int, llvm::SDValue>& llvm::SmallVectorTemplateBase<std::pair<int, llvm::SDValue>, true>::growAndEmplaceBack<unsigned long, llvm::SDValue&>(unsigned long&&, llvm::SDValue&) | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Use push_back with a copy in case Args has an internal reference,
// side-stepping reference invalidation problems without losing the realloc
// optimization.
push_back(T(std::forward<ArgTypes>(Args)...));
return this->back();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rsi)
movl $0x1, %edx
callq 0x1ec1bf8
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::DAGCombiner::scalarizeExtractedVectorLoad(llvm::SDNode*, llvm::EVT, llvm::SDValue, llvm::LoadSDNode*) | SDValue DAGCombiner::scalarizeExtractedVectorLoad(SDNode *EVE, EVT InVecVT,
SDValue EltNo,
LoadSDNode *OriginalLoad) {
assert(OriginalLoad->isSimple());
EVT ResultVT = EVE->getValueType(0);
EVT VecEltVT = InVecVT.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %r9d, %ebp
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r15
movb %dl, 0xc0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0x30(%rsi), %rax
movb (%rax), %cl
movq 0x8(%rax), %rax
movb %cl, 0x70(%rsp)
movq %rax, 0x78(%rsp)
te... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
bool llvm::all_of<llvm::SmallVector<(anonymous namespace)::DAGCombiner::refineExtractVectorEltIntoMultipleNarrowExtractVectorElts(llvm::SDNode*)::Entry, 32u>&, (anonymous namespace)::DAGCombiner::refineExtractVectorEltIntoMultipleNarrowExtractVectorElts(llvm::SDNode*)::$_0>(llvm::SmallVector<(anonymous namespace)::DAGC... | Callable() = default; | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rbx
movl 0x8(%rdi), %r13d
movq %r13, %r12
shlq $0x4, %r12
addq %rbx, %r12
movl %esi, 0xc(%rsp)
cmpq $0x4, %r13
jae 0x1ec2c2c
movq %r12, %rax
subq %rbx, %rax
sarq $0x4, %rax
cmpq $0x1, %rax
je 0x1ec2c96
cmpq $0x2, %rax
je 0x1ec2c13
mov... | /llvm/ADT/STLExtras.h |
llvm::FastISel::lookUpRegForValue(llvm::Value const*) | Register FastISel::lookUpRegForValue(const Value *V) {
// Look up the value to see if we already have a register for it. We
// cache values defined by Instructions across blocks, and other values
// only locally. This is because Instructions already have the SSA
// def-dominates-use requirement enforced.
Dens... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x20(%rdi), %rdi
addq $0x50, %rdi
callq 0x14e86f6
movq 0x20(%rbx), %rcx
movl 0x60(%rcx), %edx
shlq $0x4, %rdx
addq 0x50(%rcx), %rdx
cmpq %rdx, %rax
jne 0x1ec9ff1
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14e887a
movl 0x8(%rax), %ea... | /CodeGen/SelectionDAG/FastISel.cpp |
(anonymous namespace)::SelectionDAGLegalize::ExpandConstant(llvm::ConstantSDNode*) | SDValue SelectionDAGLegalize::ExpandConstant(ConstantSDNode *CP) {
SDLoc dl(CP);
EVT VT = CP->getValueType(0);
SDValue CPIdx = DAG.getConstantPool(CP->getConstantIntValue(),
TLI.getPointerTy(DAG.getDataLayout()));
Align Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlign(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rsi), %rsi
movq %rsi, 0x50(%rsp)
testq %rsi, %rsi
je 0x1eebd88
leaq 0x50(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r14), %eax
leaq 0x50(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq 0x30(%r... | /CodeGen/SelectionDAG/LegalizeDAG.cpp |
(anonymous namespace)::SelectionDAGLegalize::ExpandSPLAT_VECTOR(llvm::SDNode*) | SDValue SelectionDAGLegalize::ExpandSPLAT_VECTOR(SDNode *Node) {
SDLoc DL(Node);
EVT VT = Node->getValueType(0);
SDValue SplatVal = Node->getOperand(0);
return DAG.getSplatBuildVector(VT, DL, SplatVal);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rsi
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x1eecf77
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r14), %eax
leaq 0x8(%rsp), %r15
movl %eax, 0x8(%r15)
movq 0x28(%r14), %rax
movq 0x30(%r14)... | /CodeGen/SelectionDAG/LegalizeDAG.cpp |
llvm::SelectionDAGBuilder::visitSelect(llvm::User const&) | void SelectionDAGBuilder::visitSelect(const User &I) {
SmallVector<EVT, 4> ValueVTs;
ComputeValueVTs(DAG.getTargetLoweringInfo(), DAG.getDataLayout(), I.getType(),
ValueVTs);
unsigned NumValues = ValueVTs.size();
if (NumValues == 0) return;
SmallVector<SDValue, 4> Values(NumValues);
SDVal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %rbp
leaq 0x168(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x400000000, %r12 # imm = 0x400000000
movq %r12, -0x8(%r13)
movq %rdi, 0x28(%rsp)
movq 0x340(%rdi), %rax
movq 0x10(%rax), %rbx
movq 0x2... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitLandingPad(llvm::LandingPadInst const&) | void SelectionDAGBuilder::visitLandingPad(const LandingPadInst &LP) {
assert(FuncInfo.MBB->isEHPad() &&
"Call to landingpad not in landing pad!");
// If there aren't registers to copy the values into (e.g., during SjLj
// exceptions), then don't bother to create these DAG nodes.
const TargetLowering &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x340(%rdi), %rax
movq 0x398(%rdi), %rcx
movq 0x10(%rax), %r15
movq (%rcx), %rdi
callq 0x1a2e95c
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x358(%rax)
testl %eax, %eax
j... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
findUnwindDestinations(llvm::FunctionLoweringInfo&, llvm::BasicBlock const*, llvm::BranchProbability, llvm::SmallVectorImpl<std::pair<llvm::MachineBasicBlock*, llvm::BranchProbability>>&) | static void findUnwindDestinations(
FunctionLoweringInfo &FuncInfo, const BasicBlock *EHPadBB,
BranchProbability Prob,
SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
&UnwindDests) {
EHPersonality Personality =
classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
bool I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq (%rdi), %rdi
callq 0x1a2e95c
movq %rax, %rdi
callq 0x1a27b96
movq 0x10(%rsp), %rdx
cmpl $0xc, %eax
jne 0x1f014a7
movl 0xc(%rsp), %ecx
movl %ecx, 0x2c(%rsp)
m... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::addSuccessorWithProb(llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::BranchProbability) | void SelectionDAGBuilder::addSuccessorWithProb(MachineBasicBlock *Src,
MachineBasicBlock *Dst,
BranchProbability Prob) {
if (!FuncInfo.BPI)
Src->addSuccessorWithoutProb(Dst);
else {
if (Prob.isUnknown())
Prob... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x398(%rdi), %rax
cmpq $0x0, 0x20(%rax)
je 0x1f016b2
cmpl $-0x1, %ecx
jne 0x1f0169e
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1f01982
movl %eax, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %ecx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1751ea8
movq... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::shouldKeepJumpConditionsTogether(llvm::FunctionLoweringInfo const&, llvm::BranchInst const&, llvm::Instruction::BinaryOps, llvm::Value const*, llvm::Value const*, llvm::TargetLoweringBase::CondMergingParams) const | bool SelectionDAGBuilder::shouldKeepJumpConditionsTogether(
const FunctionLoweringInfo &FuncInfo, const BranchInst &I,
Instruction::BinaryOps Opc, const Value *Lhs, const Value *Rhs,
TargetLoweringBase::CondMergingParams Params) const {
if (I.getNumSuccessors() != 2)
return false;
if (!I.isConditio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl $0x7ffffff, %eax # imm = 0x7FFFFFF
andl 0x4(%rdx), %eax
cmpl $0x3, %eax
jne 0x1f02097
movl %ecx, %ebx
leaq 0x2a0(%rsp), %rax
movslq (%rax), %rcx
movq %rcx, (%rsp)
testq %rcx, %rcx
js 0x1f02097
movq %... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
std::pair<std::pair<llvm::Instruction const*, bool>*, bool> llvm::MapVector<llvm::Instruction const*, bool, llvm::SmallDenseMap<llvm::Instruction const*, unsigned int, 8u, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, unsigned int>>, llvm::SmallVector<std::pair... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&...Args) {
auto [It, Inserted] = Map.insert(std::make_pair(Key, 0));
if (Inserted) {
It->second = Vector.size();
Vector.emplace_back(std::piecewise_construct, std::forward_as_tuple(Key),
std::forward_as_tuple(std::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1f286b4
leaq 0x88(%rbx), %rdi
cmpb $0x1, 0x10(%r... | /llvm/ADT/MapVector.h |
llvm::SelectionDAGBuilder::visitSPDescriptorFailure(llvm::StackProtectorDescriptor&) | void
SelectionDAGBuilder::visitSPDescriptorFailure(StackProtectorDescriptor &SPD) {
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
TargetLowering::MakeLibCallOptions CallOptions;
CallOptions.setDiscardResult(true);
SDValue Chain =
TLI.makeLibCall(DAG, RTLIB::STACKPROTECTOR_CHECK_FAIL, MVT::isVoi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x340(%rdi), %r14
movq 0x10(%r14), %r15
xorl %eax, %eax
movb %al, 0xb0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movq %rax, 0xb8(%rsp)
movb %al, 0xc0(%rsp)
movq (%rdi), %rsi
movl 0x33... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitAtomicStore(llvm::StoreInst const&) | void SelectionDAGBuilder::visitAtomicStore(const StoreInst &I) {
SDLoc dl = getCurSDLoc();
AtomicOrdering Ordering = I.getOrdering();
SyncScope::ID SSID = I.getSyncScopeID();
SDValue InChain = getRoot();
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
EVT MemVT =
TLI.getMemValueType(DAG.ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rsi
movl 0x330(%rdi), %eax
movq $0x0, 0x50(%rsp)
movl %eax, 0x58(%rsp)
testq %rsi, %rsi
je 0x1f0b128
addq $0x30, %rsi
leaq 0x50(%rsp), %rdi
callq 0x8e1f10
movzwl 0x2(%r14), %ebp
movb 0x48(%r1... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitTargetIntrinsic(llvm::CallInst const&, unsigned int) | void SelectionDAGBuilder::visitTargetIntrinsic(const CallInst &I,
unsigned Intrinsic) {
// Ignore the callsite's attributes. A specific call site may be marked with
// readnone, but the lowering code will expect the chain based on the
// definition.
const Function ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movl %edx, %ebx
movq %rsi, %rbp
movq %rdi, %r14
movq -0x20(%rsi), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x1f0cd82
cmpb $0x0, (%rax)
cmoveq %rax, %r15
testq %r15, %r15
je 0x1f0cd91
movq 0x18(%r15), %rax
cmpq... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::DbgVariableIntrinsic::isKillLocation() const | bool isKillLocation() const {
return getWrappedLocation().isKillLocation(getExpression());
} | pushq %rax
movl 0x4(%rdi), %eax
shll $0x5, %eax
subq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movq %rsp, %rax
movq %rcx, (%rax)
movq 0x40(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq %rax, %rdi
callq 0x197826c
popq %rcx
retq
| /llvm/IR/IntrinsicInst.h |
expandExp(llvm::SDLoc const&, llvm::SDValue, llvm::SelectionDAG&, llvm::TargetLowering const&, llvm::SDNodeFlags) | static SDValue expandExp(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
const TargetLowering &TLI, SDNodeFlags Flags) {
if (Op.getValueType() == MVT::f32 &&
LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
// Put the exponent in the right bit position for later addition to ... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r9d
movq %rcx, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rcx
movl %edx, %edi
shlq $0x4, %rdi
movb (%rcx,%rdi), %al
cmpb $0xc, %al
jne 0x1f19b6c
movl 0x39cc2de(%rip), %r8d # 0x58e5dd0
decl %r8d
cmpl $0x11, %r8d
ja 0x1f19b6c
movq %rsi, 0x48(%rsp)
movl %edx, 0x50(%rsp)
mov... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitVectorSplice(llvm::CallInst const&) | void SelectionDAGBuilder::visitVectorSplice(const CallInst &I) {
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
SDLoc DL = getCurSDLoc();
SDValue V1 = getValue(I.getOperand(0));
SDValue V2 = getValue(I.getOperand(1));
int64_t Imm = cast... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x340(%rdi), %rax
movq 0x10(%rax), %r15
movq 0x28(%rax), %rdi
callq 0x1789320
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x8f1f84
movb %al, 0x40(%rsp)
movq %rdx, 0x48(%... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitVPLoad(llvm::VPIntrinsic const&, llvm::EVT, llvm::SmallVectorImpl<llvm::SDValue> const&) | void SelectionDAGBuilder::visitVPLoad(
const VPIntrinsic &VPIntrin, EVT VT,
const SmallVectorImpl<SDValue> &OpValues) {
SDLoc DL = getCurSDLoc();
Value *PtrOperand = VPIntrin.getArgOperand(0);
MaybeAlign Alignment = VPIntrin.getPointerAlignment();
AAMDNodes AAInfo = VPIntrin.getAAMetadata();
const MDN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, 0x80(%rsp)
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rsi
movl 0x330(%rdi), %eax
movq $0x0, 0x50(%rsp)
movl %eax, 0x58(%rsp)
testq %rsi, %rsi
je 0x1f1d90d
addq $0x30, %rsi
leaq 0x50(%rsp), %rd... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitMemChrCall(llvm::CallInst const&) | bool SelectionDAGBuilder::visitMemChrCall(const CallInst &I) {
const Value *Src = I.getArgOperand(0);
const Value *Char = I.getArgOperand(1);
const Value *Length = I.getArgOperand(2);
const SelectionDAGTargetInfo &TSI = DAG.getSelectionDAGInfo();
std::pair<SDValue, SDValue> Res =
TSI.EmitTargetCodeForMem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, 0x78(%rsp)
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %r13
movq 0x20(%rcx), %r14
movq 0x40(%rcx), %rbp
movq 0x340(%rdi), %r15
movq 0x8(%r15), %r12
movq (%rdi), %rsi
movl 0... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitStrCpyCall(llvm::CallInst const&, bool) | bool SelectionDAGBuilder::visitStrCpyCall(const CallInst &I, bool isStpcpy) {
const Value *Arg0 = I.getArgOperand(0), *Arg1 = I.getArgOperand(1);
const SelectionDAGTargetInfo &TSI = DAG.getSelectionDAGInfo();
std::pair<SDValue, SDValue> Res =
TSI.EmitTargetCodeForStrcpy(DAG, getCurSDLoc(), getRoot(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %edx, 0x5c(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %rbp
movq 0x20(%rcx), %r13
movq 0x340(%rdi), %r15
movq 0x8(%r15), %r12
movq (%rdi), %rsi
movl 0x330(%... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitStrCmpCall(llvm::CallInst const&) | bool SelectionDAGBuilder::visitStrCmpCall(const CallInst &I) {
const Value *Arg0 = I.getArgOperand(0), *Arg1 = I.getArgOperand(1);
const SelectionDAGTargetInfo &TSI = DAG.getSelectionDAGInfo();
std::pair<SDValue, SDValue> Res =
TSI.EmitTargetCodeForStrcmp(DAG, getCurSDLoc(), DAG.getRoot(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %rbp
movq 0x20(%rcx), %r13
movq 0x340(%rdi), %r15
movq 0x8(%r15), %r12
movq (%rdi), %rsi
movl 0x330(%rdi), %eax
movq $0x0, ... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitStrLenCall(llvm::CallInst const&) | bool SelectionDAGBuilder::visitStrLenCall(const CallInst &I) {
const Value *Arg0 = I.getArgOperand(0);
const SelectionDAGTargetInfo &TSI = DAG.getSelectionDAGInfo();
std::pair<SDValue, SDValue> Res =
TSI.EmitTargetCodeForStrlen(DAG, getCurSDLoc(), DAG.getRoot(),
getValue(Arg0)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %r13
movq 0x340(%rdi), %r15
movq 0x8(%r15), %r12
movq (%rdi), %rsi
movl 0x330(%rdi), %eax
movq $0x0, 0x28(%rsp)
movl %eax, ... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::CallBase::getOperandBundle(llvm::StringRef) const | std::optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
OperandBundleUse U = getOperandBundleAt(i);
if (U.getTagName() == Name)
return U;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdi, (%rsp)
movq %rsi, %r15
movq %rsi, %rdi
callq 0x8f17a6
testl %eax, %eax
sete %bpl
je 0x1f20f1a
movl %eax, %r12d
shlq $0x4, %r12
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x1a8f540
movq (%r... | /llvm/IR/InstrTypes.h |
llvm::SmallVectorTemplateBase<(anonymous namespace)::SDISelAsmOperandInfo, false>::destroy_range((anonymous namespace)::SDISelAsmOperandInfo*, (anonymous namespace)::SDISelAsmOperandInfo*) | static void destroy_range(T *S, T *E) {
while (S != E) {
--E;
E->~T();
}
} | cmpq %rdi, %rsi
je 0x1f29985
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq -0x28(%r14), %rdi
leaq -0x18(%r14), %rax
cmpq %rdi, %rax
je 0x1f298f8
callq 0x751980
movq -0x48(%r14), %rdi
leaq -0x38(%r14), %rax
cmpq %rdi, %rax
je 0x1f2990a
callq 0x751980
movq -0x68(%r14), %rdi
leaq -0x50(%r14), %rax
... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::Constant const*, unsigned int, llvm::DenseMapInfo<llvm::Constant const*, void>, llvm::detail::DenseMapPair<llvm::Constant const*, unsigned int>>::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<llvm::Constant const*, unsigned int, llvm::DenseMapInfo<llvm::Constant const*, void>, llvm::detail::DenseMapPair<llvm::Constant const*, unsigned int>>, llvm::Constant const*, unsigned int, llvm::DenseMapInfo<llvm::Constant const*, void>, llvm::detail::DenseMapPair<llvm::Constant const*... | 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 0x1f29f59
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::ISD::getVPExplicitVectorLengthIdx(unsigned int) | std::optional<unsigned> ISD::getVPExplicitVectorLengthIdx(unsigned Opcode) {
switch (Opcode) {
default:
return std::nullopt;
#define BEGIN_REGISTER_VP_SDNODE(VPSD, LEGALPOS, TDNAME, MASKPOS, EVLPOS) \
case ISD::VPSD: \
return EVLPOS;
#inclu... | addl $0xfffffe83, %edi # imm = 0xFFFFFE83
cmpl $0x61, %edi
ja 0x1f2c40a
movl %edi, %ecx
leaq 0x30c1ead(%rip), %rdx # 0x4fee2a8
movabsq $0x100000000, %rax # imm = 0x100000000
orq (%rdx,%rcx,8), %rax
retq
xorl %eax, %eax
retq
| /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::ISD::getSetCCOrOperation(llvm::ISD::CondCode, llvm::ISD::CondCode, llvm::EVT) | ISD::CondCode ISD::getSetCCOrOperation(ISD::CondCode Op1, ISD::CondCode Op2,
EVT Type) {
bool IsInteger = Type.isInteger();
if (IsInteger && (isSignedOp(Op1) | isSignedOp(Op2)) == 3)
// Cannot fold a signed integer setcc with an unsigned integer setcc.
return ISD::SETC... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movb %dl, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x9cbabe
testb %al, %al
je 0x1f2c6d7
movslq %ebp, %rcx
leaq 0x30c24fa(%rip), %rdx # 0x4feebbc
movslq %ebx, %rsi
movl -0x28(%rdx,%rsi,4), %esi
orl -0x28(%rdx,%rcx,4), %esi
movl $0x18,... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SDDbgValue::getSDNodes() const | SmallVector<SDNode *> getSDNodes() const {
SmallVector<SDNode *> Dependencies;
for (const SDDbgOperand &DbgOp : getLocationOps())
if (DbgOp.getKind() == SDDbgOperand::SDNODE)
Dependencies.push_back(DbgOp.getSDNode());
for (SDNode *Node : getAdditionalDependencies())
Dependencies.push_bac... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x600000000, %rax # imm = 0x600000000
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
testq %rax, %rax
je 0x1f2cde6
movq 0x8(%r14), %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d... | /CodeGen/SelectionDAG/SDNodeDbgValue.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::SDNode const*, llvm::SelectionDAG::NodeExtraInfo, llvm::DenseMapInfo<llvm::SDNode const*, void>, llvm::detail::DenseMapPair<llvm::SDNode const*, llvm::SelectionDAG::NodeExtraInfo>>, llvm::SDNode const*, llvm::SelectionDAG::NodeExtraInfo, llvm::DenseMapInfo<llvm::SDNode const*, vo... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0xa215ac
movl %eax, %ebp
testb %al, %al
je 0x1f2cfbd
movq 0x8(%rsp), %r14
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1f2cfa4
callq 0x751980
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
... | /llvm/ADT/DenseMap.h |
llvm::SelectionDAG::allnodes_clear() | void SelectionDAG::allnodes_clear() {
assert(&*AllNodes.begin() == &EntryNode);
AllNodes.remove(AllNodes.begin());
while (!AllNodes.empty())
DeallocateNode(&AllNodes.front());
#ifndef NDEBUG
NextPersistentId = 0;
#endif
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x150(%rdi), %r14
movq 0x158(%rdi), %rax
leaq -0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
cmpq %r14, 0x150(%rdi)
je 0x1f2e3d8
movq %rdi, %rbx
movq 0... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getZeroExtendInReg(llvm::SDValue, llvm::SDLoc const&, llvm::EVT) | SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT) {
EVT OpVT = Op.getValueType();
assert(VT.isInteger() && OpVT.isInteger() &&
"Cannot getZeroExtendInReg FP types");
assert(VT.isVector() == OpVT.isVector() &&
"getZeroExtendInReg type should be vector iff the operand "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movb %r8b, 0x48(%rsp)
movq %r9, 0x50(%rsp)
movq 0x30(%rsi), %rax
movl %edx, %edx
shlq $0x4, %rdx
movb (%rax,%rdx), %cl
movq 0x8(%rax,%rdx), %rax
movb %cl, 0x28(%rsp)
movq %r... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getConstantFP(double, llvm::SDLoc const&, llvm::EVT, bool) | SDValue SelectionDAG::getConstantFP(double Val, const SDLoc &DL, EVT VT,
bool isTarget) {
EVT EltVT = VT.getScalarType();
if (EltVT == MVT::f32)
return getConstantFP(APFloat((float)Val), DL, VT, isTarget);
if (EltVT == MVT::f64)
return getConstantFP(APFloat(Val), DL, VT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rsi, %rbx
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
movb %dl, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x903280
cmpb $0xd, %al
je 0x1f30a41
movzbl %al, %r12d
cmpl $0xc, %r12d
jne 0x1f30a7f
xorps %xmm0, ... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getConstantPool(llvm::MachineConstantPoolValue*, llvm::EVT, llvm::MaybeAlign, int, bool, unsigned int) | SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
MaybeAlign Alignment, int Offset,
bool isTarget, unsigned TargetFlags) {
assert((TargetFlags == 0 || isTarget) &&
"Cannot set target flags on target-independe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
movb 0xf0(%rsp), %al
movw %r8w, 0xa(%rsp)
movq %rsi, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movb %al, 0x9(%rsp)
cmpb $0x0, 0xb(%rsp)
jne 0x1f31546
movq 0x28(%rbx), %rdi
callq 0x1789320
movq 0x10(%rsp), %rcx
... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getTargetExternalSymbol(char const*, llvm::EVT, unsigned int) | SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, EVT VT,
unsigned TargetFlags) {
SDNode *&N =
TargetExternalSymbols[std::pair<std::string, unsigned>(Sym, TargetFlags)];
if (N) return SDValue(N, 0);
N = newSDNode<ExternalSymbolSDNode>(true, Sym, Tar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
leaq 0x330(%rdi), %rbx
leaq 0x18(%rsp), %r12
leaq 0xb(%rsp), %rdx
movq %r12, %rdi
callq 0x7c52c8
movl 0xc(%rsp), %eax
movl %eax, 0x20(%r12)
movq %rbx, %rdi
m... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::isNullConstant(llvm::SDValue) | unsigned getOpcode() const { return (unsigned)NodeType; } | movl 0x18(%rdi), %eax
cmpl $0x23, %eax
je 0x1f33005
cmpl $0xb, %eax
je 0x1f33005
xorl %edi, %edi
testq %rdi, %rdi
je 0x1f33021
pushq %rbx
movq 0x58(%rdi), %rdi
movl 0x20(%rdi), %ebx
addq $0x18, %rdi
cmpl $0x40, %ebx
ja 0x1f33024
cmpq $0x0, (%rdi)
jmp 0x1f3302b
xorl %eax, %eax
retq
callq 0x1c82ec2
cmpl %ebx, %eax
sete %... | /llvm/CodeGen/SelectionDAGNodes.h |
llvm::SelectionDAG::getCommutedVectorShuffle(llvm::ShuffleVectorSDNode const&) | SDValue SelectionDAG::getCommutedVectorShuffle(const ShuffleVectorSDNode &SV) {
EVT VT = SV.getValueType(0);
SmallVector<int, 8> MaskVec(SV.getMask());
ShuffleVectorSDNode::commuteMask(MaskVec);
SDValue Op0 = SV.getOperand(0);
SDValue Op1 = SV.getOperand(1);
return getVectorShuffle(VT, SDLoc(&SV), Op1, Op0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
movq 0x30(%rsi), %rax
movb (%rax), %bl
movq 0x8(%rax), %r14
movb (%rax), %cl
movq 0x8(%rax), %rax
leaq 0x50(%rsp), %rdi
movb %cl, (%rdi)
movq %rax, 0x8(%rdi)
movq 0x58(%rsi), %r12
callq 0x8fe048
movl... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::LabelSDNode* llvm::SelectionDAG::newSDNode<llvm::LabelSDNode, unsigned int&, unsigned int, llvm::DebugLoc const&, llvm::MCSymbol*&>(unsigned int&, unsigned int&&, llvm::DebugLoc const&, llvm::MCSymbol*&) | SDNodeT *newSDNode(ArgTypes &&... Args) {
return new (NodeAllocator.template Allocate<SDNodeT>())
SDNodeT(std::forward<ArgTypes>(Args)...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq 0x160(%rdi), %r13
testq %r13, %r13
je 0x1f33804
movq (%r13), %rax
movq %rax, 0x160(%rdi)
jmp 0x1f3381d
addq $0x168, %rdi # imm = 0x168
movl $0x70, %esi
movl $0x3, %edx
callq 0x8c3eba
mov... | /llvm/CodeGen/SelectionDAG.h |
llvm::SelectionDAG::getBlockAddress(llvm::BlockAddress const*, llvm::EVT, long, bool, unsigned int) | SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,
int64_t Offset, bool isTarget,
unsigned TargetFlags) {
unsigned Opc = isTarget ? ISD::TargetBlockAddress : ISD::BlockAddress;
SDVTList VTs = getVTList(VT);
FoldingSetN... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %r8, 0x10(%rsp)
testl %r9d, %r9d
movl $0x2b, %eax
movl $0x13, %esi
cmovnel %eax, %esi
movl %esi, 0xc(%rsp)
movl %edx, %edi
movq %rcx, %rsi
callq 0x1f58eb0
movq %rax, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x48(%rsp), ... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getAddrSpaceCast(llvm::SDLoc const&, llvm::EVT, llvm::SDValue, unsigned int, unsigned int) | SDValue SelectionDAG::getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr,
unsigned SrcAS, unsigned DestAS) {
SDVTList VTs = getVTList(VT);
SDValue Ops[] = {Ptr};
FoldingSetNodeID ID;
AddNodeIDNode(ID, ISD::ADDRSPACECAST, VTs, Ops);
ID.AddInteger(SrcAS);
ID.AddIntege... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %edi
movq %rcx, %rsi
callq 0x1f58eb0
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x20(%rsp), %rcx
movq %r14, (%rcx)
movl %ebp, 0x8(%rcx)
leaq 0x40(%rsp), %r12
movq %r12,... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::computeOverflowForUnsignedAdd(llvm::SDValue, llvm::SDValue) const | SelectionDAG::OverflowKind
SelectionDAG::computeOverflowForUnsignedAdd(SDValue N0, SDValue N1) const {
// X + 0 never overflow
if (isNullConstant(N1))
return OFK_Never;
// mulhi + 1 never overflow
KnownBits N1Known = computeKnownBits(N1);
if (N0.getOpcode() == ISD::UMUL_LOHI && N0.getResNo() == 1 &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r13
movq %rcx, %rdi
callq 0x1f32ff6
xorl %ebx, %ebx
testb %al, %al
jne 0x1f41414
leaq 0x58(%rsp), %rdi
movq %r15, %rbx
xorl %r15d, %r15d
movq %r13, %rsi
movq %r... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::computeOverflowForUnsignedMul(llvm::SDValue, llvm::SDValue) const | SelectionDAG::OverflowKind
SelectionDAG::computeOverflowForUnsignedMul(SDValue N0, SDValue N1) const {
// X * 0 and X * 1 never overflow.
if (isNullConstant(N1) || isOneConstant(N1))
return OFK_Never;
KnownBits N0Known = computeKnownBits(N0);
KnownBits N1Known = computeKnownBits(N1);
ConstantRange N0Rang... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r15
movq %rcx, %rdi
callq 0x1f32ff6
xorl %ebx, %ebx
testb %al, %al
jne 0x1f41880
movq %r14, %rdi
callq 0x1f41894
testb %al, %al
jne 0x1f41880
leaq 0x48(%rsp), %... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::canCreateUndefOrPoison(llvm::SDValue, llvm::APInt const&, bool, bool, unsigned int) const | bool SelectionDAG::canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts,
bool PoisonOnly, bool ConsiderFlags,
unsigned Depth) const {
// TODO: Assume we don't know anything for now.
EVT VT = Op.getValueType();
if (VT.isSca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r12
movq 0x30(%rsi), %rcx
movl %edx, %edx
shlq $0x4, %rdx
movb (%rcx,%rdx), %al
movq 0x8(%rcx,%rdx), %rcx
movb %al, 0x28(%rsp)
movq %rcx, 0x30(%... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::isConstantFPBuildVectorOrConstantFP(llvm::SDValue) const | SDNode *SelectionDAG::isConstantFPBuildVectorOrConstantFP(SDValue N) const {
if (isa<ConstantFPSDNode>(N))
return N.getNode();
if (ISD::isBuildVectorOfConstantFPSDNodes(N.getNode()))
return N.getNode();
if ((N.getOpcode() == ISD::SPLAT_VECTOR) &&
isa<ConstantFPSDNode>(N.getOperand(0)))
return ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x18(%rsi), %ebp
cmpl $0xc, %ebp
je 0x1f4a0d5
cmpl $0x24, %ebp
je 0x1f4a0d5
movq %rbx, %rdi
callq 0x1f2b920
testb %al, %al
jne 0x1f4a0d5
cmpl $0xa7, %ebp
jne 0x1f4a0d3
movq 0x28(%rbx), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
cmpl $0x24, %eax
je 0x1f4a0d5
cmpl $... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getAtomicMemcpy(llvm::SDValue, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::Type*, unsigned int, bool, llvm::MachinePointerInfo, llvm::MachinePointerInfo) | SDValue SelectionDAG::getAtomicMemcpy(SDValue Chain, const SDLoc &dl,
SDValue Dst, SDValue Src, SDValue Size,
Type *SizeTy, unsigned ElemSz,
bool isTailCall,
MachinePoi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x11b8, %rsp # imm = 0x11B8
movl %r9d, %r12d
movq %r8, %r13
movq %rcx, %r15
movl %edx, 0xc(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, %rbx
leaq 0x11f0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
leaq 0x38(%rsp), %r... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getMergeValues(llvm::ArrayRef<llvm::SDValue>, llvm::SDLoc const&) | SDValue SelectionDAG::getMergeValues(ArrayRef<SDValue> Ops, const SDLoc &dl) {
if (Ops.size() == 1)
return Ops[0];
SmallVector<EVT, 4> VTs;
VTs.reserve(Ops.size());
for (const SDValue &Op : Ops)
VTs.push_back(Op.getValueType());
return getNode(ISD::MERGE_VALUES, dl, getVTList(VTs), Ops);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
cmpq $0x1, %rdx
jne 0x1f50903
movq (%r15), %r14
movl 0x8(%r15), %ebp
jmp 0x1f509e9
movq %rdx, %rbx
movq %rdi, %r14
movq %rcx, 0x10(%rsp)
leaq 0x38(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movabsq $0x400000000, %rax # imm =... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
unsigned short llvm::SelectionDAG::getSyntheticNodeSubclassData<llvm::LoadSDNode, llvm::SDVTList&, llvm::ISD::MemIndexedMode&, llvm::ISD::LoadExtType&, llvm::EVT&, llvm::MachineMemOperand*&>(unsigned int, llvm::SDVTList&, llvm::ISD::MemIndexedMode&, llvm::ISD::LoadExtType&, llvm::EVT&, llvm::MachineMemOperand*&) | static uint16_t getSyntheticNodeSubclassData(unsigned IROrder,
ArgTypes &&... Args) {
// The compiler can reduce this expression to a constant iff we pass an
// empty DebugLoc. Thankfully, the debug location doesn't have any bearing
// on the subclass data.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edi, %eax
leaq 0x20(%rsp), %r10
movq $0x0, (%r10)
movq (%rsi), %r11
movl 0x8(%rsi), %ebx
movl (%rdx), %r15d
movl (%rcx), %ebp
movq (%r9), %rcx
movups (%r8), %xmm0
movups %xmm0, (%rsp)
movq %rcx, 0x10(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x1... | /llvm/CodeGen/SelectionDAG.h |
InferPointerInfo(llvm::MachinePointerInfo const&, llvm::SelectionDAG&, llvm::SDValue, long) | static MachinePointerInfo InferPointerInfo(const MachinePointerInfo &Info,
SelectionDAG &DAG, SDValue Ptr,
int64_t Offset = 0) {
// If this is FI+Offset, we can model it.
if (const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>... | pushq %rbx
movq %rdi, %rbx
movl 0x18(%rcx), %eax
cmpl $0x27, %eax
je 0x1f5230e
cmpl $0xf, %eax
jne 0x1f52313
movq %rcx, %rax
jmp 0x1f52315
xorl %eax, %eax
testq %rax, %rax
je 0x1f5232e
movq 0x28(%rdx), %rsi
movl 0x58(%rax), %edx
movq %rbx, %rdi
movq %r8, %rcx
callq 0x17ac29e
jmp 0x1f52392
cmpl $0x38, 0x18(%rcx)
jne 0x1... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getTruncStore(llvm::SDValue, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::MachinePointerInfo, llvm::EVT, llvm::Align, llvm::MachineMemOperand::Flags, llvm::AAMDNodes const&) | SDValue SelectionDAG::getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
SDValue Ptr, MachinePointerInfo PtrInfo,
EVT SVT, Align Alignment,
MachineMemOperand::Flags MMOFlags,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, 0x3c(%rsp)
movq %r8, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movzwl 0x100(%rsp), %r15d
leaq 0xd0(%rsp), %r14
cmpq $0x7, (%r14)
ja 0x1f52831
leaq 0xc0(%rsp), %rax
movq (%rax), %rcx
leaq ... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getIndexedStore(llvm::SDValue, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::ISD::MemIndexedMode) | SDValue SelectionDAG::getIndexedStore(SDValue OrigStore, const SDLoc &dl,
SDValue Base, SDValue Offset,
ISD::MemIndexedMode AM) {
StoreSDNode *ST = cast<StoreSDNode>(OrigStore);
assert(ST->getOffset().isUndef() && "Store is already a indexe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r9d, %ebp
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x30(%r8), %rax
movl %r9d, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdx
movl (%rax,%rcx), %esi
movl $0x1, %ecx
xorl %r8d, %r8... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getLoadVP(llvm::EVT, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::MachinePointerInfo, llvm::MaybeAlign, llvm::MachineMemOperand::Flags, llvm::AAMDNodes const&, llvm::MDNode const*, bool) | SDValue SelectionDAG::getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain,
SDValue Ptr, SDValue Mask, SDValue EVL,
MachinePointerInfo PtrInfo,
MaybeAlign Alignment,
MachineMemOperand::Flags MMOFl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %r12d
movq %r8, %r13
movq %rcx, 0xa0(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movzwl 0x160(%rsp), %ebx
movq 0x110(%rsp), %rax
movl 0x118(%rsp), %ecx
movq 0x30(%rax), %rax
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdx
... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getTruncStridedStoreVP(llvm::SDValue, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::EVT, llvm::MachineMemOperand*, bool) | SDValue SelectionDAG::getTruncStridedStoreVP(SDValue Chain, const SDLoc &DL,
SDValue Val, SDValue Ptr,
SDValue Stride, SDValue Mask,
SDValue EVL, EVT SVT,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movl %r9d, %ebp
movq %r8, %r12
movq %rcx, 0x98(%rsp)
movl %edx, 0x88(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdi, %rbx
leaq 0x260(%rsp), %rdx
leaq 0x220(%rsp), %r14
movb 0x278(%rsp), %al
movb %al, 0x86(%rsp)
movq 0x30... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::VPStridedStoreSDNode* llvm::SelectionDAG::newSDNode<llvm::VPStridedStoreSDNode, unsigned int, llvm::DebugLoc const&, llvm::SDVTList&, llvm::ISD::MemIndexedMode, bool, bool&, llvm::EVT&, llvm::MachineMemOperand*&>(unsigned int&&, llvm::DebugLoc const&, llvm::SDVTList&, llvm::ISD::MemIndexedMode&&, bool&&, bool&, l... | SDNodeT *newSDNode(ArgTypes &&... Args) {
return new (NodeAllocator.template Allocate<SDNodeT>())
SDNodeT(std::forward<ArgTypes>(Args)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbp
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r10
movq 0x160(%rdi), %rbx
testq %rbx, %rbx
je 0x1f55b66
movq (%rbx), %rax
movq %rax, 0x160(%rdi)... | /llvm/CodeGen/SelectionDAG.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.