name string | code string | asm string | file string |
|---|---|---|---|
upgradeMaskedCompare(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::CallBase&, unsigned int, bool) | static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallBase &CI,
unsigned CC, bool Signed) {
Value *Op0 = CI.getArgOperand(0);
unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements();
Value *Cmp;
if (CC == 3) {
Cmp = Constant::getNullValue(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %edx
shll $0x5, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movq (%rdi), %rdx
movq 0x8(%rdx), %rsi
movl 0x20(%rsi), %ebp
movl %eax, %eax
leaq 0x1514f4(%rip), %rsi # 0x3702bc
movslq (%rsi,%rax,4), %ra... | /IR/AutoUpgrade.cpp |
upgradeX86PSLLDQIntrinsics(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Value*, unsigned int) | static Value *upgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder, Value *Op,
unsigned Shift) {
auto *ResultTy = cast<FixedVectorType>(Op->getType());
unsigned NumElts = ResultTy->getNumElements() * 8;
// Bitcast from a 64-bit element type to a byte element type.
Type *VecT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rax), %ebp
shll $0x3, %ebp
movq 0x48(%rdi), %rdi
callq 0x26fd84
movq %rax, %rdi
movl %ebp, %esi
callq 0x... | /IR/AutoUpgrade.cpp |
upgradeAVX512MaskToSelect(llvm::StringRef, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::CallBase&, llvm::Value*&) | static bool upgradeAVX512MaskToSelect(StringRef Name, IRBuilder<> &Builder,
CallBase &CI, Value *&Rep) {
Name = Name.substr(12); // Remove avx512.mask.
unsigned VecWidth = CI.getType()->getPrimitiveSizeInBits();
unsigned EltWidth = CI.getType()->getScalarSizeInBits();
Intr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, %r15
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
cmpq $0xc, %rsi
movl $0xc, %eax
cmovbq %rsi, %rax
movq %rdi, %r13
addq %rax, %r13
subq %rax, %r14
movq 0x8(%rcx), %rdi
callq 0x26faea
leaq 0x20(%rsp), %rdi
movq %... | /IR/AutoUpgrade.cpp |
llvm::CallBase::setCalledOperand(llvm::Value*) | static Use &OpFrom(const U *that) {
return Idx < 0
? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
: OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];
} | leaq -0x20(%rdi), %rax
cmpq $0x0, -0x20(%rdi)
je 0x2214cf
movq -0x18(%rdi), %rcx
movq -0x10(%rdi), %rdx
movq %rcx, (%rdx)
movq -0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x2214cf
movq -0x10(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rsi, (%rax)
testq %rsi, %rsi
je 0x2214f7
movq 0x10(%rsi), %rcx
addq $0x10, %rsi
movq %rcx, -0x1... | /llvm/IR/User.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [50], llvm::cl::OptionHidden, llvm::cl::LocationClass<bool>, llvm::cl::initializer<bool>>(char const (&) [50], llvm::cl::OptionHidden const&, llvm::cl::LocationClass<bool> const&, llvm::cl::initializer<bool> 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 0xa30d0
movq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0x299bb7(%rip), %rax # 0x4bb658
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x299d0d(%ri... | /llvm/Support/CommandLine.h |
llvm::BasicBlock::createMarker(llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::BasicBlock>, false, false>) | void BasicBlock::dropAllReferences() {
for (Instruction &I : *this)
I.dropAllReferences();
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x30(%rdi), %rax
cmpq %rsi, %rax
je 0x221b95
leaq -0x18(%rsi), %r14
testq %rsi, %rsi
cmoveq %rsi, %r14
movq 0x40(%r14), %rbx
testq %rbx, %rbx
jne 0x221be2
movl $0x18, %edi
callq 0x8b140
movq %rax, %rbx
addq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x8(%rbx)
mov... | /IR/BasicBlock.cpp |
llvm::BasicBlock::getFirstNonPHI() const | const Instruction* BasicBlock::getFirstNonPHI() const {
for (const Instruction &I : *this)
if (!isa<PHINode>(I))
return &I;
return nullptr;
} | movq 0x38(%rdi), %rcx
addq $0x30, %rdi
cmpq %rdi, %rcx
je 0x222401
movq %rax, %rdx
leaq -0x18(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
cmpb $0x54, (%rax)
cmoveq %rdx, %rax
jne 0x222403
movq 0x8(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x2223e1
xorl %eax, %eax
retq
| /IR/BasicBlock.cpp |
llvm::BasicBlock::getUniquePredecessor() const | const_user_iterator materialized_user_begin() const {
return const_user_iterator(UseList);
} | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2224ef
movq 0x18(%rax), %rcx
movb (%rcx), %cl
cmpb $0x1d, %cl
setae %dl
movzbl %cl, %ecx
addl $-0x1e, %ecx
cmpl $0xb, %ecx
setb %cl
testb %cl, %dl
jne 0x2224ef
movq 0x8(%rax), %rax
jmp 0x2224c8
testq %rax, %rax
je 0x222561
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
testq %rcx... | /llvm/IR/Value.h |
llvm::SmallDenseMap<llvm::BasicBlock*, llvm::DbgMarker*, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DbgMarker*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x222a51
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 %e... | /llvm/ADT/DenseMap.h |
llvm::ConstantRange::intersectWith(llvm::ConstantRange const&, llvm::ConstantRange::PreferredRangeType) const | ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
PreferredRangeType Type) const {
assert(getBitWidth() == CR.getBitWidth() &&
"ConstantRange types don't agree!");
// Handle common cases.
if ( isEmptySet() || CR.isFullSet()) return *this;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, 0x14(%rsp)
movq %rdx, %r15
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
movq %r15, %r12
movq %rsi, %r15
movq %rsi, %rdi
callq 0x22303c
testb %al, %al
jne 0x22322a
movq %r12, %rdi
callq 0x2230e6
testb %al, %al
jne 0x22322a
movq %r12, %... | /IR/ConstantRange.cpp |
llvm::APInt::ashr(llvm::APInt const&) const | APInt ashr(const APInt &ShiftAmt) const {
APInt R(*this);
R.ashrInPlace(ShiftAmt);
return R;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
cmpl $0x40, %eax
ja 0x223831
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x223839
movq %rbx, %rdi
callq 0xcb252
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcc242
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
no... | /llvm/ADT/APInt.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [40], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [40], llvm::cl::initializer<bool> 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0xa30d0
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x29750b(... | /llvm/Support/CommandLine.h |
llvm::Constant::isConstantUsed() const | bool Constant::isConstantUsed() const {
for (const User *U : users()) {
const Constant *UC = dyn_cast<Constant>(U);
if (!UC || isa<GlobalValue>(UC))
return true;
if (UC->isConstantUsed())
return true;
}
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r14
testq %r14, %r14
setne %bl
je 0x225927
movq 0x18(%r14), %rdi
cmpb $0x15, (%rdi)
ja 0x225927
cmpb $0x4, (%rdi)
jb 0x225927
callq 0x2258fa
testb %al, %al
jne 0x225927
movq 0x8(%r14), %r14
jmp 0x225902
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14... | /IR/Constants.cpp |
llvm::UndefValue::getSequentialElement() const | UndefValue *UndefValue::getSequentialElement() const {
if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
return UndefValue::get(ATy->getElementType());
return UndefValue::get(cast<VectorType>(getType())->getElementType());
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
cmpb $0x11, 0x8(%rcx)
setne %al
testq %rcx, %rcx
sete %bpl
orb %al, %bpl
jne 0x226172
movq 0x18(%rcx), %rdi
callq 0x225a64
testb %bpl, %bpl
je 0x22618a
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x225a64
addq $... | /IR/Constants.cpp |
llvm::Constant* getSequenceIfElementsMatch<llvm::ConstantDataVector>(llvm::Constant*, llvm::ArrayRef<llvm::Constant*>) | static Constant *getSequenceIfElementsMatch(Constant *C,
ArrayRef<Constant *> V) {
// We speculatively build the elements here even if it turns out that there is
// a constantexpr or something else weird, since it is so uncommon for that to
// happen.
if (ConstantInt ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x12, %eax
je 0x226dcb
cmpl $0x11, %eax
jne 0x22713b
movq 0x8(%rbx), %rdi
movl $0x8, %esi
callq 0x26f764
testb %al, %al
je 0x226e09
leaq 0x30(%rsp), %r13
movq %r13... | /IR/Constants.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, std::unique_ptr<llvm::PoisonValue, std::default_delete<llvm::PoisonValue>>, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, std::unique_ptr<llvm::PoisonValue, std::default_delete<llvm::PoisonValue>>>>, llvm::Type*, std::unique_ptr<llvm::Poiso... | 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 0x23009a
movl %eax, %ebp
testb %al, %al
je 0x227f32
movq 0x8(%rsp), %r14
leaq 0x8(%r14), %rdi
callq 0x23006c
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x1171e3(%rip), %xmm0 # 0x33f110
movq %xmm0,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*>>, llvm::GlobalValue const*, llvm::DSOLocalEquivalent*, llvm::DenseMapInfo<llvm::GlobalValue const*, v... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x23082c
testb %al, %al
je 0x2283ca
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x116d4b(%rip), %xmm0 # 0x33f110
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::ConstantUniqueMap<llvm::ConstantPtrAuth>::getOrCreate(llvm::Type*, llvm::ConstantPtrAuthKeyType) | ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
LookupKey Key(Ty, V);
/// Hash once, and reuse it for the lookup and the insertion if needed.
LookupKeyHashed Lookup(MapInfo::getHashValue(Key), Key);
ConstantClass *Result = nullptr;
auto I = Map.find_as(Lookup);
if (I == Map.end())
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x28(%rsp), %r13
movq %rsi, (%r13)
movq %rdx, 0x8(%r13)
movq %rcx, 0x10(%r13)
movq %r13, %rdi
callq 0x230fcc
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movups (%r13), %xmm0
movups %xm... | /IR/ConstantsContext.h |
llvm::ConstantExpr::isSupportedCastOp(unsigned int) | bool ConstantExpr::isSupportedCastOp(unsigned Opcode) {
switch (Opcode) {
case Instruction::ZExt:
case Instruction::SExt:
case Instruction::FPTrunc:
case Instruction::FPExt:
case Instruction::UIToFP:
case Instruction::SIToFP:
case Instruction::FPToUI:
case Instruction::FPToSI:
return false;
case... | addl $-0x2f, %edi
cmpl $-0x8, %edi
setb %al
retq
| /IR/Constants.cpp |
llvm::StringMap<std::unique_ptr<llvm::ConstantDataSequential, std::default_delete<llvm::ConstantDataSequential>>, llvm::MallocAllocator>::erase(llvm::StringMapIterator<std::unique_ptr<llvm::ConstantDataSequential, std::default_delete<llvm::ConstantDataSequential>>>) | StringMapEntry<ValueTy> &operator*() const {
return *static_cast<StringMapEntry<ValueTy> *>(*this->Ptr);
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rbx
movq %rbx, %rsi
callq 0xa78d6
movq (%rbx), %r14
addq $0x11, %r14
leaq 0x8(%rbx), %rdi
callq 0x22acec
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa6092
| /llvm/ADT/StringMap.h |
llvm::Constant::handleOperandChange(llvm::Value*, llvm::Value*) | void Constant::handleOperandChange(Value *From, Value *To) {
Value *Replacement = nullptr;
switch (getValueID()) {
default:
llvm_unreachable("Not a constant!");
#define HANDLE_CONSTANT(Name) \
case Value::Name##Val: ... | pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
leaq 0x148bd0(%rip), %rcx # 0x372a28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x256c96
jmp 0x229eb9
movq %rbx, %rdi
callq 0x22a346
jmp 0x229eb9
movq %rbx, %rdi
callq 0x228146
jmp 0x229eb9
movq %rbx, %rdi
callq 0x229fe8
jmp 0x229eb9
mov... | /IR/Constants.cpp |
llvm::SmallPtrSetImpl<llvm::Constant const*>::insert(llvm::Constant const*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xa1880
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0x22ada1
cmpq $-0x2, (%rax)
jb 0x22ada1
addq $0x8, %rax
cmpq %rcx, %rax... | /llvm/ADT/SmallPtrSet.h |
llvm::DenseMap<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>>>, unsigned int, std::unique_ptr<llvm::C... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x22b690
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
neg... | /llvm/ADT/DenseMap.h |
llvm::DenseMapInfo<llvm::APInt, void>::isEqual(llvm::APInt const&, llvm::APInt const&) | unsigned getBitWidth() const { return BitWidth; } | movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x22b8df
cmpl $0x40, %eax
ja 0xcb8d6
movq (%rdi), %rax
cmpq (%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
| /llvm/ADT/APInt.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::ElementCount, llvm::APInt>, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>, llvm::DenseMapInfo<std::pair<llvm::ElementCount, llvm::APInt>, void>, llvm::detail::DenseMapPair<std::pair<llvm::ElementCount, llvm::APInt>, std::unique_ptr<llvm::Con... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x22bef6
movabsq $0x1ffffffff, %rax # imm = 0x1FFFFFFFF
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, 0x28(%rsp)
movq $-0x1, 0x20(%rsp)
movl $0xfffffffe, %ecx # imm = 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<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>>>>, llvm::APFloat, std::unique_ptr<llvm::C... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
callq 0xc24ec
leaq 0x8(%rsp), %rdx
movq $0x1, (%rdx)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22c26e
movl 0x10(%r14), %eax
testq %rax, %rax
je 0x22c442
movq (%r14), %r14
shlq $0x3, %rax
leaq (%rax,%rax,4), %r15
a... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::ElementCount, llvm::APFloat>, std::unique_ptr<llvm::ConstantFP, std::default_delete<llvm::ConstantFP>>, llvm::DenseMapInfo<std::pair<llvm::ElementCount, llvm::APFloat>, void>, llvm::detail::DenseMapPair<std::pair<llvm::ElementCount, llvm::APFloat>, std::unique_ptr<llvm:... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x22c944
leaq 0x30(%rsp), %rdi
callq 0x22c75c
leaq 0x8(%rsp), %rdi
callq 0x22c7b4
cmpq %rbx, %r14
je 0x22ca92
movq %rsp, %rbp
xorl %r13d, %r13d
movl (%r14), %eax
cmpl 0x30(%rsp), %eax... | /llvm/ADT/DenseMap.h |
llvm::ConstantAggrKeyType<llvm::ConstantArray>::operator==(llvm::ConstantArray const*) const | size_t size() const { return Length; } | movq 0x8(%rdi), %rcx
movl 0x4(%rsi), %r8d
andl $0x7ffffff, %r8d # imm = 0x7FFFFFF
cmpq %r8, %rcx
jne 0x22cf9f
testl %ecx, %ecx
sete %al
je 0x22cf9e
movq (%rdi), %rdx
movl %r8d, %edi
shll $0x5, %edi
movq %rsi, %r9
subq %rdi, %r9
movq (%rdx), %rdi
cmpq (%r9), %rdi
je 0x22cfa2
retq
xorl %eax, %eax
retq
shll $0x5, %... | /llvm/ADT/ArrayRef.h |
llvm::DenseMap<llvm::ConstantStruct*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantStruct>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantStruct*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::VectorType*, unsigned int>(unsigned long, char*, char*, llvm::VectorType* const&, unsigned int 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movq (%r8), %r8
movq %r12, %rsi
callq 0x22df1e
movq (%r12), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, (%r12)
movl (%r14), %r8d
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
mo... | /llvm/ADT/Hashing.h |
llvm::detail::DenseMapPair<llvm::PointerType*, std::unique_ptr<llvm::ConstantPointerNull, std::default_delete<llvm::ConstantPointerNull>>>* llvm::DenseMapBase<llvm::DenseMap<llvm::PointerType*, std::unique_ptr<llvm::ConstantPointerNull, std::default_delete<llvm::ConstantPointerNull>>, llvm::DenseMapInfo<llvm::PointerTy... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x22f4ed
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::Type*, std::unique_ptr<llvm::UndefValue, std::default_delete<llvm::UndefValue>>>* llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, std::unique_ptr<llvm::UndefValue, std::default_delete<llvm::UndefValue>>, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, std::... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x22fd61
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, std::unique_ptr<llvm::PoisonValue, std::default_delete<llvm::PoisonValue>>, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, std::unique_ptr<llvm::PoisonValue, std::default_delete<llvm::PoisonValue>>>>, llvm::Type*, std::unique_ptr<llvm::Poiso... | 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 0x23009a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x230170
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x23017a
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Function const*, llvm::BasicBlock const*>, llvm::BlockAddress*, llvm::DenseMapInfo<std::pair<llvm::Function const*, llvm::BasicBlock const*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Function const*, llvm::BasicBlock const*>, llvm::BlockAddress*>>, std::pair<ll... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x230760
movq (%r15), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*>>, llvm::GlobalValue const*, llvm::DSOLocalEquivalent*, llvm::DenseMapInfo<llvm::GlobalValue const*, v... | 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 0x23082c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x230822
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2308be
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::DSOLocalEquivalent*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::ConstantPtrAuth*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantPtrAuth>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantPtrAuth*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::ConstantUniqueMap<llvm::ConstantExpr>::MapInfo::getHashValue(std::pair<llvm::Type*, llvm::ConstantExprKeyType> const&) | static unsigned getHashValue(const LookupKey &Val) {
return hash_combine(Val.first, Val.second.getHash());
} | pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x2318f8
leaq 0xc(%rsp), %r9
movl %eax, (%r9)
leaq 0x50(%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, -0x4... | /IR/ConstantsContext.h |
llvm::ConstantExprKeyType::operator==(llvm::ConstantExpr const*) const | bool operator==(const ConstantExpr *CE) const {
if (Opcode != CE->getOpcode())
return false;
if (SubclassOptionalData != CE->getRawSubclassOptionalData())
return false;
if (Ops.size() != CE->getNumOperands())
return false;
for (unsigned I = 0, E = Ops.size(); I != E; ++I)
if (Ops... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movzbl (%rdi), %eax
movzwl 0x2(%rsi), %ebp
cmpw %ax, %bp
jne 0x231d98
movq %rsi, %r14
movq %rdi, %rbx
movb 0x1(%rsi), %al
shrb %al
cmpb 0x1(%rdi), %al
jne 0x231d98
movq 0x10(%rbx), %rax
movl 0x4(%r14), %edx
andl $0x7ffffff, %edx # imm = 0x7FFFFFF
cmpq %rdx, %rax
... | /IR/ConstantsContext.h |
llvm::DataLayout::reset(llvm::StringRef) | void DataLayout::reset(StringRef Desc) {
clear();
LayoutMap = nullptr;
BigEndian = false;
AllocaAddrSpace = 0;
StackNaturalAlign.reset();
ProgramAddrSpace = 0;
DefaultGlobalsAddrSpace = 0;
FunctionPtrAlign.reset();
TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
ManglingMode = MM_None;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x23412c
movq $0x0, 0x188(%r15)
movb $0x0, (%r15)
movl $0x0, 0x4(%r15)
cmpb $0x1, 0x9(%r15)
jne 0x234023
movb $0x0, 0x9(%r15)
movq $0x0, 0xc(%r15)
cmpb $0x1, 0x15(%r15)
jne 0x234037
m... | /IR/DataLayout.cpp |
llvm::DataLayout::parse(llvm::StringRef) | Expected<DataLayout> DataLayout::parse(StringRef LayoutDescription) {
DataLayout Layout("");
if (Error Err = Layout.parseSpecifier(LayoutDescription))
return std::move(Err);
return Layout;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1b6006(%rip), %rsi # 0x3eb126
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x23518c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %... | /IR/DataLayout.cpp |
llvm::DenseMap<llvm::StructType*, llvm::StructLayout*, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, llvm::StructLayout*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::PointerAlignElem* llvm::SmallVectorImpl<llvm::PointerAlignElem>::insert_one_impl<llvm::PointerAlignElem>(llvm::PointerAlignElem*, llvm::PointerAlignElem&&) | iterator insert_one_impl(iterator I, ArgType &&Elt) {
// Callers ensure that ArgType is derived from T.
static_assert(
std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
T>::value,
"ArgType must be derived from T!");
if (I == this->end()) { // Importan... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x8(%rdi), %edx
movq %rdx, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
je 0x236290
movq %rsi, %r15
subq %rax, %r15
cmpl 0xc(%rbx), %edx
jae 0x2362b6
movq (%rbx), %rax
addq %rax, %r15
movl 0x8(%rbx), %ecx
shlq $0x4, %rcx
mov... | /llvm/ADT/SmallVector.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 0x13c707(%rip), %rsi # 0x3732f8
movl $0x12, %edx
callq 0x26c566
xorl %ecx, %ecx
testq %rax, %rax
je 0x236c09
cmpb $0x1, (%rax)
cmoveq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x236c22
movq 0x80(%rcx), %rdx
xorl %ecx, %ecx
cmpb $0x11, (%rdx)
cmoveq %rdx, %rcx
jmp 0x236c24
xorl %ecx, %ecx
testq %... | /IR/DebugInfo.cpp |
llvm::detail::DenseMapPair<llvm::MDNode*, llvm::MDNode*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MDNode*, llvm::MDNode*, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<llvm::MDNode*, llvm::MDNode*>>, llvm::MDNode*, llvm::MDNode*, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x23736f
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::DILabel::getImpl(llvm::LLVMContext&, llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata::StorageType, bool) | DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
Metadata *File, unsigned Line, StorageType Storage,
bool ShouldCreate) {
assert(Scope && "Expected scope");
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
testl %r9d, %r9d
jne 0x23af68
movb 0x70(%rsp), %bpl
movq (%r14), %r15
leaq 0x438(%r15), %rdi
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, 0x8(%rsi)
movq %rcx, 0x8(%rsp... | /IR/DebugInfoMetadata.cpp |
llvm::DIObjCProperty::getImpl(llvm::LLVMContext&, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*, llvm::Metadata::StorageType, bool) | DIObjCProperty *DIObjCProperty::getImpl(
LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
MDString *GetterName, MDString *SetterName, unsigned Attributes,
Metadata *Type, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
assert(isCa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb0(%rsp), %ebp
movq 0xa8(%rsp), %rdx
movl 0xa0(%rsp), %r8d
testl %ebp, %ebp
jne 0x23b988
movb 0xb8(%rsp), %bpl
movq (%r14), %r12
leaq 0x450(%r12), %rdi
leaq 0x30(%rsp)... | /IR/DebugInfoMetadata.cpp |
llvm::MDNodeKeyImpl<llvm::DILocation>::isKeyOf(llvm::DILocation const*) const | bool isKeyOf(const DILocation *RHS) const {
return Line == RHS->getLine() && Column == RHS->getColumn() &&
Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt() &&
ImplicitCode == RHS->isImplicitCode();
} | movl (%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x23c7d0
movzwl 0x2(%rsi), %eax
cmpl %eax, 0x4(%rdi)
jne 0x23c7d0
movq 0x8(%rdi), %rdx
leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x23c787
leal (%rcx,%rcx), %r9d
andl $0x78, %r9d
movq %rax, %r8
subq %r9, %r8
jmp 0x23c78b
movq -0x20(%rsi), %r8
cmpq (%r8),... | /IR/LLVMContextImpl.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, long const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* 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 $0x18, %rsp
movq %r9, %r12
movq %rcx, %rbx
movq %rdi, %r13
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0xbe88a
movq (%rbp), %rcx
leaq 0x10(%rsp), %rbp
movq %rcx, (%rbp)
mov... | /llvm/ADT/Hashing.h |
llvm::DenseMap<llvm::DIGenericSubrange*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGenericSubrange>, llvm::detail::DenseSetPair<llvm::DIGenericSubrange*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DIEnumerator*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIEnumerator>, llvm::detail::DenseSetPair<llvm::DIEnumerator*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIEnumerator*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIEnumerator>, llvm::detail::... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x23eace
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x23ea90
xorl %ecx, %ecx
jmp 0x23eaa9
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movq (%r8), %r8
movq %r12, %rsi
callq 0x23ce84
movq (%r12), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, (%r12)
movq (%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
mov... | /llvm/ADT/Hashing.h |
llvm::MDNodeInfo<llvm::DICompositeType>::getHashValue(llvm::DICompositeType const*) | static unsigned getHashValue(const NodeTy *N) {
return KeyTy(N).getHashValue();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x2411be
leaq 0x8(%rsp), %r8
leaq 0x10(%rsp), %r9
leaq 0x18(%rsp), %rax
leaq 0x28(%rsp), %r10
leaq 0x20(%rsp), %r11
leaq 0x48(%rsp), %rbx
leaq 0x60(%rsp), %r14
leaq 0x98(%rsp), %r15
leaq 0xe0(%rsp), %rcx
xo... | /IR/LLVMContextImpl.h |
llvm::detail::DenseSetPair<llvm::DICompositeType*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DICompositeType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DICompositeType>, llvm::detail::DenseSetPair<llvm::DICompositeType*>>, llvm::DICompositeType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIComposite... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x241427
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DISubroutineType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubroutineType>, llvm::detail::DenseSetPair<llvm::DISubroutineType*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DISubroutineType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubroutineT... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x241cfa
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x241cbc
xorl %ecx, %ecx
jmp 0x241cd5
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DISubroutineType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubroutineType>, llvm::detail::DenseSetPair<llvm::DISubroutineType*>>, llvm::DISubroutineType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubroutineType>, llvm::detail::DenseSetPair<llvm::DI... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x241d72
movq %rsi, %r14
movq (%rdi), %r15
movq (%rsi), %rdi
callq 0x241d8c
decl %ebp
andl %ebp, %eax
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %edi
leaq (%r15,%rdi,8), %rdi
movq (%rdi), %r8
cmpq %r8, (%r14... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, int const&, llvm::MDString* const&, llvm::MDString* 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 $0x18, %rsp
movq %r9, %r12
movq %rcx, %rbx
movq %rdi, %r13
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0x23ce84
movq (%rbp), %rcx
leaq 0x10(%rsp), %rbp
movq %rcx, (%rbp)
mo... | /llvm/ADT/Hashing.h |
llvm::MDNodeKeyImpl<llvm::DISubprogram>::getHashValue() const | unsigned getHashValue() const {
// Use the Scope's linkage name instead of using the scope directly, as the
// scope may be a temporary one which can replaced, which would produce a
// different hash for the same DISubprogram.
llvm::StringRef ScopeLinkageName;
if (auto *CT = dyn_cast_or_null<DICompo... | pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2429e9
cmpb $0xe, (%rcx)
cmoveq %rcx, %rax
testq %rax, %rax
je 0x242a20
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x242a05
addq $-0x10, %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq ... | /IR/LLVMContextImpl.h |
llvm::MDNodeKeyImpl<llvm::DISubprogram>::MDNodeKeyImpl(llvm::DISubprogram const*) | const Header &getHeader() const {
return *(reinterpret_cast<const Header *>(this) - 1);
} | leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x243192
addl %ecx, %ecx
andl $0x78, %ecx
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x243196
movq -0x20(%rsi), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, (%rdi)
movq (%rax), %rcx
testb $0x2, %cl
jne 0x2431b2
addl %ecx, %ecx
andl $0x78, %ecx
movq %rax, %rdx
subq %rcx... | /llvm/IR/Metadata.h |
llvm::DenseMap<llvm::DISubprogram*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubprogram>, llvm::detail::DenseSetPair<llvm::DISubprogram*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DILexicalBlock*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlock>, llvm::detail::DenseSetPair<llvm::DILexicalBlock*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DILexicalBlock*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlock>, llvm... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x24396c
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x24392e
xorl %ecx, %ecx
jmp 0x243947
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DINamespace*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DIN... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x24444e
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* 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 $0x18, %rsp
movq %r9, %r12
movq %rcx, %rbx
movq %rdi, %r13
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0x23c530
movq (%rbp), %rcx
leaq 0x10(%rsp), %rbp
movq %rcx, (%rbp)
mo... | /llvm/ADT/Hashing.h |
llvm::MDNodeKeyImpl<llvm::DIModule>::MDNodeKeyImpl(llvm::DIModule const*) | static bool classof(const Metadata *MD) {
return MD->getMetadataID() == DIFileKind;
} | cmpb $0x10, (%rsi)
movq %rsi, %rax
je 0x2456f0
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x2456e9
leaq -0x10(%rsi), %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x2456ed
movq -0x20(%rsi), %rax
movq (%rax), %rax
movq %rax, (%rdi)
leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x24570d
ad... | /llvm/IR/DebugInfoMetadata.h |
llvm::MDNodeKeyImpl<llvm::DITemplateTypeParameter>::MDNodeKeyImpl(llvm::DITemplateTypeParameter const*) | const Header &getHeader() const {
return *(reinterpret_cast<const Header *>(this) - 1);
} | leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x245dd6
addl %ecx, %ecx
andl $0x78, %ecx
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x245dda
movq -0x20(%rsi), %rdx
movq (%rdx), %rcx
movq %rcx, (%rdi)
movq (%rax), %rcx
testb $0x2, %cl
jne 0x245df2
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x245df6... | /llvm/IR/Metadata.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, bool const&, llvm::Metadata* 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 $0x18, %rsp
movq %r9, %r12
movq %rcx, %rbx
movq %rdi, %r13
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0x23ce84
movq (%rbp), %rcx
leaq 0x10(%rsp), %rbp
movq %rcx, (%rbp)
mo... | /llvm/ADT/Hashing.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DITemplateValueParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DITemplateValueParameter>, llvm::detail::DenseSetPair<llvm::DITemplateValueParameter*>>, llvm::DITemplateValueParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DITemplateValueParamet... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x2464a6
movq %rsi, %r14
movq (%rdi), %r15
movq (%rsi), %rdi
callq 0x2464c0
decl %ebp
andl %ebp, %eax
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %edi
leaq (%r15,%rdi,8), %rdi
movq (%rdi), %r8
cmpq %r8, (%r14... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::DITemplateValueParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DITemplateValueParameter>, llvm::detail::DenseSetPair<llvm::DITemplateValueParameter*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&, llvm::Met... | 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 %rdi, %r12
movq 0x60(%rsp), %r14
movq 0x68(%rsp), %r15
leaq 0x18(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0x23c530
movq (%rbp), %rcx
leaq 0x20(%rsp), %rbp
movq %rcx, (%rbp)
m... | /llvm/ADT/Hashing.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movl (%r8), %r8d
movq %r12, %rsi
callq 0xcae32
movq (%r12), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, (%r12)
movq (%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
mov... | /llvm/ADT/Hashing.h |
llvm::MDNodeKeyImpl<llvm::DILocalVariable>::isKeyOf(llvm::DILocalVariable const*) const | bool isKeyOf(const DILocalVariable *RHS) const {
return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
File == RHS->getRawFile() && Line == RHS->getLine() &&
Type == RHS->getRawType() && Arg == RHS->getArg() &&
Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInB... | movq (%rdi), %rdx
leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
testb $0x2, %cl
jne 0x2476b4
leal (%rcx,%rcx), %r9d
andl $0x78, %r9d
movq %rax, %r8
subq %r9, %r8
jmp 0x2476b8
movq -0x20(%rsi), %r8
cmpq (%r8), %rdx
jne 0x24775e
movq 0x8(%rdi), %rdx
testb $0x2, %cl
jne 0x2476da
leal (%rcx,%rcx), %r9d
andl $0x78, %r9d
mov... | /IR/LLVMContextImpl.h |
llvm::MDNodeInfo<llvm::DILocalVariable>::getHashValue(llvm::DILocalVariable const*) | static unsigned getHashValue(const NodeTy *N) {
return KeyTy(N).getHashValue();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x24791a
leaq 0x8(%rsp), %r9
leaq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r10
leaq 0x20(%rsp), %r11
leaq 0x28(%rsp), %r14
leaq 0x2c(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x80(%rsp), %rcx
xorps %xmm0, %xmm0
mov... | /IR/LLVMContextImpl.h |
llvm::DenseMapIterator<llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>, llvm::DILab... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x247ce6
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>, llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>::LookupBucketFor<llvm::MDNodeKeyImpl... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x247dfe
movq (%rdi), %r13
leaq 0x8(%rsi), %r8
leaq 0x18(%rsi), %r9
leaq 0x60(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, unsigned int 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movq (%r8), %r8
movq %r12, %rsi
callq 0x23ce84
movq (%r12), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, (%r12)
movl (%r14), %r8d
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
mo... | /llvm/ADT/Hashing.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>, llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>::LookupBucketFor<llvm::DILabel*>(llv... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x247fe4
movq %rsi, %r14
movq (%rdi), %r15
movq (%rsi), %rdi
callq 0x247ffe
decl %ebp
andl %ebp, %eax
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %edi
leaq (%r15,%rdi,8), %rdi
movq (%rdi), %r8
cmpq %r8, (%r14... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DIExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIExpression>, llvm::detail::DenseSetPair<llvm::DIExpression*>>, llvm::DIExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIExpression>, llvm::detail::DenseSetPair<llvm::DIExpression*>>::Looku... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x2484b4
movq (%rdi), %r13
movq (%rsi), %rdi
movq %rsi, 0x10(%rsp)
movq 0x8(%rsi), %rax
leaq (%rdi,%rax,8), %rsi
callq 0xcaf14
movq %rax, %r15
decl %ebp
movl %ebp, 0x4(%rsp)
andl ... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* 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 $0x18, %rsp
movq %r9, %r12
movq %rcx, %rbx
movq %rdi, %r13
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %r15
leaq 0x8(%rsp), %rbp
movq %rsi, (%rbp)
movq (%r8), %r8
movq %rbp, %rsi
callq 0x23ce84
movq (%rbp), %rcx
leaq 0x10(%rsp), %rbp
movq %rcx, (%rbp)
mo... | /llvm/ADT/Hashing.h |
llvm::DenseMap<llvm::DIImportedEntity*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIImportedEntity>, llvm::detail::DenseSetPair<llvm::DIImportedEntity*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::DIMacroFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIMacroFile>, llvm::detail::DenseSetPair<llvm::DIMacroFile*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
foldOperationIfPossible(unsigned long, unsigned long, llvm::dwarf::LocationAtom) | static std::optional<uint64_t>
foldOperationIfPossible(uint64_t Const1, uint64_t Const2,
dwarf::LocationAtom Operator) {
bool ResultOverflowed;
switch (Operator) {
case dwarf::DW_OP_plus: {
auto Result = SaturatingAdd(Const1, Const2, &ResultOverflowed);
if (ResultOverflowed)
... | pushq %rbx
subq $0x10, %rsp
movl %edx, %ecx
xorl %edx, %edx
addl $-0x1b, %ecx
cmpl $0xa, %ecx
ja 0x24c10a
movq %rdi, %rax
leaq 0x12770f(%rip), %rdi # 0x3737a0
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
testq %rsi, %rsi
je 0x24c108
xorl %edx, %edx
divq %rsi
movb $0x1, %dl
jmp 0x24c11c
leaq 0xf(%rsp), %rbx
... | /IR/DIExpressionOptimizer.cpp |
llvm::DILocation::getInlinedAtScope() const | DILocalScope *getInlinedAtScope() const {
if (auto *IA = getInlinedAt())
return IA->getInlinedAtScope();
return getScope();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq -0x10(%rdi), %rax
testb $0x2, %al
jne 0x24cd28
movl %eax, %ecx
shrl $0x6, %ecx
andl $0xf, %ecx
jmp 0x24cd2b
movl -0x18(%rbx), %ecx
leaq -0x10(%rbx), %r15
cmpl $0x2, %ecx
jne 0x24cd45
testb $0x2, %al
jne 0x24cd4a
addl %eax, %eax
andl $0x78, %eax
movq %r15, %rcx
subq ... | /llvm/IR/DebugInfoMetadata.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [31], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [31], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> 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 0xa30d0
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x26e842(%rip), %rax # 0x4bb780
addq $0x10, ... | /llvm/Support/CommandLine.h |
llvm::Intrinsic::hasConstrainedFPRoundingModeOperand(unsigned int) | bool Intrinsic::hasConstrainedFPRoundingModeOperand(Intrinsic::ID QID) {
switch (QID) {
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \
return ROUND_MODE == 1;
#include "llvm/IR/ConstrainedOps.def"
#u... | leal -0x5b(%rdi), %ecx
cmpl $0x30, %ecx
setb %dl
movabsq $0xbf3c1ef8e9f7, %rax # imm = 0xBF3C1EF8E9F7
shrq %cl, %rax
andb %dl, %al
retq
| /IR/Function.cpp |
llvm::Intrinsic::matchIntrinsicSignature(llvm::FunctionType*, llvm::ArrayRef<llvm::Intrinsic::IITDescriptor>&, llvm::SmallVectorImpl<llvm::Type*>&) | Intrinsic::MatchIntrinsicTypesResult
Intrinsic::matchIntrinsicSignature(FunctionType *FTy,
ArrayRef<Intrinsic::IITDescriptor> &Infos,
SmallVectorImpl<Type *> &ArgTys) {
SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks;
if (matchIntrinsic... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq 0x10(%rdi), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rcx
xorl %r8d... | /IR/Function.cpp |
llvm::Intrinsic::matchIntrinsicVarArg(bool, llvm::ArrayRef<llvm::Intrinsic::IITDescriptor>&) | bool
Intrinsic::matchIntrinsicVarArg(bool isVarArg,
ArrayRef<Intrinsic::IITDescriptor> &Infos) {
// If there are no descriptors left, then it can't be a vararg.
if (Infos.empty())
return isVarArg;
// There should be only one descriptor remaining at this point.
if (Infos.size... | movl %edi, %eax
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x255286
cmpq $0x1, %rcx
jne 0x255287
movq (%rsi), %rcx
movl (%rcx), %edx
addq $0xc, %rcx
movq %rcx, (%rsi)
movq $0x0, 0x8(%rsi)
cmpl $0x1, %edx
setne %cl
xorb $0x1, %al
orb %cl, %al
retq
movb $0x1, %al
retq
| /IR/Function.cpp |
llvm::Function::allocHungoffUselist() | void Function::allocHungoffUselist() {
// If we've already allocated a uselist, stop here.
if (getNumOperands())
return;
allocHungoffUses(3, /*IsPhi=*/ false);
setNumHungOffUseOperands(3);
// Initialize the uselist with placeholder operands to allow traversal.
auto *CPN = ConstantPointerNull::get(Poin... | testl $0x7ffffff, 0x4(%rdi) # imm = 0x7FFFFFF
je 0x255bd4
retq
pushq %rbx
movq %rdi, %rbx
movl $0x3, %esi
xorl %edx, %edx
callq 0x274700
movl $0xf8000000, %eax # imm = 0xF8000000
andl 0x4(%rbx), %eax
orl $0x3, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x26fe84
movq %... | /IR/Function.cpp |
llvm::CallBase::isBundleOperand(unsigned int) const | bool isBundleOperand(unsigned Idx) const {
return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
Idx < getBundleOperandsEndIndex();
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1d7958
testl %eax, %eax
je 0x256b1d
movq %r14, %rdi
callq 0x274848
cmpl %ebx, 0x8(%rax)
jbe 0x256b21
xorl %eax, %eax
jmp 0x256b30
movq %r14, %rdi
callq 0x274848
cmpl %ebx, -0x4(%rax,%rdx)
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/IR/InstrTypes.h |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [31], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [31], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8b300
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x9d01e
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
or... | /llvm/Support/CommandLine.h |
llvm::iplist_impl<llvm::simple_ilist<llvm::Function>, llvm::SymbolTableListTraits<llvm::Function>>::insert(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void, false, void>, false, false>, llvm::Function*) | iterator insert(iterator where, pointer New) {
this->addNodeToList(New); // Notify traits that we added a node...
return base_list_type::insert(where, *New);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x18(%rdi), %rax
movq %rax, 0x28(%rdx)
testb $0x10, 0x7(%rdx)
je 0x256c63
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x256c63
movq %r14, %rsi
callq 0x276b5c
leaq 0x38(%r14), %rax
movq (%rbx), %rcx
movq %rbx, 0x40(%r14)
movq %rcx, 0x38(%r14)
movq %rax... | /llvm/ADT/ilist.h |
llvm::GlobalValue::getComdat() const | const Comdat *GlobalValue::getComdat() const {
if (auto *GA = dyn_cast<GlobalAlias>(this)) {
// In general we cannot compute this at the IR level, but we try.
if (const GlobalObject *GO = GA->getAliaseeObject())
return const_cast<GlobalObject *>(GO)->getComdat();
return nullptr;
}
// ifunc and i... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
cmpb $0x1, %bpl
jne 0x256ea6
movq %rbx, %rdi
callq 0x256f74
testq %rax, %rax
je 0x256ea4
movq 0x30(%rax), %rax
jmp 0x256ea6
xorl %eax, %eax
cmpb $0x1, %bpl
je 0x256eb9
cmpb $0x2, (%rbx)
jne 0x256eb5
xorl %eax, %eax
jmp 0x256eb9
movq 0x30(%rbx), %rax
add... | /IR/Globals.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::StringRef>>, llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPa... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x257944
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x257939
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2579d4
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps %xm... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::StringRef>>, llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::Dense... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2579c8
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%r11,%r11,2), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%r... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::StringRef>* llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::StringRef>>, llvm::GlobalValue const*, llvm::StringRef, llvm:... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x257a23
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalObject const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalObject const*, void>, llvm::detail::DenseMapPair<llvm::GlobalObject const*, llvm::StringRef>>, llvm::GlobalObject const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalObject const*, void>, llvm::detail::Dense... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x2580fa
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2580ef
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x25818a
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps %xm... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::GlobalAlias const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalAlias const*, void>, llvm::detail::DenseSetPair<llvm::GlobalAlias const*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalAlias const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalAlias const*, void>, llvm::detail::DenseSetPair<llvm::GlobalAlias const*>>, llvm::GlobalAlias const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::GlobalAlias const*, void>, llvm::detail::Den... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %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 0x25881b
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
n... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::InlineAsm*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::InlineAsm>::MapInfo, llvm::detail::DenseSetPair<llvm::InlineAsm*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::InlineAsm*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::InlineAsm>::MapInfo, llvm::detail::... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x25a568
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::InlineAsm*>* llvm::DenseMapBase<llvm::DenseMap<llvm::InlineAsm*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::InlineAsm>::MapInfo, llvm::detail::DenseSetPair<llvm::InlineAsm*>>, llvm::InlineAsm*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::InlineAsm>::MapInf... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x25a87b
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.