name string | code string | asm string | file string |
|---|---|---|---|
llvm::BasicAAResult::getModRefInfo(llvm::CallBase const*, llvm::CallBase const*, llvm::AAQueryInfo&) | ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call1,
const CallBase *Call2,
AAQueryInfo &AAQI) {
// Guard intrinsics are marked as arbitrarily writing so that proper control
// dependencies are maintained but they never mods a... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
cmpb $0x55, (%rsi)
jne 0x2579c63
movq %r14, %rdi
callq 0x91f89e
xorl %ecx, %ecx
testb %al, %al
cmovneq %r14, %rcx
jmp 0x2579c65
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x2579c9f
movq -0x20(%rcx), %rax
cmpl $0x96, 0x24(%rax)
jne 0x2579c9f
movq ... | /Analysis/BasicAliasAnalysis.cpp |
llvm::DenseMap<llvm::Value const*, llvm::Instruction*, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::Instruction*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AssertingVH<llvm::BasicBlock const>, std::pair<llvm::BlockFrequencyInfoImplBase::BlockNode, llvm::bfi_detail::BFICallbackVH<llvm::BasicBlock, llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>>>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::BasicBlock const>, void>, llvm::detail::Dense... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x25804dc
movl %eax, %ebp
testb %al, %al
je 0x258061b
movq 0x8(%rsp), %r14
movq 0x28(%r14), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x2580602
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2580602
testq %rax, %rax... | /llvm/ADT/DenseMap.h |
llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*>>::po_iterator(llvm::BasicBlock const*) | po_iterator(NodeRef BB) {
this->insertEdge(std::optional<NodeRef>(), BB);
VisitStack.emplace_back(BB, GT::child_begin(BB), GT::child_end(BB));
traverseChild();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
leaq 0x60(%rdi), %r14
leaq 0x70(%rdi), %rax
movq %rax, 0x60(%rdi)
movabsq $0x800000000, %rax # imm = 0x8000000... | /llvm/ADT/PostOrderIterator.h |
llvm::GraphWriter<llvm::BlockFrequencyInfo*>::writeGraph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void writeGraph(const std::string &Title = "") {
// Output the header for the graph...
writeHeader(Title);
// Emit all of the nodes in the graph...
writeNodes();
// Output any customizations on the graph
DOTGraphTraits<GraphType>::addCustomGraphFeatures(G, *this);
// Output the end of the... | pushq %rbx
movq %rdi, %rbx
callq 0x258406e
movq %rbx, %rdi
callq 0x2584290
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x2584061
leaq 0x23f13c9(%rip), %rsi # 0x497541f
movl $0x2, %edx
popq %rbx
jmp 0x2b7d704
movw $0xa7d, (%rax) # imm = 0xA7D
addq $0x2, 0x2... | /llvm/Support/GraphWriter.h |
llvm::cl::opt<double, false, llvm::cl::parser<double>>::opt<char [24], llvm::cl::initializer<double>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [24], llvm::cl::initializer<double> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0, 0x98(%r14)
leaq 0x31dbdb1(%rip), %rax # 0x57610a0
addq $0... | /llvm/Support/CommandLine.h |
llvm::bfi_detail::IrreducibleGraph::addEdge(llvm::bfi_detail::IrreducibleGraph::IrrNode&, llvm::BlockFrequencyInfoImplBase::BlockNode const&, llvm::BlockFrequencyInfoImplBase::LoopData const*) | void IrreducibleGraph::addEdge(IrrNode &Irr, const BlockNode &Succ,
const BFIBase::LoopData *OuterLoop) {
if (OuterLoop && OuterLoop->isHeader(Succ))
return;
auto L = Lookup.find(Succ.Index);
if (L == Lookup.end())
return;
IrrNode &SuccIrr = *L->second;
Irr.Edges.push_ba... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x25866d6
movl 0xc(%rcx), %eax
movq 0x60(%rcx), %rdi
cmpq $0x2, %rax
jb 0x25866ca
leaq (%rdi,%rax,4), %rsi
movq %r15, %rdx
callq 0x1d04357
jmp 0x25866d2
movl (%r15), %eax
cmpl (%rdi), %eax
sete %al
test... | /Analysis/BlockFrequencyInfoImpl.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::BlockFrequencyInfoImplBase::Weight, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::BlockFrequencyInfoImplBase::Weight>>, unsigned int, llvm::BlockFrequencyInfoImplBase::Weight, llvm::DenseMapInfo<unsigned int, void>, llvm::det... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x258735e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2587354
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x25873e2
movl (%rbx), %ecx
movl %ecx, (%rax)
xorps ... | /llvm/ADT/DenseMap.h |
llvm::BranchProbabilityInfo::SccInfo::SccInfo(llvm::Function const&) | BranchProbabilityInfo::SccInfo::SccInfo(const Function &F) {
// Record SCC numbers of blocks in the CFG to identify irreducible loops.
// FIXME: We could only calculate this if the CFG is known to be irreducible
// (perhaps cache this info in LoopInfo if we can easily calculate it there?).
int SccNum = 0;
for... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
xorl %r14d, %r14d
movq %r14, 0x28(%rdi)
movups %xmm0, (%rdi)
movl %r14d, 0x10(%rdi)
movq 0x50(%rsi), %rax
leaq -0x18(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
leaq 0x10(%rs... | /Analysis/BranchProbabilityInfo.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, int, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, int>>, llvm::BasicBlock const*, int, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, int>>::find(l... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x17ac08e
testb %al, %al
je 0x2589d5b
movq (%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
jmp 0x2589d68
movl 0x10(%rbx), %eax
shlq $0x4, %rax
addq (%rbx), %rax
movq %rax, %rdx
a... | /llvm/ADT/DenseMap.h |
llvm::BranchProbabilityInfo::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&) | bool BranchProbabilityInfo::invalidate(Function &, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &) {
// Check whether the analysis, all analyses on functions, or the function's
// CFG have been preserved.
auto PAC = PA.getChecker<BranchProbabilityAnalysi... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
leaq 0x33feb4b(%rip), %rsi # 0x598b070
movq %rsi, 0x8(%r14)
leaq 0x30(%rdx), %rdi
callq 0x90b7be
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq 0x30(%rbx), %rcx
sete %dl
movl 0x40(%rbx,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx... | /Analysis/BranchProbabilityInfo.cpp |
llvm::iterator_range<llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::GraphTraits<llvm::BasicBlock const*>::NodeRef, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*>>> llvm::post_order<llvm::BasicBlock const*>(llvm::BasicBlock const* const&) | iterator_range<po_iterator<T>> post_order(const T &G) {
return make_range(po_begin(G), po_end(G));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x1b8(%rsp), %r14
movq %r14, %rdi
callq 0x25819d6
leaq 0x8(%rsp), %r15
movl $0x1b0, %edx # imm = 0x1B0
movq %r15, %rdi
xorl %esi, %esi
callq 0x780240
leaq 0x28(%rsp), %rax
movq %rax, ... | /llvm/ADT/PostOrderIterator.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock const*, unsigned int, 4u, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, unsigned int>>, llvm::BasicBlock const*, unsigned int, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<ll... | unsigned getNumEntries() const {
return NumEntries;
} | movl (%rdi), %eax
cmpl $0x1, %eax
ja 0x258d3f1
cmpl $0x0, 0x4(%rdi)
je 0x258d4e6
leal (%rax,%rax), %edx
andl $-0x4, %edx
movl $0x4, %ecx
testb $0x1, %al
jne 0x258d403
movl 0x10(%rdi), %ecx
cmpl %ecx, %edx
setae %dl
cmpl $0x41, %ecx
setb %sil
orb %dl, %sil
je 0x25900fa
testb $0x1, %al
jne 0x258d422
movq 0x8(%rdi), %rax
... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::BasicBlock const*, unsigned int, 4u, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x258e871
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %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 %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>>, std::pair<llvm::Loop*, int>, llvm::SmallVector... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x258ed06
pushq %rbp
pushq %r14
pushq %rbx
movl (%rsi), %eax
movl 0x8(%rsi), %edi
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
leal (%rdi,%rdi,8), %r9d
leal (%rdi,%r9,4), %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>* llvm::DenseMapBase<llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, in... | 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 (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x258ed37
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x258ed77
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability, llvm::DenseMapInfo<std::pair<llvm::BasicBlock const*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %eax
testl %ecx, %ecx
je 0x258f4a8
decl %ecx
je 0x258f4ac
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x258f4b1
xorl %ebp, %ebp
jmp 0x258f4c7
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %edx
shll %cl, %edx
cmpl $0x41, %edx
mov... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>>, llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0x258f549
cmpl $0x0, 0xc(%r14)
je 0x258f645
shll $0x2, %ecx
movl 0x10(%r14), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
jne 0x258f575
movq %r14, %rdi
ad... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>>::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, %rbx
movl 0x10(%rdi), %r15d
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 %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability, llvm::DenseMapInfo<std::pair<llvm::BasicBlock const*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability>>::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, %rbx
movl 0x10(%rdi), %r15d
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 %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::iterator_range<llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*>>>::iterator_range(llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*>... | iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
: begin_iterator(std::move(begin_iterator)),
end_iterator(std::move(end_iterator)) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
movl $0x8, %edx
movq %r15, %rcx
callq 0x2b4e93a
leaq 0x70(%r14), %rax
movq %rax, 0x60(%r14)
movabsq $0x800000000, %r12 # imm = 0x800000000
movq %r12, 0x68(%r14)
cmpl $0x0, 0x68(%r15)
je 0x25... | /llvm/ADT/iterator_range.h |
llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, unsigned int, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, unsigned int>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldSize = this->size();
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldSize) {
NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
NewNumBuckets = ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
xorl %ebp, %ebp
cmpl $0x2, %eax
jb 0x2590073
movl %eax, %ecx
shrl %ecx
decl %ecx
je 0x2590055
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x259005a
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %esi
shll %cl, %esi
addl $-0x1c, %edx
cmpl $0x3, %edx
... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<double, false, llvm::cl::parser<double>>::opt<char [20], llvm::cl::initializer<double>, llvm::cl::desc>(char const (&) [20], llvm::cl::initializer<double> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movb $0x0, 0x98(%rbx)
leaq 0x31cfad6(%rip), %rax # 0x57610a0
addq $0x10, %rax
movq ... | /llvm/Support/CommandLine.h |
llvm::GraphWriter<llvm::DOTFuncInfo*>::writeGraph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void writeGraph(const std::string &Title = "") {
// Output the header for the graph...
writeHeader(Title);
// Emit all of the nodes in the graph...
writeNodes();
// Output any customizations on the graph
DOTGraphTraits<GraphType>::addCustomGraphFeatures(G, *this);
// Output the end of the... | pushq %rbx
movq %rdi, %rbx
callq 0x25925d8
movq %rbx, %rdi
callq 0x25927e4
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x25925cb
leaq 0x23e2e5f(%rip), %rsi # 0x497541f
movl $0x2, %edx
popq %rbx
jmp 0x2b7d704
movw $0xa7d, (%rax) # imm = 0xA7D
addq $0x2, 0x2... | /llvm/Support/GraphWriter.h |
llvm::GraphWriter<llvm::DOTFuncInfo*>::emitEdge(void const*, int, void const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void emitEdge(const void *SrcNodeID, int SrcNodePort,
const void *DestNodeID, int DestNodePort,
const std::string &Attrs) {
if (SrcNodePort > 64) return; // Eminating from truncated part?
if (DestNodePort > 64) DestNodePort = 64; // Targeting the truncated part?
... | cmpl $0x40, %edx
jle 0x2593622
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x19a842a(%rip), %rsi # 0x3f3ba6c
movl $0x5, %edx
callq 0x7f9ba8
movq %rax, %rdi
movq %r12, %rsi
callq 0x2b7d64e
testl %ebp, ... | /llvm/Support/GraphWriter.h |
llvm::detail::DenseMapPair<llvm::Instruction*, unsigned long>* llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, unsigned long, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned long>>, llvm::Instruction*, unsigned long, llvm::DenseMapInfo<llvm::Instruction*, void... | 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 0x25ccd75
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::DDGNode*, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::DDGNode*>>, llvm::Instruction*, llvm::DDGNode*, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm:... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x25cd8a7
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::SmallVectorImpl<llvm::BranchInst*>::operator=(llvm::SmallVectorImpl<llvm::BranchInst*>&&) | 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 0x25d06a4
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0x25d0615
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25d06b4
jmp 0x25d06a4
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %r12d
cmpl %r15d, %r12d
jae 0x25d06... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseSetImpl<llvm::AssertingVH<llvm::Value>, llvm::SmallDenseMap<llvm::AssertingVH<llvm::Value>, llvm::detail::DenseSetEmpty, 2u, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::Value>>>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>>... | unsigned getNumEntries() const {
return NumEntries;
} | movl (%rdi), %ecx
leaq 0x8(%rdi), %rax
cmpl $0x1, %ecx
ja 0x26248b7
testl %ecx, %ecx
cmoveq 0x8(%rdi), %rax
movl $0x2, %ecx
cmovel 0x10(%rdi), %ecx
leaq (%rax,%rcx,8), %rax
movq %rax, %rdx
retq
testb $0x1, %cl
cmoveq 0x8(%rdi), %rax
movl $0x2, %ecx
cmovel 0x10(%rdi), %ecx
leaq (%rax,%rcx,8), %rdx
testl %ecx, %ecx
je 0x... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::SmallVector<std::unique_ptr<llvm::IndexedReference, std::default_delete<llvm::IndexedReference>>, 8u>, false>::push_back(llvm::SmallVector<std::unique_ptr<llvm::IndexedReference, std::default_delete<llvm::IndexedReference>>, 8u>&&) | void push_back(T &&Elt) {
T *EltPtr = reserveForParamAndGetAddress(Elt);
::new ((void *)this->end()) T(::std::move(*EltPtr));
this->set_size(this->size() + 1);
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x263b798
movq (%rbx), %rdi
movl 0x8(%rbx), %ecx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq (%rdi,%rcx), %rdx
addq $0x10, %rdx
movq %rdx, -0x10(%rdx)
movabsq $0x800000000, %rsi # imm = 0x800000000
movq %rsi, -0x8(%rdx)
cmpl $0x0, 0x8(%rax)
je 0x2638b8d
addq %rcx,... | /llvm/ADT/SmallVector.h |
llvm::Loop** llvm::SmallVectorImpl<llvm::Loop*>::insert<llvm::bf_iterator<llvm::Loop*, llvm::SmallPtrSet<llvm::Loop*, 8u>, llvm::GraphTraits<llvm::Loop*>>, void>(llvm::Loop**, llvm::bf_iterator<llvm::Loop*, llvm::SmallPtrSet<llvm::Loop*, 8u>, llvm::GraphTraits<llvm::Loop*>>, llvm::bf_iterator<llvm::Loop*, llvm::SmallPt... | iterator insert(iterator I, ItTy From, ItTy To) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t InsertElt = I - this->begin();
if (I == this->end()) { // Important special case for empty vector.
append(From, To);
return this->begin()+InsertElt;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x758, %rsp # imm = 0x758
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movq (%rdi), %rax
movq %rsi, %rcx
subq %rax, %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rdi), %ecx
leaq (%rax,%rcx,8), %rax
leaq 0x60(%rdx), %r12
leaq 0x60(%r14), %rbp
c... | /llvm/ADT/SmallVector.h |
llvm::PostDominatorTree::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&) | bool PostDominatorTree::invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &) {
// Check whether the analysis, all analyses on functions, or the function's
// CFG have been preserved.
auto PAC = PA.getChecker<PostDominatorTreeAnalysis>();
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
leaq 0x3310a1d(%rip), %rsi # 0x5990950
movq %rsi, 0x8(%r14)
leaq 0x30(%rdx), %rdi
callq 0x90b7be
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq 0x30(%rbx), %rcx
sete %dl
movl 0x40(%rbx,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx... | /Analysis/PostDominators.cpp |
llvm::SmallVectorImpl<std::pair<unsigned int, llvm::StackLifetime::Marker>>::assignRemote(llvm::SmallVectorImpl<std::pair<unsigned int, llvm::StackLifetime::Marker>>&&) | 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 0x26d23d9
callq 0x780910
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %... | /llvm/ADT/SmallVector.h |
llvm::GenericSyncDependenceAnalysis<llvm::GenericSSAContext<llvm::Function>>::getJoinBlocks(llvm::BasicBlock const*) | auto llvm::GenericSyncDependenceAnalysis<ContextT>::getJoinBlocks(
const BlockT *DivTermBlock) -> const DivergenceDescriptor & {
// trivial case
if (succ_size(DivTermBlock) <= 1) {
return EmptyDivergenceDesc;
}
// already available in cache?
auto ItCached = CachedControlDivDescs.find(DivTermBlock);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
leaq 0x30(%rsi), %rcx
movq 0x30(%rsi), %rax
cmpq %rcx, %rax
je 0x26ecae0
leaq -0x18(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movzbl (%rcx), %eax
addl $-0x1e, %eax
xorl %edi, %edi
cmpl $0xb,... | /llvm/ADT/GenericUniformityImpl.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ConversionOperatorType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle:... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movb 0x3a9(%rdi), %bpl
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
movq (%rsi), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::ParameterPack::getSyntaxNode(llvm::itanium_demangle::OutputBuffer&) const | void initializePackExpansion(OutputBuffer &OB) const {
if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
OB.CurrentPackMax = static_cast<unsigned>(Data.size());
OB.CurrentPackIndex = 0;
}
} | cmpl $-0x1, 0x1c(%rsi)
jne 0x27483e1
movl 0x18(%rdi), %eax
movl %eax, 0x1c(%rsi)
movl $0x0, 0x18(%rsi)
movl 0x18(%rsi), %eax
cmpq %rax, 0x18(%rdi)
jbe 0x27483fb
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
jmpq *%rax
movq %rdi, %rax
retq
nop
| /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::LocalName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movb 0x3a9(%rdi), %al
movb %al, 0xf(%rsp)
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
movq (%rsi), %rdx
movq (%r1... | /llvm/Demangle/ItaniumDemangle.h |
llvm::SmallVectorTemplateBase<llvm::memprof::Meta, true>::push_back(llvm::memprof::Meta) | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x274c7ad
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86... | /llvm/ADT/SmallVector.h |
llvm::memprof::getHotColdSchema() | MemProfSchema getHotColdSchema() {
return {Meta::AllocCount, Meta::TotalSize, Meta::TotalLifetime,
Meta::TotalLifetimeAccessDensity};
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups 0x283f736(%rip), %xmm0 # 0x4f8bf08
leaq 0x20(%rsp), %rdx
movaps %xmm0, -0x10(%rdx)
movups 0x283f716(%rip), %xmm0 # 0x4f8bef8
movaps %xmm0, -0x20(%rdx)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x1c00000000, %rax # imm = 0x1C00000000
movq %rax, 0x8(%rdi)
mo... | /ProfileData/MemProf.cpp |
(anonymous namespace)::_object_error_category::message[abi:cxx11](int) const | std::string _object_error_category::message(int EV) const {
object_error E = static_cast<object_error>(EV);
switch (E) {
case object_error::arch_not_found:
return "No object file for requested architecture";
case object_error::invalid_file_type:
return "The file was not recognized as a valid object file... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %edx
leaq 0x27981ec(%rip), %rax # 0x4f9cf7c
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x279820c(%rip), %rsi # 0x4f9cfac
leaq 0x279822e(%rip), %rdx # 0x4f9cfd5
jmp 0x2804e27
leaq 0x27982be(%rip), %rsi # 0x4f9d06e
leaq 0x2798... | /Object/Error.cpp |
llvm::LLParser::parseParamAccessCall(llvm::FunctionSummary::ParamAccess::Call&, std::vector<std::pair<unsigned int, llvm::SMLoc>, std::allocator<std::pair<unsigned int, llvm::SMLoc>>>&) | bool LLParser::parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
IdLocListType &IdLocList) {
if (parseToken(lltok::lparen, "expected '(' here") ||
parseToken(lltok::kw_callee, "expected 'callee' here") ||
parseToken(lltok::colon, "expected ':' here"))
r... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2716582(%rip), %rdx # 0x4fb4b0f
movl $0xc, %esi
callq 0x287c786
movb $0x1, %bl
testb %al, %al
jne 0x289e68b
leaq 0x27187d3(%rip), %rdx # 0x4fb6d7b
movq %r14, %rdi
movl $0x1a8, %esi # imm = ... | /AsmParser/LLParser.cpp |
llvm::MCContext::getAssociativeCOFFSection(llvm::MCSectionCOFF*, llvm::MCSymbol const*, unsigned int) | MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
const MCSymbol *KeySym,
unsigned UniqueID) {
// Return the normal section if we don't have to be associative or unique.
if (!KeySym && Uniqu... | pushq %rax
movl %ecx, %eax
testq %rdx, %rdx
sete %cl
cmpl $-0x1, %eax
sete %r8b
testb %r8b, %cl
je 0x28d43b4
movq %rsi, %rax
jmp 0x28d441f
movl 0x94(%rsi), %ecx
testq %rdx, %rdx
je 0x28d43f8
orl $0x1000, %ecx # imm = 0x1000
movq 0x80(%rsi), %r10
movq 0x88(%rsi), %r11
xorl %r8d, %r8d
testb $0x1, 0x8(%rdx)
movl... | /MC/MCContext.cpp |
llvm::MCELFStreamer::createAttributesSection(llvm::StringRef, llvm::Twine const&, unsigned int, llvm::MCSection*&, llvm::SmallVector<llvm::MCELFStreamer::AttributeItem, 64u>&) | void MCELFStreamer::createAttributesSection(
StringRef Vendor, const Twine &Section, unsigned Type,
MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
// <format-version>
// [ <section-length> "vendor-name"
// [ <file-tag> <size> <attribute>*
// | <section-tag> <size> <section-n... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x60(%rsp), %rbx
movq (%r9), %rsi
testq %rsi, %rsi
je 0x28e0d2b
movq (%r14), %rax
movq %r14, %rdi
xorl %edx, %edx
callq *0xa8(%rax)
jmp 0x28e0d87
movq %r9, %r13
movq 0x8(%r14), %rdi
leaq 0x8(%rsp... | /MC/MCELFStreamer.cpp |
llvm::MCSymbolELF::setBinding(unsigned int) const | void MCSymbolELF::setBinding(unsigned Binding) const {
setIsBindingSet();
unsigned Val;
switch (Binding) {
default:
llvm_unreachable("Unsupported Binding");
case ELF::STB_LOCAL:
Val = 0;
break;
case ELF::STB_GLOBAL:
Val = 1;
break;
case ELF::STB_WEAK:
Val = 2;
break;
case ELF... | movabsq $0x100000000000, %rax # imm = 0x100000000000
orq 0x8(%rdi), %rax
movq %rax, 0x8(%rdi)
cmpl $0x1, %esi
jg 0x28fb03b
testl %esi, %esi
jne 0x28fb04c
movl %esi, %ecx
jmp 0x28fb062
cmpl $0x2, %esi
jne 0x28fb058
movabsq $0x1000000000, %rcx # imm = 0x1000000000
jmp 0x28fb062
movabsq $0x800000000, %rcx # imm... | /MC/MCSymbolELF.cpp |
llvm::SmallVectorImpl<std::pair<llvm::MCSymbol*, llvm::WinEH::FrameInfo::Epilog>>::clear() | void clear() {
this->destroy_range(this->begin(), this->end());
this->Size = 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x2901b50
movq (%rbx), %r14
shlq $0x4, %rax
leaq (%rax,%rax,2), %r15
movq -0x28(%r14,%r15), %rdi
testq %rdi, %rdi
je 0x2901b4a
movq -0x18(%r14,%r15), %rsi
subq %rdi, %rsi
callq 0x7800d0
addq $-0x30, %r15
jne 0x2901b33
movl $0x0, 0... | /llvm/ADT/SmallVector.h |
llvm::MCWinCOFFStreamer::MCWinCOFFStreamer(llvm::MCContext&, std::unique_ptr<llvm::MCAsmBackend, std::default_delete<llvm::MCAsmBackend>>, std::unique_ptr<llvm::MCCodeEmitter, std::default_delete<llvm::MCCodeEmitter>>, std::unique_ptr<llvm::MCObjectWriter, std::default_delete<llvm::MCObjectWriter>>) | MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context,
std::unique_ptr<MCAsmBackend> MAB,
std::unique_ptr<MCCodeEmitter> CE,
std::unique_ptr<MCObjectWriter> OW)
: MCObjectStreamer(Context, std::move(MAB)... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
xorl %esi, %esi
movq %rsi, (%rdx)
movq (%r8), %rdx
leaq 0x8(%rsp), %r9
movq %rdx, (%r9)
movq %rsi, (%r8)
movq (%rcx), %rdx
leaq 0x18(%rsp), %r15
movq %rdx, (%r15)
movq %rsi, (%rcx)... | /MC/MCWinCOFFStreamer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*>>, llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*, llvm::DenseMapInfo<llvm::MCSymb... | ValueT &operator[](KeyT &&Key) {
return FindAndConstruct(std::move(Key)).second;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x2917aaa
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2914981
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2917b44
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
a... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<(anonymous namespace)::AuxSymbol>::resize(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x2914aa5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x2914a9a
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x2914a53
leaq 0x10(%r14), %rsi
movl $0x18, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2b4ed86
movl 0x8(%r14), %ecx
movq %rbx, %rax
subq %rcx, %rax
j... | /llvm/ADT/SmallVector.h |
llvm::Constant::isFiniteNonZeroFP() const | bool Constant::isFiniteNonZeroFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().isFiniteNonZero();
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(getAggreg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movb (%rdi), %bpl
cmpb $0x12, %bpl
jne 0x29e119e
leaq 0x20(%r14), %rbx
movq 0x20(%r14), %r15
callq 0x2b06206
movq 0x28(%r14), %rcx
addq $0x8, %rcx
cmpq %r15, %rax
cmovneq %rbx, %rcx
movb 0x14(%rcx), %al
testb $0x6, %al
setne %c... | /IR/Constants.cpp |
LLVMAddTargetDependentFunctionAttr | void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
const char *V) {
Function *Func = unwrap<Function>(Fn);
Attribute Attr = Attribute::get(Func->getContext(), A, V);
Func->addFnAttr(Attr);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2a3b1a0
movq %rax, %r12
testq %r15, %r15
je 0x29f45e5
movq %r15, %rdi
callq 0x7802c0
movq %rax, %r13
jmp 0x29f45e8
xorl %r13d, %r13d
testq %r14, %r14
je 0x29f45fa
movq %r14, %rdi
callq 0x7802c0
movq %rax, %r8
... | /IR/Core.cpp |
llvm::SmallVectorTemplateBase<llvm::DISubprogram*, true>::push_back(llvm::DISubprogram*) | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x29fb303
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86... | /llvm/ADT/SmallVector.h |
std::pair<llvm::DenseMapIterator<llvm::MDNode*, unsigned int, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<llvm::MDNode*, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::MDNode*, unsigned int, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<llvm::MDNode*, ... | 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 %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 0x29fe048
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x29fe75e
xorl %ecx, %ecx
jmp 0x29fe77e
movq %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::StructType*, llvm::StructLayout*, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, llvm::StructLayout*>>, llvm::StructType*, llvm::StructLayout*, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, l... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x2a0150b
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::getDebugMetadataVersionFromModule(llvm::Module const&) | unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
M.getModuleFlag("Debug Info Version")))
return Val->getZExtValue();
return 0;
} | pushq %rax
leaq 0x25723f1(%rip), %rsi # 0x4f76036
movl $0x12, %edx
callq 0x2a84044
xorl %ecx, %ecx
testq %rax, %rax
je 0x2a03c5d
cmpb $0x1, (%rax)
cmoveq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2a03c76
movq 0x80(%rcx), %rdx
xorl %ecx, %ecx
cmpb $0x11, (%rdx)
cmoveq %rdx, %rcx
jmp 0x2a03c78
xorl %ecx, %ecx
te... | /IR/DebugInfo.cpp |
llvm::DIExpression::isImplicit() const | bool DIExpression::isImplicit() const {
if (!isValid())
return false;
if (getNumElements() == 0)
return false;
for (const auto &It : expr_ops()) {
switch (It.getOp()) {
default:
break;
case dwarf::DW_OP_stack_value:
return true;
}
}
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2a0e54e
testb %al, %al
je 0x2a0e76e
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %r15
movq %r15, %rax
subq %r14, %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x2a0e76e
movq %r14, 0x8(%rsp)
cmpq %r15, %r14
setne %al
je 0x2a0e770
cmpq $0x9f, (%r14)
je 0x2a0e... | /IR/DebugInfoMetadata.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DILocation*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocation>, llvm::detail::DenseSetPair<llvm::DILocation*>>, llvm::DILocation*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocation>, llvm::detail::DenseSetPair<llvm::DILocation*>>::LookupBucketFor<l... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x2a10dc3
movq (%rdi), %r13
leaq 0x4(%rsi), %r8
leaq 0x8(%rsi), %r9
leaq 0x10(%rsi), %rax
leaq 0x18(%rsi), %r10
leaq 0x60(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rcx)
m... | /llvm/ADT/DenseMap.h |
llvm::MDNodeInfo<llvm::DILocation>::getHashValue(llvm::DILocation const*) | static unsigned getHashValue(const NodeTy *N) {
return KeyTy(N).getHashValue();
} | subq $0xa8, %rsp
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x2a111b6
leaq 0x4(%rsp), %r8
leaq 0x8(%rsp), %r9
leaq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r10
leaq 0x60(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rcx)
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps ... | /IR/LLVMContextImpl.h |
llvm::MDNodeKeyImpl<llvm::DIDerivedType>::getHashValue() const | unsigned getHashValue() const {
// If this is a member inside an ODR type, only hash the type and the name.
// Otherwise the hash will be stronger than
// MDNodeSubsetEqualImpl::isODRMember().
if (Tag == dwarf::DW_TAG_member && Name)
if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
cmpl $0xd, (%rdi)
jne 0x2a14ce5
cmpq $0x0, 0x8(%rbx)
je 0x2a14ce5
movq 0x20(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2a14c63
cmpb $0xe, (%rcx)
cmoveq %rcx, %rax
movb $0x1, %r14b
testq %rax, %rax
je 0x2a14ce0
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x2a1... | /IR/LLVMContextImpl.h |
llvm::MDNodeKeyImpl<llvm::DICompositeType>::isKeyOf(llvm::DICompositeType const*) const | dwarf::Tag DINode::getTag() const { return (dwarf::Tag)SubclassData16; } | movzwl 0x2(%rsi), %r8d
cmpl %r8d, (%rdi)
jne 0x2a15a44
movq 0x8(%rdi), %rax
leaq -0x10(%rsi), %rcx
movq -0x10(%rsi), %rdx
testb $0x2, %dl
jne 0x2a159bf
leal (%rdx,%rdx), %r10d
andl $0x78, %r10d
movq %rcx, %r9
subq %r10, %r9
jmp 0x2a159c3
movq -0x20(%rsi), %r9
cmpq 0x10(%r9), %rax
jne 0x2a15a44
movq 0x10(%rdi), %rax
cmp... | /IR/DebugInfoMetadata.cpp |
llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DILexicalBlockFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlockFile>, llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>>, llvm::DILexicalBlockFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<ll... | 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 0x2a19165
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<llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DINamespace*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::Dense... | 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 0x2a1967e
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x2a19640
xorl %ecx, %ecx
jmp 0x2a19659
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DIModule*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIModule>, llvm::detail::DenseSetPair<llvm::DIModule*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIModule*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIModule>, llvm::detail::DenseSetPair<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 0x2a1a588
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x2a1a54a
xorl %ecx, %ecx
jmp 0x2a1a563
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DIArgList*, llvm::detail::DenseSetEmpty, llvm::DIArgListInfo, llvm::detail::DenseSetPair<llvm::DIArgList*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIArgList*, llvm::detail::DenseSetEmpty, llvm::DIArgListInfo, llvm::detail::DenseSetPair<llvm::DIArgList*>>, llvm::DIAr... | 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 0x2a20408
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x2a203ca
xorl %ecx, %ecx
jmp 0x2a203e3
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
llvm::DiagnosticInfoOptimizationBase::getMsg[abi:cxx11]() const | std::string DiagnosticInfoOptimizationBase::getMsg() const {
std::string Str;
raw_string_ostream OS(Str);
for (const DiagnosticInfoOptimizationBase::Argument &Arg :
make_range(Args.begin(), FirstExtraArgIndex == -1
? Args.end()
: Args.... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movl $0x0, 0x8(%rdi)
movb %al, 0x28(%rdi)
movl $0x1, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, ... | /IR/DiagnosticInfo.cpp |
llvm::diagnoseDontCall(llvm::CallInst const&) | void llvm::diagnoseDontCall(const CallInst &CI) {
const auto *F =
dyn_cast<Function>(CI.getCalledOperand()->stripPointerCasts());
if (!F)
return;
for (int i = 0; i != 2; ++i) {
auto AttrName = i == 0 ? "dontcall-error" : "dontcall-warn";
auto Sev = i == 0 ? DS_Error : DS_Warning;
if (F->h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq -0x20(%rdi), %rdi
callq 0x2aa0110
cmpb $0x0, (%rax)
jne 0x2a25a00
movq %rax, %r14
movl $0x2, %r12d
leaq 0x2eab25c(%rip), %rax # 0x58d0b28
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
xorl %r13d, %r13... | /IR/DiagnosticInfo.cpp |
llvm::DiagnosticInfoDontCall::print(llvm::DiagnosticPrinter&) const | void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const {
DP << "call to " << demangle(getFunctionName()) << " marked \"dontcall-";
if (getSeverity() == DiagnosticSeverity::DS_Error)
DP << "error\"";
else
DP << "warn\"";
if (!getNote().empty())
DP << ": " << getNote();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x254460d(%rip), %rsi # 0x4f6a038
movq %r14, %rdi
callq *0x30(%rax)
movq %rax, %r15
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2ba17d8
movq (%r15), %rax
mov... | /IR/DiagnosticInfo.cpp |
llvm::DomTreeNodeBase<llvm::BasicBlock>::DomTreeNodeBase(llvm::BasicBlock*, llvm::DomTreeNodeBase<llvm::BasicBlock>*) | DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
: TheBB(BB), IDom(iDom), Level(IDom ? IDom->Level + 1 : 0) {} | movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
testq %rdx, %rdx
je 0x2a2600b
movl 0x10(%rdx), %eax
incl %eax
jmp 0x2a2600d
xorl %eax, %eax
movl %eax, 0x10(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x20(%rdi)
movq $-0x1, 0x48(%rdi)
retq
nop
| /llvm/Support/GenericDomTree.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, true>::DeletesInserts, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, true>::DeletesInserts>>, llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlo... | 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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x8(%rdi), %rcx
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %eax
cmovel 0x10(%rdi), %eax
testl %eax, %eax
je 0x2a2d1c9
movl %eax, %eax
leaq (%rax,%rax,8), ... | /llvm/ADT/DenseMap.h |
unsigned int llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::runDFS<true, bool (*)(llvm::BasicBlock*, llvm::BasicBlock*)>(llvm::BasicBlock*, unsigned int, bool (*)(llvm::BasicBlock*, llvm::BasicBlock*), unsigned int, llvm::DenseMap<llvm::BasicBlock*, unsigned int, llvm::DenseMapInfo<... | 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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %r9, 0x18(%rsp)
movl %r8d, %r14d
movq %rcx, %r15
movl %edx, %ebx
movq %rdi, %r12
leaq 0x30(%rsp), %rbp
movq %rsi, (%rbp)
leaq 0x48(%rsp), %rdx
movq %rsi, -0x10(%rdx)
movl %r8d, -0x8(%rdx)
leaq 0x98(%rsp), %... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::InfoRec, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>:... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x2a2f8d4
movl %eax, %ebp
testb %al, %al
je 0x2a2f6ab
movq 0x8(%rsp), %r14
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x2a2f692
callq 0x780910
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BasicBlock*, unsigned int, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, unsigned int>>::operator=(llvm::DenseMap<llvm::BasicBlock*, unsigned int, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, unsigned int>>&&... | DenseMap& operator=(DenseMap &&other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
init(0);
swap(other);
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
xorl %eax, %eax
movl %eax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%r14), %rcx
movq %rcx, (%rbx)
movq $0x0, (%r14)
movl 0x8(%r14), %ecx
movl %ecx, 0x8... | /llvm/ADT/DenseMap.h |
unsigned int llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::runDFS<false, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::DeleteReachable(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBas... | 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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movl %r9d, %r15d
movq %r8, %r14
movl %ecx, %ebp
movl %edx, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %rsi, (%r13)
leaq 0x48(%rsp), %rdx
movq %rsi, -0x10(%rdx)
movl %r9d, -0x8(%rdx)
leaq 0x98(%rsp), %r... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::Function::convertToNewDbgValues() | void Function::convertToNewDbgValues() {
IsNewDbgInfoFormat = true;
for (auto &BB : *this) {
BB.convertToNewDbgValues();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x78(%rdi)
movq 0x50(%rdi), %r14
addq $0x48, %rbx
cmpq %rbx, %r14
je 0x2a3a9bc
leaq -0x18(%r14), %rdi
testq %r14, %r14
cmoveq %r14, %rdi
callq 0x29c8e72
movq 0x8(%r14), %r14
jmp 0x2a3a9a1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /IR/Function.cpp |
llvm::Argument::hasPointeeInMemoryValueAttr() const | uint64_t Argument::getDereferenceableOrNullBytes() const {
assert(getType()->isPointerTy() &&
"Only pointers have dereferenceable bytes");
return getParent()->getParamDereferenceableOrNullBytes(getArgNo());
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpb $0xf, 0x8(%rax)
jne 0x2a3adef
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x70(%rax), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movl 0x20(%r14), %esi
incl %esi
movl $0x4c, %edx
callq 0x29acace
movb $0x1, %bl
testb %al, %al
jne 0x2a3adf1
movl 0x20(%r14), %esi
incl %... | /IR/Function.cpp |
llvm::Function::hasStackProtectorFnAttr() const | bool Function::hasStackProtectorFnAttr() const {
return hasFnAttribute(Attribute::StackProtect) ||
hasFnAttribute(Attribute::StackProtectStrong) ||
hasFnAttribute(Attribute::StackProtectReq);
} | pushq %rbx
movq %rdi, %rbx
addq $0x70, %rbx
movq %rbx, %rdi
movl $0x40, %esi
callq 0x29acb70
testb %al, %al
jne 0x2a40d62
movq %rbx, %rdi
movl $0x42, %esi
callq 0x29acb70
testb %al, %al
je 0x2a40d66
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
movl $0x41, %esi
popq %rbx
jmp 0x29acb70
| /IR/Function.cpp |
llvm::StringRef::str[abi:cxx11]() const | [[nodiscard]] std::string str() const {
if (!Data) return std::string();
return std::string(Data, Length);
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x2a47069
leaq 0x10(%rbx), %rcx
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rcx, (%rbx)
movq %rbx, %rdi
callq 0x7fa87c
jmp 0x2a4707c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rb... | /llvm/ADT/StringRef.h |
llvm::GlobalVariable::setInitializer(llvm::Constant*) | bool GlobalValue::isDeclaration() const {
// Globals are definitions if they have an initializer.
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
return GV->getNumOperands() == 0;
// Functions are definitions if they have a body.
if (const Function *F = dyn_cast<Function>(this))
return F... | movl 0x4(%rdi), %eax
testl $0x7ffffff, %eax # imm = 0x7FFFFFF
sete %cl
movb (%rdi), %dl
testq %rsi, %rsi
je 0x2a48011
cmpb $0x3, %dl
jne 0x2a4801b
testb %cl, %cl
je 0x2a48033
andl $0xf8000000, %eax # imm = 0xF8000000
incl %eax
movl %eax, 0x4(%rdi)
jmp 0x2a48033
cmpb $0x3, %dl
jne 0x2a4807f
testb %cl, %cl
j... | /IR/Globals.cpp |
llvm::GlobalAlias::setAliasee(llvm::Constant*) | static Use *op_begin(SubClass* U) {
static_assert(
!std::is_polymorphic<SubClass>::value,
"adding virtual methods to subclasses of User breaks use lists");
return reinterpret_cast<Use*>(U) - ARITY;
} | leaq -0x20(%rdi), %rax
cmpq $0x0, -0x20(%rdi)
je 0x2a481fd
movq -0x18(%rdi), %rcx
movq -0x10(%rdi), %rdx
movq %rcx, (%rdx)
movq -0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x2a481fd
movq -0x10(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rsi, (%rax)
testq %rsi, %rsi
je 0x2a48225
movq 0x10(%rsi), %rcx
addq $0x10, %rsi
movq %rcx, -... | /llvm/IR/OperandTraits.h |
llvm::GlobalObject const* findBaseObject<llvm::GlobalAlias::getAliaseeObject() const::$_0>(llvm::Constant const*, llvm::DenseSet<llvm::GlobalAlias const*, llvm::DenseMapInfo<llvm::GlobalAlias const*, void>>&, llvm::GlobalAlias::getAliaseeObject() const::$_0 const&) | static const GlobalObject *
findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases,
const Operation &Op) {
if (auto *GO = dyn_cast<GlobalObject>(C)) {
Op(*GO);
return GO;
}
if (auto *GA = dyn_cast<GlobalAlias>(C)) {
Op(*GA);
if (Aliases.insert(GA).second)
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x3, %eax
ja 0x2a48440
movq %r14, %r15
cmpl $0x1, %eax
jne 0x2a48443
xorl %r15d, %r15d
testq %r15, %r15
jne 0x2a48554
xorl %ecx, %ecx
cmpb $0x1, %al
cmoveq %r14, %rcx
movq %rcx, 0x10(%rsp)
m... | /IR/Globals.cpp |
llvm::IRBuilderBase::CreateMemSet(llvm::Value*, llvm::Value*, llvm::Value*, llvm::MaybeAlign, bool, llvm::MDNode*, llvm::MDNode*, llvm::MDNode*) | CallInst *IRBuilderBase::CreateMemSet(Value *Ptr, Value *Val, Value *Size,
MaybeAlign Align, bool isVolatile,
MDNode *TBAATag, MDNode *ScopeTag,
MDNode *NoAliasTag) {
Value *Ops[] = {Ptr, Val, Size, getIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x48(%rdi), %rdi
callq 0x2a9aab6
movl %ebp, %esi
xorl %r15d, %r15d
movq %rax, %rdi
xor... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateLifetimeStart(llvm::Value*, llvm::ConstantInt*) | CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
assert(isa<PointerType>(Ptr->getType()) &&
"lifetime.start only applies to pointers.");
if (!Size)
Size = getInt64(-1);
else
assert(Size->getType() == getInt64Ty() &&
"lifetime.start requires the size to be a... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x2a4abb9
movq 0x48(%rbx), %rdi
callq 0x2a9aade
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x29e3250
movq %rax, %rdx
movq %rdx, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq 0x30(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x28(%... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateGCRelocate(llvm::Instruction*, int, int, llvm::Type*, llvm::Twine const&) | CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint,
int BaseOffset, int DerivedOffset,
Type *ResultType, const Twine &Name) {
Module *M = BB->getParent()->getParent();
Type *Types[] = {ResultType};
Function *FnGCRel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rdi
leaq 0x38(%rsp), %rdx
movq %r8, (%rdx)
movl $0x1, %ecx
movl $0x92, %esi
callq 0x2a43af5
mov... | /IR/IRBuilder.cpp |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StringRef, bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*, bool>(unsigned long, char*, char*, llvm::StringRef const&, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&, bool const&) | hash_code combine(size_t length, char *buffer_ptr, char *buffer_end,
const T &arg, const Ts &...args) {
buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
// Recurse to the next argument.
return combine(length, buffer_ptr, buffer_end, args...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %rcx, %rbx
movq %rdx, %rbp
movq %rdi, %r12
movq 0x68(%rsp), %r15
leaq 0x18(%rsp), %r14
movq %rsi, (%r14)
movq (%r8), %rdi
movq 0x8(%r8), %rsi
callq 0x2b57a14
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, ... | /llvm/ADT/Hashing.h |
llvm::DenseMap<llvm::InlineAsm*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::InlineAsm>::MapInfo, llvm::detail::DenseSetPair<llvm::InlineAsm*>>::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::Instruction::moveBeforeImpl(llvm::BasicBlock&, llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::BasicBlock>, false, false>, bool) | void Instruction::moveBeforeImpl(BasicBlock &BB, InstListType::iterator I,
bool Preserve) {
assert(I == BB.end() || I->getParent() == &BB);
bool InsertAtHead = I.getHeadBit();
// If we've been given the "Preserve" flag, then just move the DbgRecords with
// the instruction, no mor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movb 0x28(%rsi), %al
xorb $0x1, %al
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %bpl, %al
orb %cl, %al
xorb $0x1, %al
leaq 0x18(%rbx), %r13
cmpq %rdx, %r13... | /IR/Instruction.cpp |
llvm::Instruction::clone() const | Instruction *Instruction::clone() const {
Instruction *New = nullptr;
switch (getOpcode()) {
default:
llvm_unreachable("Unhandled Opcode.");
#define HANDLE_INST(num, opc, clas) \
case Instruction::opc: \
New... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %eax
addl $-0x1e, %eax
leaq 0x26396ea(%rip), %rcx # 0x508ce9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x2a5c790
movq %rax, %r14
movb 0x1(%rbx), %al
andb $-0x2, %al
movb 0x1(%r14), %cl
andb $0x1, %cl
orb %al, %cl
movb %... | /IR/Instruction.cpp |
llvm::AllocaInst::isArrayAllocation() const | Value *get() const { return Val; } | movq -0x20(%rdi), %rdi
movb $0x1, %al
cmpb $0x11, (%rdi)
jne 0x2a53c47
pushq %rbx
movl 0x20(%rdi), %ebx
addq $0x18, %rdi
cmpl $0x40, %ebx
ja 0x2a53c38
cmpq $0x1, (%rdi)
jmp 0x2a53c41
callq 0x2b1284c
decl %ebx
cmpl %ebx, %eax
sete %al
xorb $0x1, %al
popq %rbx
retq
| /llvm/IR/Use.h |
llvm::SelectInst::areInvalidOperands(llvm::Value*, llvm::Value*, llvm::Value*) | Type *getType() const { return VTy; } | movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
je 0x2a53d4c
leaq 0x2639527(%rip), %rax # 0x508d272
retq
pushq %r15
pushq %r14
pushq %rbx
cmpb $0xc, 0x8(%rax)
jne 0x2a53d63
leaq 0x263953e(%rip), %rax # 0x508d29c
jmp 0x2a53e00
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2a53d9c
movl $0xfe, %eax
andl 0x8(%r14), %eax
cmpl $0... | /llvm/IR/Value.h |
llvm::CallBase::getRetNoFPClass() const | FPClassTest CallBase::getRetNoFPClass() const {
FPClassTest Mask = Attrs.getRetNoFPClass();
if (const Function *F = getCalledFunction())
Mask |= F->getAttributes().getRetNoFPClass();
return Mask;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x48, %rdi
callq 0x29ad03c
movl %eax, %ebx
movq -0x20(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2a54ee0
cmpb $0x0, (%rcx)
cmoveq %rcx, %rax
testq %rax, %rax
je 0x2a54eef
movq 0x18(%rax), %rcx
cmpq 0x50(%r14), %rcx
je 0x2a54ef1
xorl %eax, %eax
testq %rax, %r... | /IR/Instructions.cpp |
llvm::GetElementPtrInst::getTypeAtIndex(llvm::Type*, llvm::Value*) | Type *GetElementPtrInst::getTypeAtIndex(Type *Ty, Value *Idx) {
if (auto *Struct = dyn_cast<StructType>(Ty)) {
if (!Struct->indexValid(Idx))
return nullptr;
return Struct->getTypeAtIndex(Idx);
}
if (!Idx->getType()->isIntOrIntVectorTy())
return nullptr;
if (auto *Array = dyn_cast<ArrayType>(Ty... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x10, 0x8(%rdi)
setne %al
testq %rdi, %rdi
sete %bpl
orb %al, %bpl
jne 0x2a57845
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a9b376
testb %al, %al
je 0x2a57843
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a9b354
jmp 0x2a57845
xorl %eax, %eax
testb %bpl, %b... | /IR/Instructions.cpp |
llvm::ShuffleVectorInst::isReplicationMask(llvm::ArrayRef<int>, int&, int&) | bool ShuffleVectorInst::isReplicationMask(ArrayRef<int> Mask,
int &ReplicationFactor, int &VF) {
// undef-less case is trivial.
if (!llvm::is_contained(Mask, PoisonMaskElem)) {
ReplicationFactor =
Mask.take_while([](int MaskElt) { return MaskElt == 0; }).size();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq (%rdi,%rsi,4), %r13
leaq 0x2634489(%rip), %rdx # 0x508d3bc
movq %r13, %rsi
callq 0x148f62c
cmpq %r13, %rax
je 0x2a5904c
testq %r15, %r15
je 0x2a58f99
leaq (,%r1... | /IR/Instructions.cpp |
llvm::SwitchInst::SwitchInst(llvm::SwitchInst const&) | SwitchInst::SwitchInst(const SwitchInst &SI)
: Instruction(SI.getType(), Instruction::Switch, nullptr, 0) {
init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands());
setNumHungOffUseOperands(SI.getNumOperands());
Use *OL = getOperandList();
const Use *InOL = SI.getOperandList();
for (unsigned i =... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a511b0
movq -0x8(%r14), %rax
movq (%rax), %rsi
movq 0x20(%rax), %rdx
movl $0x7ffffff, %ecx # imm = ... | /IR/Instructions.cpp |
llvm::SwitchInst::removeCase(llvm::SwitchInst::CaseIteratorImpl<llvm::SwitchInst::CaseHandle>) | SwitchInst::CaseIt SwitchInst::removeCase(CaseIt I) {
unsigned idx = I->getCaseIndex();
assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!");
unsigned NumOps = getNumOperands();
Use *OL = getOperandList();
// Overwrite this case with the end of the list.
if (2 + (idx + 1) * 2 != NumOps) {... | movq %rdi, %rax
movl 0x4(%rdi), %esi
movl %esi, %ecx
andl $0x7ffffff, %ecx # imm = 0x7FFFFFF
btl $0x1e, %esi
jb 0x2a5bdfd
movl %ecx, %edi
shll $0x5, %edi
movq %rax, %rsi
subq %rdi, %rsi
jmp 0x2a5be01
movq -0x8(%rax), %rsi
leal 0x4(,%rdx,2), %edi
cmpl %ecx, %edi
je 0x2a5bed8
leal (%rdx,%rdx), %edi
leal -0x2(%rcx)... | /IR/Instructions.cpp |
llvm::detail::DenseSetImpl<llvm::DIEnumerator*, llvm::DenseMap<llvm::DIEnumerator*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIEnumerator>, llvm::detail::DenseSetPair<llvm::DIEnumerator*>>, llvm::MDNodeInfo<llvm::DIEnumerator>>::begin() | [[nodiscard]] bool empty() const { return getNumEntries() == 0; } | cmpl $0x0, 0x8(%rdi)
movq (%rdi), %r8
movl 0x10(%rdi), %ecx
leaq (%r8,%rcx,8), %rdx
movq %rdx, %rax
je 0x2a64519
testq %rcx, %rcx
je 0x2a6451a
shlq $0x3, %rcx
movl $0x1000, %esi # imm = 0x1000
movq %r8, %rax
movq (%rax), %rdi
orq %rsi, %rdi
cmpq $-0x1000, %rdi # imm = 0xF000
jne 0x2a64519
addq $0x8, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, std::unique_ptr<llvm::ConstantAggregateZero, std::default_delete<llvm::ConstantAggregateZero>>, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, std::unique_ptr<llvm::ConstantAggregateZero, std::default_delete<llvm::ConstantAggregateZero>>>>, ... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x2a64d39
cmpl $0x0, 0xc(%rbx)
je 0x2a64da4
shll $0x2, %eax
movl 0x10(%rbx), %r15d
cmpl %r15d, %eax
setae %al
cmpl $0x41, %r15d
setb %cl
orb %al, %cl
jne 0x2a64d5e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2a67592
testq... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::APFloat, std::unique_ptr<llvm::ConstantFP, std::default_delete<llvm::ConstantFP>>, llvm::DenseMapInfo<llvm::APFloat, void>, llvm::detail::DenseMapPair<llvm::APFloat, std::unique_ptr<llvm::ConstantFP, std::default_delete<llvm::ConstantFP>>>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x2a661ac
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, %ecx
movl %ecx, %edx
shrl... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*) | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
const uint64_t seed = get_execution_seed();
char buffer[64], *buffer_ptr = buffer;
char *const buffer_end = std::end(buffer);
while (first != last && store_and_advance(buffer_ptr, buffer_end,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
sete %al
movq %rsp, %rsi
je 0x2a685bf
xorl %edx, %edx
movq %rdx, %rcx
cmpq $0x38, %rdx
jg 0x2a685a0
leaq 0x8(%rdx), %rcx
movq (%r14), %rdi
movq %rdi, (%rsi)
cmpq $0x38, %rdx
jg 0x2a685bb
ad... | /llvm/ADT/Hashing.h |
llvm::SmallVectorTemplateBase<llvm::Pass*, true>::push_back(llvm::Pass*) | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x2a6c01d
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86... | /llvm/ADT/SmallVector.h |
llvm::MDBuilder::createPCSections(llvm::ArrayRef<std::pair<llvm::StringRef, llvm::SmallVector<llvm::Constant*, 6u>>>) | MDNode *MDBuilder::createPCSections(ArrayRef<PCSection> Sections) {
SmallVector<Metadata *, 2> Ops;
for (const auto &Entry : Sections) {
const StringRef &Sec = Entry.first;
Ops.push_back(createString(Sec));
// If auxiliary data for this section exists, append it.
const SmallVector<Constant *> &Aux... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%rcx)
testq %rdx, %rdx
je 0x2a72a18
movq %rsi, %r14
leaq (%rdx,%rdx,4), %rax
shlq $0x4, %rax
addq %rsi, %rax... | /IR/MDBuilder.cpp |
llvm::MDBuilder::createTBAAAccessTag(llvm::MDNode*, llvm::MDNode*, unsigned long, unsigned long, bool) | MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
uint64_t Offset, uint64_t Size,
bool IsImmutable) {
IntegerType *Int64 = Type::getInt64Ty(Context);
auto *OffsetNode = createConstant(ConstantInt::get(Int64, Off... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x2a9aade
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x29e3250
movq %rax, %rdi
callq 0... | /IR/MDBuilder.cpp |
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.