name string | code string | asm string | file string |
|---|---|---|---|
llvm::BlockFrequencyInfoImplBase::WorkingData::getPackagedLoop() const | LoopData *getPackagedLoop() const {
if (!Loop || !Loop->IsPackaged)
return nullptr;
auto *L = Loop;
while (L->Parent && L->Parent->IsPackaged)
L = L->Parent;
return L;
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x338abd5
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x8(%rax)
jne 0x338abe0
movq $0x0, -0x8(%rsp)
jmp 0x338ac31
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
xorl %eax, ... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
void llvm::bfi_detail::IrreducibleGraph::addEdges<llvm::bfi_detail::BlockEdgesAdder<llvm::MachineBasicBlock>>(llvm::BlockFrequencyInfoImplBase::BlockNode const&, llvm::BlockFrequencyInfoImplBase::LoopData const*, llvm::bfi_detail::BlockEdgesAdder<llvm::MachineBasicBlock>) | void IrreducibleGraph::addEdges(const BlockNode &Node,
const BFIBase::LoopData *OuterLoop,
BlockEdgesAdder addBlockEdges) {
auto L = Lookup.find(Node.Index);
if (L == Lookup.end())
return;
IrrNode &Irr = *L->second;
const auto &Working = BFI.Wo... | subq $0x78, %rsp
movq %rcx, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x30, %rdi
movq 0x60(%rsp), %rsi
callq 0x338b850
movq (%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
addq $0x30, %rdi
callq 0x338b920
movq %rax, 0x38(%rsp)
mov... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
llvm::SmallDenseMap<unsigned int, llvm::bfi_detail::IrreducibleGraph::IrrNode*, 4u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::bfi_detail::IrreducibleGraph::IrrNode*>>::deallocateBuckets() | void deallocateBuckets() {
if (Small)
return;
deallocate_buffer(getLargeRep()->Buckets,
sizeof(BucketT) * getLargeRep()->NumBuckets,
alignof(BucketT));
getLargeRep()->~LargeRep();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x338c82f
jmp 0x338c86b
movq 0x8(%rsp), %rdi
callq 0x338b430
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x338b430
movq (%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, %... | /llvm/ADT/DenseMap.h |
llvm::BlockFrequencyInfoImpl<llvm::MachineBasicBlock>::initTransitionProbabilities(std::vector<llvm::MachineBasicBlock const*, std::allocator<llvm::MachineBasicBlock const*>> const&, llvm::DenseMap<llvm::MachineBasicBlock const*, unsigned long, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::Den... | void BlockFrequencyInfoImpl<BT>::initTransitionProbabilities(
const std::vector<const BlockT *> &Blocks,
const DenseMap<const BlockT *, size_t> &BlockIndex,
ProbMatrixType &ProbMatrix) const {
const size_t NumBlocks = Blocks.size();
auto Succs = std::vector<std::vector<std::pair<size_t, Scaled64>>>(NumB... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x278(%rsp), %rdi
callq 0x3384a50
movq %rax, 0x260(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x247(%rsp), %rdi
callq 0x33... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
llvm::ScaledNumber<unsigned long>::shiftLeft(int) | void ScaledNumber<DigitsT>::shiftLeft(int32_t Shift) {
if (!Shift || isZero())
return;
assert(Shift != INT32_MIN);
if (Shift < 0) {
shiftRight(-Shift);
return;
}
// Shift as much as we can in the exponent.
int32_t ScaleShift = std::min(Shift, ScaledNumbers::MaxScale - Scale);
Scale += ScaleSh... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x33908de
movq 0x8(%rsp), %rdi
callq 0x3390600
testb $0x1, %al
jne 0x33908de
jmp 0x33908e3
jmp 0x33909e4
cmpl $0x0, 0x3c(%rsp)
jge 0x33908ff
movq 0x8(%rsp), %rdi
xorl %esi, %esi
subl 0x3c(%rs... | /llvm/Support/ScaledNumber.h |
llvm::ScaledNumber<unsigned long>::shiftRight(int) | void ScaledNumber<DigitsT>::shiftRight(int32_t Shift) {
if (!Shift || isZero())
return;
assert(Shift != INT32_MIN);
if (Shift < 0) {
shiftLeft(-Shift);
return;
}
// Shift as much as we can in the exponent.
int32_t ScaleShift = std::min(Shift, Scale - ScaledNumbers::MinScale);
Scale -= ScaleSh... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x3390a1e
movq 0x8(%rsp), %rdi
callq 0x3390600
testb $0x1, %al
jne 0x3390a1e
jmp 0x3390a23
jmp 0x3390af2
cmpl $0x0, 0x3c(%rsp)
jge 0x3390a3f
movq 0x8(%rsp), %rdi
xorl %esi, %esi
subl 0x3c(%rs... | /llvm/Support/ScaledNumber.h |
std::pair<int, int> llvm::ScaledNumbers::getLgImpl<unsigned long>(unsigned long, short) | inline std::pair<int32_t, int> getLgImpl(DigitsT Digits, int16_t Scale) {
static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
if (!Digits)
return std::make_pair(INT32_MIN, 0);
// Get the floor of the lg of Digits.
static_assert(sizeof(Digits) <= sizeof(uint64_t));
int32_t Local... | subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3390d62
movl $0x80000000, 0x20(%rsp) # imm = 0x80000000
movl $0x0, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x418e80
movq %rax, 0x30(%rsp)
jmp 0x3390e1d
movq 0x28(%rsp), %rdi
callq 0x4e38c0
movl %ea... | /llvm/Support/ScaledNumber.h |
llvm::DenseMapIterator<llvm::MachineBasicBlock const*, unsigned long, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, unsigned long>, true>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, unsigned long> const*, llvm::detai... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
std::pair<unsigned long, short> llvm::ScaledNumbers::getRounded<unsigned long>(unsigned long, short, bool) | inline std::pair<DigitsT, int16_t> getRounded(DigitsT Digits, int16_t Scale,
bool ShouldRound) {
static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
if (ShouldRound)
if (!++Digits)
// Overflow.
return std::make_pair(DigitsT(1) ... | subq $0x68, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, 0x50(%rsp)
movw %cx, 0x4e(%rsp)
andb $0x1, %al
movb %al, 0x4d(%rsp)
testb $0x1, 0x4d(%rsp)
je 0x3392f02
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
jne 0x3392f00
callq 0x3390420
movb %al, %cl
decb %cl
movl $0x1, %eax
shlq %cl, %rax
... | /llvm/Support/ScaledNumber.h |
std::pair<unsigned long, short> llvm::ScaledNumbers::getDifference<unsigned long>(unsigned long, short, unsigned long, short) | std::pair<DigitsT, int16_t> getDifference(DigitsT LDigits, int16_t LScale,
DigitsT RDigits, int16_t RScale) {
static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
// Normalize digits to match scales.
const DigitsT SavedRDigits = RDigits;
const ... | subq $0xb8, %rsp
movw %cx, %ax
movw %si, %cx
movq %rdi, 0xa0(%rsp)
movw %cx, 0x9e(%rsp)
movq %rdx, 0x90(%rsp)
movw %ax, 0x8e(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movw 0x8e(%rsp), %ax
movw %ax, 0x7e(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x9e(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x8e(%rsp), %rcx
callq 0x3390220... | /llvm/Support/ScaledNumber.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::WriteGraph<llvm::MachineBlockFrequencyInfo*>(llvm::MachineBlockFrequencyInfo* const&, llvm::Twine const&, bool, llvm::Twine const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string WriteGraph(const GraphType &G, const Twine &Name,
bool ShortNames = false,
const Twine &Title = "",
std::string Filename = "") {
int FD;
if (Filename.empty()) {
Filename = createGraphFilename(Name.str(), FD);
} else {
std::er... | subq $0x178, %rsp # imm = 0x178
movq %r9, 0x8(%rsp)
movl %ecx, %eax
movq %rdi, %rcx
movq 0x8(%rsp), %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %r9
movq %r9, 0x18(%rsp)
movq %rcx, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movq %rdx, 0x160(%rsp)
andb $0x1, %al
movb %al, 0x15f(%rsp)
movq %r8, 0x150(%rsp)
movq %rdi, 0x148(%... | /llvm/Support/GraphWriter.h |
llvm::GraphWriter<llvm::MachineBlockFrequencyInfo*>::writeGraph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void writeGraph(const std::string &Title = "") {
// Output the header for the graph...
writeHeader(Title);
// Emit all of the nodes in the graph...
writeNodes();
// Output any customizations on the graph
DOTGraphTraits<GraphType>::addCustomGraphFeatures(G, *this);
// Output the end of the... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x3395850
movq (%rsp), %rdi
callq 0x3395b10
movq (%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x3395bc0
movq (%rsp), %rdi
callq 0x3395bd0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Support/GraphWriter.h |
llvm::GraphWriter<llvm::MachineBlockFrequencyInfo*>::writeEdge(llvm::MachineBasicBlock const*, unsigned int, __gnu_cxx::__normal_iterator<llvm::MachineBasicBlock* const*, std::vector<llvm::MachineBasicBlock*, std::allocator<llvm::MachineBasicBlock*>>>) | void writeEdge(NodeRef Node, unsigned edgeidx, child_iterator EI) {
if (NodeRef TargetNode = *EI) {
int DestPort = -1;
if (DTraits.edgeTargetsEdgeSource(Node, EI)) {
child_iterator TargetIt = DTraits.getEdgeTarget(Node, EI);
// Figure out which edge this targets...
unsigned Offs... | subq $0xd8, %rsp
movq %rcx, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movl %edx, 0xbc(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x727c20
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x33971b8
movl $0xffffffff, 0xac(%rsp) # imm = 0xFFFFFFFF
movq 0xc0(%... | /llvm/Support/GraphWriter.h |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [14], llvm::cl::desc, llvm::cl::initializer<int>, llvm::cl::OptionHidden>(char const (&) [14], llvm::cl::desc const&, llvm::cl::initializer<int> const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x76e5e0
movq (%rsp), %rsi
leaq 0x6346af6(%rip), %rax # 0x96defe... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult>... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x339986e
movl $0x0, 0x14(%rsp)
jmp 0x339988e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult>... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3399990
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x33999b0
callq 0x33999d0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x33999e0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x33999f0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::BlockChain*, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::BlockChain*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x3399ea0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x3399ef0
testb $0x1, %al
jne 0x3399e76
jmp 0x3399e81
movq (%rsp), %rdi
callq 0x3399f60
jmp 0x3399e93
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::pr... | inline iterator begin() {
// When the map is empty, avoid the overhead of advancing/retreating past
// empty buckets.
if (empty())
return end();
if (shouldReverseIterate<KeyT>())
return makeIterator(getBucketsEnd() - 1, getBuckets(), *this);
return makeIterator(getBuckets(), getBucketsEn... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x339ed70
testb $0x1, %al
jne 0x339d9ae
jmp 0x339d9c7
movq 0x18(%rsp), %rdi
callq 0x339d550
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x339da4e
callq 0xcc4af0
testb $0x1, %al
jne 0x339d9d2
jmp 0x339da13
movq 0x18(%rsp), %rdi
... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleCha... | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x339dd50
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x339dda0
testb $0x1, %al
jne 0x339dd26
jmp 0x339dd31
movq (%rsp), %rdi
callq 0x339de10
jmp 0x339dd43
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult>,... | 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()
... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x339f100
testb $0x1, %al
jne 0x339efe5
jmp 0x339f05f
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
c... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult>... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xcc4af0
testb $0x1, %al
jne 0x339f1b6
jmp 0x339f222
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::BlockAndTailDupResult>... | 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... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3399910
callq 0x33999d0
movq %rax, 0x48(%rsp)
callq 0x339aa70
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::BlockChain::merge(llvm::MachineBasicBlock*, (anonymous namespace)::BlockChain*) | void merge(MachineBasicBlock *BB, BlockChain *Chain) {
assert(BB && "Can't merge a null block.");
assert(!Blocks.empty() && "Can't merge into an empty chain.");
// Fast path in case we don't have a chain already.
if (!Chain) {
assert(!BlockToChain[BB] &&
"Passed chain is null, but BB... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x339fc91
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x8ff8c0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0x33a0740
movq 0x8(%rsp), %rc... | /CodeGen/MachineBlockPlacement.cpp |
(anonymous namespace)::MachineBlockPlacement::collectViableSuccessors(llvm::MachineBasicBlock const*, (anonymous namespace)::BlockChain const&, llvm::SmallSetVector<llvm::MachineBasicBlock const*, 16u> const*, llvm::SmallVector<llvm::MachineBasicBlock*, 4u>&) | BranchProbability MachineBlockPlacement::collectViableSuccessors(
const MachineBasicBlock *BB, const BlockChain &Chain,
const BlockFilterSet *BlockFilter,
SmallVector<MachineBasicBlock *, 4> &Successors) {
// Adjust edge probabilities by excluding edges pointing to blocks that is
// either not in BlockF... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1861720
movl %eax, 0x84(%rsp)
movq 0x70(%rsp), %rdi
callq 0x8f4400
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rax
movq %rax,... | /CodeGen/MachineBlockPlacement.cpp |
(anonymous namespace)::MachineCombiner::combineInstructions(llvm::MachineBasicBlock*) | bool MachineCombiner::combineInstructions(MachineBasicBlock *MBB) {
bool Changed = false;
LLVM_DEBUG(dbgs() << "Combining MBB " << MBB->getName() << "\n");
bool IncrementalUpdate = false;
auto BlockIter = MBB->begin();
decltype(BlockIter) LastUpdate;
// Check if the block is in a loop.
const MachineLoop ... | subq $0x3a8, %rsp # imm = 0x3A8
movq %rdi, 0x3a0(%rsp)
movq %rsi, 0x398(%rsp)
movq 0x3a0(%rsp), %rax
movq %rax, 0x50(%rsp)
movb $0x0, 0x397(%rsp)
jmp 0x33b68ae
movb $0x0, 0x396(%rsp)
movq 0x398(%rsp), %rdi
callq 0x73fe80
movq %rax, 0x388(%rsp)
leaq 0x380(%rsp), %rdi
callq 0x77a890
movq 0x50(%rsp), %rax
movq ... | /CodeGen/MachineCombiner.cpp |
(anonymous namespace)::MachineCombiner::getDepth(llvm::SmallVectorImpl<llvm::MachineInstr*>&, llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>&, llvm::MachineTraceMetrics::Trace, llvm::MachineBasicBlock const&) | unsigned
MachineCombiner::getDepth(SmallVectorImpl<MachineInstr *> &InsInstrs,
DenseMap<unsigned, unsigned> &InstrIdxForVirtReg,
MachineTraceMetrics::Trace BlockTrace,
const MachineBasicBlock &MBB) {
SmallVector<unsigned, 16> InstrDepth;
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rcx, 0x1d8(%rsp)
movq %r8, 0x1e0(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %r9, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x168(%rsp), %rdi
callq 0x77a0b0
movq 0x1c8(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x160(%... | /CodeGen/MachineCombiner.cpp |
(anonymous namespace)::MachineCSE::PerformCSE(llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*) | bool MachineCSE::PerformCSE(MachineDomTreeNode *Node) {
SmallVector<MachineDomTreeNode*, 32> Scopes;
SmallVector<MachineDomTreeNode*, 8> WorkList;
DenseMap<MachineDomTreeNode*, unsigned> OpenChildren;
CurrVN = 0;
// Perform a DFS walk to determine the order of visit.
WorkList.push_back(Node);
do {
N... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x33c5f10
leaq 0x68(%rsp), %rdi
callq 0x33ca030
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x33ca050
movq 0x8(%rsp), %rax
movl $0x0, 0x338(%rax)
movq 0x1c8(%r... | /CodeGen/MachineCSE.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::MachineFunction>>::DFSInfo, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::Machine... | 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->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33d3080
cmpl $0x0, %eax
jne 0x33d2fe2
jmp 0x33d307a
callq 0x33d3090
movq %rax, 0x28(%rsp)
callq 0x33d30a0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x33d30b0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x33d30c0
movq %... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::MachineFunction>>::DFSInfo, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::MachineFunction>>::DFSInfo... | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x33d4dd0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x33d4e20
testb $0x1, %al
jne 0x33d4da6
jmp 0x33d4db1
movq (%rsp), %rdi
callq 0x33d4e90
jmp 0x33d4dc3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::MachineFunction>>::DFSInfo>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::MachineFunction>>::DFSInfo, llvm::DenseMapInfo<llvm::Machi... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x548460
movq 0x10(%rsp), %rdi
callq 0x33d67e0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x33d3080
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::MachineBasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*>, true>::DenseMapIterator(llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*> const*, llvm::detail::DenseSetPair<... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>::print(llvm::GenericSSAContext<llvm::MachineFunction> const&) const::'lambda'(llvm::raw_ostream&)::operator()(llvm::raw_ostream&) const | Printable print(const ContextT &Ctx) const {
return Printable([this, &Ctx](raw_ostream &Out) {
Out << "depth=" << Depth << ": entries(" << printEntries(Ctx) << ')';
for (auto *Block : Blocks) {
if (isEntry(Block))
continue;
Out << ' ' << Ctx.print(Block);
}
});
} | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x4f3b0f8(%rip), %rsi # 0x8317333
callq 0x41be30
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0xa0(%rax), %esi
callq 0x41c0a0
movq %rax, %rdi
leaq 0... | /llvm/ADT/GenericCycleInfo.h |
llvm::DenseMap<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<ll... | void swap(DenseMap& RHS) {
this->incrementEpoch();
RHS.incrementEpoch();
std::swap(Buckets, RHS.Buckets);
std::swap(NumEntries, RHS.NumEntries);
std::swap(NumTombstones, RHS.NumTombstones);
std::swap(NumBuckets, RHS.NumBuckets);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x548460
movq 0x8(%rsp), %rdi
callq 0x548460
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x33e5b40
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x582e30
movq (%rsp), %rdi
addq $0xc,... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x33e6300
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x16294e0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x33e6562
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts>>, llvm::M... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x33e9fd0
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x33e5230
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x33ee012
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::InfoRec* const* llvm::SmallVectorTemplateCommon<llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::InfoRec*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::Do... | 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... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dca0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x33f0034
movq 0x3... | /llvm/ADT/SmallVector.h |
llvm::SmallVector<llvm::MachineBasicBlock*, 8u> llvm::GraphDiff<llvm::MachineBasicBlock*, false>::getChildren<true>(llvm::MachineBasicBlock*) const | VectRet getChildren(NodePtr N) const {
using DirectedNodeT =
std::conditional_t<InverseEdge, Inverse<NodePtr>, NodePtr>;
auto R = children<DirectedNodeT>(N);
VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));
// Remove nullptr children for clang.
llvm::erase(Res, nullptr);
aut... | subq $0xb8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x33f4c80
movq %rax, 0x90(%rsp)
movq %rdx, 0x98(%rsp)
movb $0x0, 0x8f(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x... | /llvm/Support/CFGDiff.h |
unsigned int llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::runDFS<false, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::DeleteUnreachable(llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo... | unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
unsigned AttachToNum,
const NodeOrderMap *SuccOrder = nullptr) {
assert(V);
SmallVector<std::pair<NodePtr, unsigned>, 64> WorkList = {{V, AttachToNum}};
NodeToInfo[V].Parent = AttachToNum;
while... | subq $0x548, %rsp # imm = 0x548
leaq 0x550(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x540(%rsp)
movq %rsi, 0x538(%rsp)
movl %edx, 0x534(%rsp)
movl %ecx, 0x530(%rsp)
movq %r8, 0x528(%rsp)
movq 0x540(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0x538(%rsp), %rsi
leaq 0x530(%rsp), %rdx
callq... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::SmallVectorImpl<llvm::MachineDominatorTree::CriticalEdge>::operator=(llvm::SmallVectorImpl<llvm::MachineDominatorTree::CriticalEdge>&&) | 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... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq 0x50(%rsp), %rax
jne 0x33fc33e
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x33fc517
movq 0x50(%rsp), %rdi
callq 0x1629aa0
testb $0x1, %al
jne 0x33fc36a
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3... | /llvm/ADT/SmallVector.h |
setUnsafeStackSize(llvm::Function const&, llvm::MachineFrameInfo&) | void setUnsafeStackSize(const Function &F, MachineFrameInfo &FrameInfo) {
if (!F.hasFnAttribute(Attribute::SafeStack))
return;
auto *Existing =
dyn_cast_or_null<MDTuple>(F.getMetadata(LLVMContext::MD_annotation));
if (!Existing || Existing->getNumOperands() != 2)
return;
auto *MetadataName = "u... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movl $0x35, %esi
callq 0x304e750
testb $0x1, %al
jne 0x33fec66
jmp 0x33fed50
movq 0x50(%rsp), %rdi
movl $0x1e, %esi
callq 0xe35350
movq %rax, %rdi
callq 0x33fed60
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x33fec99
movq 0x40(%rsp), ... | /CodeGen/MachineFunction.cpp |
llvm::MachineFunction::getOrCreateJumpTableInfo(unsigned int) | MachineJumpTableInfo *MachineFunction::
getOrCreateJumpTableInfo(unsigned EntryKind) {
if (JumpTableInfo) return JumpTableInfo;
JumpTableInfo = new (Allocator)
MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind);
return JumpTableInfo;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x48(%rax)
je 0x3400abe
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3400afa
movq 0x8(%rsp), %rsi
addq $0x80, %rsi
movl $0x20, %edi
callq 0xcb5cf0
movq %rax, %rdi
movq %rdi, (%rsp... | /CodeGen/MachineFunction.cpp |
llvm::MachineConstantPool::print(llvm::raw_ostream&) const | void MachineConstantPool::print(raw_ostream &OS) const {
if (Constants.empty()) return;
OS << "Constant Pool:\n";
for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
OS << " cp#" << i << ": ";
if (Constants[i].isMachineConstantPoolEntry())
Constants[i].Val.MachineCPVal->print(OS);
else
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x12aaef0
testb $0x1, %al
jne 0x3402eb7
jmp 0x3402ebc
jmp 0x3402ffc
movq 0x28(%rsp), %rdi
leaq 0x4f1c3d9(%rip), %rsi # 0x831f2a1
callq 0x41be30
movq 0x10(%rsp), %rdi
movl $0x0, 0x24(%rsp)
add... | /CodeGen/MachineFunction.cpp |
llvm::MachineFunction::getFilterIDFor(llvm::ArrayRef<unsigned int>) | int MachineFunction::getFilterIDFor(ArrayRef<unsigned> TyIds) {
// If the new filter coincides with the tail of an existing filter, then
// re-use the existing filter. Folding filters more than this requires
// re-ordering filters and/or their elements - probably not worth it.
for (unsigned i : FilterEnds) {
... | subq $0x78, %rsp
movq %rsi, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x268, %rax # imm = 0x268
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x434770
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4347a0
movq %rax, 0x40(%rsp)
leaq 0x48(... | /CodeGen/MachineFunction.cpp |
llvm::MachineFunction::eraseCallSiteInfo(llvm::MachineInstr const*) | void MachineFunction::eraseCallSiteInfo(const MachineInstr *MI) {
assert(MI->shouldUpdateCallSiteInfo() &&
"Call site info refers only to call (MI) candidates or "
"candidates inside bundles");
const MachineInstr *CallMI = getCallInstr(MI);
CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallM... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3404260
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
callq 0x3404020
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
addq $0x298, %rdi # i... | /CodeGen/MachineFunction.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::ValueMapCallbackVH<llvm::GlobalValue const*, std::unique_ptr<llvm::GlobalValuePseudoSourceValue const, std::default_delete<llvm::GlobalValuePseudoSourceValue const>>, llvm::ValueMapConfig<llvm::GlobalValue const*, llvm::sys::SmartMutex<false>>>, std::unique_ptr<llvm::GlobalValueP... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x34083e0
testb $0x1, %al
jne 0x340883d
jmp 0x340889b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3408c80
testb $0x1, %al
jne 0x3408852
jmp 0x3408863
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ValueMapCallbackVH<llvm::GlobalValue const*, std::unique_ptr<llvm::GlobalValuePseudoSourceValue const, std::default_delete<llvm::GlobalValuePseudoSourceValue const>>, llvm::ValueMapConfig<llvm::GlobalValue const*, llvm::sys::SmartMutex<false>>>, std::unique_ptr<llvm::GlobalValueP... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3408c80
testb $0x1, %al
jne 0x3408bd6
jmp 0x3408c42
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
llvm::MachineInstr::MachineInstr(llvm::MachineFunction&, llvm::MCInstrDesc const&, llvm::DebugLoc, bool) | MachineInstr::MachineInstr(MachineFunction &MF, const MCInstrDesc &TID,
DebugLoc DL, bool NoImp)
: MCID(&TID), NumOperands(0), Flags(0), AsmPrinterFlags(0),
DbgLoc(std::move(DL)), DebugInstrNum(0), Opcode(TID.Opcode) {
assert(DbgLoc.hasTrivialDestructor() && "Expected trivial dest... | subq $0x78, %rsp
movq %rcx, 0x8(%rsp)
movb %r8b, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3418ad0
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%... | /CodeGen/MachineInstr.cpp |
llvm::MachineInstr::setPCSections(llvm::MachineFunction&, llvm::MDNode*) | void MachineInstr::setPCSections(MachineFunction &MF, MDNode *PCSections) {
// Do nothing if old and new symbols are the same.
if (PCSections == getPCSections())
return;
setExtraInfo(MF, memoperands(), getPreInstrSymbol(), getPostInstrSymbol(),
getHeapAllocMarker(), PCSections, getCFIType(),
... | pushq %rbx
subq $0x80, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0x7ff360
movq %rax, %rcx
movq 0x50(%rsp), %rax
cmpq %rcx, %rax
jne 0x341a3e2
jmp 0x341a48d
movq 0x48(%rsp), %rdi
movq 0x70(%rsp), %r... | /CodeGen/MachineInstr.cpp |
llvm::DenseMapIterator<llvm::Register, llvm::MachineInstr*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr*>, false>::operator++() | inline DenseMapIterator& operator++() { // Preincrement
assert(isHandleInSync() && "invalid iterator access!");
assert(Ptr != End && "incrementing end() iterator");
if (shouldReverseIterate<KeyT>()) {
--Ptr;
RetreatPastEmptyBuckets();
return *this;
}
++Ptr;
AdvancePastEmptyBuc... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
callq 0xb3a6a0
testb $0x1, %al
jne 0x342a56d
jmp 0x342a58b
movq (%rsp), %rdi
movq (%rdi), %rax
addq $-0x10, %rax
movq %rax, (%rdi)
callq 0x342ad40
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x342a5a7
movq (%rsp), %rdi
movq (%rdi), %rax
addq $... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::DenseMap<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>>>, llvm::DenseMapInfo<llvm::... | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x342e5d0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x342e620
testb $0x1, %al
jne 0x342e5a6
jmp 0x342e5b1
movq (%rsp), %rdi
callq 0x342e690
jmp 0x342e5c3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Register, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>, llvm::Register, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>::destroyAll() | 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->... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x342e510
cmpl $0x0, %eax
jne 0x342ea91
jmp 0x342eb25
callq 0x342e3e0
movl %eax, 0x1c(%rsp)
callq 0x342eb90
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
callq 0x342e400
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x342e410
movq %rax, 0x8(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<int, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<int, void>, llvm::detail::DenseSetPair<int>>, int, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<int, void>, llvm::detail::DenseSetPair<int>>::initEmpty() | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3432af0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3432b10
callq 0x3432b30
movq (%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x3432b40
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3432b50
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<int, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<int, void>, llvm::detail::DenseSetPair<int>>::deallocateBuckets() | void deallocateBuckets() {
if (Small)
return;
deallocate_buffer(getLargeRep()->Buckets,
sizeof(BucketT) * getLargeRep()->NumBuckets,
alignof(BucketT));
getLargeRep()->~LargeRep();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x34344af
jmp 0x34344eb
movq 0x8(%rsp), %rdi
callq 0x3432a10
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x3432a10
movq (%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, %... | /llvm/ADT/DenseMap.h |
std::pair<llvm::MachineBasicBlock*, bool> llvm::find_singleton_nested<llvm::MachineBasicBlock, llvm::iterator_range<__gnu_cxx::__normal_iterator<llvm::MachineBasicBlock**, std::vector<llvm::MachineBasicBlock*, std::allocator<llvm::MachineBasicBlock*>>>>, std::pair<llvm::MachineBasicBlock*, bool> llvm::getExitBlockHelpe... | std::pair<T *, bool> find_singleton_nested(R &&Range, Predicate P,
bool AllowRepeats = false) {
T *RC = nullptr;
for (auto *A : Range) {
std::pair<T *, bool> PRC = P(A, AllowRepeats);
if (PRC.second) {
assert(PRC.first == nullptr &&
"Inconsistent... | subq $0x88, %rsp
movb %dl, %al
movq %rsi, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x911ec0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x911fa0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
lea... | /llvm/ADT/STLExtras.h |
void llvm::MachineOptimizationRemarkEmitter::emit<llvm::MachinePipeliner::canPipelineLoop(llvm::MachineLoop&)::$_1>(llvm::MachinePipeliner::canPipelineLoop(llvm::MachineLoop&)::$_1, decltype(fp())*) | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (MF.getFuncti... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, 0x1d0(%rsp)
movq %rdi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0x727890
movq %rax, %rdi
callq 0x3033f40
movq %rax, %rdi
callq 0x309ec30
cmpq $0x0, %rax
jne 0x345ef26
movq 0x8(%rsp), %rax
movq (%rax), %rd... | /llvm/CodeGen/MachineOptimizationRemarkEmitter.h |
llvm::DenseMap<llvm::MachineInstr*, llvm::SmallDenseSet<llvm::Register, 4u, llvm::DenseMapInfo<llvm::Register, void>>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::SmallDenseSet<llvm::Register, 4u, llvm::DenseMapInfo<llvm::Register, void>>>>::allocateBuckets(unsig... | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x347ec67
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x347ec8f
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Register, llvm::detail::DenseSetEmpty, 16u, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>, llvm::Register, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>::moveFromOldB... | 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... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x347d710
callq 0x347cb80
movl %eax, 0x3c(%rsp)
callq 0x347cba0
movl %eax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rs... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::SUnit*, std::pair<unsigned int, long>, llvm::DenseMapInfo<llvm::SUnit*, void>, llvm::detail::DenseMapPair<llvm::SUnit*, std::pair<unsigned int, long>>>, llvm::SUnit*, std::pair<unsigned int, long>, llvm::DenseMapInfo<llvm::SUnit*, void>, llvm::detail::DenseMapPair<llvm::SUnit*, s... | const_iterator makeConstIterator(const BucketT *P, const BucketT *E,
const DebugEpochBase &Epoch,
const bool NoAdvance=false) const {
if (shouldReverseIterate<KeyT>()) {
const BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x10da130
testb $0x1, %al
jne 0x3481666
jmp 0x34816d2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineInstr*, std::pair<unsigned int, long>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, std::pair<unsigned int, long>>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x34836e7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x348370d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x18, %rax,... | /llvm/ADT/DenseMap.h |
bool llvm::SetVector<llvm::SUnit*, llvm::SmallVector<llvm::SUnit*, 0u>, llvm::DenseSet<llvm::SUnit*, llvm::DenseMapInfo<llvm::SUnit*, void>>, 0u>::remove_if<llvm::SwingSchedulerDAG::removeDuplicateNodes(llvm::SmallVector<llvm::NodeSet, 8u>&)::$_0>(llvm::SwingSchedulerDAG::removeDuplicateNodes(llvm::SmallVector<llvm::No... | bool remove_if(UnaryPredicate P) {
typename vector_type::iterator I = [this, P] {
if constexpr (canBeSmall())
if (isSmall())
return llvm::remove_if(vector_, P);
return llvm::remove_if(vector_,
TestAndEraseFromSet<UnaryPredicate>(P, set_));
}();
if... | subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x348e110
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq ... | /llvm/ADT/SetVector.h |
llvm::RNSuccIterator<llvm::MachineRegionNode*, llvm::MachineBasicBlock, llvm::MachineRegion>::operator++() | inline Self& operator++() {
if(isRegionMode()) {
// The Region only has 1 successor.
advanceRegionSucc();
} else {
// Skip the exit.
do
++BItor;
while (BItor != BlockTraits::child_end(getNode()->getEntry())
&& isExit(*BItor));
}
return *this;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x34b6b00
testb $0x1, %al
jne 0x34b748e
jmp 0x34b749d
movq 0x10(%rsp), %rdi
callq 0x34b7230
jmp 0x34b751d
jmp 0x34b749f
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x8ff680
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq... | /llvm/Analysis/RegionIterator.h |
llvm::MachineRegisterInfo::constrainRegAttrs(llvm::Register, llvm::Register, unsigned int) | bool
MachineRegisterInfo::constrainRegAttrs(Register Reg,
Register ConstrainingReg,
unsigned MinNumRegs) {
const LLT RegTy = getType(Reg);
const LLT ConstrainingRegTy = getType(ConstrainingReg);
if (RegTy.isValid() && ConstrainingRegTy.... | subq $0xa8, %rsp
movl %esi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movq %rdi, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %esi
callq 0x7f52b0
movq 0x18(%rsp), %rdi
movq %rax, 0x80(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x6c(%rsp)
mo... | /CodeGen/MachineRegisterInfo.cpp |
(anonymous namespace)::MachineScheduler::createMachineScheduler() | ScheduleDAGInstrs *MachineScheduler::createMachineScheduler() {
// Select the scheduler, or set the default.
MachineSchedRegistry::ScheduleDAGCtor Ctor = MachineSchedOpt;
if (Ctor != useDefaultMachineSched)
return Ctor(this);
// Get the default scheduler set by the target for this function.
ScheduleDAGIn... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x62bf277(%rip), %rdi # 0x978cd60
addq $0x80, %rdi
callq 0x34cdfe0
movq %rax, 0x10(%rsp)
leaq -0xc691(%rip), %rax # 0x34c1470
cmpq %rax, 0x10(%rsp)
je 0x34cdb17
movq (%rsp), %rdi
callq *0x10(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x34cdb... | /CodeGen/MachineScheduler.cpp |
non-virtual thunk to llvm::RegisterPassParser<llvm::MachineSchedRegistry>::~RegisterPassParser() | void initialize() {
cl::parser<typename RegistryClass::FunctionPassCtor>::initialize();
// Add existing passes to option.
for (RegistryClass *Node = RegistryClass::getList();
Node; Node = Node->getNext()) {
this->addLiteralOption(Node->getName(),
(typename RegistryClass... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rdi
addq $-0x8, %rdi
jmp 0x34cf330
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/CodeGen/MachinePassRegistry.h |
llvm::DenseMap<std::pair<llvm::Register, llvm::MachineBasicBlock*>, llvm::MachineBasicBlock*, llvm::DenseMapInfo<std::pair<llvm::Register, llvm::MachineBasicBlock*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Register, llvm::MachineBasicBlock*>, llvm::MachineBasicBlock*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x34e0450
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x34e04a0
testb $0x1, %al
jne 0x34e0426
jmp 0x34e0431
movq (%rsp), %rdi
callq 0x34e0510
jmp 0x34e0443
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::PointerIntPairInfo<llvm::MachineInstr*, 1u, llvm::PointerLikeTypeTraits<llvm::MachineInstr*>>::updatePointer(long, llvm::MachineInstr*) | static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
intptr_t PtrWord =
reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
assert((PtrWord & ~PointerBitMask) == 0 &&
"Pointer is not sufficiently aligned");
// Preserve all low bits, just update the pointer.
retu... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x731e90
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
andq $0x7, %rcx
orq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/PointerIntPair.h |
llvm::PointerIntPairInfo<void*, 1u, llvm::pointer_union_detail::PointerUnionUIntTraits<llvm::PointerIntPair<llvm::MachineInstr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<llvm::MachineInstr*>, llvm::PointerIntPairInfo<llvm::MachineInstr*, 1u, llvm::PointerLikeTypeTraits<llvm::MachineInstr*>>>, llvm::SmallVector<llv... | static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
intptr_t PtrWord =
reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
assert((PtrWord & ~PointerBitMask) == 0 &&
"Pointer is not sufficiently aligned");
// Preserve all low bits, just update the pointer.
retu... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x34e7370
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
andq $0x3, %rcx
orq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/PointerIntPair.h |
SinkingPreventsImplicitNullCheck(llvm::MachineInstr&, llvm::TargetInstrInfo const*, llvm::TargetRegisterInfo const*) | static bool SinkingPreventsImplicitNullCheck(MachineInstr &MI,
const TargetInstrInfo *TII,
const TargetRegisterInfo *TRI) {
using MachineBranchPredicate = TargetInstrInfo::MachineBranchPredicate;
auto *MBB = MI.getParent();
... | subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x73fb40
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x8fe290
cmpl $0x1, %eax
je 0x34e9cf3
movb $0x0, 0xd7(%rsp)
jmp 0x34e9efc
movq 0xb0(%rsp), %rdi
callq 0x91de90
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), ... | /CodeGen/MachineSink.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::SmallVector<std::pair<llvm::MachineInstr*, llvm::SmallVector<unsigned int, 2u>>, 2u>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::SmallVector<std::pair<llvm::MachineInstr*, llvm::SmallVector<unsigned int, 2u>>, 2u>>>, unsig... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x34f6030
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x34f6050
callq 0x34f6070
movq (%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x34f6080
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x34f6090
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::MachineBasicBlock const*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::MachineBasicBlock const*, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, llvm::Machine... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x548460
movq 0x10(%rsp), %rdi
callq 0x35119e0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x3511810
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::Register, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr const*>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb3a7c0
movl %eax, %esi
leaq 0x1c(%rsp), %rdi
callq 0x72e210
callq 0xb3a7d0
movl %eax, %esi
leaq 0x18(%rsp), %rdi
callq 0x72e210
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0xf(%rsp)
je 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, std::pair<int, int>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, std::pair<int, int>>>, llvm::MachineInstr*, std::pair<int, int>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::Mach... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x35486ae
movl $0x0, 0x14(%rsp)
jmp 0x35486ce
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, std::pair<int, int>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, std::pair<int, int>>>, llvm::MachineInstr*, std::pair<int, int>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::Mach... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xc8f360
testb $0x1, %al
jne 0x3549106
jmp 0x3549172
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::MachineInstr*, std::pair<int, int>, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, std::pair<int, int>>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::MachineInstr*, std::pair<int, int>>*, llvm::detail::DenseMapPair<llvm::MachineIn... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
void printStackObjectDbgInfo<llvm::yaml::MachineStackObject>(llvm::MachineFunction::VariableDbgInfo const&, llvm::yaml::MachineStackObject&, llvm::ModuleSlotTracker&) | static void
printStackObjectDbgInfo(const MachineFunction::VariableDbgInfo &DebugVar,
T &Object, ModuleSlotTracker &MST) {
std::array<std::string *, 3> Outputs{{&Object.DebugVar.Value,
&Object.DebugExpr.Value,
&Obj... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rax
addq $0xe0, %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
addq $0x110, %rax # imm = 0x110
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq 0... | /CodeGen/MIRPrinter.cpp |
llvm::MIPrinter::print(llvm::MachineInstr const&, unsigned int, llvm::TargetRegisterInfo const*, llvm::TargetInstrInfo const*, bool, llvm::LLT, bool) | void MIPrinter::print(const MachineInstr &MI, unsigned OpIdx,
const TargetRegisterInfo *TRI,
const TargetInstrInfo *TII,
bool ShouldPrintRegisterTies, LLT TypeToPrint,
bool PrintDef) {
const MachineOperand &Op = MI.getOperand(OpId... | pushq %rbp
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %r9d, %eax
movq %rcx, 0x60(%rsp)
movl %edx, %ecx
movq 0x60(%rsp), %rdx
movl %ecx, 0x6c(%rsp)
movq %rsi, %rcx
movl 0x6c(%rsp), %esi
movq %rcx, 0x70(%rsp)
movq %rdi, %r9
movq 0x70(%rsp), %rdi
movb %al, %cl
movb 0x1c8(%rsp), %al
movq 0x1c0(%rsp), %r10
m... | /CodeGen/MIRPrinter.cpp |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::yaml::MachineJumpTable::Entry, std::allocator<llvm::yaml::MachineJumpTable::Entry>>, llvm::yaml::EmptyContext>(char const*, std::vector<llvm::yaml::MachineJumpTable::Entry, std::allocator<llvm::yaml::MachineJumpTable::Entry>>&, std::vector<llvm::yaml::Machine... | void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
const bool sameAsDefault = outputting() && Val == DefaultValue;
if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
... | subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
j... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::yaml::StringValue, std::allocator<llvm::yaml::StringValue>>, llvm::yaml::EmptyContext>(char const*, std::vector<llvm::yaml::StringValue, std::allocator<llvm::yaml::StringValue>>&, std::vector<llvm::yaml::StringValue, std::allocator<llvm::yaml::StringValue>> c... | void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
const bool sameAsDefault = outputting() && Val == DefaultValue;
if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
... | subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
j... | /llvm/Support/YAMLTraits.h |
llvm::DenseMapIterator<unsigned int const*, unsigned int, llvm::DenseMapInfo<unsigned int const*, void>, llvm::detail::DenseMapPair<unsigned int const*, unsigned int>, true>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3555e90
movq %rax, 0x18(%rsp)
callq 0x3556410
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x3576d98
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x357567... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::PeepholeOptimizer::foldRedundantNAPhysCopy(llvm::MachineInstr&, llvm::DenseMap<llvm::Register, llvm::MachineInstr*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr*>>&) | bool PeepholeOptimizer::foldRedundantNAPhysCopy(
MachineInstr &MI, DenseMap<Register, MachineInstr *> &NAPhysToVirtMIs) {
assert(MI.isCopy() && "expected a COPY machine instruction");
if (DisableNAPhysCopyOpt)
return false;
Register DstReg = MI.getOperand(0).getReg();
Register SrcReg = MI.getOperand(1... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x6211b7d(%rip), %rdi # 0x978ddc0
addq $0x80, %rdi
callq 0x3f1b60
testb $0x1, %al
jne 0x357c255
jmp 0x357c262
movb $0x0, 0xb7(%rsp)
jmp 0x357c44e
movq 0xa0(%rsp), %rdi
xorl %esi, %esi
ca... | /CodeGen/PeepholeOptimizer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::TargetInstrInfo::RegSubRegPair, llvm::MachineInstr*, llvm::DenseMapInfo<llvm::TargetInstrInfo::RegSubRegPair, void>, llvm::detail::DenseMapPair<llvm::TargetInstrInfo::RegSubRegPair, llvm::MachineInstr*>>, llvm::TargetInstrInfo::RegSubRegPair, llvm::MachineInstr*, llvm::DenseMapIn... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xd42dc0
testb $0x1, %al
jne 0x3583386
jmp 0x35833f2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, llvm::Register>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::Register>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::Register>, unsigned int>>, std::pair<unsigned int, llvm::Register>, unsigned int, llvm::DenseMapInfo<std::p... | 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->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3585440
cmpl $0x0, %eax
jne 0x3585882
jmp 0x358591a
callq 0x3585300
movq %rax, 0x28(%rsp)
callq 0x3585920
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3585310
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3585320
movq %... | /llvm/ADT/DenseMap.h |
allPhiOperandsUndefined(llvm::MachineInstr const&, llvm::MachineRegisterInfo const&) | static bool allPhiOperandsUndefined(const MachineInstr &MPhi,
const MachineRegisterInfo &MRI) {
for (unsigned I = 1, E = MPhi.getNumOperands(); I != E; I += 2) {
const MachineOperand &MO = MPhi.getOperand(I);
if (!isImplicitlyDefined(MO.getReg(), MRI) && !MO.isUndef())
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x732d60
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
je 0x3589d92
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x72c4d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x72c500
mov... | /CodeGen/PHIElimination.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, unsigned int, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, unsigned int>>, llvm::MachineInstr*, unsigned int, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, unsigned int>>::LookupBucketF... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x358a630
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x35856f0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x358a4e2
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>>>, llvm::MachineBasicBlock*, llvm::SmallVector<llvm::Machin... | inline iterator begin() {
// When the map is empty, avoid the overhead of advancing/retreating past
// empty buckets.
if (empty())
return end();
if (shouldReverseIterate<KeyT>())
return makeIterator(getBucketsEnd() - 1, getBuckets(), *this);
return makeIterator(getBuckets(), getBucketsEn... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3599cb0
testb $0x1, %al
jne 0x359467e
jmp 0x3594697
movq 0x18(%rsp), %rdi
callq 0x3594730
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x359471e
callq 0xd63750
testb $0x1, %al
jne 0x35946a2
jmp 0x35946e3
movq 0x18(%rsp), %rdi
... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::PEI::replaceFrameIndices(llvm::MachineFunction&) | void PEI::replaceFrameIndices(MachineFunction &MF) {
const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
for (auto &MBB : MF) {
int SPAdj = TFI.alignSPAdjust(MBB.getCallFrameSize());
if (TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsUp)
SPAdj = -SPAdj;
repla... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7edfc0
movq %rax, 0x30(%rsp)
m... | /CodeGen/PrologEpilogInserter.cpp |
assignCalleeSavedSpillSlots(llvm::MachineFunction&, llvm::BitVector const&, unsigned int&, unsigned int&) | static void assignCalleeSavedSpillSlots(MachineFunction &F,
const BitVector &SavedRegs,
unsigned &MinCSFrameIndex,
unsigned &MaxCSFrameIndex) {
if (SavedRegs.empty())
return;
const TargetRegi... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq %rcx, 0x1c8(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0xb016e0
testb $0x1, %al
jne 0x35966ca
jmp 0x35966cf
jmp 0x3596d13
movq 0x1e0(%rsp), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0xc8(%rax)... | /CodeGen/PrologEpilogInserter.cpp |
llvm::DenseMapIterator<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::MachineBasicBlock*,... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::PEI::replaceFrameIndicesBackward(llvm::MachineBasicBlock*, llvm::MachineFunction&, int&) | void PEI::replaceFrameIndicesBackward(MachineBasicBlock *BB,
MachineFunction &MF, int &SPAdj) {
assert(MF.getSubtarget().getRegisterInfo() &&
"getRegisterInfo() must be implemented!");
const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
const TargetRegis... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x120(%rsp), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, 0x110(%rsp)
movq 0x120(%rsp), %rdi
call... | /CodeGen/PrologEpilogInserter.cpp |
(anonymous namespace)::PEI::replaceFrameIndexDebugInstr(llvm::MachineFunction&, llvm::MachineInstr&, unsigned int, int) | bool PEI::replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,
unsigned OpIdx, int SPAdj) {
const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
if (MI.isDebugValue()) {
... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
movq %rdx, 0x148(%rsp)
movl %ecx, 0x144(%rsp)
movl %r8d, 0x140(%rsp)
movq 0x150(%rsp), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, 0x138(%rsp)
movq 0x150(%rsp), %rdi
callq 0x73c170
movq %rax, ... | /CodeGen/PrologEpilogInserter.cpp |
llvm::rdf::DataFlowGraph::buildStmt(llvm::rdf::NodeAddr<llvm::rdf::BlockNode*>, llvm::MachineInstr&) | void DataFlowGraph::buildStmt(Block BA, MachineInstr &In) {
Stmt SA = newStmt(BA, &In);
auto isCall = [](const MachineInstr &In) -> bool {
if (In.isCall())
return true;
// Is tail call?
if (In.isBranch()) {
for (const MachineOperand &Op : In.operands())
if (Op.isGlobal() || Op.isSym... | subq $0x368, %rsp # imm = 0x368
movq %rsi, 0x358(%rsp)
movl %edx, 0x360(%rsp)
movq %rdi, 0x350(%rsp)
movq %rcx, 0x348(%rsp)
movq 0x350(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movups 0x358(%rsp), %xmm0
movaps %xmm0, 0x320(%rsp)
movq 0x348(%rsp), %rcx
movq 0x320(%rsp), %rsi
movl 0x328(%rsp), %edx
callq 0x35a2960
mov... | /CodeGen/RDFGraph.cpp |
llvm::rdf::DataFlowGraph::buildPhis(llvm::rdf::RegisterAggrMap<unsigned int>&, llvm::rdf::NodeAddr<llvm::rdf::BlockNode*>) | void DataFlowGraph::buildPhis(BlockRefsMap &PhiM, Block BA) {
// Check if this blocks has any DF defs, i.e. if there are any defs
// that this block is in the iterated dominance frontier of.
auto HasDF = PhiM.find(BA.Id);
if (HasDF == PhiM.end() || HasDF->second.empty())
return;
// Prepare a list of Node... | subq $0x378, %rsp # imm = 0x378
movq %rdx, 0x368(%rsp)
movl %ecx, 0x370(%rsp)
movq %rdi, 0x360(%rsp)
movq %rsi, 0x358(%rsp)
movq 0x360(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x358(%rsp), %rdi
leaq 0x368(%rsp), %rsi
addq $0x8, %rsi
callq 0x35a8860
movq %rax, 0x350(%rsp)
movq 0x358(%rsp), %rdi
callq 0x35a88b0
... | /CodeGen/RDFGraph.cpp |
void llvm::rdf::DataFlowGraph::linkStmtRefs<llvm::rdf::DataFlowGraph::linkBlockRefs(std::unordered_map<unsigned int, llvm::rdf::DataFlowGraph::DefStack, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, llvm::rdf::DataFlowGraph::DefStack>>>&, llvm::rdf::NodeAddr<llvm::rd... | void DataFlowGraph::linkStmtRefs(DefStackMap &DefM, Stmt SA, Predicate P) {
#ifndef NDEBUG
RegisterSet Defs(getPRI());
#endif
// Link all nodes (upwards in the data-flow) with their reaching defs.
for (Ref RA : SA.Addr->members_if(P, *this)) {
uint16_t Kind = RA.Addr->getKind();
assert(Kind == NodeAttrs:... | subq $0x128, %rsp # imm = 0x128
movq %rdx, 0x118(%rsp)
movl %ecx, 0x120(%rsp)
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq 0x108(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x118(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x35b1e80
leaq 0xa8(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x171b3e... | /CodeGen/RDFGraph.cpp |
llvm::LiveInterval const* const* llvm::SmallVectorTemplateCommon<llvm::LiveInterval const*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::LiveInterval const*, true>>(llvm::SmallVectorTemplateBase<llvm::LiveInterval const*, true>*, llvm::LiveInterval const* const&, unsigned long) | 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... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dca0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x35e66e4
movq 0x3... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::PBQP::RegAlloc::AllowedRegVector const*, llvm::PBQP::RegAlloc::AllowedRegVector const*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::PBQP::RegAlloc::AllowedRegVector const*, llvm::PBQP::RegAlloc::AllowedRegVector const*>, void>, llvm::detail::DenseSe... | 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->... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3618e60
cmpl $0x0, %eax
jne 0x361e742
jmp 0x361e7e4
callq 0x3618d80
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
callq 0x361b8d0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x3618db0
movq 0x8(%rsp), %rdi
... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::RegisterCoalescer::adjustCopiesBackFrom(llvm::CoalescerPair const&, llvm::MachineInstr*) | bool RegisterCoalescer::adjustCopiesBackFrom(const CoalescerPair &CP,
MachineInstr *CopyMI) {
assert(!CP.isPartial() && "This doesn't work for partial copies.");
assert(!CP.isPhys() && "This doesn't work for physreg copies.");
LiveInterval &IntA =
LIS->getInterval... | subq $0x2d8, %rsp # imm = 0x2D8
movq %rdi, 0x2c8(%rsp)
movq %rsi, 0x2c0(%rsp)
movq %rdx, 0x2b8(%rsp)
movq 0x2c8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x60(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x2c0(%rsp), %rdi
callq 0x3636870
testb $0x1, %al
jne 0x36395fe
jmp 0x3639614
movq 0x2c0(%rsp), %rdi
callq 0x361f5... | /CodeGen/RegisterCoalescer.cpp |
(anonymous namespace)::JoinVals::followCopyChain(llvm::VNInfo const*) const | std::pair<const VNInfo *, Register>
JoinVals::followCopyChain(const VNInfo *VNI) const {
Register TrackReg = Reg;
while (!VNI->isPHIDef()) {
SlotIndex Def = VNI->def;
MachineInstr *MI = Indexes->getInstructionFromIndex(Def);
assert(MI && "No defining instruction");
if (!MI->isFullCopy())
retu... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x144(%rsp)
movq 0x148(%rsp), %rdi
callq 0xeaff60
xorb $-0x1, %al
testb $0x1, %al
jne 0x3642196
jmp 0x364256d
movq 0x8(%rsp), %rax
movq 0x148(%rsp), %rcx
m... | /CodeGen/RegisterCoalescer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::ValueMapping [], std::default_delete<llvm::RegisterBankInfo::ValueMapping []>>, llvm::DenseMapInfo<llvm::hash_code, void>, llvm::detail::DenseMapPair<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::ValueMapping [], std::... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x365717e
movl $0x0, 0x14(%rsp)
jmp 0x365719e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, unsigned int, llvm::DenseMapInfo<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, void>, llvm::detail::DenseMapPair<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, uns... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3674130
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3674150
callq 0x36740b0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x36740d0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x36740e0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, unsigned int, llvm::DenseMapInfo<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, void>, llvm::detail::DenseMapPair<llvm::PointerUnion<llvm::Value const*, llvm::PseudoSourceValue const*>, uns... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x367441e
movl $0x0, 0x14(%rsp)
jmp 0x367443e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /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.