name string | code string | asm string | file string |
|---|---|---|---|
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>... | 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 0x196cf26
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x196cf1c
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x196cfb8
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::BasicBlock*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::BasicBlock*>>, unsigned int, llvm::BasicBlock*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::BasicBlock*>>::FindAndConstruct... | 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 0x196e70c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x196e702
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x196e790
movl (%rbx), %ecx
movl %ecx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::AssignmentTrackingLowering::joinBlockInfo((anonymous namespace)::AssignmentTrackingLowering::BlockInfo const&, (anonymous namespace)::AssignmentTrackingLowering::BlockInfo const&) | AssignmentTrackingLowering::BlockInfo
AssignmentTrackingLowering::joinBlockInfo(const BlockInfo &A,
const BlockInfo &B) {
return BlockInfo::join(A, B, TrackedVariablesVectorSize);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movl (%rsi), %esi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x600000000, %r12 # imm = 0x600000000
movq %r12, 0x8(%rdi)
movl $0x0, 0x40(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x4... | /CodeGen/AssignmentTrackingAnalysis.cpp |
std::pair<llvm::DenseMapIterator<llvm::PointerUnion<llvm::Instruction const*, llvm::DbgRecord const*>, unsigned int, llvm::DenseMapInfo<llvm::PointerUnion<llvm::Instruction const*, llvm::DbgRecord const*>, void>, llvm::detail::DenseMapPair<llvm::PointerUnion<llvm::Instruction const*, llvm::DbgRecord const*>, unsigned i... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x19703ba
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1970ea6
xorl %ecx, %ecx
jmp 0x1970ec6
movq %r... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::MDFieldPrinter::printBool(llvm::StringRef, bool, std::optional<bool>) | void MDFieldPrinter::printBool(StringRef Name, bool Value,
std::optional<bool> Default) {
if (Default && Value == *Default)
return;
Out << FS << Name << ": " << (Value ? "true" : "false");
} | pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %r8d, %eax
shrl $0x8, %eax
cmpb %bl, %r8b
sete %cl
testb %cl, %al
je 0x198cded
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rsi, %r15
movq (%rdi), %rax
cmpb $0x1, 0x8(%rdi)
jne 0x198ce02
movb $0x0, 0x8(%rdi)
jmp 0x198ce0e
movq 0x10(%rdi), %rsi
movq %rax,... | /IR/AsmWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function const*, llvm::MapVector<llvm::Value const*, std::vector<unsigned int, std::allocator<unsigned int>>, llvm::DenseMap<llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>, llvm::SmallV... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rsp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x198d168
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::StructType*, unsigned int, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, unsigned int>>, llvm::StructType*, unsigned int, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, unsigned int>>::L... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1992d53
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
WriteOptimizationInfo(llvm::raw_ostream&, llvm::User const*) | static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U))
Out << FPO->getFastMathFlags();
if (const OverflowingBinaryOperator *OBO =
dyn_cast<OverflowingBinaryOperator>(U)) {
if (OBO->hasNoUnsignedWrap())
Out << " n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x903dce
xorb $0x1, %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1992da3
movzbl 0x1(%r14), %eax
shrl %eax
cmpl $0x7f, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovnel %eax, %ecx
leaq 0x8(%rsp), %rdi
m... | /IR/AsmWriter.cpp |
llvm::AttrBuilder::removeAttribute(llvm::Attribute::AttrKind) | AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
auto It = lower_bound(Attrs, Val, AttributeComparator());
if (It != Attrs.end() && It->hasAttribute(Val))
Attrs.erase(It);
return *this;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0x199dc67
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq 0x8(%rbx), %rdx
cmpq %rdx, %rax
je 0x1999ca6
movq %rax, %rdi
movl 0xc(%rsp), %esi
movq (%rax), %rcx
testq %rcx... | /IR/Attributes.cpp |
llvm::AttributeSetNode::getAllocSizeArgs() const | std::optional<std::pair<unsigned, std::optional<unsigned>>>
AttributeSetNode::getAllocSizeArgs() const {
if (auto A = findEnumAttribute(Attribute::AllocSize))
return A->getAllocSizeArgs();
return std::nullopt;
} | subq $0x18, %rsp
movl $0x53, %esi
callq 0x199a9f4
testb $0x1, %dl
je 0x199a4bf
movq 0x10(%rax), %rax
movl %eax, %ecx
shrq $0x20, %rax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %edi, %edi
cmpq %rsi, %rcx
setne %dil
movl %eax, 0x8(%rsp)
shlq $0x20, %rdi
orq %rcx, %rdi
movq %rdi, 0xc(%rsp)
movq 0x8(%rsp), %rax
... | /IR/Attributes.cpp |
llvm::AttributeList::get(llvm::LLVMContext&, unsigned int, llvm::ArrayRef<llvm::Attribute::AttrKind>) | AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
ArrayRef<Attribute::AttrKind> Kinds) {
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
for (const auto K : Kinds)
Attrs.emplace_back(Index, Attribute::get(C, K));
return get(C, Attrs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
testq %r14, %r14
je 0x199b147
movq %rdx, %r15
shlq $0x2, %r14
xor... | /IR/Attributes.cpp |
llvm::AttrBuilder::getAllocSizeArgs() const | std::optional<std::pair<unsigned, std::optional<unsigned>>>
AttrBuilder::getAllocSizeArgs() const {
Attribute A = getAttribute(Attribute::AllocSize);
if (A.isValid())
return A.getAllocSizeArgs();
return std::nullopt;
} | subq $0x18, %rsp
movl $0x53, %esi
callq 0x199ca0c
testq %rax, %rax
je 0x199cae7
movabsq $0x100000000, %rcx # imm = 0x100000000
movq 0x10(%rax), %rax
movl %eax, %edx
shrq $0x20, %rax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %edi, %edi
cmpq %rsi, %rdx
setne %dil
movl %eax, 0x8(%rsp)
shlq $0x20, %rdi
orq ... | /IR/Attributes.cpp |
llvm::AttributeFuncs::typeIncompatible(llvm::Type*, llvm::AttributeFuncs::AttributeSafetyKind) | AttributeMask AttributeFuncs::typeIncompatible(Type *Ty,
AttributeSafetyKind ASK) {
AttributeMask Incompatible;
if (!Ty->isIntegerTy()) {
// Attributes that only apply to integers.
if (ASK & ASK_SAFE_TO_DROP)
Incompatible.addAttribute(Attribute::AllocAli... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %rax
movl $0x0, 0x18(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movzbl 0x8(%rsi), %r14d
cmpl $0xd, %r14d
je 0x199cee6
testb $0x1, %... | /IR/Attributes.cpp |
void llvm::SmallVectorImpl<llvm::AttributeSet>::append<llvm::AttributeSet const*, void>(llvm::AttributeSet const*, llvm::AttributeSet const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x199e7a4
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
rename(llvm::GlobalValue*) | static void rename(GlobalValue *GV) { GV->setName(GV->getName() + ".old"); } | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x1a90092
leaq 0x8(%rsp), %rsi
movw $0x305, 0x20(%rsi) # imm = 0x305
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x34495db(%rip), %rax # 0x4dee300
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1a90300
addq $0x30, %rsp
popq %rbx
retq
| /IR/AutoUpgrade.cpp |
llvm::iplist_impl<llvm::simple_ilist<llvm::BasicBlock>, llvm::SymbolTableListTraits<llvm::BasicBlock>>::erase(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void, false, void>, false, false>) | iterator erase(iterator where) {
this->deleteNode(remove(where));
return where;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq 0x8(%rsi), %rbx
leaq -0x18(%rsi), %r14
testq %rsi, %rsi
cmoveq %rsi, %r14
movq %r14, %rsi
callq 0x19bbafe
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
testq %r15, %r15
je 0x19b936c
mov... | /llvm/ADT/ilist.h |
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 0x19b9799
movq %rax, %rdx
leaq -0x18(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
cmpb $0x54, (%rax)
cmoveq %rdx, %rax
jne 0x19b979b
movq 0x8(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x19b9779
xorl %eax, %eax
retq
| /IR/BasicBlock.cpp |
evaluateICmpRelation(llvm::Constant*, llvm::Constant*) | static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2) {
assert(V1->getType() == V2->getType() &&
"Cannot compare different types of values!");
if (V1 == V2) return ICmpInst::ICMP_EQ;
// The following folds only apply to pointers.
if (!V1->getType()->isPointerTy())
return ICmp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq %rsi, %rdi
je 0x19be847
movq %rdi, %rsi
movq 0x8(%rdi), %rax
movl $0x2a, %ebp
cmpb $0xf, 0x8(%rax)
jne 0x19be84c
movb (%rsi), %cl
movl $0x3, %edx
movl $0x3, %edi
cmpb $0x5, %cl
je 0x19be809
movl $0x2, %edi
cmpb $0x4, %cl
jb 0x19be809
sete %al
m... | /IR/ConstantFold.cpp |
llvm::ConstantRange::makeAllowedICmpRegion(llvm::CmpInst::Predicate, llvm::ConstantRange const&) | ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred,
const ConstantRange &CR) {
if (CR.isEmptySet())
return CR;
uint32_t W = CR.getBitWidth();
switch (Pred) {
default:
llvm_unreachable("Invalid ICmp predicate to makeAllowedICmpRe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x19bf40e
testb %al, %al
je 0x19bf594
movl 0x8(%r15), %eax
movl %eax, 0x8(%r14)
cmpl $0x40, %eax
ja 0x19bf5b5
movq (%r15), %... | /IR/ConstantRange.cpp |
llvm::Constant::hasExactInverseFP() const | bool Constant::hasExactInverseFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().getExactInverse(nullptr);
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movb (%rdi), %bpl
cmpb $0x12, %bpl
jne 0x19d125b
leaq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x9b8356
movl %eax, %ebx
cmpb $0x12, %bpl
je 0x19d1310
movq 0x8(%r14), %rax
cmpb $0x12, 0x8(%rax)
setne %cl
testq %rax, %rax
sete %bpl
orb %cl, %bpl
jne 0x1... | /IR/Constants.cpp |
llvm::Constant::containsConstantExpression() const | Type *getType() const { return VTy; } | movq 0x8(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x19d16a0
pushq %rbp
pushq %r14
pushq %rbx
movzbl 0x8(%rcx), %edx
cmpl $0x12, %edx
jne 0x19d169c
movl 0x20(%rcx), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
je 0x19d169a
movq %rdi, %rbx
decl %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19d0cd4
cmpb $0x5, (%rax)
set... | /llvm/IR/Value.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::NoCFIValue*, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::NoCFIValue*>>, llvm::GlobalValue const*, llvm::NoCFIValue*, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::Dens... | 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 0x19df342
testb %al, %al
je 0x19d68d0
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x19b67f5(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
bool 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<ll... | 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 $0x68, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %r12d
testl %r12d, %r12d
je 0x19daee9
movq %rsi, %r14
movq (%rdi), %r13
callq 0x1c76938
movq %rax, %r15
leaq 0x20(%rsp), %rdx
movq $0x1, (%rdx)
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x88bd14
leaq 0x... | /llvm/ADT/DenseMap.h |
llvm::ConstantAggrKeyType<llvm::ConstantArray>::ConstantAggrKeyType(llvm::ConstantArray const*, llvm::SmallVectorImpl<llvm::Constant*>&) | ConstantAggrKeyType(const ConstantClass *C,
SmallVectorImpl<Constant *> &Storage) {
assert(Storage.empty() && "Expected empty storage");
for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I)
Storage.push_back(C->getOperand(I));
Operands = Storage;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl 0x4(%rsi), %r12d
andq $0x7ffffff, %r12 # imm = 0x7FFFFFF
je 0x19dc0d9
movq %rsi, %r15
movq %rsi, %r13
movl 0x4(%r15), %eax
shll $0x5, %eax
movq %r13, %rcx
subq %rax, %rcx
movq (%rcx... | /IR/ConstantsContext.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::PointerType*, std::unique_ptr<llvm::ConstantPointerNull, std::default_delete<llvm::ConstantPointerNull>>, llvm::DenseMapInfo<llvm::PointerType*, void>, llvm::detail::DenseMapPair<llvm::PointerType*, std::unique_ptr<llvm::ConstantPointerNull, std::default_delete<llvm::Constan... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x19ddb89
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::TargetExtType*, std::unique_ptr<llvm::ConstantTargetNone, std::default_delete<llvm::ConstantTargetNone>>, llvm::DenseMapInfo<llvm::TargetExtType*, void>, llvm::detail::DenseMapPair<llvm::TargetExtType*, std::unique_ptr<llvm::ConstantTargetNone, std::default_delete<llvm::ConstantT... | 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 0x19ddf3e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x19ddf34
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x19ddfd0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
llvm::ConstantUniqueMap<llvm::ConstantPtrAuth>::create(llvm::Type*, llvm::ConstantPtrAuthKeyType, std::pair<unsigned int, std::pair<llvm::Type*, llvm::ConstantPtrAuthKeyType>>&) | ConstantClass *create(TypeClass *Ty, ValType V, LookupKeyHashed &HashKey) {
ConstantClass *Result = V.create(Ty);
assert(Result->getType() == Ty && "Type specified is not correct!");
Map.insert_as(Result, HashKey);
return Result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0x18, %edi
movl $0x4, %esi
callq 0x1a8f59c
movq %rax, %r12
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movq %rax, %rdi
callq 0x19d6b24
movq %rsp, %rdx
movq %r12, (%rdx)... | /IR/ConstantsContext.h |
llvm::DIBuilder::DIBuilder(llvm::Module&, bool, llvm::DICompileUnit*) | DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
: M(m), VMContext(M.getContext()), CUNode(CU), DeclareFn(nullptr),
ValueFn(nullptr), LabelFn(nullptr), AssignFn(nullptr),
AllowUnresolvedNodes(AllowUnresolvedNodes) {
if (CUNode) {
if (const auto &ETs = CUNode->getEnumTy... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
leaq 0x48(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movabsq $0x400000000, %rax # imm = 0x400000000... | /IR/DIBuilder.cpp |
llvm::DIBuilder::createStructType(llvm::DIScope*, llvm::StringRef, llvm::DIFile*, unsigned int, unsigned long, unsigned int, llvm::DINode::DIFlags, llvm::DIType*, llvm::MDTupleTypedArrayWrapper<llvm::DINode>, unsigned int, llvm::DIType*, llvm::StringRef) | DICompositeType *DIBuilder::createStructType(
DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
DIType *VTableHolder, StringRef UniqueIdentifier) {
auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x118(%rsp), %rax
movq 0x110(%rsp), %r15
movl 0x108(%rsp), %ebp
movq 0x100(%rsp), %r14
movl 0xf0(%rsp), %r12d
movl 0xe8(%rsp), %r11d
movq 0xe0(%rsp), %r10
movq 0x8(%rdi), %rdi
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x... | /IR/DIBuilder.cpp |
llvm::DIObjCProperty::getImpl(llvm::LLVMContext&, llvm::StringRef, llvm::DIFile*, unsigned int, llvm::StringRef, llvm::StringRef, unsigned int, llvm::DIType*, llvm::Metadata::StorageType, bool) | static DIObjCProperty *
getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
StringRef GetterName, StringRef SetterName, unsigned Attributes,
DIType *Type, StorageType Storage, bool ShouldCreate = true) {
return getImpl(Context, getCanonicalMDString(Context, Name), File, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdi, %r15
leaq 0x40(%rsp), %r13
testq %rdx, %rdx
je 0x19e5de9
movq %r15, %rdi
callq 0x1a65c88
movq %rax, %r12
jmp 0x19e5dec
xorl %r12d, %r12d
leaq 0x50(%rsp), %rbx
movq 0x8(%r13), %rdx
tes... | /llvm/IR/DebugInfoMetadata.h |
llvm::DISubprogram::cloneImpl() const | TempDISubprogram cloneImpl() const {
return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
getFile(), getLine(), getType(), getScopeLine(),
getContainingType(), getVirtualIndex(),
getThisAdjustment(), getFlags(), getSPFlags... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r15
movq %rdi, 0x110(%rsp)
movq 0x8(%rsi), %rax
movq %rax, %rcx
andq $-0x8, %rcx
testb $0x4, %al
je 0x19e606e
movq (%rcx), %rcx
leaq -0x10(%r15), %r13
movq -0x10(%r15), %rax
testb $0x2, %al
movq %rcx... | /llvm/IR/DebugInfoMetadata.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DISubprogram*, llvm::SmallVector<llvm::TypedTrackingMDRef<llvm::MDNode>, 4u>, llvm::DenseMapInfo<llvm::DISubprogram*, void>, llvm::detail::DenseMapPair<llvm::DISubprogram*, llvm::SmallVector<llvm::TypedTrackingMDRef<llvm::MDNode>, 4u>>>, llvm::DISubprogram*, llvm::SmallVecto... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x19e670f
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
imulq $0x38, %r11, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, ... | /llvm/ADT/DenseMap.h |
llvm::DebugInfoFinder::processLocation(llvm::Module const&, llvm::DILocation const*) | void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
if (!Loc)
return;
processScope(Loc->getScope());
processLocation(M, Loc->getInlinedAt());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x19ebec9
movq %rdx, %r15
leaq -0x10(%rdx), %r14
movq -0x10(%rdx), %rax
testb $0x2, %al
jne 0x19ebe83
addl %eax, %eax
andl $0x78, %eax
movq %r14, %rcx
subq %rax, %rcx
jmp 0x19ebe87
movq -0x20(%r15), %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq 0x19eba... | /IR/DebugInfo.cpp |
updateLoopMetadataDebugLocationsImpl(llvm::MDNode*, llvm::function_ref<llvm::Metadata* (llvm::Metadata*)>) | static MDNode *updateLoopMetadataDebugLocationsImpl(
MDNode *OrigLoopID, function_ref<Metadata *(Metadata *)> Updater) {
assert(OrigLoopID && OrigLoopID->getNumOperands() > 0 &&
"Loop ID needs at least one operand");
assert(OrigLoopID && OrigLoopID->getOperand(0).get() == OrigLoopID &&
"Loop I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq $0x0, -0x8(%rdx)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
leaq 0x8(%rsp), %r12
movq %... | /IR/DebugInfo.cpp |
isDILocationReachable(llvm::SmallPtrSetImpl<llvm::Metadata*>&, llvm::SmallPtrSetImpl<llvm::Metadata*>&, llvm::Metadata*) | static bool isDILocationReachable(SmallPtrSetImpl<Metadata *> &Visited,
SmallPtrSetImpl<Metadata *> &Reachable,
Metadata *MD) {
MDNode *N = dyn_cast_or_null<MDNode>(MD);
if (!N)
return false;
if (isa<DILocation>(N) || Reachable.count(N))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x19efc37
movq %rdx, %r12
movq %rdx, %rdi
callq 0xaf079a
xorl %r15d, %r15d
testb %al, %al
cmovneq %r12, %r15
jmp 0x19efc3a
xorl %r15d, %r15d
testq %r15, %r15
je 0x19efcab
movb $0x1, %bp... | /IR/DebugInfo.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DIAssignID*, llvm::DIAssignID*, llvm::DenseMapInfo<llvm::DIAssignID*, void>, llvm::detail::DenseMapPair<llvm::DIAssignID*, llvm::DIAssignID*>>, llvm::DIAssignID*, llvm::DIAssignID*, llvm::DenseMapInfo<llvm::DIAssignID*, void>, llvm::detail::DenseMapPair<llvm::DIAssignID*, ll... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x19f1a91
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::SetVector<llvm::at::VarRecord, llvm::SmallVector<llvm::at::VarRecord, 2u>, llvm::DenseSet<llvm::at::VarRecord, llvm::DenseMapInfo<llvm::at::VarRecord, void>>, 2u>::insert(llvm::at::VarRecord const&) | bool insert(const value_type &X) {
if constexpr (canBeSmall())
if (isSmall()) {
if (!llvm::is_contained(vector_, X)) {
vector_.push_back(X);
if (vector_.size() > N)
makeBig();
return true;
}
return false;
}
bool result = set_.insert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x19f1e84
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x19f2aac
movb 0x10(%r15), %bpl
cmpb $0x1, %bpl
jne 0x19f1ecf
addq $0x18, %rbx
movq (%r14), %rsi... | /llvm/ADT/SetVector.h |
llvm::GenericDINode* llvm::MDNode::storeImpl<llvm::GenericDINode, llvm::DenseSet<llvm::GenericDINode*, llvm::MDNodeInfo<llvm::GenericDINode>>>(llvm::GenericDINode*, llvm::Metadata::StorageType, llvm::DenseSet<llvm::GenericDINode*, llvm::MDNodeInfo<llvm::GenericDINode>>&) | T *MDNode::storeImpl(T *N, StorageType Storage, StoreT &Store) {
switch (Storage) {
case Uniqued:
Store.insert(N);
break;
case Distinct:
N->storeDistinctInContext();
break;
case Temporary:
break;
}
return N;
} | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
cmpl $0x1, %esi
je 0x19f5d9c
testl %esi, %esi
jne 0x19f5da1
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rax
leaq 0x7(%rsp), %rcx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x19fd278
jmp 0x19f5da1
callq 0x1a682e8
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
| /IR/MetadataImpl.h |
llvm::DIExpression::append(llvm::DIExpression const*, llvm::ArrayRef<unsigned long>) | DIExpression *DIExpression::append(const DIExpression *Expr,
ArrayRef<uint64_t> Ops) {
assert(Expr && !Ops.empty() && "Can't append ops to this expression");
// Copy Expr's current op list.
SmallVector<uint64_t, 16> NewOps;
for (auto Op : Expr->expr_ops()) {
// Append new... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r14
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, -0x8(%rcx)
movq 0x10(%rdi), %rax
movq %rdi, 0x10(%rsp)
movq 0x18(%rdi), %r13
movq %rax, (%rsp)
c... | /IR/DebugInfoMetadata.cpp |
llvm::DIImportedEntity* llvm::MDNode::storeImpl<llvm::DIImportedEntity, llvm::DenseSet<llvm::DIImportedEntity*, llvm::MDNodeInfo<llvm::DIImportedEntity>>>(llvm::DIImportedEntity*, llvm::Metadata::StorageType, llvm::DenseSet<llvm::DIImportedEntity*, llvm::MDNodeInfo<llvm::DIImportedEntity>>&) | T *MDNode::storeImpl(T *N, StorageType Storage, StoreT &Store) {
switch (Storage) {
case Uniqued:
Store.insert(N);
break;
case Distinct:
N->storeDistinctInContext();
break;
case Temporary:
break;
}
return N;
} | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
cmpl $0x1, %esi
je 0x19fba2e
testl %esi, %esi
jne 0x19fba33
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rax
leaq 0x7(%rsp), %rcx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1a0a3fc
jmp 0x19fba33
callq 0x1a682e8
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
| /IR/MetadataImpl.h |
llvm::MDNodeKeyImpl<llvm::GenericDINode>::isKeyOf(llvm::GenericDINode const*) const | dwarf::Tag GenericDINode::getTag() const { return (dwarf::Tag)SubclassData16; } | movzwl 0x2(%rsi), %eax
cmpl %eax, 0x24(%rdi)
jne 0x19fd151
movq 0x28(%rdi), %rax
movq -0x10(%rsi), %rdx
testb $0x2, %dl
jne 0x19fd148
leaq -0x10(%rsi), %rcx
addl %edx, %edx
andl $0x78, %edx
subq %rdx, %rcx
jmp 0x19fd14c
movq -0x20(%rsi), %rcx
cmpq (%rcx), %rax
je 0x19fd154
xorl %eax, %eax
retq
movl $0x1, %edx
jmp 0x19f... | /IR/DebugInfoMetadata.cpp |
llvm::MDNodeInfo<llvm::DIEnumerator>::getHashValue(llvm::DIEnumerator const*) | static unsigned getHashValue(const NodeTy *N) {
return KeyTy(N).getHashValue();
} | pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x19fedb4
leaq 0x10(%rsp), %r14
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)
movap... | /IR/LLVMContextImpl.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 0x1a0131a
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
x... | /IR/LLVMContextImpl.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MDString const*, llvm::DICompositeType*, llvm::DenseMapInfo<llvm::MDString const*, void>, llvm::detail::DenseMapPair<llvm::MDString const*, llvm::DICompositeType*>>, llvm::MDString const*, llvm::DICompositeType*, llvm::DenseMapInfo<llvm::MDString const*, void>, llvm::detail::Dens... | 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 0x1a01b85
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::DIFile*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DIFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIFile>, llvm::detail::DenseSetPair<llvm::DIFile*>>, llvm::DIFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIFile>, llvm::detail::DenseSetPair<llvm::DIFile*>>::Ins... | 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 0x1a02727
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::DILexicalBlockFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlockFile>, llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>>::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::detail::DenseSetPair<llvm::DIGlobalVariable*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DIGlobalVariable*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGlobalVariable>, llvm::detail::DenseSetPair<llvm::DIGlobalVariable*>>, llvm::DIGlobalVariable*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGlob... | 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 0x1a0759f
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<unsigned long, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::Den... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %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 0x1a08e9e
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x1a08e50
xorl %ecx, %ecx
jmp 0x1a08e69
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<unsigned long>* llvm::DenseMapBase<llvm::SmallDenseMap<unsigned long, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>, unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseS... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x1a08f67
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x1a08f9b
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::DIObjCProperty*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIObjCProperty>, llvm::detail::DenseSetPair<llvm::DIObjCProperty*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::DIObjCProperty*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIObjCProperty>, llvm::detail::DenseSe... | 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 0x1a0985e
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::DominatorTreeBase<llvm::BasicBlock, true>::dominates(llvm::BasicBlock const*, llvm::BasicBlock const*) const | bool DominatorTreeBase<NodeT, IsPostDom>::dominates(const NodeT *A,
const NodeT *B) const {
if (A == B)
return true;
// Cast away the const qualifiers here. This is ok since
// this function doesn't actually return the values returned
// from getNode.
r... | cmpq %rdx, %rsi
je 0x1a13869
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
movq %r12, %rdi
callq 0xb0422c
movl 0x40(%rbx), %ecx
shlq $0x4, %rcx
addq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x1a1386c
movq 0x8(%rax), %r15
jmp 0x1a1386f
movb $0x1, %al
retq
xorl %r... | /llvm/Support/GenericDomTree.h |
llvm::DominatorTree::dominates(llvm::BasicBlock const*, llvm::Use const&) const | User *getUser() const { return Parent; } | movq 0x18(%rdx), %rax
cmpb $0x54, (%rax)
jne 0x1a174ce
movq -0x8(%rax), %rcx
subq %rcx, %rdx
movl 0x48(%rax), %eax
shlq $0x5, %rax
addq %rcx, %rax
shrq $0x2, %rdx
movabsq $0x7fffffff8, %rcx # imm = 0x7FFFFFFF8
andq %rdx, %rcx
movq (%rcx,%rax), %rdx
jmp 0x1a122ac
movq 0x28(%rax), %rdx
jmp 0x1a120f0
nop
| /llvm/IR/Use.h |
llvm::Argument::hasNoFreeAttr() const | Type *getType() const { return VTy; } | movq 0x8(%rdi), %rax
cmpb $0xf, 0x8(%rax)
jne 0x1a28ab4
movq 0x18(%rdi), %rax
movl 0x20(%rdi), %esi
addq $0x70, %rax
incl %esi
movq %rax, %rdi
movl $0x1b, %edx
jmp 0x199bfc8
xorl %eax, %eax
retq
nop
| /llvm/IR/Value.h |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>, unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>::LookupBucketFor<unsigne... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1a34ae1
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movabsq $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq %rsi, %rax
movq %rax, %r8
shrq $0x1f, %r8
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%rdi,%r11,8),... | /llvm/ADT/DenseMap.h |
llvm::GlobalIFunc::removeFromParent() | void GlobalIFunc::removeFromParent() { getParent()->removeIFunc(this); } | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x1a726e2
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
popq %rbx
retq
| /IR/Globals.cpp |
llvm::IRBuilderBase::CreateElementUnorderedAtomicMemSet(llvm::Value*, llvm::Value*, llvm::Value*, llvm::Align, unsigned int, llvm::MDNode*, llvm::MDNode*, llvm::MDNode*) | CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet(
Value *Ptr, Value *Val, Value *Size, Align Alignment, uint32_t ElementSize,
MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
Value *Ops[] = {Ptr, Val, Size, getInt32(ElementSize)};
Type *Tys[] = {Ptr->getType(), Size->getType()};
Module... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0xa0(%rsp), %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x48(%rdi), %rdi
callq 0x1a89f44
movl %r15d, %esi
xorl %r15d, %... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateGCResult(llvm::Instruction*, llvm::Type*, llvm::Twine const&) | CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint,
Type *ResultType, const Twine &Name) {
Intrinsic::ID ID = Intrinsic::experimental_gc_result;
Module *M = BB->getParent()->getParent();
Type *Types[] = {ResultType};
Function *FnGCResult = Intrinsic::getDecla... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rdi
leaq 0x28(%rsp), %rax
movq %rdx, (%rax)
movl $0x1, %ecx
movl $0x93, %esi
movq %rax, %rdx
callq 0x1a3157b
movq %r15, 0x20(%rsp)
testq %rax, %rax
je 0x1a39e12... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateConstrainedFPCall(llvm::Function*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&, std::optional<llvm::RoundingMode>, std::optional<llvm::fp::ExceptionBehavior>) | CallInst *IRBuilderBase::CreateConstrainedFPCall(
Function *Callee, ArrayRef<Value *> Args, const Twine &Name,
std::optional<RoundingMode> Rounding,
std::optional<fp::ExceptionBehavior> Except) {
llvm::SmallVector<Value *, 6> UseArgs;
append_range(UseArgs, Args);
if (Intrinsic::hasConstrainedFPRound... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %r12
movzwl 0x80(%rsp), %ebp
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movabsq $0x600000000, %rax # imm = 0x600000000
movq %rax, -0x8(%rbx)
leaq (%rdx,%rcx,8), %rcx
leaq ... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreatePtrDiff(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&) | Value *IRBuilderBase::CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
const Twine &Name) {
assert(LHS->getType() == RHS->getType() &&
"Pointer subtraction operand types must match!");
Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
Value *RHS_int =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x1a89f4e
movw $0x101, %bx # imm = 0x101
leaq 0x10(%rsp), %rbp
movw %bx, 0x20(%rbp)
movq %r14, %rdi
movl $0x2f, %... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreatePreserveStructAccessIndex(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::MDNode*) | Value *IRBuilderBase::CreatePreserveStructAccessIndex(
Type *ElTy, Value *Base, unsigned Index, unsigned FieldIndex,
MDNode *DbgInfo) {
auto *BaseType = Base->getType();
assert(isa<PointerType>(BaseType) &&
"Invalid Base ptr type for preserve.struct.access.index.");
Value *GEPIndex = getInt32(In... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x20(%rsp)
movl %r8d, 0x14(%rsp)
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
movq 0x8(%rdx), %r14
movq 0x48(%rdi), %rdi
callq 0x1a89f44
movl %ebx, %esi
xorl %r13d, %r13d
movq %rax, %rdi
xorl %edx, %edx... | /IR/IRBuilder.cpp |
llvm::Instruction::clone() const | Instruction *Instruction::clone() const {
Instruction *New = nullptr;
switch (getOpcode()) {
default:
llvm_unreachable("Unhandled Opcode.");
#define HANDLE_INST(num, opc, clas) \
case Instruction::opc: \
New... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %eax
addl $-0x1e, %eax
leaq 0x346c31c(%rip), %rcx # 0x4eade2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x1a4afc0
movq %rax, %r14
movb 0x1(%rbx), %al
andb $-0x2, %al
movb 0x1(%r14), %cl
andb $0x1, %cl
orb %al, %cl
movb %... | /IR/Instruction.cpp |
llvm::LoadInst::LoadInst(llvm::Type*, llvm::Value*, llvm::Twine const&, bool, llvm::Align, llvm::AtomicOrdering, unsigned char, llvm::InsertPosition) | LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
Align Align, AtomicOrdering Order, SyncScope::ID SSID,
InsertPosition InsertBef)
: UnaryInstruction(Ty, Load, Ptr, InsertBef) {
setVolatile(isVolatile);
setAlignment(Align);
setAtomic(Order, SSID... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movq %rcx, %rbx
movq %rdx, %rcx
movq %rdi, %r14
movb 0x48(%rsp), %bpl
movl 0x40(%rsp), %r13d
movq 0x50(%rsp), %r8
movzwl 0x58(%rsp), %r9d
movl $0x20, %edx
callq 0xa2388a
movzwl 0x2(%r14), %eax
andl $0xfffffc00... | /IR/Instructions.cpp |
llvm::AtomicCmpXchgInst::Init(llvm::Value*, llvm::Value*, llvm::Value*, llvm::Align, llvm::AtomicOrdering, llvm::AtomicOrdering, unsigned char) | 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 -0x60(%rdi), %rax
cmpq $0x0, -0x60(%rdi)
je 0x1a45b37
movq -0x58(%rdi), %r10
movq -0x50(%rdi), %r11
movq %r10, (%r11)
movq -0x58(%rdi), %r10
testq %r10, %r10
je 0x1a45b37
movq -0x50(%rdi), %r11
movq %r11, 0x10(%r10)
movq %rsi, (%rax)
testq %rsi, %rsi
je 0x1a45b5f
movq 0x10(%rsi), %r10
addq $0x10, %rsi
movq %r10, -... | /llvm/IR/OperandTraits.h |
llvm::AtomicCmpXchgInst::AtomicCmpXchgInst(llvm::Value*, llvm::Value*, llvm::Value*, llvm::Align, llvm::AtomicOrdering, llvm::AtomicOrdering, unsigned char, llvm::InsertPosition) | AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
Align Alignment,
AtomicOrdering SuccessOrdering,
AtomicOrdering FailureOrdering,
SyncScope::ID S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movzbl 0x68(%rsp), %ebx
movq 0x8(%rdx), %rbp
movq %rdx, %rdi
callq 0x1a8ff24
movq %rax, %rdi
callq 0x1a89f26
movq (%rbp), %rdi
le... | /IR/Instructions.cpp |
llvm::AtomicRMWInst::Init(llvm::AtomicRMWInst::BinOp, llvm::Value*, llvm::Value*, llvm::Align, llvm::AtomicOrdering, unsigned char) | 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 -0x40(%rdi), %rax
cmpq $0x0, -0x40(%rdi)
je 0x1a45d13
movq -0x38(%rdi), %r10
movq -0x30(%rdi), %r11
movq %r10, (%r11)
movq -0x38(%rdi), %r10
testq %r10, %r10
je 0x1a45d13
movq -0x30(%rdi), %r11
movq %r11, 0x10(%r10)
movq %rdx, (%rax)
testq %rdx, %rdx
je 0x1a45d3b
movq 0x10(%rdx), %r10
addq $0x10, %rdx
movq %r10, -... | /llvm/IR/OperandTraits.h |
llvm::ShuffleVectorInst::isSpliceMask(llvm::ArrayRef<int>, int, int&) | bool ShuffleVectorInst::isSpliceMask(ArrayRef<int> Mask, int NumSrcElts,
int &Index) {
if (Mask.size() != static_cast<unsigned>(NumSrcElts))
return false;
// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
int StartIndex = -1;
for (int I = 0, E = Mask.size(); I !=... | movl %edx, %eax
cmpq %rsi, %rax
jne 0x1a47276
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
shlq $0x20, %rax
setne %r8b
je 0x1a47279
movl %esi, %eax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %r9d, %r9d
xorl %r11d, %r11d
movl $0xffffffff, %r10d # imm = 0xFFFFFFFF
movslq (%rdi,%r11,4), %rbx
cmpq $-0x1,... | /IR/Instructions.cpp |
llvm::ShuffleVectorInst::isReplicationMask(llvm::ArrayRef<int>, int&, int&) | bool ShuffleVectorInst::isReplicationMask(ArrayRef<int> Mask,
int &ReplicationFactor, int &VF) {
// undef-less case is trivial.
if (!llvm::is_contained(Mask, PoisonMaskElem)) {
ReplicationFactor =
Mask.take_while([](int MaskElt) { return MaskElt == 0; }).size();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq (%rdi,%rsi,4), %r13
leaq 0x3466c51(%rip), %rdx # 0x4eae374
movq %r13, %rsi
callq 0x1436018
cmpq %r13, %rax
je 0x1a4783c
testq %r15, %r15
je 0x1a47789
leaq (,%r1... | /IR/Instructions.cpp |
llvm::UnaryOperator::AssertOK() | void UnaryOperator::AssertOK() {
Value *LHS = getOperand(0);
(void)LHS; // Silence warnings.
#ifndef NDEBUG
switch (getOpcode()) {
case FNeg:
assert(getType() == LHS->getType() &&
"Unary operation should return same type as operand!");
assert(getType()->isFPOrFPVectorTy() &&
"Tried... | retq
nop
| /IR/Instructions.cpp |
llvm::BinaryOperator::AssertOK() | void BinaryOperator::AssertOK() {
Value *LHS = getOperand(0), *RHS = getOperand(1);
(void)LHS; (void)RHS; // Silence warnings.
assert(LHS->getType() == RHS->getType() &&
"Binary operator operand types must match!");
#ifndef NDEBUG
switch (getOpcode()) {
case Add: case Sub:
case Mul:
assert(getT... | retq
nop
| /IR/Instructions.cpp |
llvm::VPIntrinsic::getVectorLengthParamPos(unsigned int) | std::optional<unsigned>
VPIntrinsic::getVectorLengthParamPos(Intrinsic::ID IntrinsicID) {
switch (IntrinsicID) {
default:
return std::nullopt;
#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS) \
case Intrinsic::VPID: \
re... | leal -0x182(%rdi), %eax
cmpl $0x58, %eax
ja 0x1a4d402
leaq 0x34616da(%rip), %rcx # 0x4eaeacc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %eax
jmp 0x1a4d422
addl $0xffffff61, %edi # imm = 0xFFFFFF61
cmpl $0x4, %edi
ja 0x1a4d43e
leaq 0x34616a4(%rip), %rax # 0x4eaeab8
movslq (%rax,%rdi,4), %... | /IR/IntrinsicInst.cpp |
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>>>>, ... | unsigned getNumBuckets() const {
return NumBuckets;
} | pushq %r15
pushq %r14
pushq %rbx
movl 0x10(%rdi), %r14d
testq %r14, %r14
je 0x1a55856
movq (%rdi), %rbx
shlq $0x4, %r14
addq $0x8, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x8(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a5584c
movq %rbx, %rdi
callq 0x19dd7f8
addq $0x10, %r... | /llvm/ADT/DenseMap.h |
llvm::PMDataManager::emitInstrCountChangedRemark(llvm::Pass*, llvm::Module&, long, unsigned int, llvm::StringMap<std::pair<unsigned int, unsigned int>, llvm::MallocAllocator>&, llvm::Function*) | void PMDataManager::emitInstrCountChangedRemark(
Pass *P, Module &M, int64_t Delta, unsigned CountBefore,
StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount,
Function *F) {
// If it's a pass manager, don't emit a remark. (This hinges on the assumption
// that the only passes that return non-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x388, %rsp # imm = 0x388
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x70(%rax)
testq %rax, %rax
jne 0x1a5900b
movl %ebp, 0x4(%rsp)
movq %r15, 0x50(%rsp)
movq %... | /IR/LegacyPassManager.cpp |
llvm::MDBuilder::createTBAAStructTypeNode(llvm::StringRef, llvm::ArrayRef<std::pair<llvm::MDNode*, unsigned long>>) | MDNode *MDBuilder::createTBAAStructTypeNode(
StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
SmallVector<Metadata *, 4> Ops(Fields.size() * 2 + 1);
Type *Int64 = Type::getInt64Ty(Context);
Ops[0] = createString(Name);
for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
Ops[i * 2 + 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1(%r8,%r8), %rsi
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
leaq 0x8(%rsp),... | /IR/MDBuilder.cpp |
llvm::DenseMapInfo<std::pair<llvm::StringRef, llvm::StringRef>, void>::getHashValue(std::pair<llvm::StringRef, llvm::StringRef> const&) | static unsigned getHashValue(const Pair& PairVal) {
return detail::combineHashValue(FirstInfo::getHashValue(PairVal.first),
SecondInfo::getHashValue(PairVal.second));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x1cc3dfe
movl %eax, %r14d
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x1cc3dfe
shlq $0x20, %r14
movl %eax, %eax
orq %r14, %rax
movabsq $-0x40a7b892e31b1a47, %rcx # imm = 0xBF58476D1CE4E5B9
imulq %rax, %rcx
movq %rcx, %... | /llvm/ADT/DenseMapInfo.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Metadata*, llvm::MetadataAsValue*, llvm::DenseMapInfo<llvm::Metadata*, void>, llvm::detail::DenseMapPair<llvm::Metadata*, llvm::MetadataAsValue*>>, llvm::Metadata*, llvm::MetadataAsValue*, llvm::DenseMapInfo<llvm::Metadata*, void>, llvm::detail::DenseMapPair<llvm::Metadata*, llvm... | 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 0x1a6d45e
testb %al, %al
je 0x1a64458
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x1928c6d(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::MetadataAsValue::get(llvm::LLVMContext&, llvm::Metadata*) | MetadataAsValue *MetadataAsValue::get(LLVMContext &Context, Metadata *MD) {
MD = canonicalizeMetadataForValue(Context, MD);
auto *&Entry = Context.pImpl->MetadataAsValues[MD];
if (!Entry)
Entry = new MetadataAsValue(Type::getMetadataTy(Context), MD);
return Entry;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
callq 0x1a644df
movq %rax, (%r14)
movl $0x210, %edi # imm = 0x210
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x1a6d4f0
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
jne 0x1a644d1
movl $0x20, %edi
callq 0x751940
movq ... | /IR/Metadata.cpp |
llvm::MDNode::replaceOperandWith(unsigned int, llvm::Metadata*) | const Header &getHeader() const {
return *(reinterpret_cast<const Header *>(this) - 1);
} | leaq -0x10(%rdi), %rax
movq -0x10(%rdi), %rcx
testb $0x2, %cl
jne 0x1a69c9f
leal (%rcx,%rcx), %r8d
andl $0x78, %r8d
movq %rax, %r9
subq %r8, %r9
jmp 0x1a69ca3
movq -0x20(%rdi), %r9
movl %esi, %r8d
cmpq %rdx, (%r9,%r8,8)
je 0x1a69cc5
testb $0x7f, 0x1(%rdi)
jne 0x1a65e2c
testb $0x2, %cl
jne 0x1a69cc6
addl %ecx, %ecx
andl... | /llvm/IR/Metadata.h |
std::pair<llvm::DenseMapIterator<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned ... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x1a6d90e
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1a6e27a
xorl %ecx, %ecx
jmp 0x1a6e29c
movq %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Value*, llvm::ValueAsMetadata*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueAsMetadata*>>::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::SmallVectorTemplateBase<llvm::MDOperand, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r12
movl $0x8, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0x1cba3de
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a6f538
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1a6f524
cal... | /llvm/ADT/SmallVector.h |
llvm::SymbolTableListTraits<llvm::GlobalVariable>::getListOwner() | ItemParentClass *getListOwner() {
size_t Offset = reinterpret_cast<size_t>(
&((ItemParentClass *)nullptr->*ItemParentClass::getSublistAccess(
static_cast<ValueSubClass *>(
nullptr))));
ListTy *Anchor = static_cast<... | leaq -0x8(%rdi), %rax
retq
nop
| /llvm/IR/SymbolTableListTraits.h |
llvm::Module::getSemanticInterposition() const | bool Module::getSemanticInterposition() const {
Metadata *MF = getModuleFlag("SemanticInterposition");
auto *Val = cast_or_null<ConstantAsMetadata>(MF);
if (!Val)
return false;
return cast<ConstantInt>(Val->getValue())->getZExtValue();
} | pushq %rax
leaq 0x343bcf8(%rip), %rsi # 0x4eaff10
movl $0x15, %edx
callq 0x1a734f8
testq %rax, %rax
je 0x1a7423a
movq 0x80(%rax), %rax
cmpl $0x41, 0x20(%rax)
jb 0x1a7423e
movq 0x18(%rax), %rax
jmp 0x1a74242
xorl %eax, %eax
jmp 0x1a74249
addq $0x18, %rax
cmpq $0x0, (%rax)
setne %al
popq %rcx
retq
nop
| /IR/Module.cpp |
llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*>* llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::GlobalValueSummary*>>, unsigned long, llvm::GlobalValueSummary*, llvm::DenseMapInfo<u... | 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 0x1a78a70
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [17], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::NumOccurrencesFlag, llvm::cl::cb<void, int>, llvm::cl::desc>(char const (&) [17], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::NumOccurrencesFlag const&, llvm::cl... | 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
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
mo... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<llvm::cl::parser<llvm::PassInfo const*>::OptionInfo, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r8
movl $0x38, %ecx
movq %r14, %rsi
callq 0x1cba3de
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x1a7cd31
movq (%rbx), %rax
imulq $0x38, %rcx, %rcx
addq %rax, %rcx
xorl %edx, %edx
leaq 0... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::Module*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<llvm::Module, llvm::AnalysisManager<llvm::Module>::Invalidator>, std::default_delete<llvm::detail::AnalysisResultConcept<llvm::Module, llvm::AnalysisManager<llvm::Module>::Invalidator>>>>, ... | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0xaaca8a
testl %ebp, %ebp
je 0x1a80b01
decl %ebp
je 0x1a80b05
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1a80b0a
xorl %ebp, %ebp
jmp 0x1a80b20
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl... | /llvm/ADT/DenseMap.h |
llvm::PassRegistry::addRegistrationListener(llvm::PassRegistrationListener*) | void PassRegistry::addRegistrationListener(PassRegistrationListener *L) {
sys::SmartScopedWriter<true> Guard(Lock);
Listeners.push_back(L);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
callq 0x7520f0
cmpl $0x23, %eax
je 0x1a825c6
movq 0x90(%rbx), %rsi
cmpq 0x98(%rbx), %rsi
je 0x1a825a7
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x90(%rbx)
jmp 0x1a825b8
leaq 0x88(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1a82b44
movq %rbx, %rdi
cal... | /IR/PassRegistry.cpp |
llvm::unique_function<void (llvm::StringRef, llvm::Any)>& llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::Any)>, false>::growAndEmplaceBack<llvm::TimePassesHandler::registerCallbacks(llvm::PassInstrumentationCallbacks&)::$_4>(llvm::TimePassesHandler::registerCallbacks(llvm::PassInstrume... | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Grow manually in case one of Args is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(0, NewCapacity);
::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
moveElementsForGrow(NewElts);
takeAllocationFor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r8
movl $0x20, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x1cba3de
movq %rax, %r15
movl 0x8(%rbx), %ebp
shlq $0x5, %rbp
movq (%r13), %r13
movq $0x0, 0x18(%rax,%rbp)
movl $0x8, ... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char [24], llvm::cl::OptionHidden, llvm::cl::initializer<char [5]>, llvm::cl::desc>(llvm::cl::opt<s... | 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, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7512e0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1c90c20
movl (%r15), %eax
movzwl 0xa(%r13), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx... | /llvm/Support/CommandLine.h |
void llvm::SmallVectorImpl<llvm::StringRef>::append<llvm::StringRef const*, void>(llvm::StringRef const*, llvm::StringRef const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x4, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x1a86f62
leaq 0x10(%rbx), %rsi
movl $0x10, %ecx
movq %rbx, %rdi
callq 0x1c... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::IntegerType*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntegerType*>>, unsigned int, llvm::IntegerType*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntegerType*>>::moveFromOldB... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1a8b259
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %rdx... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Type*, unsigned long>, llvm::ArrayType*, llvm::DenseMapInfo<std::pair<llvm::Type*, unsigned long>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Type*, unsigned long>, llvm::ArrayType*>>, std::pair<llvm::Type*, unsigned long>, llvm::ArrayType*, llvm::DenseMapInfo<st... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1a8c3ec
movq (%r15), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1000, (%rax) # imm = 0xF000
movq $-0x1, 0x8(%rax)
addq $0x18... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::AttributeList, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AttributeList, void>, llvm::detail::DenseSetPair<llvm::AttributeList>>::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::User::getDescriptor() | MutableArrayRef<uint8_t> User::getDescriptor() {
assert(HasDescriptor && "Don't call otherwise!");
assert(!HasHungOffUses && "Invariant!");
auto *DI = reinterpret_cast<DescriptorInfo *>(getIntrusiveOperands()) - 1;
assert(DI->SizeInBytes != 0 && "Should not have had a descriptor otherwise!");
return Mutable... | movl 0x4(%rdi), %eax
shll $0x5, %eax
subq %rax, %rdi
movq -0x8(%rdi), %rdx
leaq -0x8(%rdi), %rax
subq %rdx, %rax
retq
nop
| /IR/User.cpp |
(anonymous namespace)::Verifier::visitMDNode(llvm::MDNode const&, (anonymous namespace)::Verifier::AreDebugLocsAllowed) | void Verifier::visitMDNode(const MDNode &MD, AreDebugLocsAllowed AllowLocs) {
// Only visit each node once. Metadata can be mutually recursive, so this
// avoids infinite recursion here, as well as being an optimization.
if (!MDNodes.insert(&MD).second)
return;
Check(&MD.getContext() == &Context,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, 0x14(%rsp)
movq %rsi, %r13
movq %rdi, %r12
leaq 0x1b8(%rdi), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r13, %rdx
callq 0x1993b5c
cmpb $0x1, 0x10(%r15)
jne 0x1a9b680
movq 0x8(%r13), %rcx
movq %rcx, %rax
andq $-0x8, %rax
... | /IR/Verifier.cpp |
isContiguous(llvm::ConstantRange const&, llvm::ConstantRange const&) | static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
cmpl $0x40, 0x18(%r14)
ja 0x1a9c57a
movq (%rdi), %rax
cmpq (%rbx), %rax
sete %cl
jmp 0x1a9c584
movq %rbx, %rsi
callq 0x1c820f0
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1a9c59e
addq $0x10, %rbx
cmpl $0x40, 0x8(%r14)
ja 0x1a9c5a6... | /IR/Verifier.cpp |
(anonymous namespace)::Verifier::visitEHPadPredecessors(llvm::Instruction&) | void Verifier::visitEHPadPredecessors(Instruction &I) {
assert(I.isEHPad());
BasicBlock *BB = I.getParent();
Function *F = BB->getParent();
Check(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
if (auto *LPI = dyn_cast<LandingPadInst>(&I)) {
// The landingpad instruction defines its... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %r14
movq 0x48(%r14), %rax
movq 0x50(%rax), %rax
leaq -0x18(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
cmpq %rcx, %r14
je 0x1ab0401
xorl %eax, %eax
cmpb $0x5f, (%rsi)
cmoveq %rsi, %rax
movq %rax, 0x28... | /IR/Verifier.cpp |
llvm::DenseMap<llvm::MDNode const*, bool, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, bool>>::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::SetVector<llvm::BasicBlock*, llvm::SmallVector<llvm::BasicBlock*, 8u>, llvm::DenseSet<llvm::BasicBlock const*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>>, 8u>::contains(llvm::BasicBlock const* const&) const | bool contains(const key_type &key) const {
if constexpr (canBeSmall())
if (isSmall())
return is_contained(vector_, key);
return set_.find(key) != set_.end();
} | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x1ab9af8
movq (%rdx), %rsi
movq %rbx, %rdi
callq 0x1ab9bb8
movl 0x10(%rbx), %ecx
shlq $0x3, %rcx
addq (%rbx), %rcx
jmp 0x1ab9b13
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0x1ab9b1b
movl 0x20(%rbx), %ecx
shlq $0x3, %rcx
... | /llvm/ADT/SetVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::Instruction const*, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::Instruction const*>>, llvm::Instruction const*, llvm::Instruction const*, llvm::DenseMapInfo<llvm::Instruction const*, void... | 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 0x1aba78d
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /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.