name string | code string | asm string | file string |
|---|---|---|---|
llvm::SplitAnalysis::getLastSplitPoint(llvm::MachineBasicBlock*) | SlotIndex getLastSplitPoint(MachineBasicBlock *BB) {
return IPA.getLastInsertPoint(*CurLI, *BB);
} | movq %rsi, %rdx
movq 0x28(%rdi), %rsi
movq 0x38(%rdi), %rcx
movl 0x18(%rdx), %r8d
shlq $0x4, %r8
movq (%rcx,%r8), %rax
cmpq $0x8, %rax
jb 0x18a2e05
addq %r8, %rcx
cmpq $0x8, 0x8(%rcx)
jb 0x18a2e0e
addq $0x30, %rdi
jmp 0x18a126c
retq
nop
| /CodeGen/SplitKit.h |
llvm::SplitEditor::computeRedundantBackCopies(llvm::DenseSet<unsigned int, llvm::DenseMapInfo<unsigned int, void>>&, llvm::SmallVectorImpl<llvm::VNInfo*>&) | void SplitEditor::computeRedundantBackCopies(
DenseSet<unsigned> &NotToHoistSet, SmallVectorImpl<VNInfo *> &BackCopies) {
LiveInterval *LI = &LIS.getInterval(Edit->get(0));
const LiveInterval *Parent = &Edit->getParent();
SmallVector<SmallPtrSet<VNInfo *, 8>, 8> EqualVNs(Parent->getNumValNums());
SmallPtrSe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
movq %rdx, 0x28(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movl 0x40(%rax), %eax
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
callq 0xa5d4bc
movq %rax, %... | /CodeGen/SplitKit.cpp |
llvm::SplitEditor::extendPHIKillRanges() | void SplitEditor::extendPHIKillRanges() {
// Extend live ranges to be live-out for successor PHI values.
// Visit each PHI def slot in the parent live interval. If the def is dead,
// remove it. Otherwise, extend the live interval to reach the end indexes
// of all predecessor blocks.
const LiveInterval &Pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x48(%rax), %eax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x18a4c6c
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0... | /CodeGen/SplitKit.cpp |
llvm::IntervalMap<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex>>::iterator::insertNode(unsigned int, llvm::IntervalMapImpl::NodeRef, llvm::SlotIndex) | bool IntervalMap<KeyT, ValT, N, Traits>::
iterator::insertNode(unsigned Level, IntervalMapImpl::NodeRef Node, KeyT Stop) {
assert(Level && "Cannot insert next to the root");
bool SplitRoot = false;
IntervalMap &IM = *this->map;
IntervalMapImpl::Path &P = this->path;
if (Level == 1) {
// Insert into the r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
cmpl $0x1, %esi
sete %bpl
jne 0x18a7a88
movq (%r15), %r13
movl 0xbc(%r13), %edi
cmpl $0xa, %edi
ja 0x18a7a55
movq (%rbx), %rax
movl 0xc(%rax), %eax
cmpl %eax, %edi
je 0x18a7... | /llvm/ADT/IntervalMap.h |
llvm::IntervalMap<llvm::SlotIndex, unsigned int, 9u, llvm::IntervalMapInfo<llvm::SlotIndex>>::const_iterator::treeAdvanceTo(llvm::SlotIndex) | void IntervalMap<KeyT, ValT, N, Traits>::
const_iterator::treeAdvanceTo(KeyT x) {
// Can we stay on the same leaf node?
if (!Traits::stopLess(path.leaf<Leaf>().stop(path.leafSize() - 1), x)) {
path.leafOffset() = path.leaf<Leaf>().safeFind(path.leafOffset(), x);
return;
}
// Drop the current leaf.
pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %edx
movq %rdx, %rdi
shlq $0x4, %rdi
movq -0x10(%rax,%rdi), %rsi
movl -0x8(%rax,%rdi), %ecx
decl %ecx
shlq $0x4, %rcx
movq 0x8(%rsi,%rcx), %r8
movq %r8, %rcx
andq $-0x8, %rcx
shrl %r8d
andl $0x3,... | /llvm/ADT/IntervalMap.h |
llvm::SmallVectorImpl<llvm::StackMaps::Location>::operator=(llvm::SmallVectorImpl<llvm::StackMaps::Location>&&) | 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 0x18b0f1f
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0x18b0e83
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18b0f2e
jmp 0x18b0f1f
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %r12d
cmpl %r15d, %r12d
jae 0x18b0e... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseMapPair<llvm::MCSymbol const*, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, unsigned int>>, llvm::MCSymbol const*, unsigned int, llvm::DenseMapInfo<llvm::MCSymbo... | 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 0x18b14a3
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::SmallVectorTemplateBase<llvm::SmallVector<llvm::MachineMemOperand*, 8u>, false>::moveElementsForGrow(llvm::SmallVector<llvm::MachineMemOperand*, 8u>*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x18b5b85
movq %rsi, %r14
movq (%rbx), %r15
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
movabsq $0x800000000, %r13 # imm = 0x800000000
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r13, 0x8(%r14)
cmpl $0x0,... | /llvm/ADT/SmallVector.h |
llvm::SmallPtrSet<llvm::MachineBasicBlock*, 8u>::SmallPtrSet<__gnu_cxx::__normal_iterator<llvm::MachineBasicBlock**, std::vector<llvm::MachineBasicBlock*, std::allocator<llvm::MachineBasicBlock*>>>>(__gnu_cxx::__normal_iterator<llvm::MachineBasicBlock**, std::vector<llvm::MachineBasicBlock*, std::allocator<llvm::Machin... | SmallPtrSet(It I, It E) : BaseT(SmallStorage, SmallSizePowTwo) {
this->insert(I, E);
} | leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
cmpq %rdx, %rsi
je 0x18ba12a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x972... | /llvm/ADT/SmallPtrSet.h |
llvm::TargetLoweringBase::getDefaultSafeStackPointerLocation(llvm::IRBuilderBase&, bool) const | Value *
TargetLoweringBase::getDefaultSafeStackPointerLocation(IRBuilderBase &IRB,
bool UseTLS) const {
// compiler-rt provides a variable with a magic name. Targets that do not
// link with compiler-rt may also provide such a variable.
Module *M = IRB.GetIn... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movl %edx, %ebx
movq 0x30(%rsi), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %r12
leaq 0x35210f3(%rip), %r14 # 0x4de3640
movl $0x1c, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a72daa
xorl %r15d, %r15d
testq %rax, %rax... | /CodeGen/TargetLoweringBase.cpp |
getCOFFSectionFlags(llvm::SectionKind, llvm::TargetMachine const&) | static unsigned
getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
unsigned Flags = 0;
bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
if (K.isMetadata())
Flags |=
COFF::IMAGE_SCN_MEM_DISCARDABLE;
else if (K.isExclude())
Flags |=
COFF::IMAGE_SCN_LNK_REMOVE | COFF:... | testb %dil, %dil
je 0x18c7f5c
movzbl %dil, %eax
cmpl $0x1, %eax
jne 0x18c7f62
movl $0x2000800, %eax # imm = 0x2000800
retq
movl $0x2000000, %eax # imm = 0x2000000
retq
movl %edi, %eax
andb $-0x2, %al
cmpb $0x2, %al
jne 0x18c7f7f
xorl %eax, %eax
cmpl $0x23, 0x1f0(%rsi)
sete %al
shll $0x11, %eax
orl $0x6000... | /CodeGen/TargetLoweringObjectFileImpl.cpp |
llvm::TargetLoweringObjectFileXCOFF::getTargetSymbol(llvm::GlobalValue const*, llvm::TargetMachine const&) const | MCSymbol *
TargetLoweringObjectFileXCOFF::getTargetSymbol(const GlobalValue *GV,
const TargetMachine &TM) const {
// We always use a qualname symbol for a GV that represents
// a declaration, a function descriptor, or a common symbol.
// If a GV represents a GlobalVa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0x3, %eax
ja 0x18c9ff3
movq %r12, %r15
cmpl $0x1, %eax
jne 0x18c9ff6
xorl %r15d, %r15d
testq %r15, %r15
je 0x18ca0e5
movl 0x20(%r15), %eax
andl $0xf, %eax
cmpl $0x1, %eax
je 0x18ca017
movq %r... | /CodeGen/TargetLoweringObjectFileImpl.cpp |
llvm::TargetLoweringObjectFileGOFF::SelectSectionForGlobal(llvm::GlobalObject const*, llvm::SectionKind, llvm::TargetMachine const&) const | MCSection *TargetLoweringObjectFileGOFF::SelectSectionForGlobal(
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
auto *Symbol = TM.getSymbol(GO);
if (Kind.isBSS())
return getContext().getGOFFSection(Symbol->getName(), SectionKind::getBSS(),
n... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rcx, %rdi
callq 0x1d06944
addb $-0xf, %bl
movq 0x388(%r14), %rdi
cmpb $0x2, %bl
ja 0x18cae2f
xorl %esi, %esi
testb $0x1, 0x8(%rax)
movl $0x0, %edx
je 0x18cae18
movq -0x8(%rax), %rsi
movq (%rsi), %rdx
addq $0x18, %rsi
movl $0xf, %ecx
xorl %r8d, %r8d
... | /CodeGen/TargetLoweringObjectFileImpl.cpp |
APIntToHexString[abi:cxx11](llvm::APInt const&) | static std::string APIntToHexString(const APInt &AI) {
unsigned Width = (AI.getBitWidth() / 8) * 2;
std::string HexString = toString(AI, 16, /*Signed=*/false);
llvm::transform(HexString, HexString.begin(), tolower);
unsigned Size = HexString.size();
assert(Width >= Size && "hex string is too large!");
HexSt... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %r14d
leaq 0x28(%rsp), %r12
movq %r12, -0x18(%r12)
movq $0x0, -0x10(%r12)
movq $0x28, -0x8(%r12)
movl $0x0, (%rsp)
leaq 0x10(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
xorl %r8d, %r8... | /CodeGen/TargetLoweringObjectFileImpl.cpp |
llvm::TargetPassConfig::~TargetPassConfig() | TargetPassConfig::~TargetPassConfig() {
delete Impl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f23838(%rip), %rax # 0x57effa8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x78(%rdi), %r14
testq %r14, %r14
je 0x18cc7b8
movq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
cmpq %rax, %rdi
je 0x18cc792
callq 0x751980
movq (%r14), %rdi
movl 0x10(%r14), %eax
shlq $0x3, %rax... | /CodeGen/TargetPassConfig.cpp |
llvm::TargetPassConfig::addMachineSSAOptimization() | void TargetPassConfig::addMachineSSAOptimization() {
// Pre-ra tail duplication.
addPass(&EarlyTailDuplicateID);
// Optimize PHIs before DCE: removing dead PHI cycles may make more
// instructions dead.
addPass(&OptimizePHIsID);
// This pass merges large allocas. StackSlotColoring is a different pass
//... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f1fd56(%rip), %rax # 0x57ee800
movq (%rax), %rsi
callq 0x18cd8f2
leaq 0x3f1d8f7(%rip), %rax # 0x57ec3b0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x18cd8f2
leaq 0x3f1fa35(%rip), %rax # 0x57ee500
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x18cd8f2
leaq 0x3f1aa43... | /CodeGen/TargetPassConfig.cpp |
void llvm::cl::parser<llvm::RunOutliner>::addLiteralOption<int>(llvm::StringRef, int const&, llvm::StringRef) | void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
#ifndef NDEBUG
if (findOption(Name) != Values.size())
report_fatal_error("Option '" + Name + "' already exists!");
#endif
OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
Values.push_back(X);
AddLiteralOption(Owner, Name... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rcx), %eax
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r8, 0x10(%rsi)
movq %r9, 0x18(%rsi)
leaq 0x3f2061b(%rip), %r13 # 0x57f0278
addq $0x10, %r13
leaq 0x3f205f0(%rip), %r12 ... | /llvm/Support/CommandLine.h |
llvm::detail::DenseMapPair<void const*, llvm::IdentifyingPassPtr>* llvm::DenseMapBase<llvm::DenseMap<void const*, llvm::IdentifyingPassPtr, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, llvm::IdentifyingPassPtr>>, void const*, llvm::IdentifyingPassPtr, llvm::DenseMapInfo<void const*, vo... | 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 0x18d0a33
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::TargetRegisterInfo::getAllocatableSet(llvm::MachineFunction const&, llvm::TargetRegisterClass const*) const | BitVector TargetRegisterInfo::getAllocatableSet(const MachineFunction &MF,
const TargetRegisterClass *RC) const {
BitVector Allocatable(getNumRegs());
if (RC) {
// A register class with no allocatable subclass returns an empty set.
const TargetRegisterClass *SubClas... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x10(%rsi), %r13d
leal 0x3f(%r13), %esi
shrl $0x6, %esi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x600000000, %rax # imm = 0x600000000
movq %rax, 0x8(%rdi)
xorl %edx, %edx
callq 0x8e1... | /CodeGen/TargetRegisterInfo.cpp |
llvm::TargetRegisterInfo::getRegAllocationHints(llvm::Register, llvm::ArrayRef<unsigned short>, llvm::SmallVectorImpl<unsigned short>&, llvm::MachineFunction const&, llvm::VirtRegMap const*, llvm::LiveRegMatrix const*) const | bool TargetRegisterInfo::getRegAllocationHints(
Register VirtReg, ArrayRef<MCPhysReg> Order,
SmallVectorImpl<MCPhysReg> &Hints, const MachineFunction &MF,
const VirtRegMap *VRM, const LiveRegMatrix *Matrix) const {
const MachineRegisterInfo &MRI = MF.getRegInfo();
const std::pair<unsigned, SmallVector<R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x28(%r9), %rax
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rax, 0x28(%rsp)
movq 0xf0(%rax), %rax
leaq (%rsi,%rsi,4), %rdx
leaq 0x58(%rsp), %rdi
movq %rd... | /CodeGen/TargetRegisterInfo.cpp |
llvm::TargetRegisterInfo::getCoveringSubRegIndexes(llvm::MachineRegisterInfo const&, llvm::TargetRegisterClass const*, llvm::LaneBitmask, llvm::SmallVectorImpl<unsigned int>&) const | bool TargetRegisterInfo::getCoveringSubRegIndexes(
const MachineRegisterInfo &MRI, const TargetRegisterClass *RC,
LaneBitmask LaneMask, SmallVectorImpl<unsigned> &NeededIndexes) const {
SmallVector<unsigned, 8> PossibleIndexes;
unsigned BestIdx = 0;
unsigned BestCover = 0;
for (unsigned Idx = 1, E = ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdi, %r14
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movl 0x60(%rdi), %ebx
xorl %ebp, %ebp
cmpq $0x2, %rbx
jb 0x18d244... | /CodeGen/TargetRegisterInfo.cpp |
llvm::TargetRegisterInfo::lookThruCopyLike(llvm::Register, llvm::MachineRegisterInfo const*) const | Register
TargetRegisterInfo::lookThruCopyLike(Register SrcReg,
const MachineRegisterInfo *MRI) const {
while (true) {
const MachineInstr *MI = MRI->getVRegDef(SrcReg);
if (!MI->isCopyLike())
return SrcReg;
Register CopySrcReg;
if (MI->isCopy())
CopySrc... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x17dae6c
movzwl 0x44(%rax), %ecx
cmpl $0x13, %ecx
je 0x18d2601
cmpl $0xb, %ecx
jne 0x18d2619
movl $0x44, %ecx
jmp 0x18d2606
movl $0x24, %ecx
movq 0x20(%rax), %rax
movl (%rax,%rcx), %eax
movl %eax, %ecx
shrl $0x1f, %e... | /CodeGen/TargetRegisterInfo.cpp |
llvm::TargetSchedModel::mustEndGroup(llvm::MachineInstr const*, llvm::MCSchedClassDesc const*) const | bool TargetSchedModel::mustEndGroup(const MachineInstr *MI,
const MCSchedClassDesc *SC) const {
if (hasInstrSchedModel()) {
if (!SC)
SC = resolveSchedClass(MI);
if (SC->isValid())
return SC->EndGroup;
}
return false;
} | xorl %eax, %eax
cmpb $0x1, 0x4003717(%rip) # 0x58d68f8
jne 0x18d320e
cmpq $0x0, 0x28(%rdi)
je 0x18d320e
pushq %rax
testq %rdx, %rdx
jne 0x18d31f8
callq 0x18d3146
movq %rax, %rdx
movzwl (%rdx), %eax
movl %eax, %ecx
notl %ecx
testl $0x1fff, %ecx # imm = 0x1FFF
leaq 0x8(%rsp), %rsp
jne 0x18d320f
xorl %eax, %ea... | /CodeGen/TargetSchedule.cpp |
llvm::TargetSchedModel::computeInstrLatency(llvm::MCInst const&) const | unsigned TargetSchedModel::computeInstrLatency(const MCInst &Inst) const {
if (hasInstrSchedModel())
return capLatency(SchedModel.computeInstrLatency(*STI, *TII, Inst));
return computeInstrLatency(Inst.getOpcode());
} | pushq %rax
movq %rsi, %rcx
cmpb $0x1, 0x400328f(%rip) # 0x58d68f8
jne 0x18d368b
cmpq $0x0, 0x28(%rdi)
je 0x18d368b
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rdx
addq $0x8, %rdx
callq 0x1b01f62
jmp 0x18d36b0
movl (%rcx), %eax
movq 0xb0(%rdi), %rsi
movq 0xb8(%rdi), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
negq %rax
movz... | /CodeGen/TargetSchedule.cpp |
llvm::TargetSchedModel::computeReciprocalThroughput(llvm::MachineInstr const*) const | double
TargetSchedModel::computeReciprocalThroughput(const MachineInstr *MI) const {
if (hasInstrItineraries()) {
unsigned SchedClass = MI->getDesc().getSchedClass();
return MCSchedModel::getReciprocalThroughput(SchedClass,
*getInstrItineraries());
}
if (h... | movq %rdi, %rax
cmpb $0x1, 0x40031ea(%rip) # 0x58d69b8
jne 0x18d37ee
cmpq $0x0, 0xa8(%rax)
je 0x18d37ee
movq 0x10(%rsi), %rcx
movzwl 0x6(%rcx), %edi
addq $0x48, %rax
movq %rax, %rsi
jmp 0x1b021c8
cmpb $0x1, 0x4003103(%rip) # 0x58d68f8
jne 0x18d381a
cmpq $0x0, 0x28(%rax)
je 0x18d381a
pushq %rbx
movq 0xb0(%rax), %rbx... | /CodeGen/TargetSchedule.cpp |
llvm::TwoAddressInstructionPass::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&) | PreservedAnalyses
TwoAddressInstructionPass::run(MachineFunction &MF,
MachineFunctionAnalysisManager &MFAM) {
// Disable optimizations if requested. We cannot skip the whole pass as some
// fixups are necessary for correctness.
TwoAddressInstructionImpl Impl(MF, MFAM);
if (MF.getF... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %r12
movq %rdx, -0x88(%r12)
movq 0x10(%rdx), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x80(%r12)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
m... | /CodeGen/TwoAddressInstructionPass.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Register, llvm::Register, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::Register>>, llvm::Register, llvm::Register, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::Register>>::erase(llvm::Regi... | 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 0xcbba46
testb %al, %al
je 0x18d8e6b
movq 0x8(%rsp), %rcx
movl $0xfffffffe, (%rcx) # imm = 0xFFFFFFFE
movq 0x8(%rbx), %xmm0
paddd 0x1ab425a(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::EVT::getTypeForEVT(llvm::LLVMContext&) const | Type *EVT::getTypeForEVT(LLVMContext &Context) const {
// clang-format off
switch (V.SimpleTy) {
default:
assert(isExtended() && "Type is not extended!");
return LLVMTy;
case MVT::isVoid: return Type::getVoidTy(Context);
case MVT::x86mmx: return Type::getX86_MMXTy(Context);
case MVT::aarch64svcoun... | subq $0x28, %rsp
movzbl (%rdi), %eax
addl $-0x2, %eax
cmpl $0xf7, %eax
ja 0x18ddad5
leaq 0x350895e(%rip), %rcx # 0x4de5bec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
addq $0x28, %rsp
jmp 0x1a89f26
movq %rsi, %rdi
addq $0x28, %rsp
jmp 0x1a89f58
movq %rsi, %rdi
callq 0x1a89f26
jmp 0x18ddbf4
m... | /CodeGen/ValueTypes.cpp |
llvm::ConvergingVLIWScheduler::VLIWSchedBoundary::bumpCycle() | void ConvergingVLIWScheduler::VLIWSchedBoundary::bumpCycle() {
unsigned Width = SchedModel->getIssueWidth();
IssueCount = (IssueCount <= Width) ? 0 : IssueCount - Width;
assert(MinReadyCycle < std::numeric_limits<unsigned>::max() &&
"MinReadyCycle uninitialized");
unsigned NextCycle = std::max(CurrCyc... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xac(%rdi), %eax
movq 0x8(%rdi), %rcx
movq 0x98(%rdi), %rdx
xorl %esi, %esi
subl (%rcx), %eax
cmovbl %esi, %eax
movl %eax, 0xac(%rdi)
movl 0xa8(%rdi), %ebp
incl %ebp
movl 0xb4(%rdi), %eax
cmpl %eax, %ebp
cmovbel %eax, %ebp
cmpl $0x0, 0x8(%rdx)
je 0x18df314
cmpl %ebp... | /CodeGen/VLIWMachineScheduler.cpp |
llvm::WindowScheduler::getAntiRegister(llvm::MachineInstr*) | Register WindowScheduler::getAntiRegister(MachineInstr *Phi) {
assert(Phi->isPHI() && "Expecting PHI!");
Register AntiReg;
for (auto MO : Phi->uses()) {
if (MO.isReg())
AntiReg = MO.getReg();
else if (MO.isMBB() && MO.getMBB() == MBB)
return AntiReg;
}
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r15
movq %rsi, %rdi
callq 0x1793cc8
movl %eax, %eax
shlq $0x5, %rax
leaq (%r15,%rax), %rdx
movzbl 0x2a(%r14), %ecx
movzwl 0x28(%r14), %esi
shll $0x5, %esi
shll $0x15, %ecx
orl %esi, %ecx
addq 0x20(%r14), %rcx
cmpq %rcx, %rdx
je 0x18e483a... | /CodeGen/WindowScheduler.cpp |
std::pair<llvm::Instruction const*, int>& llvm::SmallVectorImpl<std::pair<llvm::Instruction const*, int>>::emplace_back<llvm::Instruction const*&, int&>(llvm::Instruction const*&, int&) | 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), %ecx
cmpl 0xc(%rdi), %ecx
jae 0x18ea6fb
movq (%rbx), %rax
movq %rcx, %rdi
shlq $0x4, %rdi
movq (%rsi), %rsi
movq %rsi, (%rax,%rdi)
movl (%rdx), %edx
movl %edx, 0x8(%rax,%rdi)
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
popq ... | /llvm/ADT/SmallVector.h |
llvm::TinyPtrVector<llvm::BasicBlock*>::push_back(llvm::BasicBlock*) | void push_back(EltTy NewVal) {
// If we have nothing, add something.
if (Val.isNull()) {
Val = NewVal;
assert(!Val.isNull() && "Can't add a null value");
return;
}
// If we have a single value, convert to a vector.
if (isa<EltTy>(Val)) {
EltTy V = cast<EltTy>(Val);
Val... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
cmpq $0x7, %r15
ja 0x18eb0a3
andq $-0x5, %rbx
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
testb $0x4, %r15b
jne 0x18eb0e5
andq $-0x8, %r15
movl $0x30, %edi
callq 0x751940
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movabsq $0x400000... | /llvm/ADT/TinyPtrVector.h |
llvm::CatchReturnInst::setSuccessor(llvm::BasicBlock*) | static Use &OpFrom(const U *that) {
return Idx < 0
? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
: OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];
} | leaq -0x20(%rdi), %rax
cmpq $0x0, -0x20(%rdi)
je 0x18eb21f
movq -0x18(%rdi), %rcx
movq -0x10(%rdi), %rdx
movq %rcx, (%rdx)
movq -0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x18eb21f
movq -0x10(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rsi, (%rax)
testq %rsi, %rsi
je 0x18eb247
movq 0x10(%rsi), %rcx
addq $0x10, %rsi
movq %rcx, -... | /llvm/IR/User.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>, llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::L... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x18eb889
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>, llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::moveFr... | 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 0x18ebb2b
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<llvm::WinEHHandlerType>::operator=(llvm::SmallVectorImpl<llvm::WinEHHandlerType> 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 0x18ec412
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x18ec3b7
cmpl %r14d, 0xc(%rbx)
jae 0x18ec3d0
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x20, %ecx
movq %rbx, %rdi
movq %r14, %rdx
... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseMapPair<llvm::FuncletPadInst const*, int>* llvm::DenseMapBase<llvm::DenseMap<llvm::FuncletPadInst const*, int, llvm::DenseMapInfo<llvm::FuncletPadInst const*, void>, llvm::detail::DenseMapPair<llvm::FuncletPadInst const*, int>>, llvm::FuncletPadInst const*, int, llvm::DenseMapInfo<llvm::FuncletPadIns... | 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 0x18ec4bf
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<unsigned int, std::vector<(anonymous namespace)::VarLocBasedLDV::VarLoc, std::allocator<(anonymous namespace)::VarLocBasedLDV::VarLoc>>, 4u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::vector<(anonymous namespace)::VarLocBasedLDV::VarLoc, ... | 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
leaq 0x8(%rdi), %rax
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rax
movl $0x4, %ecx
cmovel 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x18f4efc
movl %ecx, %ecx
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFF... | /llvm/ADT/DenseMap.h |
llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>::const_iterator::treeFind(unsigned long) | void IntervalMap<KeyT, ValT, N, Traits>::
const_iterator::treeFind(KeyT x) {
setRoot(map->rootBranch().findFrom(0, map->rootSize, x));
if (valid())
pathFillFind(x);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0xc4(%rax), %esi
testq %rsi, %rsi
je 0x18f53a8
xorl %ecx, %ecx
cmpq %rbx, 0x60(%rax,%rcx,8)
jae 0x18f53ac
incq %rcx
cmpl %ecx, %esi
jne 0x18f5398
jmp 0x18f53ae
xorl %esi, %esi
jmp 0x18f53ae
movl %ecx, %esi
movq %r14, %rdi
callq 0x18... | /llvm/ADT/IntervalMap.h |
bool llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>::iterator::overflow<llvm::IntervalMapImpl::LeafNode<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>>(unsigned int) | bool IntervalMap<KeyT, ValT, N, Traits>::
iterator::overflow(unsigned Level) {
using namespace IntervalMapImpl;
Path &P = this->path;
unsigned CurSize[4];
NodeT *Node[4];
unsigned Nodes = 0;
unsigned Elements = 0;
unsigned Offset = P.offset(Level);
// Do we have a left sibling?
NodeRef LeftSib = P.ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r14d
leaq 0x8(%rdi), %rbx
movl %esi, %r15d
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %rax
shlq $0x4, %r15
movl 0xc(%rax,%r15), %r12d
movq %rbx, %rdi
callq 0x1ca56ee
testq %rax, %rax
movq %rax, 0x58(%rsp)
je 0x18f5ab8
movl %eax, %... | /llvm/ADT/IntervalMap.h |
llvm::IntervalMapImpl::NodeBase<std::pair<unsigned long, unsigned long>, char, 11u>::adjustFromLeftSib(unsigned int, llvm::IntervalMapImpl::NodeBase<std::pair<unsigned long, unsigned long>, char, 11u>&, unsigned int, int) | int adjustFromLeftSib(unsigned Size, NodeBase &Sib, unsigned SSize, int Add) {
if (Add > 0) {
// We want to grow, copy from sib.
unsigned Count = std::min(std::min(unsigned(Add), SSize), N - Size);
Sib.transferToRightSib(SSize, *this, Size, Count);
return Count;
} else {
// We want... | pushq %rbx
movl %r8d, %ebx
movl %esi, %eax
movq %rdi, %r8
testl %ebx, %ebx
jle 0x18f61ac
movl $0xb, %esi
subl %eax, %esi
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
cmpl %ebx, %esi
cmovbl %esi, %ebx
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, %rdx
movl %eax, %ecx
movl %ebx, %r8d
callq 0x18f61d2
jmp 0x18f61ce
negl %ebx
movl $0xb, %... | /llvm/ADT/IntervalMap.h |
bool llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>::iterator::overflow<llvm::IntervalMapImpl::BranchNode<unsigned long, char, 12u, llvm::IntervalMapInfo<unsigned long>>>(unsigned int) | bool IntervalMap<KeyT, ValT, N, Traits>::
iterator::overflow(unsigned Level) {
using namespace IntervalMapImpl;
Path &P = this->path;
unsigned CurSize[4];
NodeT *Node[4];
unsigned Nodes = 0;
unsigned Elements = 0;
unsigned Offset = P.offset(Level);
// Do we have a left sibling?
NodeRef LeftSib = P.ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r14d
leaq 0x8(%rdi), %rbx
movl %esi, %r15d
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %rax
shlq $0x4, %r15
movl 0xc(%rax,%r15), %r12d
movq %rbx, %rdi
callq 0x1ca56ee
testq %rax, %rax
movq %rax, 0x58(%rsp)
je 0x18f63f0
movl %eax, %... | /llvm/ADT/IntervalMap.h |
llvm::IntervalMapOverlaps<llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>, llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>>::IntervalMapOverlaps(llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>> const&, llvm::IntervalMap... | IntervalMapOverlaps(const MapA &a, const MapB &b)
: posA(b.empty() ? a.end() : a.find(b.start())),
posB(posA.valid() ? b.find(posA.start()) : b.end()) { advance(); } | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rcx
cmpl $0x0, 0xc4(%rdx)
movabsq $0x400000000, %r15 # imm = 0x400000000
je 0x18f8465
movq (%r14), %rax
movq %rsi, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18f5342
jmp 0x18f847e
movq ... | /llvm/ADT/IntervalMap.h |
llvm::IntervalMapOverlaps<llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>, llvm::IntervalMap<unsigned long, char, 11u, llvm::IntervalMapInfo<unsigned long>>>::operator++() | IntervalMapOverlaps &operator++() {
// Bump the iterator that ends first. The other one may have more overlaps.
if (Traits::startLess(posB.stop(), posA.stop()))
skipB();
else
skipA();
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl 0x68(%rdi), %ecx
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %rdx
movl -0x4(%rax,%rcx), %eax
shlq $0x4, %rax
movq 0x8(%rdi), %rcx
movl 0x10(%rdi), %esi
shlq $0x4, %rsi
movq -0x10(%rcx,%rsi), %r8
movl -0x4(%rcx,%rsi), %ecx
shlq $0x4, %rcx
movq 0x8(%rdx,%rax), %rax
addq $0... | /llvm/ADT/IntervalMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock const*, std::unique_ptr<llvm::CoalescingBitVector<unsigned long>, std::default_delete<llvm::CoalescingBitVector<unsigned long>>>, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, std::u... | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
movl $0x4, %eax
testb $0x1, %cl
jne 0x18faf1d
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x18faf71
testb $0x1, %cl
jne 0x18faf2c
movq 0x8(%rbx), %rbx
jmp 0x18faf30
addq $0x8, %rbx
movl %eax, %r14d
shlq $0x4, %r14
addq $0x8, %rbx
movl $0x1000, %r15d ... | /llvm/ADT/DenseMap.h |
LiveDebugValues::InstrRefBasedLDV::isCalleeSavedReg(llvm::Register) const | bool InstrRefBasedLDV::isCalleeSavedReg(Register R) const {
for (MCRegAliasIterator RAI(R, TRI, true); RAI.isValid(); ++RAI)
if (CalleeSavedRegs.test(*RAI))
return true;
return false;
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
movzwl %si, %esi
callq 0x1b0118a
testq %rdx, %rdx
setne %cl
je 0x18fca43
movq 0x38(%rbx), %rsi
movzwl (%rax), %edi
movl %edi, %r8d
shrl $0x6, %r8d
movq (%rsi,%r8,8), %r8
btq %rdi, %r8
jb 0x18fca43
addq %rdx, %rdx
mo... | /CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::MachineInstr*, unsigned int>, std::optional<LiveDebugValues::ValueIDNum>, llvm::DenseMapInfo<std::pair<llvm::MachineInstr*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MachineInstr*, unsigned int>, std::optional<LiveDebugValues::ValueIDNum>>>, std::... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0x1907179
cmpl $0x0, 0xc(%rdi)
je 0x19071c0
shll $0x2, %ecx
movl 0x10(%rdi), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
je 0x19177e0
testq %rax, %rax
je 0x19071b8
movq (%rdi), %rcx
shlq $0x5, %rax
addq %rcx, %rax
movq $-0x1000, (%rcx) # imm = 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineOperand, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<llvm::MachineOperand, void>, llvm::detail::DenseMapPair<llvm::MachineOperand, LiveDebugValues::DbgOpID>>::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 0x190943e
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 |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineOperand, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<llvm::MachineOperand, void>, llvm::detail::DenseMapPair<llvm::MachineOperand, LiveDebugValues::DbgOpID>>, llvm::MachineOperand, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<llvm::MachineOperand, void>, llvm::detail::Den... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1909a21
movq (%r15), %rax
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rcx
movl $0x15, (%rax)
movq $0x0, 0x8(%rax)
addq $0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<LiveDebugValues::ValueIDNum, void>, llvm::detail::DenseMapPair<LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID>>, LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<LiveDebugValues::V... | 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 0x1909b1a
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID>* llvm::DenseMapBase<llvm::DenseMap<LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID, llvm::DenseMapInfo<LiveDebugValues::ValueIDNum, void>, llvm::detail::DenseMapPair<LiveDebugValues::ValueIDNum, LiveDebugValues::DbgOpID>>, LiveDebug... | 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 0x1909ccf
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<unsigned int, TransferTracker::ResolvedDbgValue, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, TransferTracker::ResolvedDbgValue>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<unsigned int, TransferTracker::ResolvedDbgValue, llvm::DenseMapInfo<unsig... | 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 0x190a5c0
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x190ae94
xorl %ecx, %ecx
jmp 0x190aea7
movq %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned short, unsigned short>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned short, unsigned short>, void>, llvm::detail::DenseMapPair<std::pair<unsigned short, unsigned short>, unsigned int>>, std::pair<unsigned short, unsigned short>, unsigned int, llvm::DenseM... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x190ca6e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movzwl (%rsi), %r8d
movzwl 0x2(%rsi), %eax
leaq (%rax,%rax,8), %r9
leaq (%rax,%r9,4), %rax
movabsq $0x2500000000, %r9 # imm = 0x2500000000
imulq %r8, %r9
orq %rax, %r9
movabsq $-0x40a7b892e31b1a47, %ra... | /llvm/ADT/DenseMap.h |
std::pair<LiveDebugValues::LocIdx, unsigned int>& llvm::SmallVectorImpl<std::pair<LiveDebugValues::LocIdx, unsigned int>>::emplace_back<LiveDebugValues::LocIdx&, unsigned int&>(LiveDebugValues::LocIdx&, unsigned int&) | 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), %ecx
cmpl 0xc(%rdi), %ecx
jae 0x190d198
movq (%rbx), %rax
movl (%rsi), %esi
movl %esi, (%rax,%rcx,8)
movl (%rdx), %edx
movl %edx, 0x4(%rax,%rcx,8)
movl 0x8(%rbx), %ecx
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
popq %rbx
retq
movl ... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::SmallDenseMap<unsigned int, llvm::DILocation const*, 8u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DILocation const*>>, unsigned int, llvm::DILocation const*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DILo... | unsigned getNumEntries() const {
return NumEntries;
} | movl (%rdi), %eax
cmpl $0x1, %eax
ja 0x190e559
cmpl $0x0, 0x4(%rdi)
je 0x190e6ad
leal (%rax,%rax), %edx
andl $-0x4, %edx
movl $0x8, %ecx
testb $0x1, %al
jne 0x190e56b
movl 0x10(%rdi), %ecx
cmpl %ecx, %edx
setae %dl
cmpl $0x41, %ecx
setb %sil
orb %dl, %sil
je 0x190e6ae
testb $0x1, %al
jne 0x190e58a
movq 0x8(%rdi), %rax
... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<LiveDebugValues::LocIdx>::assignRemote(llvm::SmallVectorImpl<LiveDebugValues::LocIdx>&&) | 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 0x19144a1
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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, unsigned long, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, unsigned long>>, llvm::MachineBasicBlock*, unsigned long, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPai... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1919673
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::AggressiveAntiDepState::UnionGroups(unsigned int, unsigned int) | unsigned AggressiveAntiDepState::UnionGroups(unsigned Reg1, unsigned Reg2) {
assert(GroupNodes[0] == 0 && "GroupNode 0 not parent!");
assert(GroupNodeIndices[0] == 0 && "Reg 0 not in Group 0!");
// find group for each register
unsigned Group1 = GetGroup(Reg1);
unsigned Group2 = GetGroup(Reg2);
// if eithe... | pushq %rax
movl %esi, %esi
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %rax
leaq (%rax,%rsi,4), %r8
movl (%r8), %esi
leaq (%rcx,%rsi,4), %r8
cmpl %esi, (%r8)
jne 0x19198ed
movl %edx, %edx
leaq (%rax,%rdx,4), %rax
movl (%rax), %edx
leaq (%rcx,%rdx,4), %rax
cmpl %edx, (%rax)
jne 0x19198ff
testl %esi, %esi
movl %edx, %eax
cmove... | /CodeGen/AggressiveAntiDepBreaker.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::UniqueBBID, llvm::BBClusterInfo, llvm::DenseMapInfo<llvm::UniqueBBID, void>, llvm::detail::DenseMapPair<llvm::UniqueBBID, llvm::BBClusterInfo>>, llvm::UniqueBBID, llvm::BBClusterInfo, llvm::DenseMapInfo<llvm::UniqueBBID, void>, llvm::detail::DenseMapPair<llvm::UniqueBBID, llvm::B... | 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), %rdx
callq 0x1922a38
testb %al, %al
je 0x1922e3d
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x1922e4e
movl 0x10(%rbx), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rd... | /llvm/ADT/DenseMap.h |
llvm::StringMapEntry<llvm::SmallString<128u>>* llvm::StringMapEntry<llvm::SmallString<128u>>::create<llvm::MallocAllocator, llvm::SmallString<128u>&>(llvm::StringRef, llvm::MallocAllocator&, llvm::SmallString<128u>&) | static StringMapEntry *create(StringRef key, AllocatorTy &allocator,
InitTy &&...initVals) {
return new (StringMapEntryBase::allocateWithKey(
sizeof(StringMapEntry), alignof(StringMapEntry), key, allocator))
StringMapEntry(key.size(), std::forward<InitTy>(initVals)...... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xa1(%rsi), %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, %r14
testq %r15, %r15
je 0x19270ee
leaq 0xa0(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x751900
movb $0x0, 0xa0(%r14,%r15)
movq %r15, (%r14)
lea... | /llvm/ADT/StringMapEntry.h |
llvm::VirtRegAuxInfo::weightCalcHelper(llvm::LiveInterval&, llvm::SlotIndex*, llvm::SlotIndex*) | float VirtRegAuxInfo::weightCalcHelper(LiveInterval &LI, SlotIndex *Start,
SlotIndex *End) {
MachineRegisterInfo &MRI = MF.getRegInfo();
const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
Ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rcx, 0x60(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rax), %r13
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, 0x80(%rsp)
movq 0x8(%r15), %r... | /CodeGen/CalcSpillWeights.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, float, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, float>>, unsigned int, float, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, float>>::moveFromOldBuckets(llvm::detail::DenseMapPair<unsigned int, floa... | 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 0x1928485
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, llvm::SUnit const*, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::SUnit const*>>, llvm::MachineInstr*, llvm::SUnit const*, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::Machine... | 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 0x192aa0e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x192aa04
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x192aaa0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
parseOverrideOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static VPTransform parseOverrideOption(const std::string &TextOpt) {
return StringSwitch<VPTransform>(TextOpt) VPINTERNAL_VPLEGAL_CASES;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x100000000, %r12 # imm = 0x100000000
movq (%rdi), %r15
movq 0x8(%rdi), %r14
cmpq $0x5, %r14
jne 0x19303ca
leaq 0x34b7313(%rip), %rsi # 0x4de76c8
movq %r15, %rdi
movq %r14, %rdx
callq 0x751d10
xorl %ebx, %ebx
testl %eax, %eax
cmoveq %r12, %rbx
jmp 0... | /CodeGen/ExpandVectorPredication.cpp |
(anonymous namespace)::TransformJob& llvm::SmallVectorTemplateBase<(anonymous namespace)::TransformJob, true>::growAndEmplaceBack<llvm::VPIntrinsic*&, llvm::TargetTransformInfo::VPLegalization&>(llvm::VPIntrinsic*&, llvm::TargetTransformInfo::VPLegalization&) | 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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r14
movq (%rdx), %r15
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x193045e
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %r15, 0x8(%rax,%rcx)
incl 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%rbx)... | /llvm/ADT/SmallVector.h |
transferDecorations(llvm::Value&, llvm::VPIntrinsic&) | static void transferDecorations(Value &NewVal, VPIntrinsic &VPI) {
auto *NewInst = dyn_cast<Instruction>(&NewVal);
if (!NewInst || !isa<FPMathOperator>(NewVal))
return;
auto *OldFMOp = dyn_cast<FPMathOperator>(&VPI);
if (!OldFMOp)
return;
NewInst->setFastMathFlags(OldFMOp->getFastMathFlags());
} | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x1d, (%rdi)
cmovaeq %rdi, %rbx
jb 0x19307ca
movq %rsi, %r14
callq 0x903dce
testb %al, %al
je 0x19307ca
movq %r14, %rdi
callq 0x903dce
testb %al, %al
je 0x19307ca
movzbl 0x1(%r14), %eax
shrl %eax
cmpl $0x7f, %eax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmov... | /CodeGen/ExpandVectorPredication.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::SmallVector<std::pair<llvm::Register, int>, 8u>, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::SmallVector<std::pair<llvm::Register, int>, 8u>>>, llvm::MachineBasicBl... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1932837
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 $0x58, %r11, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::SmallVector<std::pair<llvm::Register, int>, 8u>, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::SmallVector<std::pair<llvm::Register, int>, 8u>>>::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, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned int, (anonymous namespace)::FrameIndexesCache::FrameIndexesPerSize, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, (anonymous namespace)::FrameIndexesCache::FrameIndexesPerSize>>, unsigned int, (anonymous namespace)::FrameIndexesCache::Fr... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1933433
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r14d
shlq $0x6, %r14
leaq (%rdi,%r14), %r11
movl (%rdi,%r14), %ebp
cmpl %ebp, ... | /llvm/ADT/DenseMap.h |
llvm::SmallSet<std::pair<llvm::Register, int>, 8u, std::less<std::pair<llvm::Register, int>>>::count(std::pair<llvm::Register, int> const&) const | size_type count(const T &V) const {
if (isSmall()) {
// Since the collection is small, just do a linear search.
return vfind(V) == Vector.end() ? 0 : 1;
} else {
return Set.count(V);
}
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x78(%rdi)
je 0x1933d8b
leaq 0x50(%rbx), %rdi
callq 0x19342c2
addq $0x58, %rbx
cmpq %rbx, %rax
jmp 0x1933dc5
movq (%rbx), %rax
movl 0x8(%rbx), %edx
leaq (%rax,%rdx,8), %rcx
testq %rdx, %rdx
je 0x1933dc2
movq (%rsi), %xmm0
shlq $0x3, %rdx
movq (%rax), %xmm1
pcmpeqd %xmm0, %xmm1
pshu... | /llvm/ADT/SmallSet.h |
llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::SmallSet<std::pair<llvm::Register, int>, 8u, std::less<std::pair<llvm::Register, int>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::SmallSet<std::pair<llvm::Register, int>, 8u, std::less<... | 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, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::SmallSet<std::pair<llvm::Register, int>, 8u, std::less<std::pair<llvm::Register, int>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::SmallSet<std::pair<llvm::Register, i... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x19345d7
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %r14
addq $0x58, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x58(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x19345c2
movq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ImplicitNullChecks::canHoistInst(llvm::MachineInstr*, llvm::ArrayRef<llvm::MachineInstr*>, llvm::MachineBasicBlock*, llvm::MachineInstr*&) | bool ImplicitNullChecks::canHoistInst(MachineInstr *FaultingMI,
ArrayRef<MachineInstr *> InstsSeenSoFar,
MachineBasicBlock *NullSucc,
MachineInstr *&Dependence) {
auto DepResult = computeDependence(Faulti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, 0x8(%rsp)
movq %rcx, %r8
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1935ee6
cmpb $0x1, (%r12)
jne 0x1935918
cmpb $0x0, 0x48(%rsp)... | /CodeGen/ImplicitNullChecks.cpp |
(anonymous namespace)::ImplicitNullChecks::NullCheck& llvm::SmallVectorImpl<(anonymous namespace)::ImplicitNullChecks::NullCheck>::emplace_back<llvm::MachineInstr*, llvm::MachineInstr*&, llvm::MachineBasicBlock*, llvm::MachineBasicBlock*&, llvm::MachineBasicBlock*&, llvm::MachineInstr*&>(llvm::MachineInstr*&&, llvm::Ma... | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x19360ac
pushq %rbx
movq 0x10(%rsp), %r10
movq (%rdi), %r11
leaq (%rax,%rax,2), %rbx
shlq $0x4, %rbx
movq (%rsi), %rsi
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%r8), %r8
movq (%r9), %r9
movq (%r10), %r10
movq %rsi, (%r11,%rbx)
movq %rdx, 0x8(%r11,%rbx)
movq %rcx, 0x10(%r1... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::ImplicitNullChecks::areMemoryOpsAliased(llvm::MachineInstr const&, llvm::MachineInstr const*) const | ImplicitNullChecks::AliasResult
ImplicitNullChecks::areMemoryOpsAliased(const MachineInstr &MI,
const MachineInstr *PrevMI) const {
// If it is not memory access, skip the check.
if (!(PrevMI->mayStore() || PrevMI->mayLoad()))
return AR_NoAlias;
// Load-Load may alias
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
movq %rdx, %rdi
movl $0x1, %esi
callq 0x8e0a86
testb %al, %al
jne 0x1935c4c
movq %r14, %rdi
movl $0x1, %esi
callq 0x8e0a62
testb %al, %al
je 0x1935ca2
movq %r15, %rdi
movl $0x1, %esi
... | /CodeGen/ImplicitNullChecks.cpp |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [25], llvm::cl::desc, llvm::cl::initializer<int>, llvm::cl::OptionHidden>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [25], llvm::cl::desc const&, llvm::cl::initializer<int> const&, llvm::cl::OptionHidden const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7512e0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbx)
movq (%r15), %rax
movl (%rax), %ecx
movl %ecx... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>>>, int, std::unique_ptr<llvm::LiveInterval, std::default_delete... | unsigned getNumBuckets() const {
return NumBuckets;
} | pushq %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %r14d
testq %r14, %r14
je 0x1939189
movq (%rdi), %rbx
shlq $0x4, %r14
addq $0x8, %rbx
movl $0x80000001, %ebp # imm = 0x80000001
movl -0x8(%rbx), %eax
addl %ebp, %eax
cmpl $0x2, %eax
jb 0x193917f
movq %rbx, %rdi
callq 0x18ab6da
addq $0x10, %rbx
addq $-0x10, %r14
jn... | /llvm/ADT/DenseMap.h |
std::pair<std::pair<int, llvm::VNInfo*>, llvm::SmallPtrSet<llvm::MachineInstr*, 16u>> const* llvm::SmallVectorTemplateCommon<std::pair<std::pair<int, llvm::VNInfo*>, llvm::SmallPtrSet<llvm::MachineInstr*, 16u>>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<std::pair<int, llvm::VNInfo*... | 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 0x193a422
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
imulq $0xb0, %rcx, %rcx
addq %rax, %rcx
cmpq %rbx, ... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>>>::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::InterferenceCache::Entry::RegUnitInfo const* llvm::SmallVectorTemplateCommon<llvm::InterferenceCache::Entry::RegUnitInfo, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::InterferenceCache::Entry::RegUnitInfo, false>>(llvm::SmallVectorTemplateBase<llvm::InterferenceCache::Entry::RegUnit... | 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 0x193cacc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
imulq $0x70, %rcx, %rcx
addq %rax, %rcx
cmpq %rbx, ... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<llvm::InterferenceCache::Entry::RegUnitInfo, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r12
movl $0x70, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0x1cba3de
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x193cb82
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x193cb6e
ca... | /llvm/ADT/SmallVector.h |
llvm::LatencyPriorityQueue::getSingleUnscheduledPred(llvm::SUnit*) | size_t size() const { return Size; } | movl 0x30(%rsi), %ecx
testq %rcx, %rcx
je 0x193cfef
movq 0x28(%rsi), %rdx
shlq $0x4, %rcx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi), %r8
andq $-0x8, %r8
movb $0x1, %dil
testb $0x4, 0xf9(%r8)
jne 0x193cfe0
cmpq %r8, %rax
sete %r9b
testq %rax, %rax
sete %dil
cmoveq %r8, %rax
orb %r9b, %dil
testb %dil, %dil
je 0x19... | /llvm/ADT/SmallVector.h |
llvm::LexicalScopes::extractLexicalScopes(llvm::SmallVectorImpl<std::pair<llvm::MachineInstr const*, llvm::MachineInstr const*>>&, llvm::DenseMap<llvm::MachineInstr const*, llvm::LexicalScope*, llvm::DenseMapInfo<llvm::MachineInstr const*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr const*, llvm::LexicalScope*... | void LexicalScopes::extractLexicalScopes(
SmallVectorImpl<InsnRange> &MIRanges,
DenseMap<const MachineInstr *, LexicalScope *> &MI2ScopeMap) {
// Scan each instruction and create scopes. First build working set of scopes.
for (const auto &MBB : *MF) {
const MachineInstr *RangeBeginMI = nullptr;
cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
movq 0x148(%rax), %rcx
addq $0x140, %rax # imm = 0x140
movq %rax, 0x28(%rsp)
cmpq %rax, %rcx
je 0x193d638
movq $0x0, 0x8(%rsp)
leaq 0x30(%rcx)... | /CodeGen/LexicalScopes.cpp |
llvm::SmallVectorTemplateBase<std::pair<llvm::MachineInstr const*, llvm::MachineInstr const*>, true>::push_back(std::pair<llvm::MachineInstr const*, llvm::MachineInstr const*>) | 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 0x193d884
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), %r... | /llvm/ADT/SmallVector.h |
llvm::LiveIntervalUnion::Array::init(llvm::RecyclingAllocator<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>, char, 192ul, 64ul>&, unsigned int) | void LiveIntervalUnion::Array::init(LiveIntervalUnion::Allocator &Alloc,
unsigned NSize) {
// Reuse existing allocation.
if (NSize == Size)
return;
clear();
Size = NSize;
LIUs = static_cast<LiveIntervalUnion*>(
safe_malloc(sizeof(LiveIntervalUnion)*NSize));
for ... | pushq %rbp
pushq %r14
pushq %rbx
cmpl %edx, (%rdi)
je 0x193fa6f
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x193fa86
movl %ebp, (%r14)
movl %ebp, %eax
imulq $0xd8, %rax, %rdi
callq 0x751f80
testq %rax, %rax
jne 0x193fa22
testl %ebp, %ebp
jne 0x193fa74
movl $0x1, %edi
callq 0x751f80
testq %rax, %rax
je 0x193f... | /CodeGen/LiveIntervalUnion.cpp |
llvm::IntervalMap<llvm::SlotIndex, llvm::LiveInterval const*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex>>::splitRoot(unsigned int) | IntervalMapImpl::IdxPair IntervalMap<KeyT, ValT, N, Traits>::
splitRoot(unsigned Position) {
using namespace IntervalMapImpl;
// How many external leaf nodes to hold RootBranch+1?
const unsigned Nodes = RootBranch::Capacity / Branch::Capacity + 1;
// Compute element distribution among new nodes.
unsigned Siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0xc4(%rdi), %r12d
movq 0xc8(%rdi), %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0x1940b05
movq (%r15), %rax
movq %rax, (%rdi)
jmp 0x1940b1b
addq $0x8, %rdi
movl $0xc0, %esi
movl $0x6, %edx
callq 0x8c3eba
movq %rax, %r15
movl $0xc0... | /llvm/ADT/IntervalMap.h |
llvm::LiveRangeEdit::rematerializeAt(llvm::MachineBasicBlock&, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>, llvm::Register, llvm::LiveRangeEdit::Remat const&, llvm::TargetRegisterInfo const&, bool, unsigned int, llvm::MachineInstr*) | SlotIndex LiveRangeEdit::rematerializeAt(MachineBasicBlock &MBB,
MachineBasicBlock::iterator MI,
Register DestReg, const Remat &RM,
const TargetRegisterInfo &tri,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r14
movq 0x70(%rsp), %rbx
movl 0x68(%rsp), %r8d
leaq 0x10(%rsp), %r12
movq %rdx, (%r12)
movq 0x30(%rdi), %rdi
movq 0x8(%r15), %rax
movq (%rdi), %r10
movq %r9, (%rsp)
movq %rax, %r9
callq *0xb8(%r10)
movq %... | /CodeGen/LiveRangeEdit.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::SmallVector<llvm::MachineInstr const*, 8u>, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::SmallVector<llvm::MachineInstr const*, 8u>>>, llvm::MachineBasicBlock const*, llv... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x19454b4
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
imulq $0x58, %rax, %r14
addq $0x18, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x18(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x19454a5
movq -0x10(%rbx), %rdi
cmpq %rdi, %rb... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::DebugifyMachineModule::~DebugifyMachineModule() | bool runOnModule(Module &M) override {
// We will insert new debugify metadata, so erasing the old one.
assert(!M.getNamedMetadata("llvm.mir.debugify") &&
"llvm.mir.debugify metadata already exists! Strip it first");
MachineModuleInfo &MMI =
getAnalysis<MachineModuleInfoWrapperPass>().get... | pushq %rbx
movq %rdi, %rbx
callq 0x1a7c91e
movl $0x20, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7510e0
nop
| /CodeGen/MachineDebugify.cpp |
llvm::PseudoProbeManager::profileIsValid(llvm::Function const&, llvm::sampleprof::FunctionSamples const&) const | bool profileIsValid(const Function &F, const FunctionSamples &Samples) const {
const auto *Desc = getDesc(F);
bool IsAvailableExternallyLinkage =
GlobalValue::isAvailableExternallyLinkage(F.getLinkage());
// Always check the function attribute to determine checksum mismatch for
// `available_ext... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0x19516c0
testq %rax, %rax
je 0x1950e96
movl 0x20(%rbx), %ecx
andl $0xf, %ecx
cmpl $0x1, %ecx
je 0x1950e96
movq 0x8(%rax), %rax
cmpq 0x8(%r14), %rax
setne %al
jmp 0x1950eaa
leaq 0x3497ac4(%rip), %rsi # 0x4de8961
movl $0x19, %edx
movq %rbx, %rdi
ca... | /llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h |
llvm::SampleProfileLoaderBaseImpl<llvm::MachineFunction>::getInstWeightImpl(llvm::MachineInstr const&) | ErrorOr<uint64_t>
SampleProfileLoaderBaseImpl<BT>::getInstWeightImpl(const InstructionT &Inst) {
const FunctionSamples *FS = findFunctionSamples(Inst);
if (!FS)
return std::error_code();
const DebugLoc &DLoc = Inst.getDebugLoc();
if (!DLoc)
return std::error_code();
const DILocation *DIL = DLoc;
u... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq *0x10(%rax)
testq %rax, %rax
je 0x1951f63
cmpq $0x0, 0x38(%r14)
je 0x1951f63
movq %rax, %r12
leaq 0x38(%r14), %rdi
callq 0x1a0e99e
movq %rax, %r... | /llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h |
llvm::SampleProfileLoaderBaseImpl<llvm::MachineFunction>::findEquivalenceClasses(llvm::MachineFunction&) | void SampleProfileLoaderBaseImpl<BT>::findEquivalenceClasses(FunctionT &F) {
SmallVector<BasicBlockT *, 8> DominatedBBs;
LLVM_DEBUG(dbgs() << "\nBlock equivalence classes\n");
// Find equivalence sets based on dominance and post-dominance information.
for (auto &BB : F) {
BasicBlockT *BB1 = &BB;
// Com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
leaq 0x140(%rsi), %r12
movq %rsi, 0x28(%rsp)
movq 0x148(%rsi), %r13
cmpq %r12, %r13
je 0x1954be7
... | /llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h |
llvm::cl::opt<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode, false, llvm::cl::parser<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
addq $0x98, %rdi
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x195d524
movl %eax, %r14d
testb %al, %al
jne 0x195d36e
movl 0xc(%rsp), %eax
movl %eax, 0x80(%rbx)
movw %bp, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode, false, llvm::cl::parser<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0x195d46a
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3e9549b(%rip), %r9 # 0x57f28e8
addq $0x10, %r9
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x1c965da
addq $0x18, %rsp
retq
c... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode, false, llvm::cl::parser<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode>>, char [24], llvm::cl::OptionHidden, llvm::cl::initializer<llvm::RegAllocEvictionAdvisorAnalysis::AdvisorMode>, llvm::cl::desc, llvm::cl::ValuesClass>(llvm::... | 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, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7512e0
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1c90c20
movl (%r13), %eax
movzwl 0xa(%r15), %ecx
shll $0x5, %e... | /llvm/Support/CommandLine.h |
(anonymous namespace)::StackFrameLayoutAnalysisPass::SlotData::operator<((anonymous namespace)::StackFrameLayoutAnalysisPass::SlotData const&) const | bool isVarSize() const { return SlotTy == SlotType::VariableSized; } | movl 0x20(%rdi), %ecx
cmpl $0x2, %ecx
setne %r8b
movl 0x20(%rsi), %edx
cmpl $0x2, %edx
sete %r9b
movb $0x1, %al
testb %r9b, %r8b
jne 0x1963d62
cmpl $0x2, %edx
setne %dl
cmpl $0x2, %ecx
sete %cl
testb %dl, %cl
jne 0x1963d63
movq 0x18(%rdi), %rcx
addq 0x10(%rdi), %rcx
movq 0x18(%rsi), %rdx
addq 0x10(%rsi), %rdx
cmpq %rcx... | /CodeGen/StackFrameLayoutAnalysisPass.cpp |
std::pair<llvm::DenseMapIterator<llvm::DILocalVariable const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::DILocalVariable const*, void>, llvm::detail::DenseSetPair<llvm::DILocalVariable const*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DILocalVariable const*, llvm::detail::DenseSetEmpty, llvm::D... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x19647d6
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x1964798
xorl %ecx, %ecx
jmp 0x19647b1
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::DebugVariable>::append<__gnu_cxx::__normal_iterator<llvm::DebugVariable*, std::vector<llvm::DebugVariable, std::allocator<llvm::DebugVariable>>>, void>(__gnu_cxx::__normal_iterator<llvm::DebugVariable*, std::vector<llvm::DebugVariable, std::allocator<llvm::DebugVariable>>>, __gnu_cxx::_... | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r12
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r12, %rdx
cmpq %rax, %rdx
jbe 0x1965632
le... | /llvm/ADT/SmallVector.h |
analyzeFunction(llvm::Function&, llvm::DataLayout const&, FunctionVarLocsBuilder*) | static void analyzeFunction(Function &Fn, const DataLayout &Layout,
FunctionVarLocsBuilder *FnVarLocs) {
// The analysis will generate location definitions for all variables, but we
// only need to perform a dataflow on the set of variables which have a stack
// slot. Find those now.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7f8, %rsp # imm = 0x7F8
movq %rdx, 0x58(%rsp)
movq %rsi, 0x40(%rsp)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x310(%rsp)
movl $0x0, 0x320(%rsp)
leaq 0x48(%rdi), %rax
movq %rdi, 0x78(%rsp)
movq 0x50(%rdi), %rcx
movq %rax, 0x110(%rsp)
cmpq %rax, ... | /CodeGen/AssignmentTrackingAnalysis.cpp |
llvm::DenseMap<llvm::BasicBlock const*, (anonymous namespace)::AssignmentTrackingLowering::BlockInfo, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, (anonymous namespace)::AssignmentTrackingLowering::BlockInfo>>::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 0x196c4a6
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 |
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.