name string | code string | asm string | file string |
|---|---|---|---|
non-virtual thunk to (anonymous namespace)::AAAssumptionInfoFunction::~AAAssumptionInfoFunction() | AAAssumptionInfoFunction(const IRPosition &IRP, Attributor &A)
: AAAssumptionInfoImpl(IRP, A,
getAssumptions(*IRP.getAssociatedFunction())) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x50(%rdi), %rbx
leaq 0x3701f58(%rip), %rax # 0x585d088
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x30, %rdi
callq 0x7c6c14
movq 0x30(%r14), %rdi
movl 0x40(%r14), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x1cac6c2
leaq 0x10(%r14), %rdi
callq 0x7c6c14
movq 0x10(%... | /Transforms/IPO/AttributorAttributes.cpp |
void llvm::set_intersect<llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>>(llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>&, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef... | void set_intersect(S1Ty &S1, const S2Ty &S2) {
auto Pred = [&S2](const auto &E) { return !S2.count(E); };
if constexpr (detail::HasMemberRemoveIf<S1Ty, decltype(Pred)>) {
S1.remove_if(Pred);
} else {
typename S1Ty::iterator Next;
for (typename S1Ty::iterator I = S1.begin(); I != S1.end(); I = Next) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x215b984
movq %rax, %r12
movl 0x10(%r14), %eax
shlq $0x4, %rax
addq (%r14), %rax
cmpq %rax, %r12
je 0x215b975
movq %rdx, %r15
leaq 0x8(%rsp), %r13
movq %r15, 0x10(%rsp)
leaq 0x10(%r12), %rax
movq %r... | /llvm/ADT/SetOperations.h |
llvm::IRAttribute<(llvm::Attribute::AttrKind)18, llvm::StateWrapper<llvm::BooleanState, llvm::AbstractAttribute>, llvm::AAMustProgress>::manifest(llvm::Attributor&) | ChangeStatus manifest(Attributor &A) override {
if (isa<UndefValue>(this->getIRPosition().getAssociatedValue()))
return ChangeStatus::UNCHANGED;
SmallVector<Attribute, 4> DeducedAttrs;
getDeducedAttributes(A, this->getAnchorValue().getContext(), DeducedAttrs);
if (DeducedAttrs.empty())
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0xbd3b80
movb (%rax), %al
andb $-0x2, %al
movl $0x1, %ebp
cmpb $0xc, %al
je 0x215bec1
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x400000000, %rax ... | /llvm/Transforms/IPO/Attributor.h |
bool llvm::function_ref<bool (llvm::AbstractCallSite)>::callback_fn<(anonymous namespace)::AAMustProgressFunction::updateImpl(llvm::Attributor&)::'lambda'(llvm::AbstractCallSite)>(long, llvm::AbstractCallSite) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x30(%rsp), %r12
movq %rax, -0x18(%r12)
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
cmpl $0x0, 0x10(%rsi)
je 0x215c029
leaq 0x20(%rsp), %rdi
addq $0x8, %rsi
callq 0xbd4792
movq 0x8(%rbx), %r14
movq 0x18(%rsp), %rax
xorp... | /llvm/ADT/STLFunctionalExtras.h |
bool llvm::Attributor::shouldUpdateAA<llvm::AAValueConstantRange>(llvm::IRPosition const&) | bool shouldUpdateAA(const IRPosition &IRP) {
// If this is queried in the manifest stage, we force the AA to indicate
// pessimistic fixpoint immediately.
if (Phase == AttributorPhase::MANIFEST || Phase == AttributorPhase::CLEANUP)
return false;
Function *AssociatedFn = IRP.getAssociatedFunction(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0xd78(%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
je 0x215dc6e
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xbd15c6
movq %rax, %r15
movq %r14, %rdi
callq 0xbd1662
cmpb $0x7, %al
ja 0x215dbd9
movzbl %al, %eax
movl $0xa8, %ecx
btl %eax, %ecx
jae... | /llvm/Transforms/IPO/Attributor.h |
bool llvm::function_ref<bool (llvm::AbstractCallSite)>::callback_fn<(anonymous namespace)::AANoAliasArgument::updateImpl(llvm::Attributor&)::'lambda'(llvm::AbstractCallSite)>(long, llvm::AbstractCallSite) | function_ref() = default; | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rax
leaq 0x18(%rsp), %rbx
movq %rax, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
cmpl $0x0, 0x10(%rsi)
je 0x215ea38
leaq 0x8(%rsp), %rdi
addq $0x8, %rsi
callq 0xbd4792
movl 0x10(%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x215ea4b
callq 0x751980... | /llvm/ADT/STLFunctionalExtras.h |
(anonymous namespace)::AANoAliasCallSiteArgument::updateImpl(llvm::Attributor&) | ChangeStatus updateImpl(Attributor &A) override {
// If the argument is readnone we are done as there are no accesses via the
// argument.
auto *MemBehaviorAA =
A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(), DepClassTy::NONE);
if (MemBehaviorAA && MemBehaviorAA->isAssumedReadNone()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rsi
movq 0x48(%rdi), %rdx
movl $0x1, (%rsp)
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movq %rbx, %rcx
movl $0x2, %r8d
xorl %r9d, %r9d
callq 0x213f712
movq %rax, %r14... | /Transforms/IPO/AttributorAttributes.cpp |
(anonymous namespace)::AAPrivatizablePtrFloating::identifyPrivatizableType(llvm::Attributor&) | std::optional<Type *> identifyPrivatizableType(Attributor &A) override {
Value *Obj = getUnderlyingObject(&getAssociatedValue());
if (!Obj) {
LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] No underlying object found!\n");
return nullptr;
}
if (auto *AI = dyn_cast<AllocaInst>(Obj))
if (auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x40, %rdi
callq 0xbd3b80
movq %rax, %rdi
movl $0x6, %esi
callq 0x29dce2a
movb $0x1, %bl
testq %rax, %rax
je 0x215f6c7
movq %rax, %r12
movzbl (%rax), %ebp
cmpl $0x16, %ebp
je 0x215f670
cmpl $0x3c, %e... | /Transforms/IPO/AttributorAttributes.cpp |
bool llvm::function_ref<bool (llvm::Value&)>::callback_fn<void clampReturnedValueStates<llvm::AAAlign, llvm::IncIntegerState<unsigned long, 4294967296ul, 1ul>, (llvm::Attribute::AttrKind)81, true>(llvm::Attributor&, llvm::AAAlign const&, llvm::IncIntegerState<unsigned long, 4294967296ul, 1ul>&, llvm::CallBase const*)::... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x213259c
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rcx
movl $0x1, (%rsp)
movq %rax, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x214d7a8
testq %rax, %rax
je 0x21658eb
movq (%rax), %rcx
movq %rax, %rdi
cal... | /llvm/ADT/STLFunctionalExtras.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<unsigned int, 12u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<unsigned int, 12u>>>, llvm::Instruction const*, llvm::SmallVector<unsigned int, 12u>, llvm::DenseMa... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x2177fee
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
shlq $0x3, %rax
leaq (%rax,%rax,8), %r14
addq $0x18, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x18(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2177fdf
movq -0x10(%rbx), %r... | /llvm/ADT/DenseMap.h |
bool llvm::AA::hasAssumedIRAttr<(llvm::Attribute::AttrKind)27, llvm::AbstractAttribute>(llvm::Attributor&, llvm::AbstractAttribute const*, llvm::IRPosition const&, llvm::DepClassTy, bool&, bool, llvm::AbstractAttribute const**) | bool hasAssumedIRAttr(Attributor &A, const AbstractAttribute *QueryingAA,
const IRPosition &IRP, DepClassTy DepClass, bool &IsKnown,
bool IgnoreSubsumingPositions = false,
const AAType **AAPtr = nullptr) {
IsKnown = false;
switch (AK) {
#define CASE(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movb $0x0, (%r8)
movabsq $0x3100000030, %rax # imm = 0x3100000030
leaq 0xc(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1b, 0x8(%rdx)
movl $0x3, %ecx
movq %r13,... | /llvm/Transforms/IPO/Attributor.h |
non-virtual thunk to (anonymous namespace)::AAUnderlyingObjectsCallSiteReturned::~AAUnderlyingObjectsCallSiteReturned() | AAUnderlyingObjectsCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AAUnderlyingObjectsImpl(IRP, A) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x36e2d26(%rip), %rax # 0x5866488
movq %rax, -0x50(%rdi)
leaq 0x36e2da3(%rip), %rax # 0x5866510
movq %rax, (%rdi)
movq 0x90(%rdi), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0x2183788
callq 0x751980
leaq -0x50(%rbx), %r14
movq 0x78(%rbx), %rdi
movl 0x88(%rbx)... | /Transforms/IPO/AttributorAttributes.cpp |
llvm::AAGlobalValueInfo* llvm::Attributor::lookupAAFor<llvm::AAGlobalValueInfo>(llvm::IRPosition const&, llvm::AbstractAttribute const*, llvm::DepClassTy, bool) | AAType *lookupAAFor(const IRPosition &IRP,
const AbstractAttribute *QueryingAA = nullptr,
DepClassTy DepClass = DepClassTy::OPTIONAL,
bool AllowInvalidState = false) {
static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
addq $0x68, %rdi
leaq 0x2e7d3ed(%rip), %rcx # 0x5002698
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0xb... | /llvm/Transforms/IPO/Attributor.h |
llvm::DenseMapBase<llvm::DenseMap<ReachabilityQueryInfo<llvm::Function>*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<ReachabilityQueryInfo<llvm::Function>*, void>, llvm::detail::DenseSetPair<ReachabilityQueryInfo<llvm::Function>*>>, ReachabilityQueryInfo<llvm::Function>*, llvm::detail::DenseSetEmpty, llvm::DenseMa... | 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 0x218cc58
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DOTGraphTraits<llvm::AttributorCallGraph*>::getNodeLabel[abi:cxx11](llvm::AACallGraphNode const*, llvm::AttributorCallGraph const*) | std::string getNodeLabel(const AACallGraphNode *Node,
const AttributorCallGraph *Graph) {
const AACallEdges *AACE = static_cast<const AACallEdges *>(Node);
return AACE->getAssociatedFunction()->getName().str();
} | pushq %rbx
movq %rdi, %rbx
leaq -0x60(%rdx), %rdi
testq %rdx, %rdx
cmoveq %rdx, %rdi
addq $0x40, %rdi
callq 0xbd15c6
movq %rax, %rdi
callq 0x1a90092
testq %rax, %rax
je 0x219079c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c37bc
jmp 0x21907af
leaq 0x10(%rbx), %rax
mo... | /llvm/Transforms/IPO/Attributor.h |
llvm::SetVector<unsigned long, llvm::SmallVector<unsigned long, 0u>, llvm::DenseSet<unsigned long, llvm::DenseMapInfo<unsigned long, void>>, 0u>::insert(unsigned long 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
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1acb8f8
movb 0x10(%r15), %bpl
cmpb $0x1, %bpl
jne 0x21967d9
addq $0x18, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8e0f0a
mo... | /llvm/ADT/SetVector.h |
void llvm::SmallVectorImpl<llvm::SmallVector<llvm::DeadArgumentEliminationPass::RetOrArg, 5u>>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x2199ea5
movq %rsi, %rbx
movq %rdi, %r14
jbe 0x2199e48
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2199eae
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x2199e5c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2199f10
movl 0x8(%... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::Metadata*, llvm::SmallSet<std::pair<llvm::GlobalVariable*, unsigned long>, 4u, std::less<std::pair<llvm::GlobalVariable*, unsigned long>>>, llvm::DenseMapInfo<llvm::Metadata*, void>, llvm::detail::DenseMapPair<llvm::Metadata*, llvm::SmallSet<std::pair<llvm::GlobalVariable*, unsigned long>, 4u, std:... | 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, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::BasicBlock*, llvm::CodeExtractor>, false>::destroy_range(std::pair<llvm::BasicBlock*, llvm::CodeExtractor>*, std::pair<llvm::BasicBlock*, llvm::CodeExtractor>*) | static void destroy_range(T *S, T *E) {
while (S != E) {
--E;
E->~T();
}
} | cmpq %rdi, %rsi
je 0x21baf34
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $-0x40, %r14
leaq 0x40(%r14), %rax
movq 0x30(%r14), %rdi
cmpq %rdi, %rax
je 0x21baeaf
callq 0x751980
movq 0x18(%r14), %rdi
movl 0x28(%r14), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movq -0x10(%r14), %rdi
cmpq ... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, std::pair<std::pair<unsigned int, unsigned int>, llvm::SmallVector<unsigned int, 2u>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::pair<std::pair<unsigned int, unsigned int>, llvm::SmallVector<unsigned int, 2u>>>>, unsigned int, s... | 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
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x21c406e
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,4), %rdx
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::cl::opt<llvm::ReplayInlinerSettings::Scope, false, llvm::cl::parser<llvm::ReplayInlinerSettings::Scope>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
addq $0x98, %rdi
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x21ce8d8
movl %eax, %r14d
testb %al, %al
jne 0x21ce722
movl 0xc(%rsp), %eax
movl %eax, 0x80(%rbx)
movw %bp, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<llvm::GlobPattern, false>::moveElementsForGrow(llvm::GlobPattern*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rax,%rax,8), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x21d1282
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x21d1279
movq (%rbx), %rbx
addq $-0x38, %rbx
shlq $0x3, %rax
leaq (%rax,%rax,8), %r14
leaq (%rbx,%r14), %rdi... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Comdat const*, llvm::InternalizePass::ComdatInfo, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseMapPair<llvm::Comdat const*, llvm::InternalizePass::ComdatInfo>>, llvm::Comdat const*, llvm::InternalizePass::ComdatInfo, llvm::DenseMapInfo<llvm::Comdat const... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x21d141e
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, (%... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<llvm::PassSummaryAction, false, llvm::cl::parser<llvm::PassSummaryAction>>::getValueExpectedFlagDefault() const | enum ValueExpected getValueExpectedFlagDefault() const {
// If there is an ArgStr specified, then we are of the form:
//
// -opt=O2 or -opt O2 or -optO2
//
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
// -... | movq 0xa0(%rdi), %rcx
xorl %eax, %eax
cmpq $0x1, 0x18(%rcx)
adcl $0x2, %eax
retq
| /llvm/Support/CommandLine.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Metadata*, unsigned long, llvm::DenseMapInfo<llvm::Metadata*, void>, llvm::detail::DenseMapPair<llvm::Metadata*, unsigned long>>, llvm::Metadata*, unsigned long, llvm::DenseMapInfo<llvm::Metadata*, void>, llvm::detail::DenseMapPair<llvm::Metadata*, unsigned long>>::LookupBuc... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x21e125f
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::MapVector<llvm::FunctionSummary*, std::vector<(anonymous namespace)::CallsiteContextGraph<(anonymous namespace)::IndexCallsiteContextGraph, llvm::FunctionSummary, (anonymous namespace)::IndexCall>::CallInfo, std::allocator<(anonymous namespace)::CallsiteContextGraph<(anonymous namespace)::IndexCallsiteContextGrap... | ValueT &operator[](const KeyT &Key) {
std::pair<KeyT, typename MapType::mapped_type> Pair = std::make_pair(Key, 0);
std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
auto &I = Result.first->second;
if (Result.second) {
Vector.push_back(std::make_pair(Key, ValueT()));
I =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x28(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x30(%rsp), %r15
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21fb2f2
movq (%r15), %r12
cmpb $0x1, 0x10... | /llvm/ADT/MapVector.h |
llvm::DenseMap<llvm::Function*, std::shared_ptr<llvm::SmallVector<llvm::Use*, 16u>>, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, std::shared_ptr<llvm::SmallVector<llvm::Use*, 16u>>>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::BooleanStateWithSetVector<llvm::Instruction*, false>::~BooleanStateWithSetVector() | bool contains(const Ty &Elem) const { return Set.contains(Elem); } | pushq %rbx
movq %rdi, %rbx
leaq 0x363ffa3(%rip), %rax # 0x5869978
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x22299ea
callq 0x751980
movq 0x10(%rbx), %rdi
movl 0x20(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7510e... | /Transforms/IPO/OpenMPOpt.cpp |
(anonymous namespace)::BooleanStateWithSetVector<llvm::Function*, false>::~BooleanStateWithSetVector() | bool contains(const Ty &Elem) const { return Set.contains(Elem); } | pushq %rbx
movq %rdi, %rbx
leaq 0x363ff89(%rip), %rax # 0x58699d8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2229a64
callq 0x751980
movq 0x10(%rbx), %rdi
movl 0x20(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7510e... | /Transforms/IPO/OpenMPOpt.cpp |
(anonymous namespace)::AAICVTrackerCallSite::initialize(llvm::Attributor&) | void initialize(Attributor &A) override {
assert(getAnchorScope() && "Expected anchor function");
// We only initialize this AA for getters, so we need to know which ICV it
// gets.
auto &OMPInfoCache = static_cast<OMPInformationCache &>(A.getInfoCache());
for (InternalControlVar ICV : TrackableICV... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
movq 0xa0(%rsi), %rax
movslq 0x5c(%rbx), %rcx
leaq (%rcx,%rcx,8), %rcx
movl 0x7ec8(%rax,%rcx,8), %ebp
movslq 0x7f04(%rax,%rcx,8), %rcx
imulq $0x98, %rcx, %rcx
movq 0xdc0(%rax,%rcx), %r14
callq 0xbd15c6
cmpq %rax, %r14
je 0x223383c
movq 0x50(%rbx), %rax
a... | /Transforms/IPO/OpenMPOpt.cpp |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock*, llvm::SmallPtrSet<llvm::Instruction*, 4u>, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::SmallPtrSet<llvm::Instruction*, 4u>>>, llvm::BasicBlock*, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseM... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x2237633
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %r11d
leaq (%r11,%r11,8)... | /llvm/ADT/DenseMap.h |
llvm::SampleProfileLoaderBaseImpl<llvm::Function>::getProbeWeight(llvm::Instruction const&) | ErrorOr<uint64_t>
SampleProfileLoaderBaseImpl<BT>::getProbeWeight(const InstructionT &Inst) {
assert(FunctionSamples::ProfileIsProbeBased &&
"Profile is not pseudo probe based");
std::optional<PseudoProbe> Probe = extractProbe(Inst);
// Ignore the non-probe instruction. If none of the instruction in the ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2b0261b
cmpb $0x0, 0x14(%r12)
je 0x2243fc6
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
testq %rax, %rax... | /llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h |
(anonymous namespace)::SampleProfileLoader::findCalleeFunctionSamples(llvm::CallBase const&) const | const FunctionSamples *
SampleProfileLoader::findCalleeFunctionSamples(const CallBase &Inst) const {
const DILocation *DIL = Inst.getDebugLoc();
if (!DIL) {
return nullptr;
}
StringRef CalleeName;
if (Function *Callee = Inst.getCalledFunction())
CalleeName = Callee->getName();
if (FunctionSamples:... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsi), %rdi
callq 0x1a0e99e
testq %rax, %rax
je 0x2244ed1
movq %rax, %r15
movq -0x20(%r14), %rax
xorl %edi, %edi
testq %rax, %rax
je 0x2244e30
cmpb $0x0, (%rax)
cmoveq %rax, %rdi
testq %rdi, %rdi
je 0x2244e... | /Transforms/IPO/SampleProfile.cpp |
void llvm::OptimizationRemarkEmitter::emit<llvm::SampleProfileLoaderBaseImpl<llvm::Function>::getProbeWeight(llvm::Instruction const&)::'lambda'()>(llvm::SampleProfileLoaderBaseImpl<llvm::Function>::getProbeWeight(llvm::Instruction const&)::'lambda'(), decltype(fp())*) | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
callq 0x9094d2
testb %al, %al
je 0x2244f30
leaq 0x1d0(%rsp), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2244f3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x295cdb2
leaq 0x35ae8b9(%rip), %rax # 0x57f37d8
addq $0x10, %rax
movq %rax, (%r... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::SampleProfileLoaderBaseImpl<llvm::Function>::emitCoverageRemarks(llvm::Function&) | void SampleProfileLoaderBaseImpl<BT>::emitCoverageRemarks(FunctionT &F) {
// If coverage checking was requested, compute it now.
const Function &Func = getFunction(F);
if (SampleProfileRecordCoverage) {
unsigned Used = CoverageTracker.countUsedRecords(Samples, PSI);
unsigned Total = CoverageTracker.countB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
leaq 0x36cd5f6(%rip), %rbx # 0x5917fa8
cmpl $0x0, 0x80(%rbx)
je 0x224ac6b
leaq 0x410(%r14), %r13
movq 0x478(%r14), %rsi
movq 0x4c8(%r14), %rdx
movq %r13, %rdi
callq 0x281b... | /llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h |
(anonymous namespace)::SampleProfileLoader::promoteMergeNotInlinedContextSamples(llvm::MapVector<llvm::CallBase*, llvm::sampleprof::FunctionSamples const*, llvm::DenseMap<llvm::CallBase*, unsigned int, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::DenseMapPair<llvm::CallBase*, unsigned int>>, llvm::SmallVect... | void SampleProfileLoader::promoteMergeNotInlinedContextSamples(
MapVector<CallBase *, const FunctionSamples *> NonInlinedCallSites,
const Function &F) {
// Accumulate not inlined callsite information into notInlinedSamples
for (const auto &Pair : NonInlinedCallSites) {
CallBase *I = Pair.first;
Func... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdx, 0x30(%rsp)
movq %rdi, (%rsp)
movl 0x20(%rsi), %ebp
testq %rbp, %rbp
je 0x224c52e
movq 0x18(%rsi), %r12
movq (%rsp), %rax
leaq 0x5f8(%rax), %rcx
movq %rcx, 0x10(%rsp)
addq $0x440, %rax # imm... | /Transforms/IPO/SampleProfile.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::BasicBlock const*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::BasicBlock const*>>, llvm::BasicBlock const*, llvm::BasicBlock const*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm:... | 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 0x2250650
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2250726
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2250730
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
llvm::df_iterator<llvm::Function const*, llvm::df_iterator_default_set<llvm::BasicBlock const*, 8u>, true, llvm::GraphTraits<llvm::Function const*>>::toNext() | inline void toNext() {
do {
NodeRef Node = VisitStack.back().first;
std::optional<ChildItTy> &Opt = VisitStack.back().second;
if (!Opt)
Opt.emplace(GT::child_begin(Node));
// Notice that we directly mutate *Opt here, so that
// VisitStack.back().second actually gets updated a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x10(%rbx), %r15
movq -0x20(%r15), %r12
cmpb $0x0, -0x8(%r15)
jne 0x22525e9
leaq 0x30(%r12), %rax
movq 0x30(%r12), %rcx
cmpq %rax, %rcx
je 0x22525d6
leaq -0x18(%rcx), %rax
testq... | /llvm/ADT/DepthFirstIterator.h |
llvm::idf_ext_iterator<llvm::BasicBlock const*, llvm::df_iterator_default_set<llvm::BasicBlock const*, 8u>> llvm::idf_ext_begin<llvm::BasicBlock const*, llvm::df_iterator_default_set<llvm::BasicBlock const*, 8u>>(llvm::BasicBlock const* const&, llvm::df_iterator_default_set<llvm::BasicBlock const*, 8u>&) | idf_ext_iterator<T, SetTy> idf_ext_begin(const T& G, SetTy &S) {
return idf_ext_iterator<T, SetTy>::begin(Inverse<T>(G), S);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2252738
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x2252956
movq (%r14), %rdi
testq %rdi, %rdi
je 0x... | /llvm/ADT/DepthFirstIterator.h |
void llvm::ErrorOr<std::unordered_map<llvm::sampleprof::FunctionId, unsigned long, std::hash<llvm::sampleprof::FunctionId>, std::equal_to<llvm::sampleprof::FunctionId>, std::allocator<std::pair<llvm::sampleprof::FunctionId const, unsigned long>>>>::moveConstruct<std::unordered_map<llvm::sampleprof::FunctionId, unsigned... | void moveConstruct(ErrorOr<OtherT> &&Other) {
if (!Other.HasError) {
// Get the other value.
HasError = false;
new (getStorage()) storage_type(std::move(*Other.getStorage()));
} else {
// Get other's error.
HasError = true;
new (getErrorStorage()) std::error_code(Other.getErr... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x38(%rdi), %al
testb $0x1, 0x10(%rsi)
je 0x22534c8
orb $0x1, %al
movb %al, 0x38(%rbx)
testb $0x1, 0x10(%rsi)
je 0x2253505
movl (%rsi), %ebp
movq 0x8(%rsi), %rax
jmp 0x225350c
andb $-0x2, %al
movb %al, 0x38(%rbx)
movq (%rsi), %rsi
xorl %eax, %eax
movq %rax, (%rbx)
m... | /llvm/Support/ErrorOr.h |
llvm::SampleProfileMatcher::functionHasProfile(llvm::sampleprof::FunctionId const&, llvm::Function*&) | bool SampleProfileMatcher::functionHasProfile(const FunctionId &IRFuncName,
Function *&FuncWithoutProfile) {
FuncWithoutProfile = nullptr;
auto R = FunctionsWithoutProfile.find(IRFuncName);
if (R != FunctionsWithoutProfile.end())
FuncWithoutProfile = R->second;
... | pushq %rbx
movq %rdx, %rbx
movq $0x0, (%rdx)
addq $0x110, %rdi # imm = 0x110
callq 0x224d236
testq %rax, %rax
je 0x2254c3b
movq 0x10(%rax), %rax
movq %rax, (%rbx)
cmpq $0x0, (%rbx)
sete %al
popq %rbx
retq
| /Transforms/IPO/SampleProfileMatcher.cpp |
llvm::SampleProfileMatcher::functionMatchesProfile(llvm::sampleprof::FunctionId const&, llvm::sampleprof::FunctionId const&, bool) | bool SampleProfileMatcher::functionMatchesProfile(
const FunctionId &IRFuncName, const FunctionId &ProfileFuncName,
bool FindMatchedProfileOnly) {
if (IRFuncName == ProfileFuncName)
return true;
if (!SalvageUnusedProfile)
return false;
// If IR function doesn't have profile and the profile is unu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x22479ba
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2254cc7
leaq 0x36a16c2(%rip), %rax # 0x58f6348
cmpb $0x1, 0x80(%rax)
jne 0x2254cc5
leaq 0x110(%r14)... | /Transforms/IPO/SampleProfileMatcher.cpp |
llvm::SampleProfileMatcher::longestCommonSequence(std::vector<std::pair<llvm::sampleprof::LineLocation, llvm::sampleprof::FunctionId>, std::allocator<std::pair<llvm::sampleprof::LineLocation, llvm::sampleprof::FunctionId>>> const&, std::vector<std::pair<llvm::sampleprof::LineLocation, llvm::sampleprof::FunctionId>, std... | LocToLocMap
SampleProfileMatcher::longestCommonSequence(const AnchorList &AnchorList1,
const AnchorList &AnchorList2,
bool MatchUnusedFunction) {
int32_t Size1 = AnchorList1.size(), Size2 = AnchorList2.size(),
MaxDepth =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x18(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x8(%rdx), %rsi
movq %rdx, 0x50(%rsp)
subq (%rdx), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
movq 0x8(%rcx), %rbx
movq %r... | /Transforms/IPO/SampleProfileMatcher.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [23], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [23], 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 0x7c77e2
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3491bee(%rip), %rax # 0x56f2640
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::InstCostVisitor::getUserBonus(llvm::Instruction*, llvm::Value*, llvm::Constant*) | Bonus InstCostVisitor::getUserBonus(Instruction *User, Value *Use, Constant *C) {
// We have already propagated a constant for this user.
if (KnownConstants.contains(User))
return {0, 0};
// Cache the iterator before visiting.
LastVisited = Use ? KnownConstants.insert({Use, C}).first
: ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r13
leaq 0x20(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x22753ca
movq $0x0, (%rsp)
movl $0x0, %r15d
testb %al, %al
jn... | /Transforms/IPO/FunctionSpecialization.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::SpecSig, unsigned int, llvm::DenseMapInfo<llvm::SpecSig, void>, llvm::detail::DenseMapPair<llvm::SpecSig, unsigned int>>, llvm::SpecSig, unsigned int, llvm::DenseMapInfo<llvm::SpecSig, void>, llvm::detail::DenseMapPair<llvm::SpecSig, unsigned int>>::find(llvm::SpecSig const&) | 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
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x22762e8
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x5, %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::LoopVectorizationPlanner::tryToBuildVPlanWithVPRecipes(llvm::VFRange&) | VPlanPtr
LoopVectorizationPlanner::tryToBuildVPlanWithVPRecipes(VFRange &Range) {
SmallPtrSet<const InterleaveGroup<Instruction> *, 1> InterleaveGroups;
// ---------------------------------------------------------------------------
// Build initial VPlan: Scan the body of the loop in a topological order to
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp # imm = 0x3E8
movq %rsi, %rbp
movq %rdi, 0xe8(%rsp)
leaq 0x268(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1, -0x10(%rax)
movl $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x270(%rsp), %r14
movaps %xmm0, (%r... | /Transforms/Vectorize/LoopVectorize.cpp |
llvm::VPInterleaveRecipe::VPInterleaveRecipe(llvm::InterleaveGroup<llvm::Instruction> const*, llvm::VPValue*, llvm::ArrayRef<llvm::VPValue*>, llvm::VPValue*, bool) | VPInterleaveRecipe(const InterleaveGroup<Instruction> *IG, VPValue *Addr,
ArrayRef<VPValue *> StoredValues, VPValue *Mask,
bool NeedsMaskForGaps)
: VPRecipeBase(VPDef::VPInterleaveSC, {Addr}), IG(IG),
NeedsMaskForGaps(NeedsMaskForGaps) {
for (unsigned i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movb 0x60(%rsp), %bpl
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
movl $0x1, %ecx
movq %rdi, (%rsp)
movl $0x4, %esi
movq %rax, %rdx
movq %r... | /Transforms/Vectorize/VPlan.h |
llvm::VPWidenStoreEVLRecipe::execute(llvm::VPTransformState&) | void VPWidenStoreEVLRecipe::execute(VPTransformState &State) {
assert(State.UF == 1 && "Expected only UF == 1 when vectorizing with "
"explicit vector length.");
auto *SI = cast<StoreInst>(&Ingredient);
VPValue *StoredValue = getStoredValue();
bool CreateScatter = !isConsecutive();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x68(%rdi), %rdx
movb (%rdx), %al
cmpb $0x3d, %al
jne 0x22a6663
movb 0x2(%rdx), %cl
shrb %cl
andb $0x3f, %cl
movb %cl, 0x17(%rsp)
movq 0x30(%r12), %rcx
cmpb $0x3d, %al
je 0x22a6677
movb 0x2(%rdx), %al... | /Transforms/Vectorize/LoopVectorize.cpp |
(anonymous namespace)::GeneratedRTChecks::Create(llvm::Loop*, llvm::LoopAccessInfo const&, llvm::SCEVPredicate const&, llvm::ElementCount, unsigned int) | void Create(Loop *L, const LoopAccessInfo &LAI,
const SCEVPredicate &UnionPred, ElementCount VF, unsigned IC) {
// Hard cutoff to limit compile-time increase in case a very large number of
// runtime checks needs to be generated.
// TODO: Skip cutoff if the loop is guaranteed to execute, e.g.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x8(%rdx), %rax
movl 0x130(%rax), %eax
cmpl 0x365206a(%rip), %eax # 0x58fa700
seta 0x698(%rdi)
ja 0x22a8b1c
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq %r9, 0x8(%rsp)
movq 0x20(%rsi), %rax
m... | /Transforms/Vectorize/LoopVectorize.cpp |
llvm::VPWidenLoadRecipe::clone() | VPWidenLoadRecipe *clone() override {
return new VPWidenLoadRecipe(cast<LoadInst>(Ingredient), getAddr(),
getMask(), Consecutive, Reverse,
getDebugLoc());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl $0xb0, %edi
callq 0x751940
movq %rax, %rbx
movq 0x30(%r15), %rax
cmpb $0x1, 0x72(%r15)
jne 0x22aaefd
movl 0x38(%r15), %ecx
decl %ecx
movq (%rax,%rcx,8), %rcx
jmp 0x22aaeff
xorl %ecx, %ecx
movq 0x68(%r15), %r12
movq (... | /Transforms/Vectorize/VPlan.h |
auto llvm::map_range<llvm::iterator_range<llvm::df_iterator<llvm::VPBlockShallowTraversalWrapper<llvm::VPBlockBase*>, llvm::df_iterator_default_set<llvm::VPBlockBase*, 8u>, false, llvm::GraphTraits<llvm::VPBlockShallowTraversalWrapper<llvm::VPBlockBase*>>>> const&, auto llvm::VPBlockUtils::blocksOnly<llvm::VPBasicBlock... | auto map_range(ContainerTy &&C, FuncTy F) {
return make_range(map_iterator(std::begin(C), F),
map_iterator(std::end(C), F));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x118(%rsp), %rsi
leaq 0xf8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x1cb9ff4
leaq 0x158(%rsp), %r12
leaq 0x60(%r14), %rsi
movq %r12, %rdi
callq 0x22b097a
leaq 0x28(%rsp), %rs... | /llvm/ADT/STLExtras.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ElementCount, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseMapInfo<llvm::ElementCount, void>, llvm::detail::DenseMapPair<llvm::ElementCount, llvm::SmallPtrSet<llvm::Instruction*, 4u>>>, llvm::ElementCount, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseMapInfo<llv... | 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 0x22b2e1a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x22b95d9
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x22b95e4
movl (%rbx), %ecx
movl %ecx, (%rax)
movb 0... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [14], llvm::cl::initializer<int>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [14], llvm::cl::initializer<int> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3433120(%rip), %rax # 0x56f2640
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector<std::pair<unsigned int, llvm::slpvectorizer::BoUpSLP::TreeEntry*>, 3u>, llvm::DenseMapInfo<llvm::slpvectorizer::BoUpSLP::TreeEntry*, void>, llvm::detail::DenseMapPair<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector... | 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 0x23141c0
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,8), %rdx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %r... | /llvm/ADT/DenseMap.h |
isCommutative(llvm::Instruction*) | static bool isCommutative(Instruction *I) {
if (auto *Cmp = dyn_cast<CmpInst>(I))
return Cmp->isCommutative();
if (auto *BO = dyn_cast<BinaryOperator>(I))
return BO->isCommutative() ||
(BO->getOpcode() == Instruction::Sub &&
!BO->hasNUsesOrMore(UsesLimit) &&
all_of(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb (%rdi), %r14b
andb $-0x2, %r14b
cmpb $0x52, %r14b
jne 0x22d0da3
movq %rbx, %rdi
callq 0x1a49f08
movl %eax, %ebp
cmpb $0x52, %r14b
je 0x22d0e11
movzbl (%rbx), %r12d
addl $-0x3c, %r12d
xorl %r14d, %r14d
cmpl $-0x12, %r... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::slpvectorizer::BoUpSLP::canMapToVector(llvm::Type*) const | unsigned BoUpSLP::canMapToVector(Type *T) const {
unsigned N = 1;
Type *EltTy = T;
while (isa<StructType, ArrayType, FixedVectorType>(EltTy)) {
if (auto *ST = dyn_cast<StructType>(EltTy)) {
// Check that struct is homogeneous.
for (const auto *Ty : ST->elements())
if (Ty != *ST->element_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebx
movq %rsi, %r12
movzbl 0x8(%r12), %eax
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
ja 0x22d13cf
cmpl $0x10, %eax
setne %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
je 0x22d138e
cmpl $0x11, %eax
se... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::slpvectorizer::BoUpSLP::TreeEntry::buildAltOpShuffleMask(llvm::function_ref<bool (llvm::Instruction*)>, llvm::SmallVectorImpl<int>&, llvm::SmallVectorImpl<llvm::Value*>*, llvm::SmallVectorImpl<llvm::Value*>*) const | void BoUpSLP::TreeEntry::buildAltOpShuffleMask(
const function_ref<bool(Instruction *)> IsAltOp, SmallVectorImpl<int> &Mask,
SmallVectorImpl<Value *> *OpScalars,
SmallVectorImpl<Value *> *AltScalars) const {
unsigned Sz = Scalars.size();
Mask.assign(Sz, PoisonMaskElem);
SmallVector<int> OrderMask;
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
movl 0x8(%rdi), %ebx
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xa26612
leaq... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::slpvectorizer::BoUpSLP::isFullyVectorizableTinyTree(bool) const | bool BoUpSLP::isFullyVectorizableTinyTree(bool ForReduction) const {
LLVM_DEBUG(dbgs() << "SLP: Check whether the tree with height "
<< VectorizableTree.size() << " is fully vectorizable .\n");
auto &&AreVectorizableGathers = [this](const TreeEntry *TE, unsigned Limit) {
SmallVector<int> Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpl $0x1, 0x8(%rdi)
jne 0x22d5be6
movl %esi, %eax
movq (%rbx), %rcx
movq (%rcx), %rsi
movb $0x1, %bpl
cmpl $0x0, 0x70(%rsi)
je 0x22d5c63
testb %al, %al
je 0x22d5be6
movl 0x8(%rsi), %edx
leaq 0x8(%rsp), %rdi
callq 0x22d5c6e
testb %al... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::SmallVectorTemplateBase<llvm::SmallPtrSet<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, 4u>, false>::push_back(llvm::SmallPtrSet<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, 4u> const&) | void push_back(const T &Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
::new ((void *)this->end()) T(*EltPtr);
this->set_size(this->size() + 1);
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x2322b82
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
shlq $0x6, %rdx
leaq (%rcx,%rdx), %rdi
leaq (%rcx,%rdx), %rsi
addq $0x20, %rsi
movq %rax, %rdx
callq 0x1cb9ff4
incl 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, int>>, llvm::Value*, int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, int>>::find(llvm::Value const*) | 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 0x2323bc4
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<llvm::slpvectorizer::BoUpSLP::TreeEntry const*>::swap(llvm::SmallVectorImpl<llvm::slpvectorizer::BoUpSLP::TreeEntry const*>&) | void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
if (this == &RHS) return;
// We can only avoid copying elements if neither vector is small.
if (!this->isSmall() && !RHS.isSmall()) {
std::swap(this->BeginX, RHS.BeginX);
std::swap(this->Size, RHS.Size);
std::swap(this->Capacity, RHS.Capacity);... | cmpq %rsi, %rdi
je 0x22db4cc
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x10(%rdi), %rsi
cmpq %rsi, %rax
je 0x22db3f7
movq (%rbx), %rcx
leaq 0x10(%rbx), %rdx
cmpq %rdx, %rcx
je 0x22db3f7
movq %rcx, (%r14)
movq %rax, (%rbx)
movl 0x8(%r14), %eax
movl 0x8(... | /llvm/ADT/SmallVector.h |
llvm::SmallVector<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, 6u>& llvm::SmallVectorImpl<llvm::SmallVector<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, 6u>>::emplace_back<int, llvm::slpvectorizer::BoUpSLP::TreeEntry const*&>(int&&, llvm::slpvectorizer::BoUpSLP::TreeEntry const*&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x22db63b
movq (%rbx), %rcx
shlq $0x6, %rax
leaq (%rcx,%rax), %rdi
movslq (%rsi), %rsi
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x10(%rax)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%rax)
movq (%rdx), %rdx
callq 0x2323... | /llvm/ADT/SmallVector.h |
llvm::VFShape::get(llvm::FunctionType const*, llvm::ElementCount, bool) | static VFShape get(const FunctionType *FTy, ElementCount EC,
bool HasGlobalPred) {
SmallVector<VFParameter, 8> Parameters;
for (unsigned I = 0; I < FTy->getNumParams(); ++I)
Parameters.push_back(VFParameter({I, VFParamKind::Vector}));
if (HasGlobalPred)
Parameters.push_back(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movl 0xc(%rsi), %eax
decl %eax
je 0x22e2f51
movq %rsi, %r15
xorl %r12d... | /llvm/IR/VFABIDemangler.h |
llvm::slpvectorizer::BoUpSLP::getVectorElementSize(llvm::Value*) | unsigned BoUpSLP::getVectorElementSize(Value *V) {
// If V is a store, just return the width of the stored value (or value
// truncated just before storing) without traversing the expression tree.
// This is the common case.
if (auto *Store = dyn_cast<StoreInst>(V))
return DL->getTypeSizeInBits(Store->getVa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %r15
movb (%rsi), %bl
cmpb $0x3e, %bl
jne 0x22e7b80
movq 0xad0(%r15), %rdi
movq -0x40(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x8ef294
leaq 0x88(%rsp), %rdi
movq %rax, (%rdi)
movb %dl, ... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::iterator_range<llvm::po_iterator<llvm::BasicBlock*, llvm::SmallPtrSet<llvm::GraphTraits<llvm::BasicBlock*>::NodeRef, 8u>, false, llvm::GraphTraits<llvm::BasicBlock*>>> llvm::post_order<llvm::BasicBlock*>(llvm::BasicBlock* const&) | iterator_range<po_iterator<T>> post_order(const T &G) {
return make_range(po_begin(G), po_end(G));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x1b8(%rsp), %r14
movq %r14, %rdi
callq 0x90dbae
leaq 0x8(%rsp), %r15
movl $0x1b0, %edx # imm = 0x1B0
movq %r15, %rdi
xorl %esi, %esi
callq 0x751260
leaq 0x28(%rsp), %rax
movq %rax, -... | /llvm/ADT/PostOrderIterator.h |
llvm::SLPVectorizerPass::vectorizeStores(llvm::ArrayRef<llvm::StoreInst*>, llvm::slpvectorizer::BoUpSLP&, llvm::DenseSet<std::tuple<llvm::Value*, llvm::Value*, llvm::Value*, llvm::Value*, unsigned int>, llvm::DenseMapInfo<std::tuple<llvm::Value*, llvm::Value*, llvm::Value*, llvm::Value*, unsigned int>, void>>&) | bool SLPVectorizerPass::vectorizeStores(
ArrayRef<StoreInst *> Stores, BoUpSLP &R,
DenseSet<std::tuple<Value *, Value *, Value *, Value *, unsigned>>
&Visited) {
// We may run into multiple chains that merge into a single chain. We mark the
// stores that we vectorized so that we don't visit the sam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rcx, %rbx
leaq 0x148(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x178(%rsp), %rcx
movq %rcx, -0x20(%rcx)
movq %rcx, -0x18(%rcx)
movq $0x10, -0x10(%rcx)
movl $0x0, -0x8(%rcx)
leaq 0x7(%rsp), %r... | /Transforms/Vectorize/SLPVectorizer.cpp |
findBuildAggregate(llvm::Instruction*, llvm::TargetTransformInfo*, llvm::SmallVectorImpl<llvm::Value*>&, llvm::SmallVectorImpl<llvm::Value*>&) | static bool findBuildAggregate(Instruction *LastInsertInst,
TargetTransformInfo *TTI,
SmallVectorImpl<Value *> &BuildVectorOpds,
SmallVectorImpl<Value *> &InsertElts) {
assert((isa<InsertElementInst>(LastInsertInst) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb (%rdi), %cl
cmpb $0x5b, %cl
jne 0x22f1a09
movq 0x8(%r15), %rax
movl 0x20(%rax), %ebp
movb $0x1, %al
cmpb $0x5b, %cl
je 0x22f1ace
movq 0x8(%r15), %r12
movb $0x1, %al
movl $0x1, %r13d
movzbl 0... | /Transforms/Vectorize/SLPVectorizer.cpp |
llvm::SLPVectorizerPass::vectorizeInsertElementInst(llvm::InsertElementInst*, llvm::BasicBlock*, llvm::slpvectorizer::BoUpSLP&, bool) | bool SLPVectorizerPass::vectorizeInsertElementInst(InsertElementInst *IEI,
BasicBlock *BB, BoUpSLP &R,
bool MaxVFOnly) {
SmallVector<Value *, 16> BuildVectorInsts;
SmallVector<Value *, 16> BuildVectorOpds;
SmallV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4c8, %rsp # imm = 0x4C8
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, -0x8(%r12)
leaq 0xa8(%rsp), %rcx
movq ... | /Transforms/Vectorize/SLPVectorizer.cpp |
int& llvm::SmallVectorImpl<int>::emplace_back<unsigned int&>(unsigned int&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jae 0x22f67f4
movq (%rbx), %rax
movl (%rsi), %edx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rbx), %ecx
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %ecx
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
popq %rbx
retq
movl (%rsi), %esi
movq %rbx, %rdi
callq 0x90267a
mo... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock*, llvm::SmallVector<unsigned int, 12u>, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::SmallVector<unsigned int, 12u>>>, llvm::BasicBlock*, llvm::SmallVector<unsigned int, 12u>, llvm::DenseMapInfo<llvm::Ba... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x22f85a7
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %r11d
leaq (%r11,%r11,8)... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<std::pair<unsigned long, llvm::MapVector<unsigned long, llvm::MapVector<llvm::Value*, unsigned int, llvm::DenseMap<llvm::Value*, unsigned int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>, llvm::SmallVector<std::pair<llvm::Value*, unsigned... | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x2309f22
movq %rsi, %r14
movq (%rbx), %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2309da6
addq $0x30, %r15
addq $0x30, %r14
addq $-0x30, %r12
jne 0x2309f09
movq (%rb... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<std::pair<unsigned long, llvm::MapVector<llvm::Value*, unsigned int, llvm::DenseMap<llvm::Value*, unsigned int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>, llvm::SmallVector<std::pair<llvm::Value*, unsigned int>, 0u>>>, false>::grow(unsi... | 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 $0x30, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0x1cba3de
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x230a278
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x230a1d6
ca... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<std::pair<llvm::Value*, llvm::SmallVector<llvm::Instruction*, 2u>>>::clear() | void clear() {
this->destroy_range(this->begin(), this->end());
this->Size = 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x230eed8
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rdx
leaq (%rcx,%rdx,8), %r14
addq $-0x10, %r14
shlq $0x3, %rax
leaq (%rax,%rax,4), %r15
negq %r15
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x230eece
callq 0x751980
addq $-0x28, %r1... | /llvm/ADT/SmallVector.h |
llvm::SmallDenseMap<llvm::Value*, unsigned int, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldSize = this->size();
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldSize) {
NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
NewNumBuckets = ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edx
xorl %ebp, %ebp
cmpl $0x2, %edx
jb 0x2310ad7
movl %edx, %eax
shrl %eax
decl %eax
je 0x2310ab9
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x2310abe
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %esi
shll %cl, %esi
addl $-0x1c, %eax
cmpl $0x3, %eax
... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, llvm::SmallVector<llvm::SmallVector<unsigned int, 4u>, 1u>, llvm::DenseMapInfo<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, void>, llvm::detail::DenseMapPair<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, llvm::SmallVector<llvm::SmallV... | 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 0x2312ae8
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x2312428
xorl %ecx, %ecx
jmp 0x231243b
movq %r... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector<std::pair<unsigned int, llvm::slpvectorizer::BoUpSLP::TreeEntry*>, 3u>>* llvm::DenseMapBase<llvm::DenseMap<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector<std::pair<unsigned int, llvm::slpvectorizer::BoUpSLP::TreeEntry*>,... | BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
ValueArgs &&... Values) {
TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);
TheBucket->getFirst() = std::forward<KeyArg>(Key);
::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
return ... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rcx
movq %rdx, %rsi
callq 0x23143ac
movq %rax, %r14
movq (%r15), %rax
movq %rax, (%r14)
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movabsq $0x300000000, %rax # imm = 0x300000000
movq %rax, 0x10(%r14)
cmpl $0x0, 0x8(%rbx)
je 0x2314312
movq... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<std::pair<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector<std::pair<unsigned int, llvm::slpvectorizer::BoUpSLP::TreeEntry*>, 3u>>>::append<llvm::DenseMapIterator<llvm::slpvectorizer::BoUpSLP::TreeEntry*, llvm::SmallVector<std::pair<unsigned int, llvm::slpvectorizer::BoUpSLP::TreeE... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorl %ebp, %ebp
cmpq %rcx, %rsi
je 0x231493d
movl $0x1000, %eax # imm = 0x1000
movq %r13, %rcx
addq $0x48, %rcx
cmpq %r12, %rcx
je 0x2314935
movq (%rcx), ... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, unsigned int, llvm::DenseMapInfo<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, void>, llvm::detail::DenseMapPair<llvm::slpvectorizer::BoUpSLP::TreeEntry const*, unsigned int>>, llvm::slpvectorizer::BoUpSLP::TreeEntry const*, unsign... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x23201a9
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 |
bool llvm::function_ref<bool (llvm::Use&)>::callback_fn<llvm::slpvectorizer::BoUpSLP::vectorizeTree(llvm::MapVector<llvm::Value*, llvm::SmallVector<llvm::Instruction*, 2u>, llvm::DenseMap<llvm::Value*, unsigned int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>, llvm::S... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %r15
movq 0x18(%rsi), %rsi
cmpb $0x56, (%rsi)
jne 0x2328c3e
movq %rdi, %r14
leaq 0xe(%rsp), %rdi
callq 0x2328c8c
testb %al, %al
jne 0x2328c32
movq 0x18(%rbx), %rsi
leaq 0xc(%rsp), %rdi
callq 0x2328d00
testb %al, %al
je 0x2328c3e
movq %rbx... | /llvm/ADT/STLFunctionalExtras.h |
bool llvm::PatternMatch::ThreeOps_match<llvm::PatternMatch::undef_match, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_zero_int, llvm::ConstantInt, true>, 62u>::match<llvm::Instruction>(llvm::Instruction*) | bool match(OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opcode) {
auto *I = cast<Instruction>(V);
return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
Op3.match(I->getOperand(2));
}
return false;
} | cmpb $0x5b, (%rsi)
jne 0x23390f5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
btl $0x1e, %eax
jb 0x23390f8
shll $0x5, %eax
movq %r14, %rcx
subq %rax, %rcx
jmp 0x23390fc
xorl %eax, %eax
retq
movq -0x8(%r14), %rcx
movq (%rcx), %rdi
callq 0xa23104
testb %al, %al
je 0x2339147
movl 0... | /llvm/IR/PatternMatch.h |
llvm::SmallVectorTemplateBase<llvm::SmallVector<int, 12u>, false>::moveElementsForGrow(llvm::SmallVector<int, 12u>*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
testq %r12, %r12
je 0x233aeb0
movq %rsi, %r14
movq (%rbx), %r15
shlq $0x6, %r12
movabsq $0xc00000000, %r13 # imm = 0xC00000000
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r13, 0x8(%r14)
cmpl $0x0, 0x8(%r15)
je 0x233aea2
... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::VPBlockBase*, llvm::VPBlockBase*, llvm::DenseMapInfo<llvm::VPBlockBase*, void>, llvm::detail::DenseMapPair<llvm::VPBlockBase*, llvm::VPBlockBase*>>, llvm::VPBlockBase*, llvm::VPBlockBase*, llvm::DenseMapInfo<llvm::VPBlockBase*, void>, llvm::detail::DenseMapPair<llvm::VPBlock... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2344987
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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::VPValue*, llvm::VPValue*, llvm::DenseMapInfo<llvm::VPValue*, void>, llvm::detail::DenseMapPair<llvm::VPValue*, llvm::VPValue*>>, llvm::VPValue*, llvm::VPValue*, llvm::DenseMapInfo<llvm::VPValue*, void>, llvm::detail::DenseMapPair<llvm::VPValue*, llvm::VPValue*>>::LookupBucke... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2345e39
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::DominatorTreeBase<llvm::VPBlockBase, false>::createNode(llvm::VPBlockBase*) | DomTreeNodeBase<NodeT> *createNode(NodeT *BB) {
return (DomTreeNodes[BB] =
std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr))
.get();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %rsi, (%r15)
movl $0x50, %edi
callq 0x751940
movq %rbx, (%rax)
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
movl $0x0, 0x10(%rax)
leaq 0x28(%rax), %rcx
movq %rcx, 0x18(%rax)
movabsq $0x400000000, %rcx ... | /llvm/Support/GenericDomTree.h |
llvm::detail::DenseMapPair<llvm::VPInstruction*, llvm::InterleaveGroup<llvm::VPInstruction>*>* llvm::DenseMapBase<llvm::DenseMap<llvm::VPInstruction*, llvm::InterleaveGroup<llvm::VPInstruction>*, llvm::DenseMapInfo<llvm::VPInstruction*, void>, llvm::detail::DenseMapPair<llvm::VPInstruction*, llvm::InterleaveGroup<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 0x234bf61
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::VPlanPatternMatch::BinaryRecipe_match<llvm::VPlanPatternMatch::bind_ty<llvm::VPValue>, llvm::VPlanPatternMatch::bind_ty<llvm::VPValue>, 53u, false, llvm::VPWidenRecipe, llvm::VPReplicateRecipe, llvm::VPWidenCastRecipe, llvm::VPInstruction>::match(llvm::VPRecipeBase const*) | bool match(const VPRecipeBase *R) {
if (!detail::MatchRecipeAndOpcode<Opcode, RecipeTys...>::match(R))
return false;
assert(R->getNumOperands() == 2 &&
"recipe with matched opcode does not have 2 operands");
if (Op0.match(R->getOperand(0)) && Op1.match(R->getOperand(1)))
return true;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x234dc80
cmpb $0x13, 0x8(%r14)
jne 0x234dc80
cmpl $0x35, 0xa8(%r14)
je 0x234dc8c
movq %r14, %rdi
callq 0x234dcc0
testb %al, %al
je 0x234dcb6
movq 0x30(%r14), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x234dcb6
movq (%rbx), %rcx
movq ... | /Transforms/Vectorize/VPlanPatternMatch.h |
llvm::SmallVectorTemplateBase<llvm::VPRecipeBase*, true>::push_back(llvm::VPRecipeBase*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x234ed95
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cba528... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::VPValue const*, llvm::Type*, llvm::DenseMapInfo<llvm::VPValue const*, void>, llvm::detail::DenseMapPair<llvm::VPValue const*, llvm::Type*>>, llvm::VPValue const*, llvm::Type*, llvm::DenseMapInfo<llvm::VPValue const*, void>, llvm::detail::DenseMapPair<llvm::VPValue const*, ll... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x234eef7
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 |
non-virtual thunk to llvm::VPInstruction::onlyFirstPartUsed(llvm::VPValue const*) const | bool VPInstruction::onlyFirstPartUsed(const VPValue *Op) const {
assert(is_contained(operands(), Op) && "Op must be an operand of the recipe");
if (Instruction::isBinaryOp(getOpcode()))
return vputils::onlyFirstPartUsed(this);
switch (getOpcode()) {
default:
return false;
case Instruction::ICmp:
ca... | addq $-0x28, %rdi
jmp 0x2352b38
nop
| /Transforms/Vectorize/VPlanRecipes.cpp |
llvm::VPWidenRecipe::execute(llvm::VPTransformState&) | void VPWidenRecipe::execute(VPTransformState &State) {
State.setDebugLocFrom(getDebugLoc());
auto &Builder = State.Builder;
switch (Opcode) {
case Instruction::Call:
case Instruction::Br:
case Instruction::PHI:
case Instruction::GetElementPtr:
case Instruction::Select:
llvm_unreachable("This instruc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rsi
movq %rsi, 0x20(%rsp)
testq %rsi, %rsi
je 0x2353136
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x233f7c8
movq (%... | /Transforms/Vectorize/VPlanRecipes.cpp |
llvm::iterator_range<llvm::filter_iterator_impl<decltype(adl_begin(std::declval<llvm::iterator_range<llvm::mapped_iterator<llvm::df_iterator<llvm::VPBlockDeepTraversalWrapper<llvm::VPBlockBase*>, llvm::df_iterator_default_set<llvm::VPBlockBase*, 8u>, false, llvm::GraphTraits<llvm::VPBlockDeepTraversalWrapper<llvm::VPBl... | iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
make_filter_range(RangeT &&Range, PredicateT Pred) {
using FilterIteratorT =
filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
return make_range(
FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x1a8(%rsp), %rsi
leaq 0x188(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rdx
callq 0x1cb9ff4
leaq 0x1e8(%rsp), %r15
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x22ae306
movzwl... | /llvm/ADT/STLExtras.h |
llvm::VPlanPatternMatch::detail::MatchRecipeAndOpcode<38u, llvm::VPReplicateRecipe, llvm::VPWidenCastRecipe, llvm::VPInstruction>::match(llvm::VPRecipeBase const*) | unsigned getVPDefID() const { return SubclassID; } | movb 0x8(%rdi), %cl
cmpb $0x7, %cl
setne %al
testq %rdi, %rdi
sete %dl
orb %al, %dl
jne 0x23620e7
movq 0x90(%rdi), %rdx
movb $0x1, %al
cmpb $0x43, (%rdx)
je 0x2362114
testq %rdi, %rdi
sete %al
cmpb $0xd, %cl
setne %dl
orb %al, %dl
jne 0x2362102
movb $0x1, %al
cmpl $0x26, 0xa8(%rdi)
je 0x2362114
testq %rdi, %rdi
sete %a... | /Transforms/Vectorize/VPlanValue.h |
llvm::VPlanPatternMatch::UnaryRecipe_match<llvm::VPlanPatternMatch::UnaryRecipe_match<llvm::VPlanPatternMatch::BinaryRecipe_match<llvm::VPlanPatternMatch::class_match<llvm::VPValue>, llvm::VPlanPatternMatch::class_match<llvm::VPValue>, 73u, false, llvm::VPInstruction>, 70u, llvm::VPInstruction>, 79u, llvm::VPInstructio... | static bool match(const VPRecipeBase *R) {
auto *DefR = dyn_cast<RecipeTy>(R);
return DefR && DefR->getOpcode() == Opcode;
} | pushq %rbx
testq %rsi, %rsi
je 0x2362a25
cmpb $0x3, 0x8(%rsi)
jne 0x2362a25
cmpb $0x4f, 0xa8(%rsi)
jne 0x2362a25
movq %rdi, %rbx
movq 0x30(%rsi), %rax
movq (%rax), %rdi
callq 0x233eada
testq %rax, %rax
je 0x2362a25
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x2362a2a
xorl %eax, %eax
popq %rbx
retq
nop
| /Transforms/Vectorize/VPlanPatternMatch.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::PHINode*, llvm::InductionDescriptor>, false>::moveElementsForGrow(std::pair<llvm::PHINode*, llvm::InductionDescriptor>*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x236849e
movq %rsi, %r14
movq (%rbx), %r15
imulq $0x58, %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x236831a
addq $0x58, %r15
addq $0x58, %r14
addq $-0x58, %r12
jne 0x2368485
movq (%rbx), %rdi
movl 0x8... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [24], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [24], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> 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, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7512e0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbx)
movl (%r15), %eax
movzwl 0xa(%rbx), %ecx
shll... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [19], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [19], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl... | 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
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<llvm::cl::parser<llvm::AsanDtorKind>::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 $0x30, %ecx
movq %r14, %rsi
callq 0x1cba3de
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x23786d7
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
xorl ... | /llvm/ADT/SmallVector.h |
getBranchInsertPoint((anonymous namespace)::RegInfo&) | static Instruction* getBranchInsertPoint(RegInfo &RI) {
Region *R = RI.R;
BasicBlock *EntryBB = R->getEntry();
// The hoist point is by default the terminator of the entry block, which is
// the same as the branch instruction if RI.HasBranch is true.
Instruction *HoistPoint = EntryBB->getTerminator();
for (... | movq (%rdi), %rax
movq (%rax), %rcx
andq $-0x8, %rcx
leaq 0x30(%rcx), %rdx
movq 0x30(%rcx), %rax
cmpq %rdx, %rax
je 0x2381129
leaq -0x18(%rax), %rdx
testq %rax, %rax
cmoveq %rax, %rdx
movzbl (%rdx), %esi
addl $-0x1e, %esi
xorl %eax, %eax
cmpl $0xb, %esi
cmovbq %rdx, %rax
jmp 0x238112b
xorl %eax, %eax
movl 0x18(%rdi), %... | /Transforms/Instrumentation/ControlHeightReduction.cpp |
getBaseValues(llvm::Value*, llvm::DominatorTree&, llvm::DenseMap<llvm::Value*, std::set<llvm::Value*, std::less<llvm::Value*>, std::allocator<llvm::Value*>>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, std::set<llvm::Value*, std::less<llvm::Value*>, std::allocator<llvm::Value*>>>>&) | static const std::set<Value *> &
getBaseValues(Value *V, DominatorTree &DT,
DenseMap<Value *, std::set<Value *>> &Visited) {
auto It = Visited.find(V);
if (It != Visited.end()) {
return It->second;
}
std::set<Value *> Result;
if (auto *I = dyn_cast<Instruction>(V)) {
// We don't stop at ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rdi, (%rsp)
movq %rdx, %rdi
callq 0x2383382
movq %rax, %r15
movl 0x10(%rbx), %eax
imulq $0x38, %rax, %rax
addq (%rbx), %rax
cmpq %rax, %r15
je 0x23830e6
addq $0x8, %r15
jmp 0x238336c
... | /Transforms/Instrumentation/ControlHeightReduction.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.