name string | code string | asm string | file string |
|---|---|---|---|
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [13], llvm::cl::desc, llvm::cl::cat>(char const (&) [13], llvm::cl::desc const&, llvm::cl::cat const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb %bpl, 0x91(%rbx)
leaq 0x3652924(%rip), %rax # 0x56e32a0
addq $0x1... | /llvm/Support/CommandLine.h |
polly::ScopDetection::isProfitableRegion(polly::ScopDetection::DetectionContext&) const | bool ScopDetection::isProfitableRegion(DetectionContext &Context) const {
Region &CurRegion = Context.CurRegion;
if (PollyProcessUnprofitable)
return true;
// We can probably not do a lot on scops that only write or only read
// data.
if (!Context.hasStores || !Context.hasLoads)
return invalid<Repor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x385a4cd(%rip), %rax # 0x58ebf18
movb $0x1, %bpl
cmpb $0x0, (%rax)
jne 0x2091b5d
movq %rsi, %rbx
movq (%rsi), %r14
cmpb $0x1, 0x391(%rsi)
jne 0x2091ac4
cmpb $0x0, 0x390(%rbx)
je 0x2091ac4
movq %rdi, %r15
movq 0x38(%rdi), %rsi
movq 0x40(%rdi... | /Analysis/ScopDetection.cpp |
polly::ScopDetection::isValidRegion(polly::ScopDetection::DetectionContext&) | bool ScopDetection::isValidRegion(DetectionContext &Context) {
Region &CurRegion = Context.CurRegion;
POLLY_DEBUG(dbgs() << "Checking region: " << CurRegion.getNameStr()
<< "\n\t");
if (!PollyAllowFullFunction && CurRegion.isTopLevelRegion()) {
POLLY_DEBUG(dbgs() << "Top level region is... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq (%rsi), %r14
leaq 0x385a2e6(%rip), %r12 # 0x58ec1d0
cmpb $0x0, (%r12)
jne 0x2091efc
cmpq $0x0, 0x20(%r14)
je 0x20920a5
movq $0x0, 0x10(%rsp)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2091fa2
movq ... | /Analysis/ScopDetection.cpp |
polly::ScopDetection::regionIsInvalidBecause[abi:cxx11](llvm::Region const*) const | std::string ScopDetection::regionIsInvalidBecause(const Region *R) const {
// Get the first error we found. Even in keep-going mode, this is the first
// reason that caused the candidate to be rejected.
auto *Log = lookupRejectionLog(R);
// This can happen when we marked a region invalid, but didn't track
//... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x209794c
leaq 0x2e0(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
je 0x209232a
cmpl $0x0, 0x10(%rcx)
je 0x209232a
movq 0x8(%rcx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x2092345
movq 0x37fa7c1(%rip), %rax ... | /Analysis/ScopDetection.cpp |
polly::ScopDetection::isAffine(llvm::SCEV const*, llvm::Loop*, polly::ScopDetection::DetectionContext&) const | bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
DetectionContext &Context) const {
InvariantLoadsSetTy AccessILS;
if (!isAffineExpr(&Context.CurRegion, Scope, S, SE, &AccessILS))
return false;
if (!onlyValidRequiredInvariantLoads(AccessILS, Context))
return false;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %rax
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r15
movaps %xmm0, -0x28(%r15)
movl $0x0, -0x18(%r15)
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movq (%rcx), %rdi
movq 0x38(%r14), %rcx
movq %rsp, %r8
movq %rdx, %rsi
movq %rax, %rdx
... | /Analysis/ScopDetection.cpp |
bool polly::ScopDetection::invalid<polly::ReportNonAffBranch, llvm::BasicBlock*, llvm::SCEV const*&, llvm::SCEV const*&, llvm::ICmpInst*&>(polly::ScopDetection::DetectionContext&, bool, llvm::BasicBlock*&&, llvm::SCEV const*&, llvm::SCEV const*&, llvm::ICmpInst*&) const | inline bool ScopDetection::invalid(DetectionContext &Context, bool Assert,
Args &&...Arguments) const {
if (!Context.Verifying) {
RejectLog &Log = Context.Log;
std::shared_ptr<RR> RejectReason = std::make_shared<RR>(Arguments...);
Context.IsInvalid = true;
// Log ev... | cmpb $0x0, 0x2d8(%rsi)
jne 0x20933e2
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x50(%rsp), %rax
leaq 0x30(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
leaq 0x17(%rsp), %rdx
movq %r14, %rsi
callq 0x209b078
movb $0x1, 0x2d9(%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rax
movq %... | /Analysis/ScopDetection.cpp |
polly::ScopDetection::isValidInstruction(llvm::Instruction&, polly::ScopDetection::DetectionContext&) | bool ScopDetection::isValidInstruction(Instruction &Inst,
DetectionContext &Context) {
for (auto &Op : Inst.operands()) {
auto *OpInst = dyn_cast<Instruction>(&Op);
if (!OpInst)
continue;
if (isErrorBlock(*OpInst->getParent(), Context.CurRegion)) {
auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x903b1e
cmpq %rdx, %rax
sete %bpl
je 0x20958ee
movq %rax, %r12
movq %rdx, %r13
movq (%r12), %r15
movl $0x3, %eax
cmpb $0x1d, (%r15)
jb 0x20958cc
movq 0x28(%r15)... | /Analysis/ScopDetection.cpp |
polly::MemAccInst::isSimple() const | bool isSimple() const {
if (isLoad())
return asLoad()->isSimple();
if (isStore())
return asStore()->isSimple();
if (isMemIntrinsic())
return !asMemIntrinsic()->isVolatile();
if (isCallInst())
return true;
llvm_unreachable("Operation not supported on nullptr");
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2095e79
cmpb $0x3d, (%r14)
je 0x2095e60
testq %r14, %r14
je 0x2095e79
cmpb $0x3e, (%r14)
jne 0x2095e79
movq %r14, %rdi
callq 0x1a40db0
movzwl 0x2(%r14), %ecx
testb $0x1, %cl
sete %cl
notb %al
andb %cl, %al
jmp 0x2095e93
movq %rbx, ... | /polly/Support/ScopHelper.h |
llvm::SmallDenseMap<llvm::SCEV const*, llvm::SCEV const*, 4u, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x2098b2c
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::SCEV const*, llvm::SCEV const*, 4u, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>>, llvm::SCEV const*, llvm::SCEV const*, llvm::DenseMapInfo<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 (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x2098eeb
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x2098f22
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
polly::MemAccInst::isMemIntrinsic() const | bool isMemIntrinsic() const { return I && llvm::isa<llvm::MemIntrinsic>(I); } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2099335
cmpb $0x55, (%rbx)
jne 0x2099335
movq %rbx, %rdi
callq 0x8f16ea
testb %al, %al
je 0x2099335
movq -0x20(%rbx), %rax
movl $0xffffff19, %ecx # imm = 0xFFFFFF19
addl 0x24(%rax), %ecx
cmpl $0x7, %ecx
ja 0x2099335
movb $-0x53, %al
shrb %cl, %al
jmp 0x2099337
xo... | /polly/Support/ScopHelper.h |
llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, std::unique_ptr<polly::ScopDetection::DetectionContext, std::default_delete<polly::ScopDetection::DetectionContext>>>* llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, std::unique_ptr<polly::ScopDetection::Dete... | 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 0x209a0c7
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::SmallVectorTemplateBase<llvm::AssertingVH<llvm::LoadInst>, true>::push_back(llvm::AssertingVH<llvm::LoadInst>) | 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 0x209ac9b
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 |
llvm::DenseMapBase<llvm::DenseMap<llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::LoadInst>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>>, llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Assertin... | 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 0x209afa9
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::SCEV const*>::append<std::move_iterator<llvm::SCEV const**>, void>(std::move_iterator<llvm::SCEV const**>, std::move_iterator<llvm::SCEV const**>) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x209b422
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<llvm::SCEV const*>::operator=(llvm::SmallVectorImpl<llvm::SCEV const*> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x209b8ba
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x209b85d
cmpl %r14d, 0xc(%rbx)
jae 0x209b877
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
movq %r14, %rdx
c... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::tuple<llvm::BasicBlock const*, llvm::Region const*>, bool, llvm::DenseMapInfo<std::tuple<llvm::BasicBlock const*, llvm::Region const*>, void>, llvm::detail::DenseMapPair<std::tuple<llvm::BasicBlock const*, llvm::Region const*>, bool>>, std::tuple<llvm::BasicBlock const*, llvm... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x209c735
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %eax
movl 0x8(%rsi), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
shrl $0x9, %r8d
xorl %r9d, %r8d
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
movabsq $0x1ce4e5b900000000, %r9 # imm = 0x1CE4E5B... | /llvm/ADT/DenseMap.h |
polly::ReportIndirectPredecessor::ReportIndirectPredecessor(llvm::Instruction*, llvm::DebugLoc) | ReportIndirectPredecessor(Instruction *Inst, DebugLoc DbgLoc)
: ReportCFG(RejectReasonKind::IndirectPredecessor), Inst(Inst),
DbgLoc(DbgLoc) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x4, %esi
callq 0x209dc4a
leaq 0x37bb931(%rip), %rax # 0x5858708
addq $0x10, %rax
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq (%r14), %rsi
movq %rsi, 0x18(%rbx)
testq %rsi, %rsi
je 0x209ce04
addq $0x18, %rbx
movl $0x1, %edx
movq %... | /polly/ScopDetectionDiagnostic.h |
polly::emitRejectionRemarks(std::pair<llvm::BasicBlock*, llvm::BasicBlock*> const&, polly::RejectLog const&, llvm::OptimizationRemarkEmitter&) | void emitRejectionRemarks(const BBPair &P, const RejectLog &Log,
OptimizationRemarkEmitter &ORE) {
DebugLoc Begin, End;
getDebugLocations(P, Begin, End);
ORE.emit(
OptimizationRemarkMissed(DEBUG_TYPE, "RejectionErrors", Begin, P.first)
<< "The following errors keep this regi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %r15, %rsi
callq 0x209d59e
leaq 0x20(%rsp), %r12
movq %r12, %r... | /Analysis/ScopDetectionDiagnostic.cpp |
polly::RejectLog::print(llvm::raw_ostream&, int) const | void RejectLog::print(raw_ostream &OS, int level) const {
int j = 0;
for (auto Reason : ErrorReports)
OS.indent(level) << "[" << j++ << "] " << Reason->getMessage() << "\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movl 0x10(%rdi), %ebx
testq %rbx, %rbx
je 0x209dc3a
movq 0x8(%rdi), %r14
shlq $0x4, %rbx
addq %r14, %rbx
xorl %r15d, %r15d
movq (%r14), %rbp
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x209db88
mo... | /Analysis/ScopDetectionDiagnostic.cpp |
polly::ReportUndefCond::getMessage[abi:cxx11]() const | std::string ReportUndefCond::getMessage() const {
return ("Condition based on 'undef' value in BB: " + BB->getName()).str();
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x1a90092
leaq 0x8(%rsp), %rsi
movw $0x503, 0x20(%rsi) # imm = 0x503
leaq 0x2f5ec83(%rip), %rcx # 0x4ffcdfe
movq %rcx, (%rsi)
movq %rax, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %rbx, %rdi
callq 0x1cce554
movq %rbx, %rax
addq $0x30, %rsp
popq %... | /Analysis/ScopDetectionDiagnostic.cpp |
polly::ReportLoopHasMultipleExits::getMessage[abi:cxx11]() const | std::string ReportLoopHasMultipleExits::getMessage() const {
return "Loop " + L->getHeader()->getName() + " has multiple exits.";
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x1a90092
movw $0x503, 0x48(%rsp) # imm = 0x503
leaq 0x2f9c4ec(%rip), %rcx # 0x503b60a
movq %rcx, 0x28(%rsp)
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movu... | /Analysis/ScopDetectionDiagnostic.cpp |
polly::ReportAlias::formatInvalidAlias(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | std::string ReportAlias::formatInvalidAlias(std::string Prefix,
std::string Suffix) const {
std::string Message;
raw_string_ostream OS(Message);
OS << Prefix;
for (PointerSnapshotTy::const_iterator PI = Pointers.begin(),
PE =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %r15
movl $0x0, 0x8(%r15)
movb %al, 0x28(%r15)
mo... | /Analysis/ScopDetectionDiagnostic.cpp |
polly::ScopArrayInfo::isCompatibleWith(polly::ScopArrayInfo const*) const | Type *getElementType() const { return ElementType; } | movq 0x48(%rsi), %rcx
xorl %eax, %eax
cmpq 0x48(%rdi), %rcx
je 0x20a108b
retq
movl 0xc0(%rsi), %ecx
decl %ecx
movl $0x0, %edx
cmpl $0x3, %ecx
jb 0x20a10a0
movl 0x68(%rsi), %edx
movl 0xc0(%rdi), %r8d
decl %r8d
movl $0x0, %ecx
cmpl $0x3, %r8d
jb 0x20a10b8
movl 0x68(%rdi), %ecx
cmpl %ecx, %edx
jne 0x20a108a
testl %ecx, %e... | /polly/ScopInfo.h |
polly::MemoryAccess::createBasicAccessMap(polly::ScopStmt*) | isl::basic_map MemoryAccess::createBasicAccessMap(ScopStmt *Statement) {
isl::space Space = isl::space(Statement->getIslCtx(), 0, 1);
Space = Space.align_params(Statement->getDomainSpace());
return isl::basic_map::from_domain_and_range(
isl::basic_set::universe(Statement->getDomainSpace()),
isl::basi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x26662c1
movq %rax, %r12
movq 0x10(%r15), %rdi
callq 0x2606416
movq %rax, %r14
movq %r12, %rdi
callq 0x26665a8
movq %rax, %rdi
movq %r14, %rsi
callq 0x266a6f4... | /Analysis/ScopInfo.cpp |
polly::MemoryAccess::~MemoryAccess() | MemoryAccess::~MemoryAccess() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x108(%rdi), %rdi
testq %rdi, %rdi
je 0x20a4a5b
callq 0x260663c
movq 0x100(%rbx), %rdi
testq %rdi, %rdi
je 0x20a4a6c
callq 0x260663c
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0x20a4a84
callq 0x751980
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x20... | /Analysis/ScopInfo.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::PHINode*, polly::MemoryAccess*, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, polly::MemoryAccess*>>, llvm::PHINode*, polly::MemoryAccess*, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, polly::MemoryAcc... | 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 0x207087e
testb %al, %al
je 0x20a68da
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x12e67eb(%rip), %xmm0 # 0x338d0c0
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
polly::Scop::addParameterBounds() | void Scop::addParameterBounds() {
unsigned PDim = 0;
for (auto *Parameter : Parameters) {
ConstantRange SRange = SE->getSignedRange(Parameter);
Context = addRangeBoundsToSet(Context, SRange, PDim++, isl::dim::param);
}
intersectDefinedBehavior(Context, AS_ASSUMPTION);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0xb0(%rdi), %ebp
testq %rbp, %rbp
je 0x20a7830
movq 0xa8(%rbx), %r12
shlq $0x3, %rbp
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %rsp, %r13
movq (%r12,%r14,8), %rdx
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x20a3... | /Analysis/ScopInfo.cpp |
polly::Scop::getFullParamSpace() const | isl::space Scop::getFullParamSpace() const {
isl::space Space = isl::space::params_alloc(getIslCtx(), ParameterIds.size());
unsigned PDim = 0;
for (const SCEV *Parameter : Parameters) {
isl::id Id = getIdForParam(Parameter);
Space = Space.set_dim_id(isl::dim::param, PDim++, Id);
}
return Space;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movl 0xc0(%rsi), %esi
callq 0x2666352
movq %rax, %rbp
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
movl 0xb0(%r14), %r13d
testq %r13, %r13
je 0x20a7bcb
leaq 0xb8(%r14), %r15
movq 0xa8(%r14), %r... | /Analysis/ScopInfo.cpp |
polly::Scop::getScopArrayInfo(llvm::Value*, polly::MemoryKind) | ScopArrayInfo *Scop::getScopArrayInfo(Value *BasePtr, MemoryKind Kind) {
auto *SAI = getScopArrayInfoOrNull(BasePtr, Kind);
assert(SAI && "No ScopArrayInfo available for this base pointer");
return SAI;
} | subq $0x18, %rsp
addq $0x188, %rdi # imm = 0x188
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0x8(%rax)
movq %rax, %rsi
callq 0x20a8bc0
movq (%rax), %rax
addq $0x18, %rsp
retq
| /Analysis/ScopInfo.cpp |
polly::Scop::getIncomingStmtFor(llvm::Use const&) const | ScopStmt *Scop::getIncomingStmtFor(const Use &U) const {
auto *PHI = cast<PHINode>(U.getUser());
BasicBlock *IncomingBB = PHI->getIncomingBlock(U);
// If the value is a non-synthesizable from the incoming block, use the
// statement that contains it as user statement.
if (auto *IncomingInst = dyn_cast<Instru... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x18(%rsi), %rax
movq -0x8(%rax), %rdx
subq %rdx, %rsi
movl 0x48(%rax), %eax
shlq $0x5, %rax
addq %rdx, %rax
shrq $0x2, %rsi
movabsq $0x7fffffff8, %rdx # imm = 0x7FFFFFFF8
andq %rsi, %rdx
movq (%rdx,%rax), %r14
movb $0x1, %dl
cmpb $0x1d,... | /Analysis/ScopInfo.cpp |
polly::Scop::getRelativeLoopDepth(llvm::Loop const*) const | int Scop::getRelativeLoopDepth(const Loop *L) const {
if (!L || !R.contains(L))
return -1;
// outermostLoopInRegion always returns nullptr for top level regions
if (R.isTopLevelRegion()) {
// LoopInfo's depths start at 1, we start at 0
return L->getLoopDepth() - 1;
} else {
Loop *OuterLoop = R.o... | pushq %r15
pushq %r14
pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x20ab6aa
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0x29642ac
testb %al, %al
je 0x20ab6aa
movq 0x20(%r15), %rdi
cmpq $0x0, 0x20(%rdi)
je 0x20ab69b
movq %r14, %rsi
callq 0x2964380
xorl %ebx, %ebx
movq (... | /Analysis/ScopInfo.cpp |
polly::Scop::getPHIIncomings(polly::ScopArrayInfo const*) const | ArrayRef<MemoryAccess *> Scop::getPHIIncomings(const ScopArrayInfo *SAI) const {
assert(SAI->isPHIKind() || SAI->isExitPHIKind());
auto It = PHIIncomingAccs.find(SAI);
if (It == PHIIncomingAccs.end())
return {};
return It->second;
} | pushq %rbx
movq %rdi, %rbx
addq $0x638, %rdi # imm = 0x638
callq 0x20ab7f4
movl 0x648(%rbx), %ecx
imulq $0x38, %rcx, %rcx
addq 0x638(%rbx), %rcx
cmpq %rcx, %rax
je 0x20ab8a9
movq 0x8(%rax), %rcx
movl 0x10(%rax), %edx
jmp 0x20ab8ad
xorl %edx, %edx
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
| /Analysis/ScopInfo.cpp |
llvm::detail::DenseSetPair<llvm::SCEV const*>* llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseSetPair<llvm::SCEV const*>>, llvm::SCEV const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::SCEV const*, void>, 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 0x20af34f
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::SCEV const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseSetPair<llvm::SCEV const*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
std::pair<llvm::StringMapIterator<std::unique_ptr<polly::ScopArrayInfo, std::default_delete<polly::ScopArrayInfo>>>, bool> llvm::StringMap<std::unique_ptr<polly::ScopArrayInfo, std::default_delete<polly::ScopArrayInfo>>, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1cc24fa
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x20b0032
testq %rax, %rax
je 0x20b0036
jmp 0x20b0020
addq $0x8, %... | /llvm/ADT/StringMap.h |
bool llvm::AnalysisManager<llvm::Function>::Invalidator::invalidateImpl<llvm::detail::AnalysisResultModel<llvm::Function, polly::ScopAnalysis, polly::ScopDetection, llvm::AnalysisManager<llvm::Function>::Invalidator, false>>(llvm::AnalysisKey*, llvm::Function&, llvm::PreservedAnalyses const&) | bool invalidateImpl(AnalysisKey *ID, IRUnitT &IR,
const PreservedAnalyses &PA) {
// If we've already visited this pass, return true if it was invalidated
// and false otherwise.
auto IMapI = IsResultInvalidated.find(ID);
if (IMapI != IsResultInvalidated.end())
ret... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x17ae518
movq (%r15), %rcx
testb $0x1, (%rcx)
leaq 0x8(%rcx), %rdx
cmoveq 0x8(%rcx), %rdx
movl $0x8, %esi
cmovel 0x10(%rcx), %esi
shlq $0x4, %rsi
addq %rdx, %r... | /llvm/IR/PassManager.h |
llvm::SmallVectorTemplateBase<std::pair<isl::pw_multi_aff, isl::pw_multi_aff>, false>::moveElementsForGrow(std::pair<isl::pw_multi_aff, isl::pw_multi_aff>*) | 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 %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %esi
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x20c1066
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
shlq $0x4, %rsi
addq %rdi, %rsi
popq %rbx
jmp 0x20af884
| /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [31], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::cat>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [31], llvm::cl::desc const&, llvm::cl::OptionHidden c... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | 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
movq %rsi, %rdi
callq 0x7512e0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r13), %xmm0
movups %xmm0, 0x20(%r14)
movl (%r... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char [16], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<char [1]>>(llvm::cl::opt<s... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7512e0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll... | /llvm/Support/CommandLine.h |
llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Function>, polly::Scop, polly::ScopStandardAnalysisResults&>::Result::invalidate(polly::Scop&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator&) | bool invalidate(
IRUnitT &IRUnit, const PreservedAnalyses &PA,
typename AnalysisManager<IRUnitT, ExtraArgTs...>::Invalidator &Inv) {
// Loop over the set of registered outer invalidation mappings and if any
// of them map to an analysis that is now invalid, clear it out.
SmallVector<An... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, %r15
movq %rsi, 0x28(%rsp)
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
movq %rdi, 0x20(%rsp)... | /llvm/IR/PassManager.h |
(anonymous namespace)::runPruneUnprofitable(polly::Scop&) | static bool runPruneUnprofitable(Scop &S) {
if (PollyProcessUnprofitable) {
POLLY_DEBUG(
dbgs() << "NOTE: -polly-process-unprofitable active, won't prune "
"anything\n");
return false;
}
ScopsProcessed++;
if (!S.isProfitable(true)) {
POLLY_DEBUG(
dbgs() << "SCoP p... | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x38247af(%rip), %rax # 0x58ebf18
cmpb $0x0, (%rax)
jne 0x20c77b8
movq %rdi, %rbx
movl $0x1, %esi
callq 0x20a93ae
testb %al, %al
jne 0x20c77ab
movq %rsp, %r14
movq $0x0, (%r14)
movq %rbx, %rdi
movl $0x4, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x20a8ca0
movq (%r14), %rsi... | /Analysis/PruneUnprofitable.cpp |
astBuildAfterMark(isl_ast_node*, isl_ast_build*, void*) | static __isl_give isl_ast_node *
astBuildAfterMark(__isl_take isl_ast_node *Node,
__isl_keep isl_ast_build *Build, void *User) {
assert(isl_ast_node_get_type(Node) == isl_ast_node_mark);
AstBuildUserInfo *BuildInfo = (AstBuildUserInfo *)User;
auto *Id = isl_ast_node_mark_get_id(Node);
if (strc... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x25d485e
movq %rax, %r15
movq %rax, %rdi
callq 0x25f59ec
leaq 0x2af1763(%rip), %rsi # 0x4bba690
movq %rax, %rdi
callq 0x751e70
testl %eax, %eax
jne 0x20c8f3e
movb $0x0, 0x9(%r14)
movq %r15, %rdi
callq 0x25f4c81
movq %rbx, %rax
popq %rbx
popq %r14... | /CodeGen/IslAst.cpp |
polly::IslAstInfo::isParallel(isl::ast_node const&) | bool IslAstInfo::isParallel(const isl::ast_node &Node) {
return IslAstInfo::isInnermostParallel(Node) ||
IslAstInfo::isOutermostParallel(Node);
} | pushq %rbx
movq %rdi, %rbx
callq 0x20c8fe6
testq %rax, %rax
je 0x20c904f
movq %rax, %rcx
movb $0x1, %al
cmpb $0x0, 0x2(%rcx)
jne 0x20c9063
movq %rbx, %rdi
callq 0x20c8fe6
testq %rax, %rax
je 0x20c9061
movb 0x3(%rax), %al
jmp 0x20c9063
xorl %eax, %eax
popq %rbx
retq
nop
| /CodeGen/IslAst.cpp |
void llvm::SmallVectorImpl<llvm::Metadata*>::append<std::move_iterator<llvm::Metadata**>, void>(std::move_iterator<llvm::Metadata**>, std::move_iterator<llvm::Metadata**>) | 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 0x20cd71c
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
polly::SCEVAffinator::interpretAsUnsigned(std::pair<isl::pw_aff, isl::set>&, unsigned int) | void SCEVAffinator::interpretAsUnsigned(PWACtx &PWAC, unsigned Width) {
auto *NonNegDom = isl_pw_aff_nonneg_set(PWAC.first.copy());
auto *NonNegPWA =
isl_pw_aff_intersect_domain(PWAC.first.copy(), isl_set_copy(NonNegDom));
auto *ExpPWA = getWidthExpValOnDomain(Width, isl_set_complement(NonNegDom));
PWAC.f... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq (%rsi), %rdi
callq 0x25a438b
movq %rax, %rdi
callq 0x25b1648
movq %rax, %r14
movq (%rbx), %rdi
callq 0x25a438b
movq %rax, %r15
movq %r14, %rdi
callq 0x26073fc
movq %r15, %rdi
movq %rax, %rsi
callq 0x25acc77
movq %rax, %r15
movq ... | /Support/SCEVAffinator.cpp |
polly::SCEVAffinator::visitSRemInstruction(llvm::Instruction*) | PWACtx SCEVAffinator::visitSRemInstruction(Instruction *SRem) {
assert(SRem->getOpcode() == Instruction::SRem && "Assumed SRem instruction!");
auto *Scope = getScope();
auto *Divisor = SRem->getOperand(1);
auto *DivisorSCEV = SE.getSCEVAtScope(Divisor, Scope);
auto DivisorPWAC = visit(DivisorSCEV);
assert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20d1414
movq %rax, %r12
movl 0x4(%r15), %eax
btl $0x1e, %eax
jb 0x20d35df
shll $0x5, %eax
movq %r15, %rcx
subq %rax, %rcx
jmp 0x20d35e3
movq -0x8(%r15), %rcx
movq 0x... | /Support/SCEVAffinator.cpp |
SCEVValidator::visitGenericInst(llvm::Instruction*, llvm::SCEV const*) | ValidatorResult visitGenericInst(Instruction *I, const SCEV *S) {
if (R->contains(I)) {
POLLY_DEBUG(dbgs() << "INVALID: UnknownExpr references an instruction "
"within the region\n");
return ValidatorResult(SCEVType::INVALID);
}
return ValidatorResult(SCEVType::PARAM... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x28(%rdx), %rsi
callq 0x2962e2a
testb %al, %al
je 0x20d5b28
movl $0x3, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
jmp 0x20d5b5b
movq %rs... | /Support/SCEVValidator.cpp |
polly::afterScatter(isl::map, bool) | isl::map polly::afterScatter(isl::map Map, bool Strict) {
isl::space RangeSpace = Map.get_space().range();
isl::map ScatterRel =
Strict ? isl::map::lex_lt(RangeSpace) : isl::map::lex_le(RangeSpace);
return Map.apply_range(ScatterRel);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x2606401
movq %rax, %r12
movq %rax, %rdi
callq 0x26665a8
movq %rax, %rdi
callq 0x266892d
movq %rax, %r14
testq %r12, %r12
je 0x20d8d1a
movq %r12, %rdi
callq 0x2666664
mov... | /Support/ISLTools.cpp |
polly::afterScatter(isl::union_map const&, bool) | isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
isl::map After = afterScatter(Map, Strict);
Result = Result.unite(After);
}
return Result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x268334e
movq %rax, %rdi
callq 0x26833f9
movq %rax, (%r15)
movq (%rbx), %rdi
callq 0x2683bb7
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x28(%rsp), %rbx
movq %rbx, %rd... | /Support/ISLTools.cpp |
polly::RegionGenerator::copyStmt(polly::ScopStmt&, llvm::DenseMap<llvm::Loop const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, llvm::SCEV const*>>&, isl_id_to_ast_expr*) | void RegionGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
__isl_keep isl_id_to_ast_expr *IdToAstExp) {
assert(Stmt.isRegionStmt() &&
"Only region statements can be copied by the region generator");
// Forget all old mappings.
StartBlockMap.clear();
EndBlockMap.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, 0x78(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
addq $0x58, %rdi
movq %rdi, 0x30(%rsp)
callq 0x20e21c2
leaq 0x70(%rbp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x20e21c... | /CodeGen/BlockGenerators.cpp |
polly::RegionGenerator::getExitScalar(polly::MemoryAccess*, llvm::DenseMap<llvm::Loop const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, llvm::SCEV const*>>&, llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, llvm::DenseMapI... | Value *RegionGenerator::getExitScalar(MemoryAccess *MA, LoopToScevMapT <S,
ValueMapT &BBMap) {
ScopStmt *Stmt = MA->getStatement();
// TODO: Add some test cases that ensure this is really the right choice.
Loop *L = LI.getLoopFor(Stmt->getRegion()->getExit());
if (MA->i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq 0x18(%rsi), %r12
movq 0x10(%rdi), %rdi
movq 0xe8(%r12), %rax
movq 0x20(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdx
callq 0xb0401e
testb %al, %al
je 0x20e2b8... | /CodeGen/BlockGenerators.cpp |
llvm::SCEVRewriteVisitor<llvm::SCEVLoopAddRecRewriter>::visitPtrToIntExpr(llvm::SCEVPtrToIntExpr const*) | const SCEV *visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) {
const SCEV *Operand = ((SC *)this)->visit(Expr->getOperand());
return Operand == Expr->getOperand()
? Expr
: SE.getPtrToIntExpr(Operand, Expr->getType());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x20e2cfe
cmpq 0x20(%rbx), %rax
je 0x20e2e05
movq (%r14), %rdi
movq 0x28(%rbx), %rdx
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x296e9d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Analysis/ScalarEvolutionExpressions.h |
llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>, llvm::detail::DenseMapPair<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>>>::copyFrom(llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, ll... | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl 0x10(%r14), %edi
movl %edi, 0x10(%rbx)
testq %rdi, %rdi
je 0x20e3631
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::BasicBlock*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::BasicBlock*>>::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 0x20e485e
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::BasicBlock*, llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>, llvm::detail::DenseMapPair<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>>>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detai... | 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 0x20cbda6
testl %ebp, %ebp
je 0x20e4971
decl %ebp
je 0x20e4975
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x20e497a
xorl %ebp, %ebp
jmp 0x20e4990
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
llvm::SCEVRewriteVisitor<llvm::SCEVParameterRewriter>::visitAddExpr(llvm::SCEVAddExpr const*) | const SCEV *visitAddExpr(const SCEVAddExpr *Expr) {
SmallVector<const SCEV *, 2> Operands;
bool Changed = false;
for (const auto *Op : Expr->operands()) {
Operands.push_back(((SC *)this)->visit(Op));
Changed |= Op != Operands.back();
}
return !Changed ? Expr : SE.getAddExpr(Operands);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%rbx)
movq 0x28(%rsi), %rbp
testq %rbp, %rbp
je 0x20e8a2e
movq %rdi, %r14
movq %r15, (%rsp)
movq 0x20(%r15),... | /llvm/Analysis/ScalarEvolutionExpressions.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [35], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(char const (&) [35], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x35f95d... | /llvm/Support/CommandLine.h |
polly::IslNodeBuilder::createForSequential(isl::ast_node_for, bool) | void IslNodeBuilder::createForSequential(isl::ast_node_for For,
bool MarkParallel) {
Value *ValueLB, *ValueUB, *ValueInc;
Type *MaxType;
BasicBlock *ExitBlock;
Value *IV;
CmpInst::Predicate Predicate;
bool LoopVectorizerDisabled = IsLoopVectorizerDisabled(For);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, 0x24(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x25d275f
movq %rax, %r14
movq %rax, %rdi
callq 0x25d4511
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x25d3ee5
cmpl $0x4, %eax
jne 0x20eb6a3
leaq 0x18(%rsp), %... | /CodeGen/IslNodeBuilder.cpp |
polly::IslNodeBuilder::addParameters(isl_set*) | void IslNodeBuilder::addParameters(__isl_take isl_set *Context) {
// Materialize values for the parameters of the SCoP.
materializeParameters();
// Generate values for the current loop iteration for all surrounding loops.
//
// We may also reference loops outside of the scop which do not contain the
// sco... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20ede80
movq 0x8(%r14), %rax
movq 0x1d0(%r14), %rdi
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $-0x8, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdx
callq 0xb0401e
testb %al, %al
je 0x20eebdc
movq (%rsp), %rax
movq ... | /CodeGen/IslNodeBuilder.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Loop const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, llvm::SCEV const*>>, llvm::Loop const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, llvm::S... | 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 0x20e3552
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x20f0842
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x20e3a54
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Loop const*, unsigned int, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, unsigned int>>, llvm::Loop const*, unsigned int, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, unsigned int>>::moveFr... | 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 0x20f0bab
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<polly::OMPGeneralSchedulingType, true, llvm::cl::parser<polly::OMPGeneralSchedulingType>>::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 0x20f1ffc
movl %eax, %r14d
testb %al, %al
jne 0x20f1e3d
movl 0xc(%rsp), %eax
movq 0x80(%rbx), %rcx
movl %eax, (%rcx)
movw %bp, 0xc(%rbx)
cmpq ... | /llvm/Support/CommandLine.h |
llvm::DenseMap<llvm::PointerIntPair<llvm::Instruction const*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Instruction const*>, llvm::PointerIntPairInfo<llvm::Instruction const*, 1u, llvm::PointerLikeTypeTraits<llvm::Instruction const*>>>, llvm::Register, llvm::DenseMapInfo<llvm::PointerIntPair<llvm::Instruction const*,... | 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 0x20f7daa
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::SwitchCG::SwitchLowering::buildJumpTable(std::vector<llvm::SwitchCG::CaseCluster, std::allocator<llvm::SwitchCG::CaseCluster>> const&, unsigned int, unsigned int, llvm::SwitchInst const*, std::optional<llvm::SDLoc> const&, llvm::MachineBasicBlock*, llvm::SwitchCG::CaseCluster&) | bool SwitchCG::SwitchLowering::buildJumpTable(const CaseClusterVector &Clusters,
unsigned First, unsigned Last,
const SwitchInst *SI,
const std::optional<SDLoc> &SL,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r9, 0xe8(%rsp)
movq %r8, 0x98(%rsp)
movl %ecx, %r13d
movq %rsi, %r14
movq %rdi, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movaps %xmm0, 0xb0(%rsp)
movl $0x0, 0xc0(%rsp)
m... | /CodeGen/SwitchLoweringUtils.cpp |
llvm::SmallDenseMap<llvm::StringRef, llvm::StringRef, 4u, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::StringRef>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x20fdf00
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x5, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::StringRef, llvm::StringRef, 4u, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::StringRef>>, llvm::StringRef, llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::Strin... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leaq 0x8(%rdi), %r12
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %r12
movl $0x4, %r15d
cmovel 0x10(%rdi), %r15d
testl %r15d, %r15d
je 0x20fe0e9
movq %rsi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1cc3dfe
movl %eax, %e... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::StringRef, llvm::StringRef, 4u, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::StringRef>>, llvm::StringRef, llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::StringRef>... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
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 0x20fe348
shlq $0x5, %rcx
addq %rax, %rcx
movq $-0x1, (%rax)
movq $0x0, 0x... | /llvm/ADT/DenseMap.h |
llvm::PrintModulePass::PrintModulePass(llvm::raw_ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
bool ShouldPreserveUseListOrder,
bool EmitSummaryIndex)
: OS(OS), Banner(Banner),
ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
EmitSummaryIndex(EmitSu... | pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x7c3db0
movb %bpl, 0x28(%r14)
movb %bl, 0x29(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
| /IRPrinter/IRPrintingPasses.cpp |
llvm::PrintModulePass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &AM) {
// RemoveDIs: Regardless of the format we've processed this module in, use
// `WriteNewDbgInfoFormat` to determine which format we use to write it.
ScopedDbgInfoFormatSetter FormatSetter(M, WriteNewDbgInfoFormat);
// Remove intrinsic... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x37dca81(%rip), %r14 # 0x58daf80
movzbl 0x80(%r14), %esi
movb 0x310(%rdx), %al
movb %al, 0xf(%rsp)
movq %rdx, %rdi
callq 0x182a53c
cmpb $0x1, 0x80(%r14)
jne 0x... | /IRPrinter/IRPrintingPasses.cpp |
llvm::OperandBundleDefT<llvm::Value*>& llvm::SmallVectorImpl<llvm::OperandBundleDefT<llvm::Value*>>::emplace_back<char const (&) [8], llvm::FuncletPadInst*&>(char const (&) [8], llvm::FuncletPadInst*&) | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x2104a60
movq (%rbx), %r13
imulq $0x38, %rax, %r14
leaq (%r14,%r13), %rbp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r15, %rdi
movq %rdx, %r12
callq 0... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, unsigned long, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned long>>, llvm::Value*, unsigned long, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned long>>::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 0x2107efe
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::objcarc::ProvenanceAnalysis::relatedCheck(llvm::Value const*, llvm::Value const*) | bool ProvenanceAnalysis::relatedCheck(const Value *A, const Value *B) {
// Ask regular AliasAnalysis, for a first approximation.
switch (AA->alias(A, B)) {
case AliasResult::NoAlias:
return false;
case AliasResult::MustAlias:
case AliasResult::PartialAlias:
return true;
case AliasResult::MayAlias:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %rsi
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
movq $-0x1, %rax
movq %rax, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
movups %xmm0, 0x20(%rdx)
... | /Transforms/ObjCARC/ProvenanceAnalysis.cpp |
llvm::objcarc::BottomUpPtrState::MatchWithRetain() | void PtrState::SetKnownPositiveRefCount() {
LLVM_DEBUG(dbgs() << " Setting Known Positive.\n");
KnownPositiveRefCount = true;
} | pushq %rbx
movb $0x1, (%rdi)
movzbl 0x2(%rdi), %eax
movb $0x1, %bl
leaq 0x2ef379d(%rip), %rcx # 0x500059c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %ebx, %ebx
jmp 0x210ce1c
cmpq $0x0, 0x10(%rdi)
je 0x210ce1c
addq $0x48, %rdi
callq 0xb8854c
movl %ebx, %eax
popq %rbx
retq
| /Transforms/ObjCARC/PtrState.cpp |
llvm::objcarc::BottomUpPtrState::HandlePotentialUse(llvm::BasicBlock*, llvm::Instruction*, llvm::Value const*, llvm::objcarc::ProvenanceAnalysis&, llvm::objcarc::ARCInstKind) | void BottomUpPtrState::HandlePotentialUse(BasicBlock *BB, Instruction *Inst,
const Value *Ptr,
ProvenanceAnalysis &PA,
ARCInstKind Class) {
auto SetSeqAndInsertReverseInsertPt = [&](Sequence N... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r14
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rcx
movq %rdx, (%rcx)
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movzbl 0x2(%rdi), %eax
cmpl $0x4, %eax
je 0x210cebb
cmpl $0x5, %eax
jne 0... | /Transforms/ObjCARC/PtrState.cpp |
llvm::objcarc::BundledRetainClaimRVs::~BundledRetainClaimRVs() | CallInst *BundledRetainClaimRVs::insertRVCall(BasicBlock::iterator InsertPt,
CallBase *AnnotatedCall) {
DenseMap<BasicBlock *, ColorVector> BlockColors;
return insertRVCallWithColors(InsertPt, AnnotatedCall, BlockColors);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rdx
movl 0x10(%rdi), %ecx
movq %rcx, %rax
shlq $0x4, %rax
leaq (%rdx,%rax), %r13
movq %rdi, 0x8(%rsp)
cmpl $0x0, 0x8(%rdi)
movq %r13, %rbp
je 0x210d80b
testq %rcx, %rcx
je 0x210d808
movl $0x1000, %ecx # imm = 0x10... | /Transforms/ObjCARC/ObjCARC.cpp |
llvm::CoroEarlyPass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | PreservedAnalyses CoroEarlyPass::run(Module &M, ModuleAnalysisManager &) {
if (!declaresCoroEarlyIntrinsics(M))
return PreservedAnalyses::all();
Lowerer L(M);
for (auto &F : M)
L.lowerEarlyIntrinsics(F);
PreservedAnalyses PA;
PA.preserveSet<CFGAnalyses>();
return PA;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rdx, %rbp
movq %rdi, %r14
leaq 0x374b946(%rip), %rsi # 0x585a240
leaq 0x178(%rsp), %rbx
movl $0xd0, %edx
movq %rbx, %rdi
callq 0x751900
movl $0xd, %edx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2118f78
tes... | /Transforms/Coroutines/CoroEarly.cpp |
llvm::CoroIdInst::getInfo() const | Info getInfo() const {
Info Result;
auto *GV = dyn_cast<GlobalVariable>(getRawInfo());
if (!GV)
return Result;
assert(GV->isConstant() && GV->hasDefinitiveInitializer());
Constant *Initializer = GV->getInitializer();
if ((Result.OutlinedParts = dyn_cast<ConstantStruct>(Initializer)))
... | pushq %rax
movl 0x4(%rdi), %eax
shll $0x5, %eax
subq %rax, %rdi
movq 0x60(%rdi), %rdi
callq 0x1a90a38
cmpb $0x3, (%rax)
jne 0x210f461
movq -0x20(%rax), %rcx
xorl %edx, %edx
cmpb $0xa, (%rcx)
movl $0x0, %eax
cmoveq %rcx, %rax
testq %rax, %rax
cmoveq %rcx, %rdx
jmp 0x210f465
xorl %eax, %eax
xorl %edx, %edx
popq %rcx
retq... | /Transforms/Coroutines/CoroInstr.h |
llvm::SmallVectorTemplateBase<llvm::CoroBeginInst*, true>::push_back(llvm::CoroBeginInst*) | 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 0x21111db
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 |
llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*, void>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x2118c05
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::MapVector<llvm::Value*, llvm::SmallVector<llvm::Instruction*, 2u>, llvm::SmallDenseMap<llvm::Value*, unsigned int, 8u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>>, llvm::SmallVector<std::pair<llvm::Value*, llvm::SmallVector<llvm::Instruction*, 2u>>, 8u>>::operat... | 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x58(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x212bd52
movq (%r15), %r12
cmpb $0x1, 0x10(%r15)
jne 0x21249... | /llvm/ADT/MapVector.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DIType*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DIType*>>, unsigned int, llvm::DIType*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DIType*>>::moveFromOldBuckets(llvm::detail:... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x212af77
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %rdx... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::DILocalVariable*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::DILocalVariable*>>, llvm::Value*, llvm::DILocalVariable*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::DILocalVari... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x212b043
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::DenseMap<llvm::Type*, llvm::DIType*, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, llvm::DIType*>>::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::TinyPtrVector<llvm::DbgDeclareInst*>::operator=(llvm::TinyPtrVector<llvm::DbgDeclareInst*>&&) | TinyPtrVector &operator=(TinyPtrVector &&RHS) {
if (this == &RHS)
return *this;
if (RHS.empty()) {
this->clear();
return *this;
}
// If this vector has been allocated on the heap, re-use it if cheap. If it
// would require more copying, just delete it and we'll steal the other
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x212baf4
movq %rsi, %r14
movq (%rsi), %rax
cmpq $0x8, %rax
jae 0x212ba60
movq (%rbx), %rax
testb $0x4, %al
jne 0x212baba
movq $0x0, (%rbx)
jmp 0x212baf4
testb $0x4, %al
sete %dl
movq %rax, %rcx
andq $-0x8, %rcx
sete %sil
orb %dl, %sil
jne 0x212ba7b
cm... | /llvm/ADT/TinyPtrVector.h |
llvm::AAResults& llvm::function_ref<llvm::AAResults& (llvm::Function&)>::callback_fn<(anonymous namespace)::AlwaysInlinerLegacyPass::runOnModule(llvm::Module&)::'lambda'(llvm::Function&)>(long, llvm::Function&) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r8
movq (%rdi), %rdx
movq 0x8(%rdx), %rsi
leaq 0x37ecc0a(%rip), %rbx # 0x5919c78
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1a5cdee
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x60(%rax)
movq 0x20(%rax), %rax
addq $0x18, %rsp
popq ... | /llvm/ADT/STLFunctionalExtras.h |
std::pair<llvm::DenseMapIterator<llvm::CallBase*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::DenseSetPair<llvm::CallBase*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::CallBase*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::De... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x212d634
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x212d5f6
xorl %ecx, %ecx
jmp 0x212d60f
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<unsigned int, true, llvm::cl::parser<unsigned int>>::opt<char [43], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::LocationClass<unsigned int>, llvm::cl::initializer<int>>(char const (&) [43], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::LocationClass<unsigned int> const&, llvm::cl::... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
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, 0x94(%r14)
leaq 0x35bfcd6(%rip), %rax # 0x56f1eb8
addq $0x10, %rax
... | /llvm/Support/CommandLine.h |
isAssumedReadOnlyOrReadNone(llvm::Attributor&, llvm::IRPosition const&, llvm::AbstractAttribute const&, bool, bool&) | static bool isAssumedReadOnlyOrReadNone(Attributor &A, const IRPosition &IRP,
const AbstractAttribute &QueryingAA,
bool RequireReadNone, bool &IsKnown) {
if (RequireReadNone) {
if (AA::hasAssumedIRAttr<Attribute::ReadNone>(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
testl %ecx, %ecx
je 0x2133135
movq $0x0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x1, %ecx
movq %r15, %r8
movl $0x1, %r9d
callq 0x213efc8
jmp 0... | /Transforms/IPO/Attributor.cpp |
llvm::MustBeExecutedContextExplorer::begin(llvm::Instruction const*) | iterator &begin(const Instruction *PP) {
auto &It = InstructionIteratorMap[PP];
if (!It)
It.reset(new iterator(*this, PP));
return *It;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
addq $0x98, %rdi
movq %rax, %rsi
callq 0x2140e54
leaq 0x8(%rax), %rbx
cmpq $0x0, 0x8(%rax)
jne 0x213456a
movl $0x38, %edi
callq 0x751940
movq %rax, %r15
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2... | /llvm/Analysis/MustExecute.h |
llvm::ChangeStatus llvm::Attributor::updateAttrMap<llvm::StringRef>(llvm::IRPosition const&, llvm::ArrayRef<llvm::StringRef>, llvm::function_ref<bool (llvm::StringRef const&, llvm::AttributeSet, llvm::AttributeMask&, llvm::AttrBuilder&)>) | ChangeStatus
Attributor::updateAttrMap(const IRPosition &IRP, ArrayRef<DescTy> AttrDescs,
function_ref<bool(const DescTy &, AttributeSet,
AttributeMask &, AttrBuilder &)>
CB) {
if (AttrDescs.empty())
return ChangeS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl $0x1, %ebx
testq %rcx, %rcx
je 0x2134cfb
movq %r9, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %r8, 0x20(%rsp)
movq %rsi, %rdi
callq 0xbd1662
cmpb $0x2, %al
jb 0x2134cfb
movq $0x0, (%rsp)
movq %rbp, %rd... | /Transforms/IPO/Attributor.cpp |
llvm::SubsumingPositionIterator::SubsumingPositionIterator(llvm::IRPosition const&) | SubsumingPositionIterator::SubsumingPositionIterator(const IRPosition &IRP) {
IRPositions.emplace_back(IRP);
// Helper to determine if operand bundles on a call site are benign or
// potentially problematic. We handle only llvm.assume for now.
auto CanIgnoreOperandBundles = [](const CallBase &CB) {
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x8(%rdi)
callq 0x21351ec
movq (%r15), %r14
movl %r14d, %eax
notl %eax
andq $-0x4, %r14
testb $0x3, %a... | /Transforms/IPO/Attributor.cpp |
llvm::Attributor::ArgumentReplacementInfo::ArgumentReplacementInfo(llvm::Attributor&, llvm::Argument&, llvm::ArrayRef<llvm::Type*>, std::function<void (llvm::Attributor::ArgumentReplacementInfo const&, llvm::Function&, llvm::Argument*)>&&, std::function<void (llvm::Attributor::ArgumentReplacementInfo const&, llvm::Abst... | ArgumentReplacementInfo(Attributor &A, Argument &Arg,
ArrayRef<Type *> ReplacementTypes,
CalleeRepairCBTy &&CalleeRepairCB,
ACSRepairCBTy &&ACSRepairCB)
: A(A), ReplacedFn(*Arg.getParent()), ReplacedArg(Arg),
Replaceme... | pushq %r15
pushq %r14
pushq %rbx
movq %r9, %r14
movq %rdi, %rbx
movq 0x20(%rsp), %r15
movq %rsi, (%rdi)
movq 0x18(%rdx), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
addq $0x18, %rdi
leaq (%rcx,%r8,8), %rdx
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x2... | /llvm/Transforms/IPO/Attributor.h |
llvm::SmallVectorImpl<llvm::AttributeSet>::append(unsigned long, llvm::AttributeSet) | void append(size_type NumInputs, ValueParamT Elt) {
const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %rsi, %rdx
cmpq %rax, %rdx
ja 0x213b99b
movl 0x8(%r14), %eax
testq %rbx, %rbx
je 0x213b98f
movq (%r14), %rdx
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rsi
movq %rsi, %xmm0
pshufd... | /llvm/ADT/SmallVector.h |
llvm::InformationCache::FunctionInfo::~FunctionInfo() | InformationCache::FunctionInfo::~FunctionInfo() {
// The instruction vectors are allocated using a BumpPtrAllocator, we need to
// manually destroy them.
for (auto &It : OpcodeInstMap)
It.getSecond()->~InstructionVectorTy();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movl 0x10(%rdi), %edx
movq %rdx, %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %r14
cmpl $0x0, 0x8(%rdi)
movq %r14, %r15
je 0x213bf4d
movq %rcx, %r15
testq %rdx, %rdx
je 0x213bf4d
cmpl $-0x2, (%r15)
jb 0x213bf4d
addq $0x10, %r15
addq $-0x... | /Transforms/IPO/Attributor.cpp |
void llvm::Attributor::checkAndQueryIRAttr<(llvm::Attribute::AttrKind)32, llvm::AANoRecurse>(llvm::IRPosition const&, llvm::AttributeSet) | void Attributor::checkAndQueryIRAttr(const IRPosition &IRP,
AttributeSet Attrs) {
bool IsKnown;
if (!Attrs.hasAttribute(AK))
if (!Configuration.Allowed || Configuration.Allowed->count(&AAType::ID))
if (!AA::hasAssumedIRAttr<AK>(*this, nullptr, IRP, DepClassTy::NONE,
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rdx, (%rdi)
movl $0x20, %esi
callq 0x1999964
testb %al, %al
jne 0x213caf7
movq 0x1090(%rbx), %rdi
testq %rdi, %rdi
je 0x213cac0
leaq 0x2ec5bd0(%rip), %rax # 0x500267a
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%r... | /Transforms/IPO/Attributor.cpp |
llvm::operator<<(llvm::raw_ostream&, llvm::IRPosition::Kind) | raw_ostream &llvm::operator<<(raw_ostream &OS, IRPosition::Kind AP) {
switch (AP) {
case IRPosition::IRP_INVALID:
return OS << "inv";
case IRPosition::IRP_FLOAT:
return OS << "flt";
case IRPosition::IRP_RETURNED:
return OS << "fn_ret";
case IRPosition::IRP_CALL_SITE_RETURNED:
return OS << "cs_... | movl %esi, %eax
leaq 0x2ec4652(%rip), %rcx # 0x50013b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1920129(%rip), %rsi # 0x3a5ce97
jmp 0x213cdbd
leaq 0x2ebfd4c(%rip), %rsi # 0x4ffcac3
jmp 0x213cdac
leaq 0x2ec4c27(%rip), %rsi # 0x50019a7
jmp 0x213cd92
leaq 0x2ec4c25(%rip), %rsi # 0x50019ae
jmp... | /Transforms/IPO/Attributor.cpp |
bool llvm::AA::hasAssumedIRAttr<(llvm::Attribute::AttrKind)49, 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
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movb $0x0, (%r8)
movq %rdx, %rsi
movl $0x31, %edx
movl %r9d, %ecx
callq 0x213f0f6
movb $0x1, %bl
movb $0x1, %cl
testb %al, %al
je 0x213f09c
movb %cl, (%r14)
jmp 0x2... | /llvm/Transforms/IPO/Attributor.h |
llvm::DenseMap<llvm::Instruction const*, std::unique_ptr<llvm::MustBeExecutedIterator, std::default_delete<llvm::MustBeExecutedIterator>>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, std::unique_ptr<llvm::MustBeExecutedIterator, std::default_delete<llvm::Must... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::PointerIntPair<llvm::Instruction const*, 1u, llvm::ExplorationDirection, llvm::PointerLikeTypeTraits<llvm::Instruction const*>, llvm::PointerIntPairInfo<llvm::Instruction const*, 1u, llvm::PointerLikeTypeTraits<llvm::Instruction const*>>>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Point... | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
testq %r15, %r15
je 0x214129a
leaq (,%r15,8), %rdi
movl $0x8, %esi
callq 0x1cac6bd
jmp 0x214129c
xorl %eax, %eax
movq %ra... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.