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 any particular memory
// location.
//
// *Unlike* assumes, guard intrinsics are modeled as reading memory since the
// heap state at the point the guard is issued needs to be consistent in case
// the guard invokes the "deopt" continuation.
// NB! This function is *not* commutative, so we special case two
// possibilities for guard intrinsics.
if (isIntrinsicCall(Call1, Intrinsic::experimental_guard))
return isModSet(getMemoryEffects(Call2, AAQI).getModRef())
? ModRefInfo::Ref
: ModRefInfo::NoModRef;
if (isIntrinsicCall(Call2, Intrinsic::experimental_guard))
return isModSet(getMemoryEffects(Call1, AAQI).getModRef())
? ModRefInfo::Mod
: ModRefInfo::NoModRef;
// Be conservative.
return ModRefInfo::ModRef;
}
|
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 %r15, %rsi
movq %rbx, %rdx
callq 0x2579004
movl %eax, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %edx, %esi
shrl %cl, %esi
orb %sil, %al
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x2579c88
shrb %al
andb $0x1, %al
jmp 0x2579cf1
cmpb $0x55, (%r15)
jne 0x2579cb7
movq %r15, %rdi
callq 0x91f89e
xorl %ecx, %ecx
testb %al, %al
cmovneq %r15, %rcx
jmp 0x2579cb9
xorl %ecx, %ecx
movb $0x3, %al
testq %rcx, %rcx
je 0x2579cf1
movq -0x20(%rcx), %rcx
cmpl $0x96, 0x24(%rcx)
jne 0x2579cf1
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2579004
movl %eax, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %edx, %esi
shrl %cl, %esi
orb %sil, %al
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x2579cde
andb $0x2, %al
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x257dcc2
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x257dd8a
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x257dd83
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x637314(%rip), %xmm1 # 0x2bb5020
movdqa 0x63731c(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x257dd60
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x257dd76
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x257dd1c
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::DenseMapPair<llvm::AssertingVH<llvm::BasicBlock const>, std::pair<llvm::BlockFrequencyInfoImplBase::BlockNode, llvm::bfi_detail::BFICallbackVH<llvm::BasicBlock, llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>>>>>, 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::DenseMapPair<llvm::AssertingVH<llvm::BasicBlock const>, std::pair<llvm::BlockFrequencyInfoImplBase::BlockNode, llvm::bfi_detail::BFICallbackVH<llvm::BasicBlock, llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>>>>>::erase(llvm::AssertingVH<llvm::BasicBlock const> const&)
|
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
je 0x2580602
leaq 0x18(%r14), %rdi
callq 0x2aa1dc0
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0xe2303a(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/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 = 0x800000000
movq %rax, 0x68(%rdi)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x91daf4
movq (%rsp), %rdi
leaq 0x30(%rdi), %rcx
movq 0x30(%rdi), %rax
cmpq %rcx, %rax
je 0x2581a57
leaq -0x18(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movzbl (%rcx), %edx
addl $-0x1e, %edx
xorl %eax, %eax
cmpl $0xb, %edx
cmovbq %rcx, %rax
jmp 0x2581a59
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
callq 0x15a3440
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x15a33fc
movq %rbx, %rdi
callq 0x25818f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 graph
writeFooter();
}
|
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, 0x20(%rdi)
popq %rbx
retq
nop
|
/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 $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x31dbd37(%rip), %rax # 0x5761038
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x3372899(%rip), %rax # 0x58f7ba8
addq $0x10, %rax
movq %rax, 0xa0(%r14)
movups %xmm0, 0xa8(%r14)
leaq -0x1a80c7f(%rip), %rax # 0xb046aa
movq %rax, 0xc0(%r14)
leaq -0x1a80c8b(%rip), %rax # 0xb046ac
movq %rax, 0xb8(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2588a11
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b1e814
nop
|
/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_back(&SuccIrr);
SuccIrr.Edges.push_front(&Irr);
++SuccIrr.NumIn;
}
|
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
testb %al, %al
jne 0x2586748
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x1d04cf6
testb $0x1, 0x30(%r14)
leaq 0x38(%r14), %rcx
cmoveq 0x38(%r14), %rcx
movl $0x4, %edx
cmovel 0x40(%r14), %edx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
je 0x2586748
movq 0x8(%rax), %r15
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %r14, %rsi
callq 0x2588af8
movq %rbx, (%r14)
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x2586736
movq %rbx, -0x8(%rax)
addq $-0x8, 0x18(%r15)
jmp 0x2586744
leaq 0x8(%r15), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2588d54
incl 0x4(%r15)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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::detail::DenseMapPair<unsigned int, llvm::BlockFrequencyInfoImplBase::Weight>>::FindAndConstruct(unsigned int const&)
|
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 %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0xffffffff, 0xc(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 (scc_iterator<const Function *> It = scc_begin(&F); !It.isAtEnd();
++It, ++SccNum) {
// Ignore single-block SCCs since they either aren't loops or LoopInfo will
// catch them.
const std::vector<const BasicBlock *> &Scc = *It;
if (Scc.size() == 1)
continue;
LLVM_DEBUG(dbgs() << "BPI: SCC " << SccNum << ":");
for (const auto *BB : Scc) {
LLVM_DEBUG(dbgs() << " " << BB->getName());
SccNums[BB] = SccNum;
calculateSccBlockType(BB, SccNum);
}
LLVM_DEBUG(dbgs() << "\n");
}
}
|
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(%rsp), %r15
movl %r14d, (%r15)
movups %xmm0, 0x8(%r15)
movl %r14d, 0x18(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x50(%r15)
movq %r14, 0x60(%r15)
movq %r15, %rdi
callq 0x258dec2
movq %r15, %rdi
callq 0x258df8c
movq 0x38(%r15), %r13
cmpq 0x40(%r15), %r13
je 0x25899f7
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x50(%rsp), %rbp
movq %rbp, %rax
subq %r13, %rax
sete %cl
cmpq $0x8, %rax
sete %al
orb %cl, %al
jne 0x25899e0
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17ac040
movl %r14d, 0x8(%rax)
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x2589a62
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x25899af
movq %r15, %rdi
callq 0x258df8c
incl %r14d
movq 0x48(%rsp), %r13
cmpq 0x50(%rsp), %r13
jne 0x2589996
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2589a0e
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2589a25
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2589a3c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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(llvm::BasicBlock const*) const
|
const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
}
|
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
addq $0x10, %rsp
popq %rbx
retq
|
/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<BranchProbabilityAnalysis>();
return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
PAC.preservedSet<CFGAnalyses>());
}
|
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, %rax
setne 0x10(%r14)
movq %r14, %rdi
callq 0x1a01030
testb %al, %al
jne 0x258c567
movq %rsp, %rdi
callq 0x1a010a4
testb %al, %al
je 0x258c56b
xorl %eax, %eax
jmp 0x258c575
movq %rsp, %rdi
callq 0x1c30784
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/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, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x8, -0x10(%rax)
movl $0x0, -0x8(%rax)
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x258fe6f
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x258d26f
callq 0x780910
movq 0x10(%rsp), %rdi
cmpq 0x8(%rsp), %rdi
je 0x258d280
callq 0x780910
leaq 0x228(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x258d296
callq 0x780910
movq 0x1c0(%rsp), %rdi
cmpq 0x1b8(%rsp), %rdi
je 0x258d2ad
callq 0x780910
movq %rbx, %rax
addq $0x368, %rsp # imm = 0x368
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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<llvm::BasicBlock const*, unsigned int>>::clear()
|
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
jmp 0x258d426
leaq 0x8(%rdi), %rax
testl %ecx, %ecx
je 0x258d4dc
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x627bbb(%rip), %xmm1 # 0x2bb5020
movdqa 0x627bc3(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x258d4b9
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x258d4cf
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x258d475
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
retq
nop
|
/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<BucketT *>(&TmpStorage);
BucketT *TmpEnd = TmpBegin;
// Loop over the buckets, moving non-empty, non-tombstones into the
// temporary storage. Have the loop move the TmpEnd forward as it goes.
const KeyT EmptyKey = this->getEmptyKey();
const KeyT TombstoneKey = this->getTombstoneKey();
for (BucketT *P = getBuckets(), *E = P + InlineBuckets; P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
assert(size_t(TmpEnd - TmpBegin) < InlineBuckets &&
"Too many inline buckets!");
::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
++TmpEnd;
P->getSecond().~ValueT();
}
P->getFirst().~KeyT();
}
// AtLeast == InlineBuckets can happen if there are many tombstones,
// and grow() is used to remove them. Usually we always switch to the
// large rep here.
if (AtLeast > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(TmpBegin, TmpEnd);
return;
}
LargeRep OldRep = std::move(*getLargeRep());
getLargeRep()->~LargeRep();
if (AtLeast <= InlineBuckets) {
Small = true;
} else {
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);
// Free the old table.
deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
alignof(BucketT));
}
|
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 %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
cmpl $0x41, %eax
movl $0x40, %ebp
cmovael %eax, %ebp
movl (%rbx), %eax
testb $0x1, %al
jne 0x258e88e
movq 0x8(%rbx), %r14
movl 0x10(%rbx), %r15d
cmpl $0x4, %ebp
ja 0x258e902
orl $0x1, %eax
movl %eax, (%rbx)
jmp 0x258e919
leaq 0x8(%rsp), %r14
movl $0x10, %eax
movq -0x8(%rbx,%rax), %rcx
movq %rcx, %rdx
orq $0x1000, %rdx # imm = 0x1000
cmpq $-0x1000, %rdx # imm = 0xF000
je 0x258e8be
movq %rcx, (%r14)
movl (%rbx,%rax), %ecx
movl %ecx, 0x8(%r14)
addq $0x10, %r14
addq $0x10, %rax
cmpq $0x50, %rax
jne 0x258e898
cmpl $0x4, %ebp
jbe 0x258e8e7
andb $-0x2, (%rbx)
movl %ebp, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x258e946
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x258e946
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b410f1
|
/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<llvm::BasicBlock*, 4u>, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>>::LookupBucketFor<std::pair<llvm::Loop*, int>>(std::pair<llvm::Loop*, int> const&, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>> const*&) const
|
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
shlq $0x20, %rax
orq %rax, %rdi
movabsq $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq %rdi, %rax
movq %rax, %rdi
shrq $0x1f, %rdi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %r14d
shlq $0x6, %r14
leaq (%rcx,%r14), %r11
movq (%rcx,%r14), %rbx
movl 0x8(%rcx,%r14), %ebp
cmpq %rbx, (%rsi)
jne 0x258ecb8
cmpl %ebp, 0x8(%rsi)
jne 0x258ecb8
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x258ec8b
jmp 0x258ed00
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x258ecda
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
jne 0x258ecda
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x258ecb1
testq %r9, %r9
cmovneq %r9, %r11
negl %ebp
cmovnoq %r9, %r11
cmpq $-0x2000, %rbx # imm = 0xE000
cmoveq %r11, %r9
addl %r10d, %edi
incl %r10d
andl %r8d, %edi
movb $0x1, %r11b
jmp 0x258ecb1
popq %rbx
popq %r14
popq %rbp
jmp 0x258ed0f
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
|
/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*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>>, std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>>::InsertIntoBucketImpl<std::pair<llvm::Loop*, int>>(std::pair<llvm::Loop*, int> const&, std::pair<llvm::Loop*, int> const&, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x4(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x258ed79
addl $0x2, (%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
jne 0x258ed6a
cmpl $0x7fffffff, 0x8(%rax) # imm = 0x7FFFFFFF
je 0x258ed6d
decl 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x258ed9a
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x258ec20
movq (%r15), %rax
jmp 0x258ed55
nop
|
/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 (NewNumBuckets == NumBuckets) {
this->BaseT::initEmpty();
return;
}
deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
init(NewNumBuckets);
}
|
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
movl $0x40, %ebp
cmovgel %edx, %ebp
cmpl %eax, %ebp
jne 0x258f501
movq $0x0, 0x8(%rbx)
testq %rax, %rax
je 0x258f4fa
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq $-0x1000, (%rcx) # imm = 0xF000
movl $0xffffffff, 0x8(%rcx) # imm = 0xFFFFFFFF
addq $0x18, %rcx
cmpq %rax, %rcx
jne 0x258f4e3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x258d9c8
|
/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::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>>::clear()
|
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;
}
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
if (std::is_trivially_destructible<ValueT>::value) {
// Use a simpler loop when values don't need destruction.
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
P->getFirst() = EmptyKey;
} else {
unsigned NumEntries = getNumEntries();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey)) {
if (!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
P->getSecond().~ValueT();
--NumEntries;
}
P->getFirst() = EmptyKey;
}
}
assert(NumEntries == 0 && "Node count imbalance!");
(void)NumEntries;
}
setNumEntries(0);
setNumTombstones(0);
}
|
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
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x258f654
leaq 0x38(%rsp), %rbx
movl $0x2, %ecx
movq %rcx, (%rbx)
xorl %edx, %edx
movq %rdx, 0x8(%rbx)
movq $-0x1000, 0x10(%rbx) # imm = 0xF000
leaq 0x32f0039(%rip), %rsi # 0x587f5d0
addq $0x10, %rsi
movq %rsi, -0x8(%rbx)
movq %rdx, 0x18(%rbx)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq $-0x2000, 0x20(%rsp) # imm = 0xE000
movq %rsi, 0x8(%rsp)
movq %rdx, 0x28(%rsp)
testq %rax, %rax
je 0x258f5f7
movq (%r14), %r15
shlq $0x3, %rax
leaq (%rax,%rax,4), %r12
leaq 0x8(%r15), %r13
xorl %ebp, %ebp
movq %r13, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
callq 0xb1e8aa
movq 0x50(%rsp), %rax
movq %rax, 0x20(%r15,%rbp)
addq $0x28, %rbp
cmpq %rbp, %r12
jne 0x258f5d6
movq $0x0, 0x8(%r14)
movq 0x20(%rsp), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x258f623
cmpq $-0x1000, %rax # imm = 0xF000
je 0x258f623
testq %rax, %rax
je 0x258f623
leaq 0x10(%rsp), %rdi
callq 0x2aa1dc0
movq 0x48(%rsp), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x258f645
cmpq $-0x1000, %rax # imm = 0xF000
je 0x258f645
testq %rax, %rax
je 0x258f645
movq %rbx, %rdi
callq 0x2aa1dc0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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 %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movq (%rdi), %r14
movl %ecx, 0x10(%rdi)
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%rbx)
testq %r14, %r14
je 0x258fa13
shlq $0x3, %r15
leaq (%r15,%r15,4), %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x258fa20
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x258d910
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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 %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movq (%rdi), %r14
movl %ecx, 0x10(%rdi)
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%rbx)
testq %r14, %r14
je 0x258fca5
shlq $0x3, %r15
leaq (%r15,%r15,2), %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x258fcda
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%rbx)
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x258fcd4
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1000, (%rax) # imm = 0xF000
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x258fcbd
popq %rbx
popq %r14
popq %r15
retq
|
/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*>>, 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 0x258ffd3
leaq 0x60(%r14), %rdi
addq $0x60, %r15
movq %r15, %rsi
callq 0x15a3554
leaq 0x1b0(%r14), %rdi
leaq 0x1d0(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rcx
callq 0x2b4e93a
leaq 0x220(%r14), %rax
movq %rax, 0x210(%r14)
movq %r12, 0x218(%r14)
cmpl $0x0, 0x68(%rbx)
je 0x259002a
addq $0x210, %r14 # imm = 0x210
addq $0x60, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15a3554
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 = 64;
}
if ((Small && NewNumBuckets <= InlineBuckets) ||
(!Small && NewNumBuckets == getLargeRep()->NumBuckets)) {
this->BaseT::initEmpty();
return;
}
deallocateBuckets();
init(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
movl $0x40, %ebp
cmovael %esi, %ebp
andl $0x1, %eax
je 0x259007d
cmpl $0x5, %ebp
jb 0x2590086
testl %eax, %eax
jne 0x25900cd
cmpl 0x10(%rbx), %ebp
jne 0x25900cd
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
leaq 0x8(%rbx), %rcx
testl %eax, %eax
cmoveq 0x8(%rbx), %rcx
movl $0x4, %eax
cmovel 0x10(%rbx), %eax
testl %eax, %eax
je 0x25900c6
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq $-0x1000, (%rcx) # imm = 0xF000
movl $0x7fffffff, 0x8(%rcx) # imm = 0x7FFFFFFF
addq $0x18, %rcx
cmpq %rax, %rcx
jne 0x25900af
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %eax, %eax
jne 0x25900ea
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1bfbdf4
|
/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 %rax, 0x88(%rbx)
leaq 0x31cfa5c(%rip), %rax # 0x5761038
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x33665be(%rip), %rax # 0x58f7ba8
addq $0x10, %rax
movq %rax, 0xa0(%rbx)
movups %xmm0, 0xa8(%rbx)
leaq -0x1a8cf59(%rip), %rax # 0xb046aa
movq %rax, 0xc0(%rbx)
leaq -0x1a8cf65(%rip), %rax # 0xb046ac
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x259441a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b1e814
|
/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 graph
writeFooter();
}
|
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, 0x20(%rdi)
popq %rbx
retq
nop
|
/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?
O << "\tNode" << SrcNodeID;
if (SrcNodePort >= 0)
O << ":s" << SrcNodePort;
O << " -> Node" << DestNodeID;
if (DestNodePort >= 0 && DTraits.hasEdgeDestLabels())
O << ":d" << DestNodePort;
if (!Attrs.empty())
O << "[" << Attrs << "]";
O << ";\n";
}
|
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, %ebp
js 0x2593679
movq (%rbx), %rdi
leaq 0x19d71d2(%rip), %rsi # 0x3f6a837
movl $0x2, %edx
callq 0x7f9ba8
movl %ebp, %esi
movq %rax, %rdi
callq 0x2b7d122
movq (%rbx), %rdi
leaq 0x19a84ab(%rip), %rsi # 0x3f3bb2e
movl $0x8, %edx
callq 0x7f9ba8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2b7d64e
cmpq $0x0, 0x8(%r14)
je 0x25936d6
movq (%rbx), %rdi
leaq 0x2369b53(%rip), %rsi # 0x48fd1fc
movl $0x1, %edx
callq 0x7f9ba8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x2b7d704
leaq 0x2a36321(%rip), %rsi # 0x4fc99ea
movl $0x1, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%rbx), %rdi
leaq 0x29ef839(%rip), %rsi # 0x4f82f19
movl $0x2, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7f9ba8
|
/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>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned long>>::InsertIntoBucketImpl<llvm::Instruction*>(llvm::Instruction* const&, llvm::Instruction* const&, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned long>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x25ccd77
incl 0x8(%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x25ccd6b
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x25ccd98
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x25ccc94
movq (%r15), %rax
jmp 0x25ccd5c
nop
|
/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::DDGNode*>>::LookupBucketFor<llvm::Instruction const*>(llvm::Instruction const* const&, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::DDGNode*> const*&) const
|
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)
jne 0x25cd86e
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x25cd84b
jmp 0x25cd8a4
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x25cd888
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x25cd867
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x25cd867
popq %rbx
jmp 0x25cd8b0
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/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 have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
}
|
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 0x25d0645
cmpl %r15d, 0xc(%rbx)
jae 0x25d065c
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2b4ed86
jmp 0x25d0673
testl %r15d, %r15d
je 0x25d0698
movq (%rbx), %rdi
leaq (,%r15,8), %rdx
callq 0x780120
jmp 0x25d0698
testq %r12, %r12
je 0x25d0673
leaq (,%r12,8), %rdx
movq (%rbx), %rdi
callq 0x780120
jmp 0x25d0676
xorl %r12d, %r12d
movl 0x8(%r14), %edx
subq %r12, %rdx
je 0x25d0698
shlq $0x3, %r12
movq (%r14), %rsi
addq %r12, %rsi
addq (%rbx), %r12
shlq $0x3, %rdx
movq %r12, %rdi
callq 0x780890
movl %r15d, 0x8(%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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>>::begin()
|
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 0x26248f6
leaq (,%rcx,8), %rcx
movl $0x1000, %esi # imm = 0x1000
movq (%rax), %rdi
orq %rsi, %rdi
cmpq $-0x1000, %rdi # imm = 0xF000
jne 0x26248f6
addq $0x8, %rax
addq $-0x8, %rcx
jne 0x26248dd
retq
nop
|
/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, %rdi
movq %rax, %rsi
callq 0x263b904
incl 0x8(%rbx)
popq %rbx
retq
|
/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::SmallPtrSet<llvm::Loop*, 8u>, llvm::GraphTraits<llvm::Loop*>>)
|
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;
}
assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
// Check that the reserve that follows doesn't invalidate the iterators.
this->assertSafeToAddRange(From, To);
size_t NumToInsert = std::distance(From, To);
// Ensure there is enough space.
reserve(this->size() + NumToInsert);
// Uninvalidate the iterator.
I = this->begin()+InsertElt;
// If there are more elements between the insertion point and the end of the
// range than there are being inserted, we can use a simple approach to
// insertion. Since we already reserved space, we know that this won't
// reallocate the vector.
if (size_t(this->end()-I) >= NumToInsert) {
T *OldEnd = this->end();
append(std::move_iterator<iterator>(this->end() - NumToInsert),
std::move_iterator<iterator>(this->end()));
// Copy the existing elements that get replaced.
std::move_backward(I, OldEnd-NumToInsert, OldEnd);
std::copy(From, To, I);
return I;
}
// Otherwise, we're inserting more elements than exist already, and we're
// not inserting at the end.
// Move over the elements that we're about to overwrite.
T *OldEnd = this->end();
this->set_size(this->size() + NumToInsert);
size_t NumOverwritten = OldEnd-I;
this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
// Replace the overwritten part.
for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
*J = *From;
++J; ++From;
}
// Insert the non-overwritten middle part.
this->uninitialized_copy(From, To, OldEnd);
return I;
}
|
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
cmpq %rsi, %rax
je 0x263a3a9
leaq 0x328(%rsp), %rsi
leaq 0x308(%rsp), %rdi
movq %r15, %rdx
callq 0x2b4e852
leaq 0x368(%rsp), %rbx
movq %rbx, %rdi
movq %r12, (%rsp)
movq %r12, %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%rbx)
leaq 0x608(%rsp), %rsi
leaq 0x5e8(%rsp), %rdi
movq %r14, %rdx
callq 0x2b4e852
leaq 0x648(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x263ab4c
movl 0xb0(%r14), %eax
movl %eax, 0x50(%r12)
movq %r12, %rdi
callq 0x2638ce6
movq -0x58(%r12), %rdi
cmpq -0x60(%r12), %rdi
je 0x263a163
callq 0x780910
movq %rbp, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2638ce6
movq 0x310(%rsp), %rdi
cmpq 0x308(%rsp), %rdi
je 0x263a187
callq 0x780910
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x2b4e852
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%rbx)
leaq 0x550(%rsp), %rsi
leaq 0x530(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rdx
callq 0x2b4e852
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r14), %eax
movl %eax, 0x50(%rbx)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x263a7e8
movq %rax, %r12
movq %rbx, %rdi
callq 0x2638ce6
movq -0x58(%rbx), %rdi
cmpq -0x60(%rbx), %rdi
je 0x263a219
callq 0x780910
leaq 0x88(%rsp), %rdi
callq 0x2638ce6
movq 0x30(%rsp), %rdi
cmpq 0x28(%rsp), %rdi
je 0x263a237
callq 0x780910
movq %r14, 0x18(%rsp)
movl 0x8(%r13), %edx
movl 0xc(%r13), %eax
addq %r12, %rdx
cmpq %rax, %rdx
jbe 0x263a25d
leaq 0x10(%r13), %rsi
movl $0x8, %ecx
movq %r13, %rdi
callq 0x2b4ed86
movq (%r13), %rax
movq 0x10(%rsp), %rsi
leaq (%rax,%rsi), %rbp
movl 0x8(%r13), %ecx
leaq (,%rcx,8), %r14
leaq (%rax,%rcx,8), %r8
movq %r14, %rdx
subq %rsi, %rdx
movq %rdx, %rbx
sarq $0x3, %rbx
cmpq %r12, %rbx
jae 0x263a46d
movq %r8, 0x20(%rsp)
addl %ecx, %r12d
movl %r12d, 0x8(%r13)
cmpq %rsi, %r14
je 0x263a2c0
movl %r12d, %ecx
leaq (%rax,%rcx,8), %rdi
leaq (,%rbx,8), %rax
subq %rax, %rdi
movq %rbp, %rsi
callq 0x780890
movq 0x10(%rsp), %rsi
cmpq %rsi, %r14
je 0x263a2e4
xorl %r14d, %r14d
movq 0x70(%r15), %rax
movq (%rax), %rax
movq %rax, (%rbp,%r14,8)
movq %r15, %rdi
callq 0x263b334
incq %r14
cmpq %r14, %rbx
jne 0x263a2c8
leaq 0x1b8(%rsp), %rsi
leaq 0x198(%rsp), %r13
movq %r13, %rdi
movq %r15, %rdx
callq 0x2b4e852
leaq 0x1f8(%rsp), %r12
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%r12)
leaq 0x3e0(%rsp), %rsi
leaq 0x3c0(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x2b4e852
leaq 0x420(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%r14)
movq %r13, %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %rdx
callq 0x263aa78
movq %r14, %rdi
callq 0x2638ce6
movq -0x58(%r14), %rdi
cmpq -0x60(%r14), %rdi
je 0x263a386
callq 0x780910
movq %r12, %rdi
callq 0x2638ce6
movq 0x1a0(%rsp), %rdi
cmpq 0x198(%rsp), %rdi
jne 0x263a557
jmp 0x263a55c
leaq 0x100(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
movq %r15, %rdx
callq 0x2b4e852
leaq 0x140(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%rbx)
leaq 0x6c0(%rsp), %rsi
leaq 0x6a0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2b4e852
movq %rbp, %rsi
leaq 0x700(%rsp), %rbp
movq %rbp, %rdi
callq 0x263ab4c
movl 0xb0(%r14), %eax
movl %eax, 0x50(%rbp)
movq %r13, %rdi
leaq 0xe0(%rsp), %rsi
movq %r15, %rdx
callq 0x263a572
movq %rbp, %rdi
callq 0x2638ce6
movq -0x58(%rbp), %rdi
cmpq -0x60(%rbp), %rdi
je 0x263a440
callq 0x780910
movq %rbx, %rdi
callq 0x2638ce6
movq 0xe8(%rsp), %rdi
cmpq 0xe0(%rsp), %rdi
je 0x263a45f
callq 0x780910
movq 0x10(%rsp), %rbp
addq (%r13), %rbp
jmp 0x263a55c
shlq $0x3, %r12
movq %r8, %r14
subq %r12, %r14
movq %r13, %rdi
movq %r14, %rsi
movq %r8, %rdx
movq %r8, %rbx
callq 0x1a739da
subq %rbp, %r14
je 0x263a49e
subq %r14, %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x780120
leaq 0x270(%rsp), %rsi
leaq 0x250(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x2b4e852
leaq 0x2b0(%rsp), %r14
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r15), %eax
movl %eax, 0x50(%r14)
leaq 0x498(%rsp), %rsi
leaq 0x478(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %r13
movq %r13, %rdx
callq 0x2b4e852
leaq 0x4d8(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x263ab4c
movl 0xb0(%r13), %eax
movl %eax, 0x50(%r15)
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x263a8e8
movq %r15, %rdi
callq 0x2638ce6
movq -0x58(%r15), %rdi
cmpq -0x60(%r15), %rdi
je 0x263a53d
callq 0x780910
movq %r14, %rdi
callq 0x2638ce6
movq 0x258(%rsp), %rdi
cmpq 0x250(%rsp), %rdi
je 0x263a55c
callq 0x780910
movq %rbp, %rax
addq $0x758, %rsp # imm = 0x758
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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>();
return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
PAC.preservedSet<CFGAnalyses>());
}
|
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, %rax
setne 0x10(%r14)
movq %r14, %rdi
callq 0x1a01030
testb %al, %al
jne 0x267ff75
movq %rsp, %rdi
callq 0x1a010a4
testb %al, %al
je 0x267ff79
xorl %eax, %eax
jmp 0x267ff83
movq %rsp, %rdi
callq 0x1c30784
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 %r14
retq
|
/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);
if (ItCached != CachedControlDivDescs.end())
return *ItCached->second;
// compute all join points
DivergencePropagatorT Propagator(CyclePO, DT, CI, *DivTermBlock);
auto DivDesc = Propagator.computeJoinPoints();
auto printBlockSet = [&](ConstBlockSet &Blocks) {
return Printable([&](raw_ostream &Out) {
Out << "[";
ListSeparator LS;
for (const auto *BB : Blocks) {
Out << LS << CI.getSSAContext().print(BB);
}
Out << "]\n";
});
};
LLVM_DEBUG(
dbgs() << "\nResult (" << CI.getSSAContext().print(DivTermBlock)
<< "):\n JoinDivBlocks: " << printBlockSet(DivDesc->JoinDivBlocks)
<< " CycleDivBlocks: " << printBlockSet(DivDesc->CycleDivBlocks)
<< "\n");
(void)printBlockSet;
auto ItInserted =
CachedControlDivDescs.try_emplace(DivTermBlock, std::move(DivDesc));
assert(ItInserted.second);
return *ItInserted.first->second;
}
|
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, %eax
cmovbq %rcx, %rdi
jmp 0x26ecae2
xorl %edi, %edi
leaq 0x32b583f(%rip), %rbx # 0x59a2328
testq %rdi, %rdi
je 0x26ecc4c
callq 0x2a5323e
cmpl $0x2, %eax
jb 0x26ecc4c
leaq 0x190(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26ecdfc
movl 0x1a0(%r14), %ecx
shlq $0x4, %rcx
addq 0x190(%r14), %rcx
cmpq %rcx, %rax
je 0x26ecb32
movq 0x8(%rax), %rbx
jmp 0x26ecc4c
movq 0x180(%r14), %rax
movq 0x188(%r14), %rcx
leaq 0x8(%rsp), %r15
movq (%r15), %rdx
leaq 0x38(%rsp), %r13
movq %r14, -0x28(%r13)
movq %rax, -0x20(%r13)
movq %rcx, -0x18(%r13)
movq %rdx, -0x10(%r13)
movq %rcx, -0x8(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq %r13, 0x8(%r13)
movq %r13, (%r13)
movq $0x0, 0x10(%r13)
movq %r13, 0x18(%r13)
movl $0x98, %edi
callq 0x7808d0
leaq 0x20(%rax), %rcx
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
movl $0x4, %ecx
movq %rcx, 0x10(%rax)
xorl %edx, %edx
movl %edx, 0x18(%rax)
leaq 0x60(%rax), %rsi
movq %rsi, 0x40(%rax)
movq %rsi, 0x48(%rax)
movq %rcx, 0x50(%rax)
movl %edx, 0x58(%rax)
leaq 0x80(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rax)
movl %edx, 0x90(%rax)
movq %rax, 0x20(%r13)
movq %rcx, 0x28(%r13)
movq %rsp, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x26ece3a
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x26ed3d2
movq (%r12), %rax
movq 0x8(%rax), %rbx
movq (%r14), %rsi
testq %rsi, %rsi
je 0x26ecc10
movq %rsp, %rdi
callq 0x26ebf6c
movq 0x58(%rsp), %rsi
testq %rsi, %rsi
je 0x26ecc24
leaq 0x58(%rsp), %rdi
callq 0x26ebf6c
movq $0x0, 0x58(%rsp)
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x26ecc4c
movq (%rdi), %r14
movl $0x28, %esi
callq 0x7800d0
movq %r14, %rdi
cmpq %r13, %r14
jne 0x26ecc37
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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*&)
|
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 $0x4, %esi
callq 0x2737c48
leaq 0x388(%rbx), %r12
leaq 0x316cf70(%rip), %rcx # 0x58b41c8
movq %rsp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2b32606
movq %rax, %r15
testq %rax, %rax
je 0x2747274
leaq 0x8(%r15), %r14
jmp 0x27472e4
testb %bpl, %bpl
je 0x27472e1
leaq 0x328(%rbx), %rdi
movl $0x20, %esi
movl $0x3, %edx
callq 0x8f284c
movq $0x0, (%rax)
leaq 0x8(%rax), %r14
movq (%r13), %rcx
movb $0x4, 0x10(%rax)
movzwl 0x11(%rax), %edx
andl $0xfffff000, %edx # imm = 0xFFFFF000
orl $0x540, %edx # imm = 0x540
movw %dx, 0x11(%rax)
leaq 0x316e7a3(%rip), %rdx # 0x58b5a60
addq $0x10, %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq (%rsp), %rdx
leaq 0x316cef4(%rip), %rcx # 0x58b41c8
movq %r12, %rdi
movq %rax, %rsi
callq 0x2b3252c
jmp 0x27472e4
xorl %r14d, %r14d
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x27472f8
callq 0x780910
testq %r15, %r15
je 0x2747327
testq %r14, %r14
je 0x2747330
leaq 0x3b0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rsp, %rdx
callq 0x27381fa
testb %al, %al
je 0x2747335
movq (%rsp), %rax
movq 0x8(%rax), %rax
jmp 0x2747337
movq %r14, 0x398(%rbx)
jmp 0x274734e
xorl %r14d, %r14d
jmp 0x274734e
xorl %eax, %eax
testq %rax, %rax
cmovneq %rax, %r14
cmpq 0x3a0(%rbx), %r14
jne 0x274734e
movb $0x1, 0x3a8(%rbx)
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&)
|
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 (%r13), %rcx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl $0x1a, %esi
callq 0x2737ad5
leaq 0x388(%rbx), %r12
leaq 0x316a0aa(%rip), %rcx # 0x58b41c8
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2b32606
movq %rax, %r15
testq %rax, %rax
je 0x274a13c
leaq 0x8(%r15), %r14
jmp 0x274a1b7
cmpb $0x0, 0xf(%rsp)
je 0x274a1b4
leaq 0x328(%rbx), %rdi
movl $0x28, %esi
movl $0x3, %edx
callq 0x8f284c
movq $0x0, (%rax)
leaq 0x8(%rax), %r14
movq (%rbp), %rcx
movq (%r13), %rdx
movb $0x1a, 0x10(%rax)
movzwl 0x11(%rax), %esi
andl $0xfffff000, %esi # imm = 0xFFFFF000
orl $0x540, %esi # imm = 0x540
movw %si, 0x11(%rax)
leaq 0x316c065(%rip), %rsi # 0x58b61f0
addq $0x10, %rsi
movq %rsi, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq %rdx, 0x20(%rax)
movq 0x10(%rsp), %rdx
leaq 0x316a021(%rip), %rcx # 0x58b41c8
movq %r12, %rdi
movq %rax, %rsi
callq 0x2b3252c
jmp 0x274a1b7
xorl %r14d, %r14d
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x274a1cb
callq 0x780910
testq %r15, %r15
je 0x274a1fd
testq %r14, %r14
je 0x274a206
leaq 0x3b0(%rbx), %rdi
leaq 0x18(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdx
callq 0x27381fa
testb %al, %al
je 0x274a20b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
jmp 0x274a20d
movq %r14, 0x398(%rbx)
jmp 0x274a224
xorl %r14d, %r14d
jmp 0x274a224
xorl %eax, %eax
testq %rax, %rax
cmovneq %rax, %r14
cmpq 0x3a0(%rbx), %r14
jne 0x274a224
movb $0x1, 0x3a8(%rbx)
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
jmp 0x274c798
|
/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)
movq %rsp, %rsi
callq 0x274e1ce
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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";
case object_error::parse_failed:
return "Invalid data was encountered while parsing the file";
case object_error::unexpected_eof:
return "The end of the file was unexpectedly encountered";
case object_error::string_table_non_null_end:
return "String table must end with a null terminator";
case object_error::invalid_section_index:
return "Invalid section index";
case object_error::bitcode_section_not_found:
return "Bitcode section not found in object file";
case object_error::invalid_symbol_index:
return "Invalid symbol index";
case object_error::section_stripped:
return "Section has been stripped from the object file";
}
llvm_unreachable("An enumerator of object_error does not have a message "
"defined.");
}
|
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 0x27982e3(%rip), %rdx # 0x4f9d09a
jmp 0x2804e27
leaq 0x2798249(%rip), %rsi # 0x4f9d009
leaq 0x2798275(%rip), %rdx # 0x4f9d03c
jmp 0x2804e27
leaq 0x279826d(%rip), %rsi # 0x4f9d03d
leaq 0x2798296(%rip), %rdx # 0x4f9d06d
jmp 0x2804e27
leaq 0x27982fa(%rip), %rsi # 0x4f9d0da
leaq 0x2798307(%rip), %rdx # 0x4f9d0ee
jmp 0x2804e27
leaq 0x27981e6(%rip), %rsi # 0x4f9cfd6
leaq 0x2798211(%rip), %rdx # 0x4f9d008
jmp 0x2804e27
leaq 0x279829b(%rip), %rsi # 0x4f9d09b
leaq 0x27982a9(%rip), %rdx # 0x4f9d0b0
jmp 0x2804e27
leaq 0x27982a1(%rip), %rsi # 0x4f9d0b1
leaq 0x27982c2(%rip), %rdx # 0x4f9d0d9
jmp 0x2804e27
leaq 0x27982cf(%rip), %rsi # 0x4f9d0ef
leaq 0x27982f6(%rip), %rdx # 0x4f9d11d
movq %rbx, %rdi
callq 0x7fa87c
movq %rbx, %rax
popq %rbx
retq
|
/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"))
return true;
unsigned GVId;
ValueInfo VI;
LocTy Loc = Lex.getLoc();
if (parseGVReference(VI, GVId))
return true;
Call.Callee = VI;
IdLocList.emplace_back(GVId, Loc);
if (parseToken(lltok::comma, "expected ',' here") ||
parseParamNo(Call.ParamNo) ||
parseToken(lltok::comma, "expected ',' here") ||
parseParamAccessOffset(Call.Offsets))
return true;
if (parseToken(lltok::rparen, "expected ')' here"))
return true;
return false;
}
|
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 = 0x1A8
callq 0x287c786
testb %al, %al
jne 0x289e68b
leaq 0x2718234(%rip), %rdx # 0x4fb67f8
movq %r14, %rdi
movl $0x10, %esi
callq 0x287c786
testb %al, %al
jne 0x289e68b
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
movq 0xe0(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x289a2f2
movb $0x1, %bl
testb %al, %al
jne 0x289e68b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r15)
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x289e69a
leaq 0x27181f5(%rip), %rdx # 0x4fb681f
movq %r14, %rdi
movl $0x4, %esi
callq 0x287c786
testb %al, %al
jne 0x289e68b
movq %r14, %rdi
movq %r15, %rsi
callq 0x289e114
testb %al, %al
jne 0x289e68b
leaq 0x27181ce(%rip), %rdx # 0x4fb681f
movq %r14, %rdi
movl $0x4, %esi
callq 0x287c786
testb %al, %al
jne 0x289e68b
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x289e168
testb %al, %al
jne 0x289e68b
leaq 0x27164a5(%rip), %rdx # 0x4fb4b21
movq %r14, %rdi
movl $0xd, %esi
callq 0x287c786
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 && UniqueID == GenericSectionID)
return Sec;
// If we have a key symbol, make an associative section with the same name and
// kind as the normal section.
unsigned Characteristics = Sec->getCharacteristics();
if (KeySym) {
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
return getCOFFSection(Sec->getName(), Characteristics, KeySym->getName(),
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
}
return getCOFFSection(Sec->getName(), Characteristics, "", 0, UniqueID);
}
|
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 $0x0, %r9d
je 0x28d43ed
movq -0x8(%rdx), %r8
movq (%r8), %r9
addq $0x18, %r8
movq %r10, %rsi
movq %r11, %rdx
pushq %rax
pushq $0x5
jmp 0x28d4416
movq 0x80(%rsi), %r9
movq 0x88(%rsi), %rdx
leaq 0x16870ab(%rip), %r8 # 0x3f5b4b8
movq %r9, %rsi
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x28d4016
addq $0x10, %rsp
popq %rcx
retq
nop
|
/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-number>* 0 <attribute>*
// | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
// ]+
// ]*
// Switch section to AttributeSection or get/create the section.
if (AttributeSection) {
switchSection(AttributeSection);
} else {
AttributeSection = getContext().getELFSection(Section, Type, 0);
switchSection(AttributeSection);
// Format version
emitInt8(0x41);
}
// Vendor size + Vendor name + '\0'
const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
// Tag + Tag Size
const size_t TagHeaderSize = 1 + 4;
const size_t ContentsSize = calculateContentSize(AttrsVec);
emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
emitBytes(Vendor);
emitInt8(0); // '\0'
emitInt8(ARMBuildAttrs::File);
emitInt32(TagHeaderSize + ContentsSize);
// Size should have been accounted for already, now
// emit each field as its type (ULEB or String)
for (const AttributeItem &Item : AttrsVec) {
emitULEB128IntValue(Item.Tag);
switch (Item.Type) {
default:
llvm_unreachable("Invalid attribute type");
case AttributeItem::NumericAttribute:
emitULEB128IntValue(Item.IntValue);
break;
case AttributeItem::TextAttribute:
emitBytes(Item.StringValue);
emitInt8(0); // '\0'
break;
case AttributeItem::NumericAndTextAttributes:
emitULEB128IntValue(Item.IntValue);
emitBytes(Item.StringValue);
emitInt8(0); // '\0'
break;
}
}
AttrsVec.clear();
}
|
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), %r9
movw $0x101, 0x20(%r9) # imm = 0x101
subq $0x8, %rsp
movq %rcx, %rsi
movl %r8d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq $0x0
pushq $-0x1
pushq $0x0
callq 0x28d38c0
addq $0x20, %rsp
movq %rax, (%r13)
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq *0xa8(%rcx)
movq (%r14), %rax
movl $0x41, %esi
movq %r14, %rdi
movl $0x1, %edx
callq *0x208(%rax)
movq %rbx, %rsi
callq 0x28e11b2
movq %rax, %r13
leaq (%r15,%rax), %rsi
addq $0xa, %rsi
movq (%r14), %rax
movq %r14, %rdi
movl $0x4, %edx
callq *0x208(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x1f0(%rax)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq *0x208(%rax)
movq (%r14), %rax
movl $0x1, %esi
movq %r14, %rdi
movl $0x1, %edx
callq *0x208(%rax)
addq $0x5, %r13
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movl $0x4, %edx
callq *0x208(%rax)
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x28e0e83
movq (%rbx), %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movl 0x4(%r15,%r13), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x28f6052
movl (%r15,%r13), %eax
cmpl $0x1, %eax
je 0x28e0e6b
cmpl $0x2, %eax
je 0x28e0e40
movl 0x8(%r15,%r13), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x28f6052
movq 0x10(%r15,%r13), %rsi
movq 0x18(%r15,%r13), %rdx
movq (%r14), %rax
movq %r14, %rdi
callq *0x1f0(%rax)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq *0x208(%rax)
jmp 0x28e0e7a
movl 0x8(%r15,%r13), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x28f6052
addq $0x30, %r13
cmpq %r13, %r12
jne 0x28e0e14
movq %rbx, %rdi
callq 0x28e1262
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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::STB_GNU_UNIQUE:
Val = 3;
break;
}
uint32_t OtherFlags = getFlags() & ~(0x3 << ELF_STB_Shift);
setFlags(OtherFlags | (Val << ELF_STB_Shift));
}
|
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 = 0x800000000
jmp 0x28fb062
movabsq $0x1800000000, %rcx # imm = 0x1800000000
movabsq $-0x1800000001, %rdx # imm = 0xFFFFFFE7FFFFFFFF
andq %rdx, %rax
orq %rcx, %rax
movq %rax, 0x8(%rdi)
retq
nop
|
/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, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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), std::move(OW), std::move(CE)),
CurSymbol(nullptr) {
auto *TO = Context.getTargetOptions();
if (TO && TO->MCIncrementalLinkerCompatible)
getWriter().setIncrementalLinkerCompatible(true);
}
|
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)
movq %r14, %rsi
movq %rax, %rdx
movq %r9, %rcx
movq %r15, %r8
callq 0x28eb7ac
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2901ce6
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2901cff
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2901d18
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0x2fbbc6a(%rip), %rcx # 0x58bd990
addq $0x10, %rcx
movq %rcx, (%rbx)
movq %rax, 0x1a8(%rbx)
movq 0x928(%r14), %rax
testq %rax, %rax
je 0x2901d57
testb $-0x80, (%rax)
je 0x2901d57
movq 0x120(%rbx), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x80(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, (anonymous namespace)::COFFSymbol*>>::operator[](llvm::MCSymbol const*&&)
|
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)
addq $0x8, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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
je 0x2914a9a
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
leaq (%rax,%rax,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
xorl %esi, %esi
callq 0x780240
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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>(getAggregateElement(I));
if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
return false;
}
return true;
}
if (getType()->isVectorTy())
if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
return SplatCFP->isFiniteNonZeroFP();
// It *may* contain finite non-zero, we can't tell.
return false;
}
|
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 %cl
andb $0x7, %al
cmpb $0x3, %al
setne %bl
andb %cl, %bl
cmpb $0x12, %bpl
je 0x29e128a
movq 0x8(%r14), %rax
cmpb $0x12, 0x8(%rax)
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x29e1243
movl 0x20(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x29e1241
movb %dl, 0x3(%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x29e0e60
testq %rax, %rax
je 0x29e11eb
movq %rax, %r12
cmpb $0x12, (%rax)
je 0x29e11ee
xorl %r12d, %r12d
testq %r12, %r12
je 0x29e1227
leaq 0x20(%r12), %rbp
movq 0x20(%r12), %r13
callq 0x2b06206
movq 0x28(%r12), %rcx
addq $0x8, %rcx
cmpq %r13, %rax
cmovneq %rbp, %rcx
movb 0x14(%rcx), %al
testb $0x6, %al
setne %cl
andb $0x7, %al
cmpb $0x3, %al
setne %al
andb %cl, %al
andb %al, %bl
jmp 0x29e122b
xorl %eax, %eax
xorl %ebx, %ebx
testb %al, %al
je 0x29e123b
incl %r15d
cmpl %r15d, 0x4(%rsp)
jne 0x29e11d3
movb $0x1, %bl
movb 0x3(%rsp), %dl
jmp 0x29e1243
movb $0x1, %bl
testb %dl, %dl
je 0x29e128a
movq 0x8(%r14), %rax
movl $0xfe, %ecx
andl 0x8(%rax), %ecx
cmpl $0x12, %ecx
jne 0x29e1288
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x29e0948
testq %rax, %rax
je 0x29e1274
xorl %r15d, %r15d
cmpb $0x12, (%rax)
cmoveq %rax, %r15
testq %r15, %r15
je 0x29e1283
movq %r15, %rdi
callq 0x29e115a
movl %eax, %ebx
testq %r15, %r15
jne 0x29e128a
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
jmp 0x29f45fd
xorl %r8d, %r8d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x29a66b2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a4084e
|
/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
jmp 0x29fb2ee
nop
|
/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*, unsigned int>>, llvm::MDNode*, unsigned int, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<llvm::MDNode*, unsigned int>>::try_emplace<unsigned int const&>(llvm::MDNode* const&, unsigned int const&)
|
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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
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 %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x29fe0da
movq (%r12), %rcx
movq %rcx, (%rax)
movl (%r15), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x4, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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*, llvm::StructLayout*>>::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::StructType*, llvm::StructLayout*>*, llvm::detail::DenseMapPair<llvm::StructType*, llvm::StructLayout*>*)
|
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::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
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
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x1b3b8c(%rip), %xmm1 # 0x2bb5020
movdqa 0x1b3b94(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2a014e8
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x2a014fe
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x2a014a4
cmpq %rbx, %r14
je 0x2a01557
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2a0154e
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2a011e4
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
incl 0x8(%r15)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x2a0151b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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
testq %rcx, %rcx
je 0x2a03c8f
cmpl $0x41, 0x20(%rcx)
jb 0x2a03c89
movq 0x18(%rcx), %rcx
jmp 0x2a03c8d
addq $0x18, %rcx
movl (%rcx), %eax
popq %rcx
retq
nop
|
/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 0x2a0e770
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2a0e4c8
movl %eax, %eax
leaq (%r14,%rax,8), %r14
movq %r14, 0x8(%rsp)
cmpq %r15, %r14
setne %al
je 0x2a0e770
cmpq $0x9f, (%r14)
jne 0x2a0e748
jmp 0x2a0e770
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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<llvm::MDNodeKeyImpl<llvm::DILocation>>(llvm::MDNodeKeyImpl<llvm::DILocation> const&, llvm::detail::DenseSetPair<llvm::DILocation*> const*&) const
|
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 whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
}
|
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)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movaps %xmm0, -0x40(%rcx)
movq $0x0, 0x30(%rcx)
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rdx, 0x38(%rcx)
movq %rsi, 0x18(%rsp)
movl (%rsi), %esi
leaq 0x24(%rsp), %rdx
movl %esi, -0x4(%rdx)
xorl %r12d, %r12d
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
pushq %r10
pushq %rax
callq 0x2a10de4
addq $0x10, %rsp
movq %rax, %r15
decl %ebp
movl %ebp, 0xc(%rsp)
andl %ebp, %r15d
movl $0x1, %eax
movq %rax, 0x10(%rsp)
movl %r15d, %eax
leaq (,%rax,8), %r14
addq %r13, %r14
movq (%r14), %rsi
movq %rsi, %rax
orq $0x1000, %rax # imm = 0x1000
cmpq $-0x1000, %rax # imm = 0xF000
jne 0x2a10d81
movq (%r14), %rax
cmpq $-0x1000, %rax # imm = 0xF000
jne 0x2a10d9d
testq %r12, %r12
cmovneq %r12, %r14
movq %r14, (%rbx)
xorl %eax, %eax
xorl %ebp, %ebp
jmp 0x2a10d97
movq 0x18(%rsp), %rdi
callq 0x2a10fa6
testb %al, %al
je 0x2a10d66
movq %r14, (%rbx)
movb $0x1, %bpl
xorl %eax, %eax
testb %al, %al
jne 0x2a10d44
jmp 0x2a10dcc
xorq $-0x2000, %rax # imm = 0xE000
orq %r12, %rax
cmoveq %r14, %r12
movq 0x10(%rsp), %rax
addl %eax, %r15d
leal 0x1(%rax), %ecx
andl 0xc(%rsp), %r15d
movb $0x1, %al
movq %rcx, 0x10(%rsp)
jmp 0x2a10d97
movq $0x0, (%rbx)
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movq $0x0, 0x30(%rcx)
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rdx, 0x38(%rcx)
movl -0x18(%r10), %esi
leaq 0x24(%rsp), %rdx
movl %esi, -0x4(%rdx)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
pushq %r10
pushq %rax
callq 0x2a10de4
addq $0x10, %rsp
addq $0xa8, %rsp
retq
|
/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))
if (CT->getRawIdentifier())
return hash_combine(Name, Scope);
// Intentionally computes the hash on a subset of the operands for
// performance reason. The subset has to be significant enough to avoid
// collision "most of the time". There is no correctness issue in case of
// collision because of the full check above.
return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
}
|
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 0x2a14c82
addq $-0x10, %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x2a14c86
movq -0x20(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x2a14ce0
leaq 0x8(%rbx), %r8
leaq 0x20(%rbx), %r9
leaq 0x40(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movaps %xmm0, -0x40(%rcx)
movq $0x0, 0x30(%rcx)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
movq %rax, 0x38(%rcx)
xorl %r14d, %r14d
movq %rsp, %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x2a14d60
jmp 0x2a14ce0
testb %r14b, %r14b
je 0x2a14d55
leaq 0x8(%rbx), %r8
leaq 0x10(%rbx), %r9
leaq 0x18(%rbx), %rax
leaq 0x20(%rbx), %r10
leaq 0x28(%rbx), %r11
leaq 0x54(%rbx), %r14
leaq 0x40(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movaps %xmm0, -0x40(%rcx)
movq $0x0, 0x30(%rcx)
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rdx, 0x38(%rcx)
movl (%rbx), %esi
leaq 0x4(%rsp), %rdx
movl %esi, -0x4(%rdx)
movq %rsp, %rdi
xorl %esi, %esi
pushq %r14
pushq %r11
pushq %r10
pushq %rax
callq 0x2a14dc8
addq $0x20, %rsp
addq $0x88, %rsp
popq %rbx
popq %r14
retq
|
/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
cmpb $0x10, (%rsi)
movq %rsi, %r9
je 0x2a159f1
testb $0x2, %dl
jne 0x2a159ea
leal (%rdx,%rdx), %r10d
andl $0x78, %r10d
movq %rcx, %r9
subq %r10, %r9
jmp 0x2a159ee
movq -0x20(%rsi), %r9
movq (%r9), %r9
cmpq %r9, %rax
jne 0x2a15a44
movl 0x18(%rdi), %eax
cmpl 0x10(%rsi), %eax
jne 0x2a15a44
movq 0x20(%rdi), %rax
testb $0x2, %dl
jne 0x2a15a17
leal (%rdx,%rdx), %r10d
andl $0x78, %r10d
movq %rcx, %r9
subq %r10, %r9
jmp 0x2a15a1b
movq -0x20(%rsi), %r9
cmpq 0x8(%r9), %rax
jne 0x2a15a44
movq 0x28(%rdi), %rax
testb $0x2, %dl
jne 0x2a15a3a
leal (%rdx,%rdx), %r10d
andl $0x78, %r10d
movq %rcx, %r9
subq %r10, %r9
jmp 0x2a15a3e
movq -0x20(%rsi), %r9
cmpq 0x18(%r9), %rax
je 0x2a15a47
xorl %eax, %eax
retq
movq 0x30(%rdi), %r9
xorl %eax, %eax
cmpq 0x18(%rsi), %r9
jne 0x2a15a46
movl 0x40(%rdi), %r9d
movzwl %r8w, %r10d
movl $0x0, %r8d
cmpl $0x4300, %r10d # imm = 0x4300
je 0x2a15a6e
movl 0x4(%rsi), %r8d
cmpl %r8d, %r9d
jne 0x2a15a46
movq 0x38(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x2a15a44
movl 0x44(%rdi), %eax
cmpl 0x14(%rsi), %eax
jne 0x2a15a44
movq 0x48(%rdi), %rax
testb $0x2, %dl
jne 0x2a15a9e
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15aa2
movq -0x20(%rsi), %r8
cmpq 0x20(%r8), %rax
jne 0x2a15a44
movl 0x50(%rdi), %eax
cmpl 0x28(%rsi), %eax
jne 0x2a15a44
movq 0x58(%rdi), %rax
testb $0x2, %dl
jne 0x2a15ac9
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15acd
movq -0x20(%rsi), %r8
cmpq 0x28(%r8), %rax
jne 0x2a15a44
movq 0x60(%rdi), %rax
testb $0x2, %dl
jne 0x2a15af0
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15af4
movq -0x20(%rsi), %r8
cmpq 0x30(%r8), %rax
jne 0x2a15a44
movq 0x68(%rdi), %rax
testb $0x2, %dl
jne 0x2a15b17
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15b1b
movq -0x20(%rsi), %r8
cmpq 0x38(%r8), %rax
jne 0x2a15a44
movq 0x70(%rdi), %rax
testb $0x2, %dl
jne 0x2a15b3e
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15b42
movq -0x20(%rsi), %r8
cmpq 0x40(%r8), %rax
jne 0x2a15a44
movq 0x78(%rdi), %rax
testb $0x2, %dl
jne 0x2a15b65
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15b69
movq -0x20(%rsi), %r8
cmpq 0x48(%r8), %rax
jne 0x2a15a44
movq 0x80(%rdi), %rax
testb $0x2, %dl
jne 0x2a15b8f
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15b93
movq -0x20(%rsi), %r8
cmpq 0x50(%r8), %rax
jne 0x2a15a44
movq 0x88(%rdi), %rax
testb $0x2, %dl
jne 0x2a15bb9
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15bbd
movq -0x20(%rsi), %r8
cmpq 0x58(%r8), %rax
jne 0x2a15a44
movq 0x90(%rdi), %rax
testb $0x2, %dl
jne 0x2a15be3
leal (%rdx,%rdx), %r9d
andl $0x78, %r9d
movq %rcx, %r8
subq %r9, %r8
jmp 0x2a15be7
movq -0x20(%rsi), %r8
cmpq 0x60(%r8), %rax
jne 0x2a15a44
movq 0x98(%rdi), %rax
testb $0x2, %dl
jne 0x2a15c07
addl %edx, %edx
andl $0x78, %edx
subq %rdx, %rcx
jmp 0x2a15c0b
movq -0x20(%rsi), %rcx
cmpq 0x68(%rcx), %rax
sete %al
retq
nop
|
/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<llvm::DILexicalBlockFile>, llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>>::InsertIntoBucketImpl<llvm::DILexicalBlockFile*>(llvm::DILexicalBlockFile* const&, llvm::DILexicalBlockFile* const&, llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x2a19167
incl 0x8(%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x2a1915b
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x2a19188
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2a18fba
movq (%r15), %rax
jmp 0x2a1914c
nop
|
/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::DenseSetPair<llvm::DINamespace*>>, llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DINamespace*>>::try_emplace<llvm::detail::DenseSetEmpty&>(llvm::DINamespace* const&, llvm::detail::DenseSetEmpty&)
|
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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
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, %rdx
movq %rax, %rcx
callq 0x2a197d0
movq (%r15), %rcx
movq %rcx, (%rax)
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x3, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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::DIModule*>>, llvm::DIModule*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIModule>, llvm::detail::DenseSetPair<llvm::DIModule*>>::try_emplace<llvm::detail::DenseSetEmpty&>(llvm::DIModule* const&, llvm::detail::DenseSetEmpty&)
|
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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
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, %rdx
movq %rax, %rcx
callq 0x2a1a77c
movq (%r15), %rcx
movq %rcx, (%rax)
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x3, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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::DIArgList*, llvm::detail::DenseSetEmpty, llvm::DIArgListInfo, llvm::detail::DenseSetPair<llvm::DIArgList*>>::try_emplace<llvm::detail::DenseSetEmpty&>(llvm::DIArgList* const&, llvm::detail::DenseSetEmpty&)
|
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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
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, %rdx
movq %rax, %rcx
callq 0x2a204aa
movq (%r15), %rcx
movq %rcx, (%rax)
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x3, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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.begin() + FirstExtraArgIndex))
OS << Arg.Val;
return Str;
}
|
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, 0x10(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x2ed5465(%rip), %rax # 0x58f9f80
addq $0x10, %rax
movq %rax, (%rdi)
movq %rbx, 0x30(%rdi)
callq 0x7fa22e
movslq 0x1a4(%r14), %rcx
cmpq $-0x1, %rcx
movl 0x58(%r14), %eax
cmovneq %rcx, %rax
testq %rax, %rax
je 0x2a24b72
movq 0x50(%r14), %r15
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movq 0x20(%r15,%r13), %rsi
movq 0x28(%r15,%r13), %rdx
movq %r14, %rdi
callq 0x2b7d704
addq $0x50, %r13
cmpq %r13, %r12
jne 0x2a24b57
leaq 0x8(%rsp), %rdi
callq 0x2b7e98e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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->hasFnAttribute(AttrName)) {
uint64_t LocCookie = 0;
auto A = F->getFnAttribute(AttrName);
if (MDNode *MD = CI.getMetadata("srcloc"))
LocCookie =
mdconst::extract<ConstantInt>(MD->getOperand(0))->getZExtValue();
DiagnosticInfoDontCall D(F->getName(), A.getValueAsString(), Sev,
LocCookie);
F->getContext().diagnose(D);
}
}
}
|
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, %r13d
cmpl $0x2, %r12d
setne %r13b
leaq 0x25a9852(%rip), %rbp # 0x4fcf13e
leaq 0x25a985a(%rip), %rax # 0x4fcf14d
cmovneq %rax, %rbp
movl $0xe, %r15d
subq %r13, %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x2a40a70
testb %al, %al
je 0x2a259f7
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x2a40aac
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rbx)
jne 0x2a25940
movl 0x4(%rbx), %eax
movl $0x20000000, %ecx # imm = 0x20000000
andl %ecx, %eax
jne 0x2a25940
xorl %eax, %eax
jmp 0x2a25954
movl $0x6, %edx
movq %rbx, %rdi
leaq 0x1531fad(%rip), %rsi # 0x3f578fc
callq 0x2a7cfd4
testq %rax, %rax
je 0x2a25970
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x2a25974
addq $-0x10, %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x2a25978
xorl %ebx, %ebx
jmp 0x2a25995
movq -0x20(%rax), %rax
movq (%rax), %rax
movq 0x80(%rax), %rax
cmpl $0x41, 0x20(%rax)
jb 0x2a2598e
movq 0x18(%rax), %rax
jmp 0x2a25992
addq $0x18, %rax
movq (%rax), %rbx
movq %r14, %rdi
callq 0x2a9f76a
movq %rax, %r15
movq %rdx, %rbp
leaq 0x18(%rsp), %rdi
callq 0x29a900e
movl $0x16, 0x28(%rsp)
movb %r13b, 0x2c(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq %r15, 0x30(%rsp)
movq %rbp, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
movq %r14, %rdi
callq 0x2a3b1a0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a60432
movq 0x10(%rsp), %rbx
decl %r12d
jne 0x2a258da
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
movq %r15, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq (%rax), %rcx
leaq 0x25a96fc(%rip), %rsi # 0x4fcf15b
movq %rax, %rdi
callq *0x30(%rcx)
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a25a80
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7800d0
cmpb $0x0, 0xc(%rbx)
movq (%r14), %rax
leaq 0x25a96e0(%rip), %rcx # 0x4fcf16e
leaq 0x25a96e0(%rip), %rsi # 0x4fcf175
cmoveq %rcx, %rsi
movq %r14, %rdi
callq *0x30(%rax)
cmpq $0x0, 0x28(%rbx)
je 0x2a25ac7
movq (%r14), %rax
leaq 0x24ea3e9(%rip), %rsi # 0x4f0fe99
movq %r14, %rdi
callq *0x30(%rax)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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::BasicBlock*, true>::DeletesInserts, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, true>::DeletesInserts>>::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, true>::DeletesInserts>*, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, true>::DeletesInserts>*)
|
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::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
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), %rax
leaq -0x48(,%rax,8), %rax
movabsq $-0x1c71c71c71c71c71, %rdx # imm = 0xE38E38E38E38E38F
mulq %rdx
movq %rdx, %xmm0
shrq $0x6, %rdx
addq $0x2, %rdx
andq $-0x2, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x6, %xmm0
xorl %eax, %eax
movdqa 0x187ed1(%rip), %xmm1 # 0x2bb5020
movdqa 0x187ed9(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rax, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2a2d1a2
movq $-0x1000, (%rcx) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x2a2d1b9
movq $-0x1000, 0x48(%rcx) # imm = 0xF000
addq $0x2, %rax
addq $0x90, %rcx
cmpq %rax, %rdx
jne 0x2a2d15f
cmpq %rbx, %r14
je 0x2a2d291
leaq 0x38(%r14), %r13
movabsq $0x200000000, %r12 # imm = 0x200000000
movq %rbx, 0x8(%rsp)
movq (%r14), %rax
movl $0x1000, %ecx # imm = 0x1000
orq %rcx, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2a2d280
movq %rbp, %rbx
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2a2cdea
movq 0x10(%rsp), %rbp
movq (%r14), %rax
movq %rax, (%rbp)
xorl %r15d, %r15d
leaq (%r15,%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq %r12, -0x8(%rax)
cmpl $0x0, 0x10(%r14,%r15)
je 0x2a2d24b
leaq (%r15,%rbp), %rdi
addq $0x8, %rdi
leaq (%r14,%r15), %rsi
addq $0x8, %rsi
callq 0x1bfd36c
addq $0x20, %r15
cmpq $0x40, %r15
jne 0x2a2d21e
movq %rbx, %rbp
addl $0x2, (%rbx)
xorl %r15d, %r15d
movq 0x8(%rsp), %rbx
movq 0x28(%r14,%r15), %rdi
leaq (%r15,%r13), %rax
cmpq %rdi, %rax
je 0x2a2d276
callq 0x780910
addq $-0x20, %r15
cmpq $-0x40, %r15
jne 0x2a2d263
addq $0x48, %r14
addq $0x48, %r13
cmpq %rbx, %r14
jne 0x2a2d1e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, unsigned int>> const*)
|
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 (!WorkList.empty()) {
const auto [BB, ParentNum] = WorkList.pop_back_val();
auto &BBInfo = NodeToInfo[BB];
BBInfo.ReverseChildren.push_back(ParentNum);
// Visited nodes always have positive DFS numbers.
if (BBInfo.DFSNum != 0) continue;
BBInfo.Parent = ParentNum;
BBInfo.DFSNum = BBInfo.Semi = BBInfo.Label = ++LastNum;
NumToNode.push_back(BB);
constexpr bool Direction = IsReverse != IsPostDom; // XOR.
auto Successors = getChildren<Direction>(BB, BatchUpdates);
if (SuccOrder && Successors.size() > 1)
llvm::sort(
Successors.begin(), Successors.end(), [=](NodePtr A, NodePtr B) {
return SuccOrder->find(A)->second < SuccOrder->find(B)->second;
});
for (const NodePtr Succ : Successors) {
if (!Condition(BB, Succ)) continue;
WorkList.push_back({Succ, LastNum});
}
}
return LastNum;
}
|
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), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
leaq 0x88(%rsp), %r13
leaq 0x38(%rsp), %rsi
movq %r13, %rdi
callq 0x2a2da2e
movq %r12, 0x28(%rsp)
addq $0x210, %r12 # imm = 0x210
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2a2ff0c
movl %r14d, 0xc(%rax)
movl 0x8(%r13), %eax
testl %eax, %eax
je 0x2a2f631
leaq 0x8(%rsp), %r13
movq %r12, 0x20(%rsp)
movq 0x88(%rsp), %rcx
movl %eax, %edx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rsi
movl -0x8(%rcx,%rdx), %ecx
decl %eax
movl %eax, 0x90(%rsp)
movq %rsi, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2a2ff0c
movq %rax, %r14
leaq 0x20(%rax), %rdi
movl 0x10(%rsp), %esi
callq 0x81fb4c
cmpl $0x0, 0x8(%r14)
jne 0x2a2f622
movl 0x10(%rsp), %eax
movl %eax, 0xc(%r14)
incl %ebx
movl %ebx, 0x14(%r14)
movl %ebx, 0x10(%r14)
movl %ebx, 0x8(%r14)
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x93b734
movq 0x8(%rsp), %rsi
movq 0x228(%r14), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2a2fc9c
cmpq $0x0, 0x18(%rsp)
je 0x2a2f5bf
movl 0x40(%rsp), %eax
cmpq $0x2, %rax
jb 0x2a2f5bf
movq 0x38(%rsp), %r14
leaq (%r14,%rax,8), %r12
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %r13
movq %r13, %rcx
callq 0x2a307d0
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2a30897
movl 0x40(%rsp), %r12d
testq %r12, %r12
je 0x2a2f604
movq 0x38(%rsp), %rbp
shlq $0x3, %r12
xorl %r13d, %r13d
movq (%rbp,%r13), %r14
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%r15
testb %al, %al
je 0x2a2f5fb
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1fbb982
addq $0x8, %r13
cmpq %r13, %r12
jne 0x2a2f5d5
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2a2f618
callq 0x780910
movq 0x20(%rsp), %r12
leaq 0x8(%rsp), %r13
movl 0x90(%rsp), %eax
testl %eax, %eax
jne 0x2a2f4e9
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x2a2f64b
callq 0x780910
movl %ebx, %eax
addq $0x498, %rsp # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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>>::InfoRec>>, 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>>::InfoRec>>::erase(llvm::BasicBlock* const&)
|
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), %xmm0
paddd 0x973faa(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/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(%rbx)
movl %eax, 0x8(%r14)
movl 0xc(%rbx), %eax
movl 0xc(%r14), %ecx
movl %ecx, 0xc(%rbx)
movl %eax, 0xc(%r14)
movl 0x10(%rbx), %eax
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rbx)
movl %eax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::DominatorTreeBase<llvm::BasicBlock, false>>::BatchUpdateInfo*, llvm::DomTreeNodeBase<llvm::BasicBlock>*, llvm::DomTreeNodeBase<llvm::BasicBlock>*)::'lambda'(llvm::BasicBlock*, llvm::BasicBlock*)>(llvm::BasicBlock*, unsigned int, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::DeleteReachable(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::BatchUpdateInfo*, llvm::DomTreeNodeBase<llvm::BasicBlock>*, llvm::DomTreeNodeBase<llvm::BasicBlock>*)::'lambda'(llvm::BasicBlock*, llvm::BasicBlock*), unsigned int, llvm::DenseMap<llvm::BasicBlock*, unsigned int, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, unsigned int>> const*)
|
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 (!WorkList.empty()) {
const auto [BB, ParentNum] = WorkList.pop_back_val();
auto &BBInfo = NodeToInfo[BB];
BBInfo.ReverseChildren.push_back(ParentNum);
// Visited nodes always have positive DFS numbers.
if (BBInfo.DFSNum != 0) continue;
BBInfo.Parent = ParentNum;
BBInfo.DFSNum = BBInfo.Semi = BBInfo.Label = ++LastNum;
NumToNode.push_back(BB);
constexpr bool Direction = IsReverse != IsPostDom; // XOR.
auto Successors = getChildren<Direction>(BB, BatchUpdates);
if (SuccOrder && Successors.size() > 1)
llvm::sort(
Successors.begin(), Successors.end(), [=](NodePtr A, NodePtr B) {
return SuccOrder->find(A)->second < SuccOrder->find(B)->second;
});
for (const NodePtr Succ : Successors) {
if (!Condition(BB, Succ)) continue;
WorkList.push_back({Succ, LastNum});
}
}
return LastNum;
}
|
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), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
leaq 0x88(%rsp), %r12
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0x2a2da2e
movq %rbx, 0x28(%rsp)
addq $0x210, %rbx # imm = 0x210
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2a2da94
movl %r15d, 0xc(%rax)
movl 0x8(%r12), %eax
testl %eax, %eax
je 0x2a33eb2
addq $0x18, %r14
leaq 0x10(%rsp), %r12
movq %rbx, 0x20(%rsp)
movq 0x88(%rsp), %rcx
movl %eax, %edx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rsi
movl -0x8(%rcx,%rdx), %ecx
decl %eax
movl %eax, 0x90(%rsp)
movq %rsi, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a2da94
movq %rax, %r15
leaq 0x20(%rax), %rdi
movl 0x18(%rsp), %esi
callq 0x81fb4c
cmpl $0x0, 0x8(%r15)
jne 0x2a33ea3
movl 0x18(%rsp), %eax
movl %eax, 0xc(%r15)
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0x14(%r15)
movl %eax, 0x10(%r15)
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%r15)
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x93b734
movq 0x10(%rsp), %rsi
movq 0x228(%rbx), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2a2da00
cmpq $0x0, 0x4d0(%rsp)
je 0x2a33e3b
movl 0x40(%rsp), %eax
cmpq $0x2, %rax
jb 0x2a33e3b
movq 0x38(%rsp), %r15
leaq (%r15,%rax,8), %r13
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r13, %rsi
movq 0x4d0(%rsp), %rbx
movq %rbx, %rcx
callq 0x2a33fad
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2a34074
movl 0x40(%rsp), %r13d
testq %r13, %r13
je 0x2a33e85
movq 0x38(%rsp), %r12
shlq $0x3, %r13
xorl %ebx, %ebx
movq (%r12,%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb31e60
movq 0x8(%rax), %rax
cmpl %ebp, 0x10(%rax)
jbe 0x2a33e7c
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
callq 0x1fbb982
addq $0x8, %rbx
cmpq %rbx, %r13
jne 0x2a33e50
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2a33e99
callq 0x780910
movq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r12
movl 0x90(%rsp), %eax
testl %eax, %eax
jne 0x2a33d57
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x2a33ecc
callq 0x780910
movl 0xc(%rsp), %eax
addq $0x498, %rsp # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 %esi
movq %rsp, %rdi
movl $0x50, %edx
callq 0x29acace
testb %al, %al
jne 0x2a3adf1
movl 0x20(%r14), %esi
incl %esi
movq %rsp, %rdi
movl $0x4e, %edx
callq 0x29acace
testb %al, %al
jne 0x2a3adf1
movl 0x20(%r14), %esi
incl %esi
movq %rsp, %rdi
movl $0x4f, %edx
callq 0x29acace
testb %al, %al
jne 0x2a3adf1
movl 0x20(%r14), %esi
incl %esi
movq %rsp, %rdi
movl $0x4b, %edx
callq 0x29acace
movl %eax, %ebx
jmp 0x2a3adf1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 %rbx
retq
nop
|
/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->empty() && !F->isMaterializable();
// Aliases and ifuncs are always definitions.
assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
return false;
}
|
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
je 0x2a48093
retq
xorl %ecx, %ecx
testb %dl, %dl
cmoveq %rdi, %rcx
jne 0x2a48033
leaq 0x48(%rcx), %rdx
cmpq %rdx, 0x48(%rcx)
je 0x2a480c6
cmpq $0x0, -0x20(%rdi)
je 0x2a48056
movq -0x18(%rdi), %rax
movq -0x10(%rdi), %rcx
movq %rax, (%rcx)
movq -0x18(%rdi), %rax
testq %rax, %rax
je 0x2a48056
movq -0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
leaq -0x20(%rdi), %rax
movq %rsi, -0x20(%rdi)
movq 0x10(%rsi), %rcx
addq $0x10, %rsi
movq %rcx, -0x18(%rdi)
testq %rcx, %rcx
je 0x2a48077
leaq -0x18(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rsi, -0x10(%rdi)
movq %rax, (%rsi)
retq
xorl %eax, %eax
testb %dl, %dl
cmoveq %rdi, %rax
jne 0x2a48093
leaq 0x48(%rax), %rcx
cmpq %rcx, 0x48(%rax)
je 0x2a480d2
cmpq $0x0, -0x20(%rdi)
je 0x2a480b6
movq -0x18(%rdi), %rax
movq -0x10(%rdi), %rcx
movq %rax, (%rcx)
movq -0x18(%rdi), %rax
testq %rax, %rax
je 0x2a480b6
movq -0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, -0x20(%rdi)
andl $0xf8000000, 0x4(%rdi) # imm = 0xF8000000
retq
testb $0x8, 0x23(%rcx)
sete %cl
jmp 0x2a48001
testb $0x8, 0x23(%rax)
sete %cl
jmp 0x2a48016
|
/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, -0x18(%rdi)
testq %rcx, %rcx
je 0x2a4821e
leaq -0x18(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rsi, -0x10(%rdi)
movq %rax, (%rsi)
retq
|
/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)
return findBaseObject(GA->getOperand(0), Aliases, Op);
}
if (auto *CE = dyn_cast<ConstantExpr>(C)) {
switch (CE->getOpcode()) {
case Instruction::Add: {
auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op);
auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op);
if (LHS && RHS)
return nullptr;
return LHS ? LHS : RHS;
}
case Instruction::Sub: {
if (findBaseObject(CE->getOperand(1), Aliases, Op))
return nullptr;
return findBaseObject(CE->getOperand(0), Aliases, Op);
}
case Instruction::IntToPtr:
case Instruction::PtrToInt:
case Instruction::BitCast:
case Instruction::GetElementPtr:
return findBaseObject(CE->getOperand(0), Aliases, Op);
default:
break;
}
}
return nullptr;
}
|
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)
movb $0x1, %bpl
testq %rcx, %rcx
je 0x2a48499
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2a494d4
cmpb $0x1, 0x10(%r12)
jne 0x2a48499
movq 0x10(%rsp), %rax
movq -0x20(%rax), %rdi
movq %rbx, %rsi
callq 0x2a4841e
movq %rax, %r15
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x2a48554
cmpb $0x5, (%r14)
jne 0x2a48551
movzwl 0x2(%r14), %eax
xorl %r15d, %r15d
cmpl $0x2e, %eax
jg 0x2a484cd
cmpl $0xd, %eax
je 0x2a484ef
cmpl $0xf, %eax
je 0x2a48533
cmpl $0x22, %eax
je 0x2a484d5
jmp 0x2a48554
addl $-0x2f, %eax
cmpl $0x3, %eax
jae 0x2a48554
movl 0x4(%r14), %eax
shll $0x5, %eax
subq %rax, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2a4841e
movq %rax, %r15
jmp 0x2a48554
movl 0x4(%r14), %eax
shll $0x5, %eax
movq %r14, %rcx
subq %rax, %rcx
movq (%rcx), %rdi
movq %rbx, %rsi
callq 0x2a4841e
movq %rax, %r12
movl 0x4(%r14), %eax
shll $0x5, %eax
subq %rax, %r14
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x2a4841e
xorl %r15d, %r15d
testq %rax, %rax
cmoveq %r12, %r15
testq %r12, %r12
cmoveq %rax, %r15
jmp 0x2a48554
movl 0x4(%r14), %eax
shll $0x5, %eax
movq %r14, %rcx
subq %rax, %rcx
movq 0x20(%rcx), %rdi
movq %rbx, %rsi
callq 0x2a4841e
testq %rax, %rax
je 0x2a484d5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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, getInt1(isVolatile)};
Type *Tys[] = { Ptr->getType(), Size->getType() };
Module *M = BB->getParent()->getParent();
Function *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
CallInst *CI = CreateCall(TheFn, Ops);
if (Align)
cast<MemSetInst>(CI)->setDestAlignment(*Align);
// Set the TBAA info if present.
if (TBAATag)
CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
if (ScopeTag)
CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
if (NoAliasTag)
CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
return CI;
}
|
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
xorl %edx, %edx
callq 0x29e3250
movq %rax, 0x28(%rsp)
movq 0x8(%r13), %rax
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rdx)
movq 0x30(%r14), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rdi
movl $0x2, %ecx
movl $0xec, %esi
callq 0x2a43af5
testq %rax, %rax
je 0x2a49e14
movq 0x18(%rax), %r15
movq 0xa0(%rsp), %r12
leaq 0x40(%rsp), %r9
movw $0x101, 0x20(%r9) # imm = 0x101
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rcx
movl $0x4, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9386f2
movq %rax, %r14
btl $0x8, %ebx
jae 0x2a49e5d
movzbl %bl, %esi
movq %r14, %rdi
callq 0x1c88c4a
movq 0xa8(%rsp), %rbx
testq %r12, %r12
je 0x2a49e7a
movq %r14, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x2a7cf4a
movq 0xb0(%rsp), %r15
testq %rbx, %rbx
je 0x2a49e97
movq %r14, %rdi
movl $0x7, %esi
movq %rbx, %rdx
callq 0x2a7cf4a
testq %r15, %r15
je 0x2a49eac
movq %r14, %rdi
movl $0x8, %esi
movq %r15, %rdx
callq 0x2a7cf4a
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 an i64");
Value *Ops[] = { Size, Ptr };
Module *M = BB->getParent()->getParent();
Function *TheFn =
Intrinsic::getDeclaration(M, Intrinsic::lifetime_start, {Ptr->getType()});
return CreateCall(TheFn, Ops);
}
|
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(%rax), %rdi
movq 0x8(%r14), %rax
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, %ecx
movl $0xcd, %esi
callq 0x2a43af5
testq %rax, %rax
je 0x2a4abf5
movq 0x18(%rax), %rsi
jmp 0x2a4abf7
xorl %esi, %esi
leaq 0x20(%rsp), %r9
movw $0x101, 0x20(%r9) # imm = 0x101
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rcx
movl $0x2, %r8d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9386f2
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 *FnGCRelocate =
Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_relocate, Types);
Value *Args[] = {Statepoint, getInt32(BaseOffset), getInt32(DerivedOffset)};
return CreateCall(FnGCRelocate, Args, {}, Name);
}
|
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
movq %rax, %r15
movq %r13, 0x20(%rsp)
movq 0x48(%r14), %rdi
callq 0x2a9aad4
movl %r12d, %esi
xorl %r12d, %r12d
movq %rax, %rdi
xorl %edx, %edx
callq 0x29e3250
movq %rax, 0x28(%rsp)
movq 0x48(%r14), %rdi
callq 0x2a9aad4
movl %ebp, %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x29e3250
movq %rax, 0x30(%rsp)
testq %r15, %r15
je 0x2a4c024
movq 0x18(%r15), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rcx
movl $0x3, %r8d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %r9
callq 0x99fcd0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, %rcx
movq %rax, %r8
callq 0xa8ce9e
movq (%r14), %rcx
leaq 0x20(%rsp), %r14
movq %rcx, (%r14)
movzbl (%r13), %r8d
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x1661c22
movq (%r14), %rsi
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %rax, %rdx
movq %rbx, %rcx
movq 0x60(%rsp), %r8
movq %r15, %r9
callq 0x2a502b2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x3, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x2a5093e
leaq (%r14,%rbx,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a50a00
shlq $0x3, %rbx
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x2a509f9
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x16469c(%rip), %xmm1 # 0x2bb5020
movdqa 0x1646a4(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2a509d8
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x2a509f0
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x2a50994
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 more special handling needed.
if (BB.IsNewDbgInfoFormat && DebugMarker && !Preserve) {
if (I != this->getIterator() || InsertAtHead) {
// "this" is definitely moving in the list, or it's moving ahead of its
// attached DbgVariableRecords. Detach any existing DbgRecords.
handleMarkerRemoval();
}
}
// Move this single instruction. Use the list splice method directly, not
// the block splicer, which will do more debug-info things.
BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
if (BB.IsNewDbgInfoFormat && !Preserve) {
DbgMarker *NextMarker = getParent()->getNextMarker(this);
// If we're inserting at point I, and not in front of the DbgRecords
// attached there, then we should absorb the DbgRecords attached to I.
if (!InsertAtHead && NextMarker && !NextMarker->empty()) {
adoptDbgRecords(&BB, I, false);
}
}
if (isTerminator())
getParent()->flushTerminatorDbgRecords();
}
|
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
setne %cl
orb %r14b, %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2a51585
movq 0x28(%rbx), %rax
cmpb $0x1, 0x28(%rax)
jne 0x2a51585
callq 0x2a23066
leaq 0x30(%r12), %rdi
movq 0x28(%rbx), %rcx
addq $0x30, %rcx
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x2a51676
movb 0x28(%r12), %al
xorb $0x1, %al
orb %bpl, %al
jne 0x2a515ea
movq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x29cb780
testq %rax, %rax
sete %cl
orb %r14b, %cl
testb $0x1, %cl
jne 0x2a515ea
movq %rax, %rcx
addq $0x8, %rcx
cmpq %rcx, 0x8(%rax)
je 0x2a515ea
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x2a51452
movzbl (%rbx), %eax
addl $-0x1e, %eax
cmpl $0xa, %eax
ja 0x2a5160c
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29cb178
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 = cast<clas>(this)->cloneImpl(); \
break;
#include "llvm/IR/Instruction.def"
#undef HANDLE_INST
}
New->SubclassOptionalData = SubclassOptionalData;
New->copyMetadata(*this);
return 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 %cl, 0x1(%r14)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2a53626
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2a5d488
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cdea
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cc46
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c7fe
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cf02
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d030
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cae0
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cb7e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cc00
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cd18
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c6fc
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cf48
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d0f0
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d1b0
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d4f0
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cf8e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c72e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5ce30
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d232
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d314
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d45e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d2c0
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c90e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c93e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c9fc
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d2ea
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d3fc
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5ce76
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d25c
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d28e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c96e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5ca76
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d3cc
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d4ba
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d370
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d42e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cd5e
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d09a
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d146
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5ccd2
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cda4
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cc8c
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5d208
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cfd4
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5c886
jmp 0x2a537c3
movq %rbx, %rdi
callq 0x2a5cebc
jmp 0x2a537c3
|
/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 $0x12, %eax
jne 0x2a53d9c
movq %rsi, %rbx
movq 0x18(%r14), %r15
callq 0x2a9f5fc
movq %rax, %rdi
callq 0x2a9aab6
cmpq %rax, %r15
je 0x2a53db7
leaq 0x2639527(%rip), %rax # 0x508d2c1
jmp 0x2a53e00
callq 0x2a9f5fc
movq %rax, %rdi
callq 0x2a9aab6
cmpq %rax, %r14
je 0x2a53dfe
leaq 0x26395c9(%rip), %rax # 0x508d37e
jmp 0x2a53e00
movq 0x8(%rbx), %rdx
xorl %ecx, %ecx
leaq 0x263952d(%rip), %rax # 0x508d2f1
testq %rdx, %rdx
je 0x2a53dfa
movl $0xfe, %esi
andl 0x8(%rdx), %esi
cmpl $0x12, %esi
jne 0x2a53dfa
cmpb $0x13, 0x8(%rdx)
movl 0x20(%rdx), %eax
sete %dl
cmpl 0x20(%r14), %eax
sete %al
cmpb $0x13, 0x8(%r14)
setne %cl
xorb %dl, %cl
andb %al, %cl
leaq 0x2639529(%rip), %rax # 0x508d323
testb %cl, %cl
je 0x2a53e00
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/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, %rax
je 0x2a54f07
movq 0x70(%rax), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x29ad03c
orl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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))
return Array->getElementType();
if (auto *Vector = dyn_cast<VectorType>(Ty))
return Vector->getElementType();
return nullptr;
}
|
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, %bpl
je 0x2a5789b
movq 0x8(%r14), %rcx
movl $0xfe, %edx
andl 0x8(%rcx), %edx
cmpl $0x12, %edx
jne 0x2a57862
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0xd, 0x8(%rcx)
jne 0x2a57899
movzbl 0x8(%rbx), %ecx
cmpl $0x11, %ecx
setne %sil
testq %rbx, %rbx
sete %dl
orb %sil, %dl
jne 0x2a57882
movq 0x18(%rbx), %rax
testb %dl, %dl
je 0x2a5789b
andl $-0x2, %ecx
cmpl $0x12, %ecx
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
je 0x2a578a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%rbx), %rax
jmp 0x2a5789b
|
/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();
if (ReplicationFactor == 0 || Mask.size() % ReplicationFactor != 0)
return false;
VF = Mask.size() / ReplicationFactor;
return isReplicationMaskWithParams(Mask, ReplicationFactor, VF);
}
// However, if the mask contains undef's, we have to enumerate possible tuples
// and pick one. There are bounds on replication factor: [1, mask size]
// (where RF=1 is an identity shuffle, RF=mask size is a broadcast shuffle)
// Additionally, mask size is a replication factor multiplied by vector size,
// which further significantly reduces the search space.
// Before doing that, let's perform basic correctness checking first.
int Largest = -1;
for (int MaskElt : Mask) {
if (MaskElt == PoisonMaskElem)
continue;
// Elements must be in non-decreasing order.
if (MaskElt < Largest)
return false;
Largest = std::max(Largest, MaskElt);
}
// Prefer larger replication factor if all else equal.
for (int PossibleReplicationFactor :
reverse(seq_inclusive<unsigned>(1, Mask.size()))) {
if (Mask.size() % PossibleReplicationFactor != 0)
continue;
int PossibleVF = Mask.size() / PossibleReplicationFactor;
if (!isReplicationMaskWithParams(Mask, PossibleReplicationFactor,
PossibleVF))
continue;
ReplicationFactor = PossibleReplicationFactor;
VF = PossibleVF;
return true;
}
return false;
}
|
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 (,%r15,4), %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0x3, %esi
movl (%r12,%rdx), %edi
xorl %r8d, %r8d
cmpl %ecx, %edi
setl %r8b
cmpl $-0x1, %edi
cmovel %esi, %r8d
cmpl $0x3, %r8d
je 0x2a58f80
testl %r8d, %r8d
jne 0x2a5912c
cmpl %ecx, %edi
movl %ecx, %r8d
cmovgl %edi, %r8d
cmpl $-0x1, %edi
cmovnel %r8d, %ecx
addq $0x4, %rdx
cmpq %rdx, %rax
jne 0x2a58f5d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
andq %r15, %r14
je 0x2a5912c
movq %rbx, 0x18(%rsp)
movq %r14, %rsi
negq %rsi
shlq $0x20, %r14
xorl %ebx, %ebx
movabsq $-0x100000000, %rdi # imm = 0xFFFFFFFF00000000
movq $0x0, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %r14, %rcx
sarq $0x20, %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbp
movb $0x1, %al
testq %rdx, %rdx
jne 0x2a59034
movq %r15, %rsi
addq %rbx, %r15
movq %r12, %r13
movq %r12, %rdi
movq %rsi, %r12
movl %r15d, %edx
movl %ebp, %ecx
callq 0x2a59142
testb %al, %al
je 0x2a5901d
movq 0x18(%rsp), %rcx
movl %r15d, (%rcx)
movq 0x10(%rsp), %rcx
movl %ebp, (%rcx)
movb $0x1, %cl
movq %rcx, 0x8(%rsp)
xorb $0x1, %al
movq %r12, %r15
movq %r13, %r12
movq 0x20(%rsp), %rsi
movabsq $-0x100000000, %rdi # imm = 0xFFFFFFFF00000000
testb %al, %al
je 0x2a590c1
decq %rbx
addq %rdi, %r14
cmpq %rbx, %rsi
jne 0x2a58fd1
jmp 0x2a5912c
movq %r15, %rdx
sarq $0x2, %rdx
movq %r12, %rax
testq %rdx, %rdx
jle 0x2a59092
movq %r15, %rax
andq $-0x4, %rax
leaq (%r12,%rax,4), %rax
incq %rdx
leaq 0x8(%r12), %rcx
cmpl $0x0, -0x8(%rcx)
jne 0x2a590c8
cmpl $0x0, -0x4(%rcx)
jne 0x2a590ce
cmpl $0x0, (%rcx)
jne 0x2a590e9
cmpl $0x0, 0x4(%rcx)
jne 0x2a590d4
decq %rdx
addq $0x10, %rcx
cmpq $0x1, %rdx
jg 0x2a5906e
movq %r13, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq $0x1, %rcx
je 0x2a590de
cmpq $0x2, %rcx
je 0x2a590b7
cmpq $0x3, %rcx
jne 0x2a590e6
cmpl $0x0, (%rax)
jne 0x2a590bc
addq $0x4, %rax
cmpl $0x0, (%rax)
je 0x2a590da
movq %rax, %rcx
jmp 0x2a590e9
movq 0x8(%rsp), %rcx
jmp 0x2a5912e
addq $-0x8, %rcx
jmp 0x2a590e9
addq $-0x4, %rcx
jmp 0x2a590e9
addq $0x4, %rcx
jmp 0x2a590e9
addq $0x4, %rax
cmpl $0x0, (%rax)
movq %rax, %rcx
jne 0x2a590e9
movq %r13, %rcx
subq %r12, %rcx
shrq $0x2, %rcx
movl %ecx, (%rbx)
testl %ecx, %ecx
je 0x2a5912c
movslq %ecx, %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
xorl %ecx, %ecx
testq %rdx, %rdx
jne 0x2a5912e
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl (%rbx), %edx
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a59142
xorl %ecx, %ecx
andb $0x1, %cl
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 = 2, E = SI.getNumOperands(); i != E; i += 2) {
OL[i] = InOL[i];
OL[i+1] = InOL[i+1];
}
SubclassOptionalData = SI.SubclassOptionalData;
}
|
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 = 0x7FFFFFF
andl 0x4(%r14), %ecx
movq %rbx, %rdi
callq 0x2a5ba58
movl 0x4(%r14), %ecx
andl $0x7ffffff, %ecx # imm = 0x7FFFFFF
movl 0x4(%rbx), %eax
movl %eax, %edx
andl $0xf8000000, %edx # imm = 0xF8000000
orl %ecx, %edx
movl %edx, 0x4(%rbx)
btl $0x1e, %eax
jb 0x2a5bc17
shll $0x5, %ecx
movq %rbx, %rax
subq %rcx, %rax
jmp 0x2a5bc1b
movq -0x8(%rbx), %rax
movl 0x4(%r14), %ecx
btl $0x1e, %ecx
jb 0x2a5bc32
movl %ecx, %esi
shll $0x5, %esi
movq %r14, %rdx
subq %rsi, %rdx
jmp 0x2a5bc36
movq -0x8(%r14), %rdx
andl $0x7ffffff, %ecx # imm = 0x7FFFFFF
cmpl $0x2, %ecx
je 0x2a5bd0a
movl $0x2, %esi
movl %esi, %r9d
shlq $0x5, %r9
leaq (%rax,%r9), %rdi
movq (%rdx,%r9), %r8
cmpq $0x0, (%rax,%r9)
je 0x2a5bc7c
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %r10
movq %r9, (%r10)
movq 0x8(%rdi), %r9
testq %r9, %r9
je 0x2a5bc7c
movq 0x10(%rdi), %r10
movq %r10, 0x10(%r9)
movq %r8, (%rdi)
testq %r8, %r8
je 0x2a5bca4
movq 0x10(%r8), %r9
movq %r9, 0x8(%rdi)
testq %r9, %r9
je 0x2a5bc99
leaq 0x8(%rdi), %r10
movq %r10, 0x10(%r9)
addq $0x10, %r8
movq %r8, 0x10(%rdi)
movq %rdi, (%r8)
leal 0x1(%rsi), %r9d
shlq $0x5, %r9
leaq (%rax,%r9), %rdi
movq (%rdx,%r9), %r8
cmpq $0x0, (%rax,%r9)
je 0x2a5bcd7
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %r10
movq %r9, (%r10)
movq 0x8(%rdi), %r9
testq %r9, %r9
je 0x2a5bcd7
movq 0x10(%rdi), %r10
movq %r10, 0x10(%r9)
movq %r8, (%rdi)
testq %r8, %r8
je 0x2a5bcff
movq 0x10(%r8), %r9
movq %r9, 0x8(%rdi)
testq %r9, %r9
je 0x2a5bcf4
leaq 0x8(%rdi), %r10
movq %r10, 0x10(%r9)
addq $0x10, %r8
movq %r8, 0x10(%rdi)
movq %rdi, (%r8)
addl $0x2, %esi
cmpl %esi, %ecx
jne 0x2a5bc4a
movb 0x1(%r14), %al
andb $-0x2, %al
movb 0x1(%rbx), %cl
andb $0x1, %cl
orb %al, %cl
movb %cl, 0x1(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/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) {
OL[2 + idx * 2] = OL[NumOps - 2];
OL[2 + idx * 2 + 1] = OL[NumOps - 1];
}
// Nuke the last value.
OL[NumOps-2].set(nullptr);
OL[NumOps-2+1].set(nullptr);
setNumHungOffUseOperands(NumOps-2);
return CaseIt(this, idx);
}
|
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), %r9d
shlq $0x5, %r9
leal 0x2(%rdi), %r10d
shlq $0x5, %r10
leaq (%rsi,%r10), %r8
movq (%rsi,%r9), %r9
cmpq $0x0, (%rsi,%r10)
je 0x2a5be4e
movq 0x8(%r8), %r10
movq 0x10(%r8), %r11
movq %r10, (%r11)
movq 0x8(%r8), %r10
testq %r10, %r10
je 0x2a5be4e
movq 0x10(%r8), %r11
movq %r11, 0x10(%r10)
movq %r9, (%r8)
testq %r9, %r9
je 0x2a5be76
movq 0x10(%r9), %r10
addq $0x10, %r9
movq %r10, 0x8(%r8)
testq %r10, %r10
je 0x2a5be6f
leaq 0x8(%r8), %r11
movq %r11, 0x10(%r10)
movq %r9, 0x10(%r8)
movq %r8, (%r9)
leal -0x1(%rcx), %r9d
shlq $0x5, %r9
addl $0x3, %edi
shlq $0x5, %rdi
leaq (%rsi,%rdi), %r8
movq (%rsi,%r9), %r9
cmpq $0x0, (%rsi,%rdi)
je 0x2a5beb0
movq 0x8(%r8), %rdi
movq 0x10(%r8), %r10
movq %rdi, (%r10)
movq 0x8(%r8), %rdi
testq %rdi, %rdi
je 0x2a5beb0
movq 0x10(%r8), %r10
movq %r10, 0x10(%rdi)
movq %r9, (%r8)
testq %r9, %r9
je 0x2a5bed8
movq 0x10(%r9), %rdi
addq $0x10, %r9
movq %rdi, 0x8(%r8)
testq %rdi, %rdi
je 0x2a5bed1
leaq 0x8(%r8), %r10
movq %r10, 0x10(%rdi)
movq %r9, 0x10(%r8)
movq %r8, (%r9)
leal -0x2(%rcx), %edi
movq %rdi, %r9
shlq $0x5, %r9
leaq (%rsi,%r9), %r8
cmpq $0x0, (%rsi,%r9)
je 0x2a5bf09
movq 0x8(%r8), %r9
movq 0x10(%r8), %r10
movq %r9, (%r10)
movq 0x8(%r8), %r9
testq %r9, %r9
je 0x2a5bf09
movq 0x10(%r8), %r10
movq %r10, 0x10(%r9)
movq $0x0, (%r8)
leal -0x1(%rcx), %r8d
shlq $0x5, %r8
leaq (%rsi,%r8), %rcx
cmpq $0x0, (%rsi,%r8)
je 0x2a5bf3f
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %r8
movq %rsi, (%r8)
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x2a5bf3f
movq 0x10(%rcx), %r8
movq %r8, 0x10(%rsi)
movq $0x0, (%rcx)
andl $0x7ffffff, %edi # imm = 0x7FFFFFF
movl $0xf8000000, %ecx # imm = 0xF8000000
andl 0x4(%rax), %ecx
orl %edi, %ecx
movl %ecx, 0x4(%rax)
movl %edx, %edx
retq
|
/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, %rax
addq $-0x8, %rcx
jne 0x2a64500
retq
movq %r8, %rax
retq
|
/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>>>>, 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>>>>::clear()
|
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;
}
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
if (std::is_trivially_destructible<ValueT>::value) {
// Use a simpler loop when values don't need destruction.
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
P->getFirst() = EmptyKey;
} else {
unsigned NumEntries = getNumEntries();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey)) {
if (!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
P->getSecond().~ValueT();
--NumEntries;
}
P->getFirst() = EmptyKey;
}
}
assert(NumEntries == 0 && "Node count imbalance!");
(void)NumEntries;
}
setNumEntries(0);
setNumTombstones(0);
}
|
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 %r15, %r15
je 0x2a64d9c
movq (%rbx), %r14
shlq $0x4, %r15
addq $0x8, %r14
movq -0x8(%r14), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x2a64d8a
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2a64d92
movq %r14, %rdi
callq 0x29ed544
movq $-0x1000, -0x8(%r14) # imm = 0xF000
addq $0x10, %r14
addq $-0x10, %r15
jne 0x2a64d6e
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/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 $0x8, %edx
orl %ecx, %edx
movl %edx, %eax
shrl $0x10, %eax
orl %edx, %eax
incl %eax
jmp 0x2a661ae
xorl %eax, %eax
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x2a661d5
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x29eadf4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
nop
|
/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,
get_hashable_data(*first)))
++first;
if (first == last)
return hash_short(buffer, buffer_ptr - buffer, seed);
assert(buffer_ptr == buffer_end);
hash_state state = state.create(buffer, seed);
size_t length = 64;
while (first != last) {
// Fill up the buffer. We don't clear it, which re-mixes the last round
// when only a partial 64-byte chunk is left.
buffer_ptr = buffer;
while (first != last && store_and_advance(buffer_ptr, buffer_end,
get_hashable_data(*first)))
++first;
// Rotate the buffer if we did a partial fill in order to simulate doing
// a mix of the last 64-bytes. That is how the algorithm works when we
// have a contiguous byte sequence, and we want to emulate that here.
std::rotate(buffer, buffer_ptr, buffer_end);
// Mix this chunk into the current state.
state.mix(buffer);
length += buffer_ptr - buffer;
};
return state.finalize(length);
}
|
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
addq $0x8, %r14
leaq (%rsp,%rcx), %rsi
movq %rcx, %rdx
cmpq %rbx, %r14
sete %al
jne 0x2a68590
jmp 0x2a685bf
leaq (%rsp,%rcx), %rsi
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
testb $0x1, %al
je 0x2a685dd
movq %rsp, %rdi
subq %rdi, %rsi
callq 0xa8cfe6
jmp 0x2a686b2
leaq 0x40(%rsp), %rdi
movq $0x0, (%rdi)
movq %rdx, 0x8(%rdi)
movabsq $0x75c285c0667d5866, %rax # imm = 0x75C285C0667D5866
movq %rax, 0x10(%rdi)
movabsq $-0x7323d61940a0da1f, %rax # imm = 0x8CDC29E6BF5F25E1
movq %rax, 0x18(%rdi)
movabsq $-0x409daf76c3bff5e9, %rax # imm = 0xBF6250893C400A17
movq %rax, 0x20(%rdi)
addq $-0x11a5f, %rdx # imm = 0xFFFEE5A1
movq %rdx, 0x28(%rdi)
movabsq $-0x85335acd9bb6c6a, %rax # imm = 0xF7ACCA5326449396
movq %rax, 0x30(%rdi)
movq %rsp, %r13
movq %r13, %rsi
callq 0xa8cd7e
movl $0x40, %r12d
cmpq %rbx, %r14
je 0x2a686a5
leaq 0x40(%rsp), %rbp
movq %r13, %r15
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x38, %rcx
jg 0x2a68663
leaq 0x8(%rcx), %rax
movq (%r14), %rdx
movq %rdx, (%r15)
cmpq $0x38, %rcx
jg 0x2a6867b
addq $0x8, %r14
leaq (%rsp,%rax), %r15
movq %rax, %rcx
cmpq %rbx, %r14
jne 0x2a68653
jmp 0x2a6867f
leaq (%rsp,%rax), %r15
movq %r13, %rdi
movq %r15, %rsi
leaq 0x40(%rsp), %rdx
callq 0xa8d301
movq %rbp, %rdi
movq %r13, %rsi
callq 0xa8cd7e
subq %r13, %r12
addq %r15, %r12
cmpq %rbx, %r14
jne 0x2a6864b
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0xa8d246
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
jmp 0x2a6c008
nop
|
/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 *> &AuxConsts = Entry.second;
if (!AuxConsts.empty()) {
SmallVector<Metadata *, 1> AuxMDs;
AuxMDs.reserve(AuxConsts.size());
for (Constant *C : AuxConsts)
AuxMDs.push_back(createConstant(C));
Ops.push_back(MDNode::get(Context, AuxMDs));
}
}
return MDNode::get(Context, Ops);
}
|
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
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %r15
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r13
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%r12), %rdi
callq 0x2a76bb8
movq %rbx, %rdi
movq %rax, %rsi
callq 0xafc6b4
movl 0x18(%r14), %edx
testq %rdx, %rdx
je 0x2a72a09
movq %r12, %rbx
movq %r15, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
cmpl $0x1, %edx
je 0x2a72999
movl $0x8, %ecx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2b4ed86
movl 0x18(%r14), %r15d
testq %r15, %r15
je 0x2a729c9
movq 0x10(%r14), %r12
shlq $0x3, %r15
xorl %ebp, %ebp
movq (%r12,%rbp), %rdi
callq 0x2a75606
movq %r13, %rdi
movq %rax, %rsi
callq 0xafc6b4
addq $0x8, %rbp
cmpq %rbp, %r15
jne 0x2a729ac
movq %rbx, %r12
movq (%rbx), %rdi
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2a7a9c2
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xafc6b4
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0x2a72a09
callq 0x780910
addq $0x50, %r14
cmpq 0x20(%rsp), %r14
jne 0x2a72945
movq (%r12), %rdi
movq 0x28(%rsp), %rsi
movl 0x30(%rsp), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2a7a9c2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2a72a49
callq 0x780910
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, Offset));
auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
if (IsImmutable) {
auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
ImmutabilityFlagNode});
}
return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
}
|
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 0x2a75606
movq %rax, %r12
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x29e3250
movq %rax, %rdi
callq 0x2a75606
movq %rax, %rbx
testl %ebp, %ebp
je 0x2a7317d
movl $0x1, %esi
movq %r13, %rdi
xorl %edx, %edx
callq 0x29e3250
movq %rax, %rdi
callq 0x2a75606
movq (%r15), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movq %rbx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movl $0x5, %edx
jmp 0x2a7319e
movq (%r15), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movq %rbx, 0x18(%rsi)
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2a7a9c2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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.