name string | code string | asm string | file string |
|---|---|---|---|
llvm::LibCallSimplifier::optimizeStrNDup(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilderBase &B) {
Value *Src = CI->getArgOperand(0);
ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
uint64_t SrcLen = GetStringLength(Src);
if (SrcLen && Size) {
annotateDereferenceableBytes(CI, 0, SrcLen);
if (SrcLen <= Size->g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %r12
movq 0x20(%rcx), %rbp
cmpb $0x11, (%rbp)
setne %r14b
movq %r12, %rdi
movl $0x8, %esi
callq 0x29dd... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizeStpCpy(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
Function *Callee = CI->getCalledFunction();
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
// stpcpy(d,s) -> strcpy(d,s) if the result is not used.
if (CI->use_empty())
return copyFlags(*CI, emitStrCpy(Dst, Src, B, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movq -0x20(%rsi), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x2840c2e
cmpb $0x0, (%rax)
cmoveq %rax, %r14
testq %r14, %r14
je 0x2840c3d
movq 0x18(%r14), %rax
cmpq 0x50(%rbx), %rax
je 0x284... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizeMemRChr(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
Value *SrcStr = CI->getArgOperand(0);
Value *Size = CI->getArgOperand(2);
annotateNonNullAndDereferenceable(CI, 0, Size, DL);
Value *CharVal = CI->getArgOperand(1);
ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
Value *NullPtr = C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %rbp
movq 0x40(%rcx), %r12
leaq 0x38(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x10(%rdi), %r8
movl $0x1, %edx
movq %r15, %rdi
mov... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::cl::opt<unsigned int, false, (anonymous namespace)::HotColdHintParser>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0x284bd86
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %edx
leaq 0x2ea6188(%rip), %rax # 0x56f1ed8
addq $0x10, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl 0x90(%rsi), %eax
movl %eax, 0x8(%rcx)
movb 0x94(%rsi), %al
movb %al, 0xc(%rcx)
leaq 0x2ea6143(%r... | /llvm/Support/CommandLine.h |
getGVPartitioningRoot(llvm::GlobalValue const*) | static const GlobalObject *getGVPartitioningRoot(const GlobalValue *GV) {
const GlobalObject *GO = GV->getAliaseeObject();
if (const auto *GI = dyn_cast_or_null<GlobalIFunc>(GO))
GO = GI->getResolverFunction();
return GO;
} | pushq %rax
callq 0x1a359e8
xorl %edi, %edi
testq %rax, %rax
je 0x284d86e
cmpb $0x2, (%rax)
cmoveq %rax, %rdi
testq %rdi, %rdi
je 0x284d879
popq %rax
jmp 0x1a3646c
popq %rcx
retq
| /Transforms/Utils/SplitModule.cpp |
(anonymous namespace)::ExplicitRewriteDescriptor<(llvm::SymbolRewriter::RewriteDescriptor::Type)3, llvm::GlobalAlias, &llvm::Module::getNamedAlias(llvm::StringRef) const>::performOnModule(llvm::Module&) | bool ExplicitRewriteDescriptor<DT, ValueType, Get>::performOnModule(Module &M) {
bool Changed = false;
if (ValueType *S = (M.*Get)(Source)) {
if (GlobalObject *GO = dyn_cast<GlobalObject>(S))
rewriteComdat(M, GO, Source, Target);
if (Value *T = (M.*Get)(Target))
S->setValueName(T->getValueName(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
movq %r15, %rdi
callq 0x1a73026
movq %rax, %rbx
testq %rax, %rax
je 0x2850ee4
movzbl (%rbx), %eax
cmpl $0x3, %eax
ja 0x2850e89
movq %rbx, %rsi
cmpl $0x1, %eax
jne 0x2850e8b
xorl %esi, %esi
testq... | /Transforms/Utils/SymbolRewriter.cpp |
void llvm::SmallVectorImpl<llvm::Constant*>::append<llvm::Constant**, void>(llvm::Constant**, llvm::Constant**) | 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 0x28540bc
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Metadata const*, (anonymous namespace)::MDNodeMapper::Data, 32u, llvm::DenseMapInfo<llvm::Metadata const*, void>, llvm::detail::DenseMapPair<llvm::Metadata const*, (anonymous namespace)::MDNodeMapper::Data>>, llvm::Metadata const*, (anonymous namespace)::MDNodeMapper::Data, ... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2854dd0
testb %al, %al
je 0x2855305
movq (%rsp), %rax
jmp 0x2855322
testb $0x1, (%rbx)
leaq 0x8(%rbx), %rax
cmoveq 0x8(%rbx), %rax
movl $0x20, %ecx
cmovel 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
... | /llvm/ADT/DenseMap.h |
llvm::AAResults::AAResults(llvm::AAResults&&) | AAResults::AAResults(AAResults &&Arg)
: TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {} | movq (%rsi), %rax
movq %rax, (%rdi)
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups 0x20(%rsi), %xmm1
movups %xmm1, 0x20(%rdi)
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x30(%... | /Analysis/AliasAnalysis.cpp |
llvm::AAResultsWrapperPass::getAnalysisUsage(llvm::AnalysisUsage&) const | void AAResultsWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequiredTransitive<BasicAAWrapperPass>();
AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
// We also need to mark all the alias analysis passes we will potentially
// probe in runOnFunction as used he... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x1, 0xa0(%rsi)
leaq 0x30c25e3(%rip), %rsi # 0x591a720
movq %rbx, %rdi
callq 0x1a7c8ee
leaq 0x30da104(%rip), %rsi # 0x5932250
movq %rbx, %rdi
callq 0x1a7c8ee
leaq 0x90(%rbx), %r14
leaq 0x30da7be(%rip), %rdx # 0x5932920
movq %rbx, %rdi
movq %r14, %rsi
callq 0x... | /Analysis/AliasAnalysis.cpp |
llvm::AAManager::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | AAManager::Result AAManager::run(Function &F, FunctionAnalysisManager &AM) {
Result R(AM.getResult<TargetLibraryAnalysis>(F));
for (auto &Getter : ResultGetters)
(*Getter)(F, AM, R);
return R;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x30da07e(%rip), %rsi # 0x5932258
movq %rcx, %rdi
callq 0x1a7f6e0
addq $0x8, %rax
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movu... | /Analysis/AliasAnalysis.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::Value const*, llvm::Type*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value const*, llvm::Type*>>>, std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSe... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x285a246
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %eax
movl 0x8(%rsi), %r8d
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
movl %r8d, %r9d
shrl $0x4, %r9d
shrl $0x9, %r8d
xorl %r9d, %r8d
shlq $0x20, %rax
orq %rax, %r8
movabsq $-0x40a7b89... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<llvm::Value const*>::assignRemote(llvm::SmallVectorImpl<llvm::Value const*>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x285ccb3
callq 0x751980
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_delete<llvm::AssumptionCache>>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCac... | void erase(iterator I) {
BucketT *TheBucket = &*I;
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
testq %rsi, %rsi
je 0x285f6db
leaq 0x28(%r14), %rdi
callq 0x28609bc
xorl %eax, %eax
movq %rax, 0x28(%r14)
leaq 0x8(%rsp), %r15
movq $0x2, (%r15)
movq %rax, 0x8(%r15)
movq $-0x2000, %r12 # imm = 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_delete<llvm::AssumptionCache>>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_de... | 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 0x285feb6
testl %ebp, %ebp
je 0x285fe63
decl %ebp
je 0x285fe67
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x285fe6c
xorl %ebp, %ebp
jmp 0x285fe82
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
llvm::BasicAAWrapperPass::runOnFunction(llvm::Function&) | bool BasicAAWrapperPass::runOnFunction(Function &F) {
auto &ACT = getAnalysis<AssumptionCacheTracker>();
auto &TLIWP = getAnalysis<TargetLibraryInfoWrapperPass>();
auto &DTWP = getAnalysis<DominatorTreeWrapperPass>();
Result.reset(new BasicAAResult(F.getDataLayout(), F,
TLIWP.g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x30b3a31(%rip), %rcx # 0x591a590
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x2866b6c
movq 0x8(%rdx), %rdi
je 0x2866b76
movq %... | /Analysis/BasicAliasAnalysis.cpp |
bool llvm::DenseMapBase<llvm::SmallDenseMap<std::pair<llvm::AACacheLoc, llvm::AACacheLoc>, llvm::AAQueryInfo::CacheEntry, 8u, llvm::DenseMapInfo<std::pair<llvm::AACacheLoc, llvm::AACacheLoc>, void>, llvm::detail::DenseMapPair<std::pair<llvm::AACacheLoc, llvm::AACacheLoc>, llvm::AAQueryInfo::CacheEntry>>, std::pair<llvm... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq 0x8(%rdi), %r15
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %r15
movl $0x8, %ebp
cmovel 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x2867ec2
movq %rsi, %r14
movq %rsi, %rdi
callq 0x2867edc
decl %ebp
andl %ebp, %eax
movl $0x1, %esi
xorl %edx, %edx
movl %eax,... | /llvm/ADT/DenseMap.h |
llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>::print(llvm::raw_ostream&) const | raw_ostream &BlockFrequencyInfoImpl<BT>::print(raw_ostream &OS) const {
if (!F)
return OS;
OS << "block-frequency-info: " << F->getName() << "\n";
for (const BlockT &BB : *F) {
OS << " - " << bfi_detail::getBlockName(&BB) << ": float = ";
getFloatingBlockFreq(&BB).print(OS, 5)
<< ", int = " <<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x28699d0
movq %rdi, %r14
leaq 0x256dfbe(%rip), %rsi # 0x4dd777f
movl $0x16, %edx
movq %rbx, %rdi
callq 0x7c4562
movq %rax, %r15
movq 0x80(%r14), %rdi
callq 0x1a90092
movq %r15, %rdi
movq %rax, ... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
void llvm::SmallVectorImpl<llvm::BlockFrequencyInfoImplBase::BlockNode>::append<llvm::BlockFrequencyInfoImplBase::BlockNode*, void>(llvm::BlockFrequencyInfoImplBase::BlockNode*, llvm::BlockFrequencyInfoImplBase::BlockNode*) | 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 $0x2, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x2872120
leaq 0x10(%rbx), %rsi
movl $0x4, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
llvm::iterator_range<llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*>>>::begin() const | IteratorT begin() const { return begin_iterator; } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %rsi
movq %r14, %rdx
callq 0x1cb9ff4
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x68(%rbx)
cmpl $0x0, 0x68(%r14)
je 0x2876aa6
movq %rbx, %rdi
addq $0x60, %rdi
addq $0x60, %r1... | /llvm/ADT/iterator_range.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>>, llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x8(%rsp), %rbx
movq $0x2, (%rbx)
movq %rax, 0x8(%rbx)
movq $-0x1000, 0x10(%rbx) # imm = 0xF000
leaq 0x2f6f6b5(%rip), %r14 # 0x57e6798
addq $0x10, %r14
movq %r14, -0x8(%rbx)
movq %rax, 0x18(... | /llvm/ADT/DenseMap.h |
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>>>>::opt<char [24], llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [24], llvm::cl::OptionHidden const&, llvm::cl::des... | 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 %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
leaq 0x90(%rbx), %rax
movq %rax, 0x80(%rbx)
movq %r13, 0x88(%rbx)
movb %r13b, 0x90(%rbx)
leaq 0xb8(%rbx), %rax
movq %rax, 0xa8(%rbx)
mov... | /llvm/Support/CommandLine.h |
llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::Module>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | CGSCCAnalysisManagerModuleProxy::Result
CGSCCAnalysisManagerModuleProxy::run(Module &M, ModuleAnalysisManager &AM) {
// Force the Function analysis manager to also be available so that it can
// be accessed in an SCC analysis and proxied onward to function passes.
// FIXME: It is pretty awkward to just drop the r... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x305a01b(%rip), %rsi # 0x58db698
movq %rdx, %rdi
movq %r14, %rdx
callq 0x1a7ec42
movq (%r15), %r15
leaq 0x309d726(%rip), %rsi # 0x591edb8
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1a7ec42
leaq 0x8(%rax), %rdx
movq %r15, %rax
popq %... | /Analysis/CGSCCPassManager.cpp |
void llvm::function_ref<void (llvm::ArrayRef<llvm::LazyCallGraph::SCC*>)>::callback_fn<updateCGAndAnalysisManagerForPass(llvm::LazyCallGraph&, llvm::LazyCallGraph::SCC&, llvm::LazyCallGraph::Node&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::CGSCCUpdateResult&, llvm::AnalysisManager<ll... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, (%rsp)
testq %rdx, %rdx
je 0x2884540
movq %rdx, %rbx
movq %rdi, %r15
shlq $0x3, %rbx
leaq 0x8(%rsp), %r12
movl $0x2, %r14d
xorl %ebp, %ebp
movq (%rsp), %rax
movq (%rax,%rbp), %r13
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0x2... | /llvm/ADT/STLFunctionalExtras.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::LazyCallGraph::SCC*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResul... | 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 0x2884def
movq (%r15), %rax
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*, void>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long>>, llvm::LazyCallGraph::RefSCC*, long, llvm::DenseMapInfo<l... | 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 0x28857bb
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x28857f2
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, unsigned int, 16u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>, llvm::Value*, unsigned int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>::clear() | unsigned getNumEntries() const {
return NumEntries;
} | movl (%rdi), %eax
cmpl $0x1, %eax
ja 0x2885c91
cmpl $0x0, 0x4(%rdi)
je 0x2885d86
leal (%rax,%rax), %edx
andl $-0x4, %edx
movl $0x10, %ecx
testb $0x1, %al
jne 0x2885ca3
movl 0x10(%rdi), %ecx
cmpl %ecx, %edx
setae %dl
cmpl $0x41, %ecx
setb %sil
orb %dl, %sil
je 0x2885d88
testb $0x1, %al
jne 0x2885cc2
movq 0x8(%rdi), %rax... | /llvm/ADT/DenseMap.h |
bool __gnu_cxx::__ops::_Iter_pred<llvm::DevirtSCCRepeatedPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::$_1>::operator()<std::pair<llvm::Value*, llvm::WeakTrackingVH>*>(std::pair<llvm::Value*, llvm::WeakTracki... | Value *getValPtr() const { return Val; } | movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2885f31
movzbl (%rax), %ecx
cmpl $0x1d, %ecx
jb 0x2885f09
addl $-0x22, %ecx
cmpl $0x33, %ecx
ja 0x2885f09
movabsq $0x8000000000041, %rdx # imm = 0x8000000000041
btq %rcx, %rdx
jb 0x2885f0b
xorl %eax, %eax
testq %rax, %rax
je 0x2885f31
movq -0x20(%rax), %rdx
xorl %ecx, %ecx
t... | /llvm/IR/ValueHandle.h |
llvm::CallGraph::~CallGraph() | CallGraph::~CallGraph() {
// CallsExternalNode is not in the function map, delete it explicitly.
if (CallsExternalNode)
CallsExternalNode->allReferencesDropped();
// Reset all node's use counts to zero before deleting them to prevent an
// assertion from firing.
#ifndef NDEBUG
for (auto &I : FunctionMap)
... | pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x28862a4
movl $0x0, 0x28(%rax)
callq 0x28862ba
movq 0x18(%rbx), %rsi
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2887370
| /Analysis/CallGraph.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::CallGraphNode*, unsigned int, llvm::DenseMapInfo<llvm::CallGraphNode*, void>, llvm::detail::DenseMapPair<llvm::CallGraphNode*, unsigned int>>, llvm::CallGraphNode*, unsigned int, llvm::DenseMapInfo<llvm::CallGraphNode*, void>, llvm::detail::DenseMapPair<llvm::CallGraphNode*,... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x28885f5
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::CaptureTracker::isDereferenceableOrNull(llvm::Value*, llvm::DataLayout const&) | bool CaptureTracker::isDereferenceableOrNull(Value *O, const DataLayout &DL) {
// We want comparisons to null pointers to not be considered capturing,
// but need to guard against cases like gep(p, -ptrtoint(p2)) == null,
// which are equivalent to p == p2 and would capture the pointer.
//
// A dereferenceabl... | pushq %rax
movq %rsi, %rdi
leaq 0x7(%rsp), %rax
leaq 0x6(%rsp), %rcx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1a91a10
testq %rax, %rax
setne %al
popq %rcx
retq
| /Analysis/CaptureTracking.cpp |
llvm::PointerMayBeCapturedBefore(llvm::Value const*, bool, bool, llvm::Instruction const*, llvm::DominatorTree const*, bool, unsigned int, llvm::LoopInfo const*) | bool llvm::PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
bool StoreCaptures, const Instruction *I,
const DominatorTree *DT, bool IncludeI,
unsigned MaxUsesToExplore,
... | pushq %rbx
subq $0x30, %rsp
movl 0x40(%rsp), %edx
testq %r8, %r8
je 0x288c893
movq 0x48(%rsp), %rax
leaq 0x2fe506a(%rip), %r10 # 0x58718d0
leaq 0x8(%rsp), %rbx
movq %r10, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r8, 0x10(%rbx)
movb %sil, 0x18(%rbx)
movb %r9b, 0x19(%rbx)
movb $0x0, 0x1a(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx,... | /Analysis/CaptureTracking.cpp |
llvm::SmallDenseMap<llvm::Value const*, bool, 8u, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, bool>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x9, %esi
jb 0x288cfba
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<llvm::TargetTransformInfo::TargetCostKind, false, llvm::cl::parser<llvm::TargetTransformInfo::TargetCostKind>>::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 0x288df60
movl %eax, %r14d
testb %al, %al
jne 0x288ddaa
movl 0xc(%rsp), %eax
movl %eax, 0x80(%rbx)
movw %bp, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ConstantFoldFP(double (*)(double), llvm::APFloat const&, llvm::Type*) | Constant *ConstantFoldFP(double (*NativeFP)(double), const APFloat &V,
Type *Ty) {
llvm_fenv_clearexcept();
double Result = NativeFP(V.convertToDouble());
if (llvm_fenv_testexcept()) {
llvm_fenv_clearexcept();
return nullptr;
}
return GetConstantFoldFPValue(Result, Ty);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x3d, %edi
callq 0x751750
callq 0x7520c0
movq %rax, %r14
movl $0x0, (%rax)
movq %r15, %rdi
callq 0x1c8136c
callq *%r12
movl (%r14), %eax
addl $-0x21, %eax
cmpl $0x2, %eax
jb 0x2898455
movl $0x1d, %edi
movsd %xmm... | /Analysis/ConstantFolding.cpp |
llvm::detail::DenseMapPair<llvm::Constant*, llvm::Constant*>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Constant*, llvm::Constant*, 4u, llvm::DenseMapInfo<llvm::Constant*, void>, llvm::detail::DenseMapPair<llvm::Constant*, llvm::Constant*>>, llvm::Constant*, llvm::Constant*, llvm::DenseMapInfo<llvm::Constant*, void>... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x2898c01
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x2898c38
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Constant*, llvm::Constant*, 4u, llvm::DenseMapInfo<llvm::Constant*, void>, llvm::detail::DenseMapPair<llvm::Constant*, llvm::Constant*>>, llvm::Constant*, llvm::Constant*, llvm::DenseMapInfo<llvm::Constant*, void>, llvm::detail::DenseMapPair<llvm::Constant*, llvm::Constant*>... | 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
leaq 0x8(%rdi), %rax
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rax
movl $0x4, %ecx
cmovel 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2898e5e
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rd... | /llvm/ADT/DenseMap.h |
llvm::APFloat::isSignaling() const | bool isSignaling() const { return getIEEE().isSignaling(); } | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %r15
callq 0x1c76792
movq 0x10(%rbx), %rdi
addq $0x8, %rdi
cmpq %r15, %rax
cmovneq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1c786d0
| /llvm/ADT/APFloat.h |
llvm::operator<<(llvm::raw_ostream&, llvm::DDGEdge::EdgeKind) | raw_ostream &llvm::operator<<(raw_ostream &OS, const DDGEdge::EdgeKind K) {
const char *Out;
switch (K) {
case DDGEdge::EdgeKind::RegisterDefUse:
Out = "def-use";
break;
case DDGEdge::EdgeKind::MemoryDependence:
Out = "memory";
break;
case DDGEdge::EdgeKind::Rooted:
Out = "rooted";
bre... | pushq %rbx
movq %rdi, %rbx
cmpl $0x3, %esi
ja 0x289ab9f
movl %esi, %eax
leaq 0x2fd71bf(%rip), %rcx # 0x5871d58
movq (%rcx,%rax,8), %rsi
jmp 0x289aba6
leaq 0x2798ce7(%rip), %rsi # 0x503388d
movq %rbx, %rdi
callq 0x7c4532
movq %rbx, %rax
popq %rbx
retq
nop
| /Analysis/DDG.cpp |
llvm::AbstractDependenceGraphBuilder<llvm::DataDependenceGraph>::createMemoryDependencyEdges() | void AbstractDependenceGraphBuilder<G>::createMemoryDependencyEdges() {
using DGIterator = typename G::iterator;
auto isMemoryAccess = [](const Instruction *I) {
return I->mayReadOrWriteMemory();
};
for (DGIterator SrcIt = Graph.begin(), E = Graph.end(); SrcIt != E; ++SrcIt) {
InstructionListType SrcILi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0x8(%rdi), %rax
movl 0x68(%rax), %ecx
testq %rcx, %rcx
je 0x28b1047
movq %rdi, %rbx
movq 0x60(%rax), %r15
leaq (%r15,%rcx,8), %rax
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %r14
leaq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movabsq $0x20... | /Analysis/DependenceGraphBuilder.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DenseSet<llvm::IRSimilarity::IRSimilarityCandidate*, llvm::DenseMapInfo<llvm::IRSimilarity::IRSimilarityCandidate*, void>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DenseSet<llvm::IRSimilarity::IRSimilarityCandidate... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x28c944c
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x5, %rbx
leaq (%rdi,%rbx), %r11
movl (%rdi,%rbx), %ebx
cmpl %ebx, %esi
jne 0x28c9417
movq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::InlineCostAnnotationWriter::emitInstructionAnnot(llvm::Instruction const*, llvm::formatted_raw_ostream&) | void InlineCostAnnotationWriter::emitInstructionAnnot(
const Instruction *I, formatted_raw_ostream &OS) {
// The cost of inlining of the given instruction is printed always.
// The threshold delta is printed only when it is non-zero. It happens
// when we decided to give a bonus at a particular instruction.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movl $0x268, %r12d # imm = 0x268
addq 0x8(%rdi), %r12
movq %rsi, %r14
movq %rsi, 0x28(%rsp)
leaq 0x18(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x28d5fa0
movl %eax... | /Analysis/InlineCost.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, (anonymous namespace)::InstructionCostDetail, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, (anonymous namespace)::InstructionCostDetail>>, llvm::Instruction const*, (anonymous namespace)::InstructionC... | ValueT &operator[](const KeyT &Key) {
return FindAndConstruct(Key).second;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x28d5fa0
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x28d5f70
movl 0x8(%r14), %ecx
movl 0x10(%r14), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x28d5f7e
... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>>>, llvm::Value*, std::pair<llvm::Value*, llvm::APInt>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::De... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x28d6e3f
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 $0x5, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::AllocaInst*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::AllocaInst*>>, llvm::Value*, llvm::AllocaInst*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::AllocaInst*>>::FindAndConstruct... | 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 0x25582a8
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x28d7196
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x255833a
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::InlineCostFeaturesAnalyzer::onLoweredCall(llvm::Function*, llvm::CallBase&, bool) | void onLoweredCall(Function *F, CallBase &Call,
bool IsIndirectCall) override {
increment(InlineCostFeatureIndex::lowered_call_arg_setup,
Call.arg_size() * InstrCost);
if (IsIndirectCall) {
InlineParams IndirectCallParams = {/* DefaultThreshold*/ 0,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x380, %rsp # imm = 0x380
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x8f171e
movl $0x7ffffff, %ecx # imm = 0x7FFFFFF
andl 0x4(%r14), %ecx
negl %ecx
shlq $0x5, %rcx
addq %r14, %rcx
subq %rcx, %rax
s... | /Analysis/InlineCost.cpp |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [22], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [22], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7512e0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c90c20
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx... | /llvm/Support/CommandLine.h |
llvm::InlineAdvice::recordInlining() | void InlineAdvice::recordInlining() {
markRecorded();
recordInlineStatsIfNeeded();
recordInliningImpl();
} | pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x39(%rdi)
movq 0x8(%rdi), %rax
movq 0x48(%rax), %rdi
testq %rdi, %rdi
je 0x28d9576
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
callq 0x29f8776
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x10(%rax)
| /Analysis/InlineAdvisor.cpp |
llvm::InlineAdvisorAnalysis::Result::tryCreate(llvm::InlineParams, llvm::InliningAdvisorMode, llvm::ReplayInlinerSettings const&, llvm::InlineContext) | bool InlineAdvisorAnalysis::Result::tryCreate(
InlineParams Params, InliningAdvisorMode Mode,
const ReplayInlinerSettings &ReplaySettings, InlineContext IC) {
auto &FAM = MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
if (PluginInlineAdvisorAnalysis::HasBeenRegistered) {
auto &DA = M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x100(%rsp), %r13
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
leaq 0x30020ba(%rip), %rsi # 0x58db698
callq 0x1a7ec42
movq 0x8(%rax), %r14
leaq 0x30453c2(%rip), %rax # 0x... | /Analysis/InlineAdvisor.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::CallBase const*, (anonymous namespace)::SizePriority, llvm::DenseMapInfo<llvm::CallBase const*, void>, llvm::detail::DenseMapPair<llvm::CallBase const*, (anonymous namespace)::SizePriority>>, llvm::CallBase const*, (anonymous namespace)::SizePriority, llvm::DenseMapInfo<llvm::Cal... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x28dd8ae
testb %al, %al
je 0x28dd89d
movq (%rsp), %rax
jmp 0x28dd8a7
movl 0x10(%rbx), %eax
shlq $0x4, %rax
addq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::CallBase*, int, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::DenseMapPair<llvm::CallBase*, int>>, llvm::CallBase*, int, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::DenseMapPair<llvm::CallBase*, int>>::FindAndConstruct(llvm::CallBase* const&) | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x28ddcac
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x28ddca1
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x28ddd3e
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::PriorityInlineOrder<(anonymous namespace)::CostPriority>::push(std::pair<llvm::CallBase*, int> const&) | void push(const T &Elt) override {
CallBase *CB = Elt.first;
const int InlineHistoryID = Elt.second;
Heap.push_back(CB);
Priorities[CB] = PriorityT(CB, FAM, Params);
std::push_heap(Heap.begin(), Heap.end(), isLess);
InlineHistoryMap[CB] = InlineHistoryID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl 0x8(%rsi), %ebp
addq $0x8, %rdi
movq %rax, %rsi
callq 0x971336
movq (%r15), %rsi
movq 0xe8(%rbx), %rdx
movq 0xf0(%rbx), %rcx
leaq 0x10(%rsp), %rdi
callq 0x28def9a
leaq 0x... | /Analysis/InlineOrder.cpp |
simplifyAndOrWithICmpEq(unsigned int, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int) | static Value *simplifyAndOrWithICmpEq(unsigned Opcode, Value *Op0, Value *Op1,
const SimplifyQuery &Q,
unsigned MaxRecurse) {
assert((Opcode == Instruction::And || Opcode == Instruction::Or) &&
"Must be and/or");
ICmpInst::Predicat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpb $0x52, (%rsi)
jne 0x28ef412
movq %rsi, %rbx
movq -0x40(%rsi), %r12
testq %r12, %r12
je 0x28ef412
movl %r8d, %r15d
movq -0x20(%rbx), %r8
testq %r8, %r8
je 0x28ef412
movzwl 0x2(%rbx), %r14d
movl %r14d, %eax
andl $0x3e, %eax
cmpl $0x20... | /Analysis/InstructionSimplify.cpp |
simplifyICmpWithBinOp(llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int) | static Value *simplifyICmpWithBinOp(CmpInst::Predicate Pred, Value *LHS,
Value *RHS, const SimplifyQuery &Q,
unsigned MaxRecurse) {
BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS);
BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS);
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r13
movq %rsi, %rbp
movb (%rsi), %al
cmpb $0x1d, %al
setae %cl
movzbl %al, %eax
addl $-0x2a, %eax
cmpl $0x12, %eax
setb %al
xorl %r12d, %r12d
andb %cl, %al
movb %al, 0x17(%rsp)
movl $0x0, %eax
cmovneq %rsi, %rax
movq %rax, 0x... | /Analysis/InstructionSimplify.cpp |
computePointerICmp(llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&) | static Constant *computePointerICmp(CmpInst::Predicate Pred, Value *LHS,
Value *RHS, const SimplifyQuery &Q) {
assert(LHS->getType() == RHS->getType() && "Must have same types");
const DataLayout &DL = Q.DL;
const TargetLibraryInfo *TLI = Q.TLI;
// We can only fold certain p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq (%rcx), %r15
movq 0x8(%rcx), %r14
leal -0x22(%rdi), %eax
cmpl $0x4, %eax
jae 0x28f2b57
callq 0x1a49faa
movl %eax, %edi
jmp 0x28f2b63
leal -0x20(%rdi), %eax
cm... | /Analysis/InstructionSimplify.cpp |
threadCmpOverPHI(llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int) | static Value *threadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
const SimplifyQuery &Q, unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
return nullptr;
// Make sure the phi is on the LHS.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebx
movl %edi, 0x4(%rsp)
subl $0x1, %ebx
jb 0x28f3469
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
cmpb $0x54, (%rsi)
jne 0x28f3359
movq %r15, %r12
movq %r13, %r15
jmp 0x28f3369
movl 0x4(%rsp), %edi
callq 0x1a49fca
movl %e... | /Analysis/InstructionSimplify.cpp |
llvm::LazyBlockFrequencyInfoPass::runOnFunction(llvm::Function&) | bool LazyBlockFrequencyInfoPass::runOnFunction(Function &F) {
auto &BPIPass = getAnalysis<LazyBranchProbabilityInfoPass>();
LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
LBFI.setAnalysis(&F, &BPIPass, &LI);
return false;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x30274bf(%rip), %rcx # 0x591edac
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x28f78fa
movq 0x8(%rdx), %rdi
je 0x28f7904
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x28f78ed
movq... | /Analysis/LazyBlockFrequencyInfo.cpp |
llvm::SmallPtrSetImpl<llvm::LazyCallGraph::SCC const*>::insert(llvm::LazyCallGraph::SCC const*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8efa2e
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0x28f8c63
cmpq $-0x2, (%rax)
jb 0x28f8c63
addq $0x8, %rax
cmpq %rcx, %... | /llvm/ADT/SmallPtrSet.h |
llvm::SmallPtrSetImpl<llvm::LazyCallGraph::RefSCC*>::insert(llvm::LazyCallGraph::RefSCC*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8efa2e
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0x28fb803
cmpq $-0x2, (%rax)
jb 0x28fb803
addq $0x8, %rax
cmpq %rcx, %... | /llvm/ADT/SmallPtrSet.h |
llvm::LazyCallGraph::buildSCCs(llvm::LazyCallGraph::RefSCC&, llvm::iterator_range<std::reverse_iterator<llvm::LazyCallGraph::Node**>>) | void LazyCallGraph::buildSCCs(RefSCC &RC, node_stack_range Nodes) {
assert(RC.SCCs.empty() && "Already built SCCs!");
assert(RC.SCCIndices.empty() && "Already mapped SCC indices!");
for (Node *N : Nodes) {
assert(N->LowLink >= (*Nodes.begin())->LowLink &&
"We cannot have a low link in an SCC lower... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rsi
je 0x28fd4df
movq %rsi, %rax
movq -0x8(%rax), %rcx
addq $-0x8, %rax
movq $0x0, 0x10(%rcx)
cmpq %rdx, %rax
jne 0x28fd4c... | /Analysis/LazyCallGraph.cpp |
llvm::LazyValueInfoImpl::getBlockValue(llvm::Value*, llvm::BasicBlock*, llvm::Instruction*) | std::optional<ValueLatticeElement>
LazyValueInfoImpl::getBlockValue(Value *Val, BasicBlock *BB,
Instruction *CxtI) {
// If already a constant, there is nothing to compute.
if (Constant *VC = dyn_cast<Constant>(Val))
return ValueLatticeElement::get(VC);
if (std::optional<Value... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x15, (%rdx)
jbe 0x2901abd
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %r12
movq %r14, (%rsp)
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x2908bda
testq %rax, %rax
je 0x2901b3a
movq %rax, %rbp
leaq 0xc8(%ra... | /Analysis/LazyValueInfo.cpp |
llvm::LazyValueInfoImpl::getValueFromSimpleICmpCondition(llvm::CmpInst::Predicate, llvm::Value*, llvm::APInt const&, llvm::Instruction*, bool) | std::optional<ValueLatticeElement>
LazyValueInfoImpl::getValueFromSimpleICmpCondition(CmpInst::Predicate Pred,
Value *RHS,
const APInt &Offset,
Instruction *CxtI,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %r12
movq %r8, 0x80(%rsp)
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rcx), %rdi
callq 0x1a89d64
movq %rsp, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x19bef70
cmpb $0x11, (%r15)
jne 0x2904149
mov... | /Analysis/LazyValueInfo.cpp |
matchICmpOperand(llvm::APInt&, llvm::Value*, llvm::Value*, llvm::CmpInst::Predicate) | static bool matchICmpOperand(APInt &Offset, Value *LHS, Value *Val,
ICmpInst::Predicate Pred) {
if (LHS == Val)
return true;
// Handle range checking idiom produced by InstCombine. We will subtract the
// offset from the allowed range for RHS in this case.
const APInt *C;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq %rdx, %rsi
je 0x2904bad
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
leaq 0x18(%rsp), %rdi
movq %r13, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
movq %r13, 0x20(%rdi)
movb %al, 0x28(%rdi)... | /Analysis/LazyValueInfo.cpp |
llvm::LintPass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses LintPass::run(Function &F, FunctionAnalysisManager &AM) {
auto *Mod = F.getParent();
auto *DL = &F.getDataLayout();
auto *AA = &AM.getResult<AAManager>(F);
auto *AC = &AM.getResult<AssumptionAnalysis>(F);
auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
auto *TLI = &AM.getResult<TargetL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, 0xf0(%rsp)
movq 0x28(%rdx), %rax
movq %rax, 0x60(%rsp)
movq %rdx, %rdi
callq 0x1a28d16
movq %rax, %r15
leaq 0x300f7c8(%rip), %rsi # 0x5919c68
movq %r12, %rdi
movq %r1... | /Analysis/Lint.cpp |
(anonymous namespace)::Lint::findValue(llvm::Value*, bool) const | void Lint::visitShl(BinaryOperator &I) {
if (ConstantInt *CI =
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
Check(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
"Undefined result: Shift count out of range", &I);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x28(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x4, -0x10(%rax)
movl $0x0, -0x8(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rcx
callq 0x290b06a
movq %rax, %rbx
movq 0x8(%r14), %rdi
cmpq (%r14), %rdi
je 0x290b05f
callq 0x751980
movq %rbx, %rax
addq $0x48, %rsp... | /Analysis/Lint.cpp |
isDereferenceableAndAlignedPointer(llvm::Value const*, llvm::Align, llvm::APInt const&, llvm::DataLayout const&, llvm::Instruction const*, llvm::AssumptionCache*, llvm::DominatorTree const*, llvm::TargetLibraryInfo const*, llvm::SmallPtrSetImpl<llvm::Value const*>&, unsigned int) | static bool isDereferenceableAndAlignedPointer(
const Value *V, Align Alignment, const APInt &Size, const DataLayout &DL,
const Instruction *CtxI, AssumptionCache *AC, const DominatorTree *DT,
const TargetLibraryInfo *TLI, SmallPtrSetImpl<const Value *> &Visited,
unsigned MaxDepth) {
assert(V->getType... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl 0x158(%rsp), %r13d
movb %sil, 0xd(%rsp)
movq %r8, 0x18(%rsp)
subl $0x1, %r13d
jb 0x290c5fe
movq %r9, %r14
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, %r12
movq 0x150(%rsp), %rsi
leaq 0x48(%rsp), %rbx
movq %r... | /Analysis/Loads.cpp |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [22], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<int>>(char const (&) [22], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<int> 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 0x2de30e0(%rip), %rax # 0x56f1eb8
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [21], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::LocationClass<bool>, llvm::cl::initializer<bool>>(char const (&) [21], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::LocationClass<bool> const&, llvm::cl::initializer<bool> const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0x2dd4414(%rip), %rax # 0x56e32a0
addq $0x10, %rax
... | /llvm/Support/CommandLine.h |
llvm::MemoryDepChecker::Dependence::print(llvm::raw_ostream&, unsigned int, llvm::SmallVectorImpl<llvm::Instruction*> const&) const | void MemoryDepChecker::Dependence::print(
raw_ostream &OS, unsigned Depth,
const SmallVectorImpl<Instruction *> &Instrs) const {
OS.indent(Depth) << DepName[Type] << ":\n";
OS.indent(Depth + 2) << *Instrs[Source] << " -> \n";
OS.indent(Depth + 2) << *Instrs[Destination] << "\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0x1cea6fa
movl 0x8(%r14), %ecx
leaq 0x2f848f8(%rip), %rdx # 0x5896750
movq (%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x7c4532
leaq 0x24c4e44(%rip), %rsi # 0x4d... | /Analysis/LoopAccessAnalysis.cpp |
llvm::DenseMap<llvm::Value*, llvm::SmallVector<llvm::Value const*, 16u>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::SmallVector<llvm::Value const*, 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, %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 |
(anonymous namespace)::AccessAnalysis::createCheckForAccess(llvm::RuntimePointerChecking&, llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*>>>, llvm::Type*, llvm::DenseMap<llvm::Value*, llvm::SCEV ... | bool AccessAnalysis::createCheckForAccess(RuntimePointerChecking &RtCheck,
MemAccessInfo Access, Type *AccessTy,
const DenseMap<Value *, const SCEV *> &StridesMap,
DenseMap<Value *, unsigned> &D... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, 0x30(%rsp)
movq %r8, %r14
movq %rcx, 0x20(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdi, %r13
movq 0x100(%rsp), %rsi
movq %rdx, 0x28(%rsp)
andq $-0x8, %rdx
movq 0x408(%rdi), %rbx
movq 0x58(%rbx), %r12
leaq 0x98(%rsp), %r15
movq %r15, -... | /Analysis/LoopAccessAnalysis.cpp |
llvm::DenseMap<llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*>>>, std::vector<unsigned int, std::allocator<unsigned int>>, llvm::DenseMapInfo<llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::Po... | 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::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>::getCachedResultImpl(llvm::AnalysisKey*, llvm::Loop&) const | ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
typename AnalysisResultMapT::const_iterator RI =
AnalysisResults.find({ID, &IR});
return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rax, %rsi
callq 0x1c5b00c
movl 0x40(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x291a546
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
jmp 0x291a548
... | /llvm/IR/PassManager.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Loop*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResultConcept<llvm::Loop, ll... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x291ae1b
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 $0x5, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::CacheCost::populateReferenceGroups(llvm::SmallVector<llvm::SmallVector<std::unique_ptr<llvm::IndexedReference, std::default_delete<llvm::IndexedReference>>, 8u>, 8u>&) const | bool CacheCost::populateReferenceGroups(ReferenceGroupsTy &RefGroups) const {
assert(RefGroups.empty() && "Reference groups should be empty");
unsigned CLS = TTI.getCacheLineSize();
Loop *InnerMostLoop = getInnerMostLoop(Loops);
assert(InnerMostLoop != nullptr && "Expecting a valid innermost loop");
for (Ba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0xe8(%rdi), %rdi
callq 0x29c5312
movl %eax, 0xc(%rsp)
movq %r14, %rdi
callq 0x291cef6
movq 0x20(%rax), %rcx
movq %rax, 0x30(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %rcx
je 0x291d1... | /Analysis/LoopCacheAnalysis.cpp |
llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::contains(llvm::Loop const*) const | bool contains(const LoopT *L) const {
assert(!isInvalid() && "Loop not in a valid state!");
if (L == this)
return true;
if (!L)
return false;
return contains(L->getParentLoop());
} | cmpq %rdi, %rsi
je 0x29221f7
testq %rsi, %rsi
je 0x29221fa
movq (%rsi), %rsi
jmp 0x29221e8
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
| /llvm/Support/GenericLoopInfo.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::Loop*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::Loop*>>, llvm::BasicBlock const*, llvm::Loop*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlo... | 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 0xb0401e
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::Loop::LoopBounds::getDirection() const | Direction Loop::LoopBounds::getDirection() const {
if (const SCEVAddRecExpr *StepAddRecExpr =
dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&getStepInst())))
if (const SCEV *StepRecur = StepAddRecExpr->getStepRecurrence(SE)) {
if (SE.isKnownPositive(StepRecur))
return Direction::Increasing;
if... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x28(%rdi), %rdi
callq 0x2977744
movq %rax, %rdi
movl $0x2, %eax
testq %rdi, %rdi
je 0x2925299
cmpw $0x8, 0x18(%rdi)
jne 0x2925299
movq 0x28(%rbx), %rsi
callq 0x905c38
testq %rax, %rax
je 0x2925294
movq %rax, %r14
movq 0x28(%rbx), %rdi
movq %ra... | /Analysis/LoopInfo.cpp |
llvm::getOptionalIntLoopAttribute(llvm::Loop const*, llvm::StringRef) | std::optional<int> llvm::getOptionalIntLoopAttribute(const Loop *TheLoop,
StringRef Name) {
const MDOperand *AttrMD =
findStringMetadataForLoop(TheLoop, Name).value_or(nullptr);
if (!AttrMD)
return std::nullopt;
ConstantInt *IntMD = mdconst::extract_... | pushq %rax
callq 0x2927035
testq %rax, %rax
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x29271a2
movq (%rax), %rax
testq %rax, %rax
je 0x292717b
movq 0x80(%rax), %rax
jmp 0x292717d
xorl %eax, %eax
testq %rax, %rax
je 0x29271a2
movl 0x20(%rax), %edx
cmpl $0x40, %edx
ja 0x29271a8
movq 0x18(%rax), %rsi
movl %edx, %ecx
neg... | /Analysis/LoopInfo.cpp |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock*, llvm::SizeOffsetAPInt, 8u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::SizeOffsetAPInt>>, llvm::BasicBlock*, llvm::SizeOffsetAPInt, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm:... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rcx
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x8, %eax
cmovel 0x10(%rdi), %eax
testl %eax, %eax
je 0x2935419
movl %eax, %eax
leaq (%rax,%rax,4), %rax
l... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Instruction*, llvm::SizeOffsetAPInt, 8u, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::SizeOffsetAPInt>>, llvm::Instruction*, llvm::SizeOffsetAPInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMap... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x8, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x2935707
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,4)... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::Instruction*, llvm::SizeOffsetAPInt, 8u, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::SizeOffsetAPInt>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x9, %esi
jb 0x29357dc
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::SizeOffsetAPInt, 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 $0x20, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0x1cba3de
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2935cde
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2935cca
ca... | /llvm/ADT/SmallVector.h |
llvm::SizeOffsetWeakTrackingVH::SizeOffsetWeakTrackingVH() | SizeOffsetWeakTrackingVH() : SizeOffsetType(nullptr, nullptr) {} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x6, %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdx)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movups %xmm0, 0x8(%r14)
movl $0x3, %esi
callq 0xaa1ac4
addq $0x18, %rbx
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0... | /llvm/Analysis/MemoryBuiltins.h |
llvm::MemoryDependenceResults::getNonLocalPointerDependency(llvm::Instruction*, llvm::SmallVectorImpl<llvm::NonLocalDepResult>&) | void MemoryDependenceResults::getNonLocalPointerDependency(
Instruction *QueryInst, SmallVectorImpl<NonLocalDepResult> &Result) {
const MemoryLocation Loc = MemoryLocation::get(QueryInst);
bool isLoad = isa<LoadInst>(QueryInst);
BasicBlock *FromBB = QueryInst->getParent();
assert(FromBB);
assert(Loc.Ptr-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0x293e4d8
movdqu (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movdqa %xmm0, ... | /Analysis/MemoryDependenceAnalysis.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::SmallPtrSet<llvm::Value const*, 4u>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::SmallPtrSet<llvm::Value const*, 4u>>>, llvm::Instruction*, llvm::SmallPtrSet<llvm::Value const*, 4u>, llvm::DenseMapInfo<llv... | 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 0x293dec2
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 |
llvm::DenseMap<llvm::LoadInst*, int, llvm::DenseMapInfo<llvm::LoadInst*, void>, llvm::detail::DenseMapPair<llvm::LoadInst*, int>>::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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::SmallPtrSet<llvm::Instruction*, 4u>>>, llvm::Instruction*, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseMapInf... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x293c838
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,8), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%... | /llvm/ADT/DenseMap.h |
llvm::MemoryLocation::get(llvm::LoadInst const*) | MemoryLocation MemoryLocation::get(const LoadInst *LI) {
const auto &DL = LI->getDataLayout();
return MemoryLocation(
LI->getPointerOperand(),
LocationSize::precise(DL.getTypeStoreSize(LI->getType())),
LI->getAAMetadata());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1a3f4d6
movq -0x20(%r14), %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x8ef294
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
subq %rcx, %rax
shrq $0x3, %rax
addq %rcx, %rax
movzbl %dl, %r12d
andl $0x1, %r12d
... | /Analysis/MemoryLocation.cpp |
llvm::MemorySSA::createMemoryPhi(llvm::BasicBlock*) | MemoryPhi *MemorySSA::createMemoryPhi(BasicBlock *BB) {
assert(!getMemoryAccess(BB) && "MemoryPhi already exists for this BB");
MemoryPhi *Phi = new MemoryPhi(BB->getContext(), BB, NextID++);
// Phi's always are placed at the front of the block.
insertIntoListsForBlock(Phi, BB, Beginning);
ValueToMemoryAccess... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x50, %edi
callq 0x1a8f686
movq %rax, %rbx
movq %r15, %rdi
callq 0x19b8816
movl 0x140(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x140(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x2942030
movq %r14,... | /Analysis/MemorySSA.cpp |
llvm::MemorySSAUpdater::recursePhi(llvm::MemoryAccess*) | MemoryAccess *MemorySSAUpdater::recursePhi(MemoryAccess *Phi) {
if (!Phi)
return nullptr;
TrackingVH<MemoryAccess> Res(Phi);
SmallVector<TrackingVH<Value>, 8> Uses;
std::copy(Phi->user_begin(), Phi->user_end(), std::back_inserter(Uses));
for (auto &U : Uses)
if (MemoryPhi *UsePhi = dyn_cast<MemoryPhi>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
testq %rsi, %rsi
je 0x294906b
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq $0x6, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
callq 0xaf13d0
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx ... | /Analysis/MemorySSAUpdater.cpp |
llvm::MemorySSAUpdater::createMemoryAccessAfter(llvm::Instruction*, llvm::MemoryAccess*, llvm::MemoryAccess*) | MemoryUseOrDef *MemorySSAUpdater::createMemoryAccessAfter(
Instruction *I, MemoryAccess *Definition, MemoryAccess *InsertPt) {
assert(I->getParent() == InsertPt->getBlock() &&
"New and old access must be in the same block");
MemoryUseOrDef *NewAccess = MSSA->createDefinedAccess(I, Definition);
MSSA->... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x29420a0
movq %rax, %r15
movq (%r14), %rdi
movq 0x28(%rbx), %rcx
movq 0x40(%rbx), %rdx
movq %rax, %rsi
callq 0x2941d40
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /Analysis/MemorySSAUpdater.cpp |
llvm::DenseMap<llvm::ValueInfo, unsigned int, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseMapPair<llvm::ValueInfo, unsigned int>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x29555fc
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ec... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::ValueInfo, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseSetPair<llvm::ValueInfo>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x295572e
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ec... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::FunctionSummary::VFuncId, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::FunctionSummary::VFuncId, void>, llvm::detail::DenseSetPair<llvm::FunctionSummary::VFuncId>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x295585a
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ec... | /llvm/ADT/DenseMap.h |
addVCallToSet(llvm::DevirtCallSite, unsigned long, llvm::SetVector<llvm::FunctionSummary::VFuncId, std::vector<llvm::FunctionSummary::VFuncId, std::allocator<llvm::FunctionSummary::VFuncId>>, llvm::DenseSet<llvm::FunctionSummary::VFuncId, llvm::DenseMapInfo<llvm::FunctionSummary::VFuncId, void>>, 0u>&, llvm::SetVector<... | static void addVCallToSet(
DevirtCallSite Call, GlobalValue::GUID Guid,
SetVector<FunctionSummary::VFuncId, std::vector<FunctionSummary::VFuncId>>
&VCalls,
SetVector<FunctionSummary::ConstVCall,
std::vector<FunctionSummary::ConstVCall>> &ConstVCalls) {
std::vector<uint64_t> Args;
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rbx
subq %rax, %rbx
movq %rsi, %rdi
callq 0x8f171e
... | /Analysis/ModuleSummaryAnalysis.cpp |
llvm::DenseMap<llvm::FunctionSummary::VFuncId, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::FunctionSummary::VFuncId, void>, llvm::detail::DenseSetPair<llvm::FunctionSummary::VFuncId>>::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::FunctionSummary::ConstVCall>* llvm::DenseMapBase<llvm::DenseMap<llvm::FunctionSummary::ConstVCall, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::FunctionSummary::ConstVCall, void>, llvm::detail::DenseSetPair<llvm::FunctionSummary::ConstVCall>>, llvm::FunctionSummary::ConstVCall,... | 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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x2956689
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ValueInfo, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseSetPair<llvm::ValueInfo>>, llvm::ValueInfo, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseSetPair<llvm::ValueInfo>>::erase(llvm::Valu... | 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 0x1a78322
testb %al, %al
je 0x2956c36
movq 0x8(%rsp), %rcx
movq $-0x10, (%rcx)
movq 0x8(%rbx), %xmm0
paddd 0xa3648f(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::APSInt::operator==(long) const | bool operator==(int64_t RHS) const {
return compareValues(*this, get(RHS)) == 0;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %r14
movl $0x40, 0x8(%r14)
movq %rsi, (%r14)
movb $0x0, 0xc(%r14)
movq %r14, %rsi
callq 0x10d32e2
movl %eax, %ebx
cmpl $0x41, 0x8(%r14)
jb 0x29578f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29578f0
callq 0x7512d0
testl %ebx, %ebx
sete %al
addq $0x18, %rsp
popq %r... | /llvm/ADT/APSInt.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.