name string | code string | asm string | file string |
|---|---|---|---|
void llvm::OptimizationRemarkEmitter::emit<void (anonymous namespace)::OpenMPOpt::emitRemark<llvm::OptimizationRemark, (anonymous namespace)::OpenMPOpt::deduplicateRuntimeCalls(llvm::Function&, (anonymous namespace)::OMPInformationCache::RuntimeFunctionInfo&, llvm::Value*)::'lambda'(llvm::Use&, llvm::Function&)::operat... | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | subq $0x1d8, %rsp # imm = 0x1D8
leaq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x483ca2c
jmp 0x483ca54
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x483cba0
movq 0x10(%rsp), %rdi
le... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, bool, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, bool>>, llvm::BasicBlock*, bool, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, bool>>::initEmpty() | 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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x48482d0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x48482f0
callq 0x4848310
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x4848320
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x4848330
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, bool, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, bool>>, llvm::BasicBlock*, bool, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, bool>>::moveFromOldBuckets(llvm::detail::Dense... | 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... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4848250
callq 0x4848310
movq %rax, 0x48(%rsp)
callq 0x48486c0
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::CallBase&, (anonymous namespace)::PartialInlinerImpl::FunctionCloner&, llvm::BlockFrequency, llvm::OptimizationRemarkEmitter&) const::$_4>((anonymous namespace)::PartialInlinerImpl::shouldPartialInline(llvm::... | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | subq $0x1d8, %rsp # imm = 0x1D8
leaq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x484c97c
jmp 0x484c9a4
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x484d2b0
movq 0x10(%rsp), %rdi
le... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [32], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [32], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x77c040
movq (%rsp), %rsi
leaq 0x4e8f16e(%rip), %rax # 0x96df04... | /llvm/Support/CommandLine.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [37], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [37], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x77c040
movq (%rsp), %rsi
leaq 0x4e8f02e(%rip), %rax # 0x96df04... | /llvm/Support/CommandLine.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 [29], llvm::cl::initializer<char [1]>, llvm::cl::value_desc, llvm::cl::desc, llvm::cl::OptionHidden>(char const... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x1177330
movq 0x8(%rsp), %rsi
leaq 0x4... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [37], llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::desc>(char const (&) [37], llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x3f7700
movq (%rsp), %rsi
leaq 0x4e8ec26(%rip), %rax # 0x96df18... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::sampleprof::ProfiledCallGraphNode*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::sampleprof::ProfiledCallGraphNode*>>, unsigned long, llvm::sampleprof::ProfiledCallGraphNode*, llvm::DenseMapInfo<unsigned long, void>, llvm... | inline iterator begin() {
// When the map is empty, avoid the overhead of advancing/retreating past
// empty buckets.
if (empty())
return end();
if (shouldReverseIterate<KeyT>())
return makeIterator(getBucketsEnd() - 1, getBuckets(), *this);
return makeIterator(getBuckets(), getBucketsEn... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x48656c0
testb $0x1, %al
jne 0x48654be
jmp 0x48654d7
movq 0x18(%rsp), %rdi
callq 0x4863830
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x486555e
callq 0x903c70
testb $0x1, %al
jne 0x48654e2
jmp 0x4865523
movq 0x18(%rsp), %rdi
... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::sampleprof::ProfiledCallGraphEdge const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::sampleprof::ProfiledCallGraphEdge const*, void>, llvm::detail::DenseSetPair<llvm::sampleprof::ProfiledCallGraphEdge const*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x486b770
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x486b7c0
testb $0x1, %al
jne 0x486b746
jmp 0x486b751
movq (%rsp), %rdi
callq 0x486b830
jmp 0x486b763
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function*, (anonymous namespace)::SampleProfileLoader::NotInlinedProfileInfo, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, (anonymous namespace)::SampleProfileLoader::NotInlinedProfileInfo>>, llvm::Function*, (anonymous namespace)::Sample... | 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... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4854d00
callq 0x4854dc0
movq %rax, 0x48(%rsp)
callq 0x4885490
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::SmallVector<llvm::BasicBlock const*, 8u>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::SmallVector<llvm::BasicBlock const*, 8u>>>, llvm::BasicBlock const*, llvm::SmallVector<llvm::BasicB... | 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... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x488a050
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x4854280
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x4889f02
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::BasicBlock const*, unsigned long, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, unsigned long>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb860b0
movq %rax, 0x18(%rsp)
callq 0xb860d0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x488fd78
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4853900
... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::DevirtModule::applyVirtualConstProp((anonymous namespace)::CallSiteInfo&, llvm::StringRef, llvm::Constant*, llvm::Constant*) | void DevirtModule::applyVirtualConstProp(CallSiteInfo &CSInfo, StringRef FnName,
Constant *Byte, Constant *Bit) {
for (auto Call : CSInfo.CallSites) {
if (!OptimizedCalls.insert(&Call.CB).second)
continue;
auto *RetType = cast<IntegerType>(Call.CB.getType());
... | subq $0x2f8, %rsp # imm = 0x2F8
movq %rdx, 0x2e8(%rsp)
movq %rcx, 0x2f0(%rsp)
movq %rdi, 0x2e0(%rsp)
movq %rsi, 0x2d8(%rsp)
movq %r8, 0x2d0(%rsp)
movq %r9, 0x2c8(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movq 0x2c0(%rsp), %rdi
callq 0x48d4580
movq %rax, ... | /Transforms/IPO/WholeProgramDevirt.cpp |
llvm::SmallVectorImpl<llvm::ArgInfo>::operator=(llvm::SmallVectorImpl<llvm::ArgInfo>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq 0x50(%rsp), %rax
jne 0x48f762e
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x48f7810
movq 0x50(%rsp), %rdi
callq 0x48f13b0
testb $0x1, %al
jne 0x48f765a
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x4... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseSetPair<(anonymous namespace)::Vectorizer::gatherChains(llvm::ArrayRef<llvm::Instruction*>)::InstrListElem*>* llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::Vectorizer::gatherChains(llvm::ArrayRef<llvm::Instruction*>)::InstrListElem*, llvm::detail::DenseSetEmpty, (anonymous namespace)::Vect... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x548460
movq 0x10(%rsp), %rdi
callq 0x4908a00
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x4905d90
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::Instruction*, llvm::APInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>*, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>*, llvm::De... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::APInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>>, llvm::Instruction*, llvm::APInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>>::move... | 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... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x447fce0
callq 0x447fda0
movq %rax, 0x48(%rsp)
callq 0x44804a0
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
llvm::iterator_range<llvm::filter_iterator_impl<decltype(adl_begin(std::declval<llvm::iterator_range<llvm::mapped_iterator<llvm::df_iterator<llvm::VPBlockShallowTraversalWrapper<llvm::VPBlockBase*>, llvm::df_iterator_default_set<llvm::VPBlockBase*, 8u>, false, llvm::GraphTraits<llvm::VPBlockShallowTraversalWrapper<llvm... | iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
make_filter_range(RangeT &&Range, PredicateT Pred) {
using FilterIteratorT =
filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
return make_range(
FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
... | subq $0x448, %rsp # imm = 0x448
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x440(%rsp)
movq %rsi, 0x430(%rsp)
movq 0x430(%rsp), %rsi
leaq 0x2a8(%rsp), %rdi
callq 0x4962050
movq 0x430(%rsp), %rsi
leaq 0x228(%rsp), %rdi
callq 0x4962080
leaq 0x328(%rsp), %rdi
leaq 0x2a8(%rsp), %rsi
leaq 0... | /llvm/ADT/STLExtras.h |
llvm::DenseMapIterator<llvm::ElementCount, llvm::SmallPtrSet<llvm::Instruction*, 4u>, llvm::DenseMapInfo<llvm::ElementCount, void>, llvm::detail::DenseMapPair<llvm::ElementCount, llvm::SmallPtrSet<llvm::Instruction*, 4u>>, true>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::ElementCount, llvm::SmallPtrSet<llvm::In... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Instruction*, llvm::InterleaveGroup<llvm::Instruction>*, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::InterleaveGroup<llvm::Instruction>*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x496dcd0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x496dd20
testb $0x1, %al
jne 0x496dc96
jmp 0x496dca1
movq (%rsp), %rdi
callq 0x496dbe0
jmp 0x496dcb3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::VPValue*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::VPValue*>>, llvm::Value*, llvm::VPValue*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::VPValue*>>::LookupBucketFor<llvm::V... | 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... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4975830
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x4975840
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x4975a32
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::VPBlockBase*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::VPBlockBase>, std::default_delete<llvm::DomTreeNodeBase<llvm::VPBlockBase>>>, llvm::DenseMapInfo<llvm::VPBlockBase*, void>, llvm::detail::DenseMapPair<llvm::VPBlockBase*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::VPBlock... | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x497ad10
cmpl $0x0, %eax
jne 0x497adc2
jmp 0x497ae62
callq 0x497ac30
movq %rax, 0x28(%rsp)
callq 0x497ae70
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x497ac40
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x497ac50
movq %... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<std::pair<llvm::CallInst*, llvm::ElementCount>, llvm::LoopVectorizationCostModel::CallWideningDecision, llvm::DenseMapInfo<std::pair<llvm::CallInst*, llvm::ElementCount>, void>, llvm::detail::DenseMapPair<std::pair<llvm::CallInst*, llvm::ElementCount>, llvm::LoopVectorizationCostModel::CallWideni... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::VPValue*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::VPValue*>>, llvm::BasicBlock*, llvm::VPValue*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::VPValue*>>... | const_iterator makeConstIterator(const BucketT *P, const BucketT *E,
const DebugEpochBase &Epoch,
const bool NoAdvance=false) const {
if (shouldReverseIterate<KeyT>()) {
const BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x202c1f0
testb $0x1, %al
jne 0x4995cb6
jmp 0x4995d22
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::BasicBlock*, llvm::VPValue*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::VPValue*>, true>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::VPValue*> const*, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::VPValue*... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, std::pair<unsigned int, unsigned int>>>, llvm::Value*, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail:... | 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... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4a3ec60
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x4a3da60
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x4a3eee2
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm::DataLayout const&, llvm::TargetTransformInfo*, llvm::TargetLibraryInfo const&)::'lambda0'()>((anonymous namespace)::HorizontalReduction::tryToReduce(llvm::slpvectorizer::BoUpSLP&, llvm... | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | subq $0x1d8, %rsp # imm = 0x1D8
leaq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x4a5ce6c
jmp 0x4a5ce94
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4a64250
movq 0x10(%rsp), %rdi
le... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::DenseMapIterator<llvm::Value*, llvm::SmallVector<llvm::StoreInst*, 6u>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::SmallVector<llvm::StoreInst*, 6u>>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x7cae90
movq %rax, 0x18(%rsp)
callq 0x7cb4a0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x4a80248
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4a7d320
... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<int, llvm::slpvectorizer::BoUpSLP::TreeEntry const*, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, llvm::slpvectorizer::BoUpSLP::TreeEntry const*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x4aac730
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x4aac780
testb $0x1, %al
jne 0x4aac706
jmp 0x4aac711
movq (%rsp), %rdi
callq 0x4aac7f0
jmp 0x4aac723
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Value*, llvm::InsertElementInst*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::InsertElementInst*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x4abbbb0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x4a2fe80
testb $0x1, %al
jne 0x4abbb86
jmp 0x4abbb91
movq (%rsp), %rdi
callq 0x4a2fef0
jmp 0x4abbba3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
bool llvm::is_contained<llvm::SmallVector<llvm::VPBlockBase*, 8u>&, llvm::VPBlockBase*>(llvm::SmallVector<llvm::VPBlockBase*, 8u>&, llvm::VPBlockBase* const&) | bool is_contained(R &&Range, const E &Element) {
if constexpr (detail::HasMemberContains<R, E>)
return Range.contains(Element);
else if constexpr (detail::HasMemberFind<R, E>)
return Range.find(Element) != Range.end();
else
return std::find(adl_begin(Range), adl_end(Range), Element) !=
adl_... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4b13bb0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4b13bc0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x4978bc0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4b13bc0
movq %rax, %rcx
movq 0x10(%... | /llvm/ADT/STLExtras.h |
(anonymous namespace)::AddressSanitizer::initializeCallbacks(llvm::Module&, llvm::TargetLibraryInfo const*) | void AddressSanitizer::initializeCallbacks(Module &M, const TargetLibraryInfo *TLI) {
IRBuilder<> IRB(*C);
// Create __asan_report* callbacks.
// IsWrite, TypeSize and Exp are encoded in the function name.
for (int Exp = 0; Exp < 2; Exp++) {
for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++... | subq $0x778, %rsp # imm = 0x778
movq %rdi, 0x770(%rsp)
movq %rsi, 0x768(%rsp)
movq %rdx, 0x760(%rsp)
movq 0x770(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq (%rax), %rax
movq %rax, 0xe0(%rsp)
leaq 0x6c0(%rsp), %rdi
callq 0x7b2080
movq 0xe0(%rsp), %rsi
movq 0x6c0(%rsp), %rcx
movq 0x6c8(%rsp), %r8
leaq 0x6d0(%rsp), ... | /Transforms/Instrumentation/AddressSanitizer.cpp |
llvm::CFGMST<(anonymous namespace)::Edge, (anonymous namespace)::BBInfo>::buildEdges() | void buildEdges() {
LLVM_DEBUG(dbgs() << "Build Edge on " << F.getName() << "\n");
BasicBlock *Entry = &(F.getEntryBlock());
uint64_t EntryWeight =
(BFI != nullptr ? BFI->getEntryFreq().getFrequency() : 2);
// If we want to instrument the entry count, lower the weight to 0.
if (InstrumentFu... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4bd661e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7df0f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xe8(%rsp)
cmpq $0x0, 0x48(%rax)
je 0x4bd666c
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x5603e70
movq %rax, 0x... | /llvm/Transforms/Instrumentation/CFGMST.h |
llvm::CFGMST<(anonymous namespace)::Edge, (anonymous namespace)::BBInfo>::handleCoroSuspendEdge((anonymous namespace)::Edge*) | void handleCoroSuspendEdge(Edge *E) {
// We must not add instrumentation to the BB representing the
// "suspend" path, else CoroSplit won't be able to lower
// llvm.coro.suspend to a tail call. We do want profiling info for
// the other branches (resume/destroy). So we do 2 things:
// 1. we prefer i... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4bd73fc
jmp 0x4bd7421
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x53b57f0
testb $0x1, %al
jne 0x4bd7418
jmp 0x4bd7421
movq 0x8(%rsp), %rax
movb $0x1, 0x29(%rax)
addq $... | /llvm/Transforms/Instrumentation/CFGMST.h |
llvm::SmallVectorImpl<std::vector<llvm::memprof::Frame, std::allocator<llvm::memprof::Frame>>>::assignRemote(llvm::SmallVectorImpl<std::vector<llvm::memprof::Frame, std::allocator<llvm::memprof::Frame>>>&&) | 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();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4beda70
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x4beda80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4befee0
movq 0x10(%rsp), %rdi
callq 0x4befdd0
testb $0x1, %al
jne 0x4befe59
movq 0x10(%rsp), %r... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::MemorySanitizerVisitor::handleVectorStoreIntrinsic(llvm::IntrinsicInst&) | bool handleVectorStoreIntrinsic(IntrinsicInst &I) {
IRBuilder<> IRB(&I);
Value *Addr = I.getArgOperand(0);
Value *Shadow = getShadow(&I, 1);
Value *ShadowPtr, *OriginPtr;
// We don't know the pointer alignment (could be unaligned SSE store!).
// Have to assume to worst case.
std::tie(Shadow... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x128(%rsp), %rax
movq %rax, (%rsp)
leaq 0x88(%rsp), %rdi
callq 0x7b2080
movq (%rsp), %rsi
movq 0x88(%rsp), %rcx
movq 0x90(%rsp), %r8
leaq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax,... | /Transforms/Instrumentation/MemorySanitizer.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [14], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>>(char const (&) [14], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x3f7700
movq (%rsp), %rsi
leaq 0x4a35716(%rip), %rax # 0x96df18... | /llvm/Support/CommandLine.h |
(anonymous namespace)::HWAddressSanitizer::createHwasanCtorComdat() | void HWAddressSanitizer::createHwasanCtorComdat() {
std::tie(HwasanCtorFunction, std::ignore) =
getOrCreateSanitizerCtorAndInitFunctions(
M, kHwasanModuleCtorName, kHwasanInitName,
/*InitArgTypes=*/{},
/*InitArgs=*/{},
// This callback is invoked when the functions are cr... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x3c0, %rsp # imm = 0x3C0
movq %rdi, 0x3b8(%rsp)
movq 0x3b8(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0x390(%rsp), %rdi
leaq 0x37c64d5(%rip), %rsi # 0x84728b0
callq 0x3ee9c0
leaq 0x380(%rsp), %rdi
leaq 0x37c64d4(%rip), %rsi #... | /Transforms/Instrumentation/HWAddressSanitizer.cpp |
(anonymous namespace)::ModuleBitcodeWriter::writeSyncScopeNames() | void ModuleBitcodeWriter::writeSyncScopeNames() {
SmallVector<StringRef, 8> SSNs;
M.getContext().getSyncScopeNames(SSNs);
if (SSNs.empty())
return;
Stream.EnterSubblock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID, 2);
SmallVector<uint64_t, 64> Record;
for (auto SSN : SSNs) {
Record.append(SSN.begin(), SSN.end... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2e0(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x250(%rsp), %rdi
callq 0x2ec1c30
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7de120
movq %rax, %rdi
leaq 0x250(%rsp), %rsi
callq 0x309f4f0
leaq 0x250(%rsp), %rdi
callq 0x3a8dce0
testb $0x1, %al
jne... | /Bitcode/Writer/BitcodeWriter.cpp |
llvm::DenseMap<llvm::Type*, unsigned int, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, unsigned 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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x8(%rsp)
leaq 0x... | /llvm/ADT/DenseMap.h |
llvm::OpenMPIRBuilder::getOrCreateRuntimeFunction(llvm::Module&, llvm::omp::RuntimeFunction) | FunctionCallee
OpenMPIRBuilder::getOrCreateRuntimeFunction(Module &M, RuntimeFunction FnID) {
FunctionType *FnTy = nullptr;
Function *Fn = nullptr;
// Try to find the declation in the module first.
switch (FnID) {
#define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...) \
case Enum: ... | subq $0x6b18, %rsp # imm = 0x6B18
movq %rdi, 0x6b00(%rsp)
movq %rsi, 0x6af8(%rsp)
movl %edx, 0x6af4(%rsp)
movq 0x6b00(%rsp), %rax
movq %rax, 0x1208(%rsp)
movq $0x0, 0x6ae8(%rsp)
movq $0x0, 0x6ae0(%rsp)
movl 0x6af4(%rsp), %eax
movq %rax, 0x1210(%rsp)
subq $0xbe, %rax
ja 0x4d40229
movq 0x1210(%rsp), %rax
leaq 0... | /Frontend/OpenMP/OMPIRBuilder.cpp |
hostParallelCallback(llvm::OpenMPIRBuilder*, llvm::Function&, llvm::Function*, llvm::Value*, llvm::Value*, llvm::Instruction*, llvm::AllocaInst*, llvm::SmallVector<llvm::Instruction*, 4u> const&) | static void
hostParallelCallback(OpenMPIRBuilder *OMPIRBuilder, Function &OutlinedFn,
Function *OuterFn, Value *Ident, Value *IfCondition,
Instruction *PrivTID, AllocaInst *PrivTIDAddr,
const SmallVector<Instruction *, 4> &ToBeDeleted) {
IRBuilder<> &Buil... | subq $0x3a8, %rsp # imm = 0x3A8
movq 0x3b8(%rsp), %rax
movq 0x3b0(%rsp), %rax
movq %rdi, 0x3a0(%rsp)
movq %rsi, 0x398(%rsp)
movq %rdx, 0x390(%rsp)
movq %rcx, 0x388(%rsp)
movq %r8, 0x380(%rsp)
movq %r9, 0x378(%rsp)
movq 0x3a0(%rsp), %rax
addq $0x1b8, %rax # imm = 0x1B8
movq %rax, 0x370(%rsp)
leaq 0... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::DenseMapIterator<llvm::BasicBlock*, bool, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, bool>, false>::RetreatPastEmptyBuckets() | void RetreatPastEmptyBuckets() {
assert(Ptr >= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
-... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb538d0
movq %rax, 0x18(%rsp)
callq 0xb53da0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x4d58570
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x10, %rd... | /llvm/ADT/DenseMap.h |
llvm::IDFCalculatorDetail::ChildrenGetterTy<llvm::BasicBlock, true>::get(llvm::BasicBlock* const&) | typename ChildrenGetterTy<BasicBlock, IsPostDom>::ChildrenTy
ChildrenGetterTy<BasicBlock, IsPostDom>::get(const NodeRef &N) {
using OrderedNodeTy =
typename IDFCalculatorBase<BasicBlock, IsPostDom>::OrderedNodeTy;
if (!GD) {
auto Children = children<OrderedNodeTy>(N);
return {Children.begin(), Child... | subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
jne 0x4d597b8
movq 0x40(%rsp), %rdi
callq 0x3020740
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x30(%rsp), %rd... | /llvm/Analysis/IteratedDominanceFrontier.h |
llvm::po_iterator<llvm::Inverse<llvm::BasicBlock*>, llvm::SmallPtrSet<llvm::BasicBlock*, 16u>, true, llvm::GraphTraits<llvm::Inverse<llvm::BasicBlock*>>>::traverseChild() | void traverseChild() {
while (true) {
auto &Entry = VisitStack.back();
if (std::get<1>(Entry) == std::get<2>(Entry))
break;
NodeRef BB = *std::get<1>(Entry)++;
if (this->insertEdge(std::optional<NodeRef>(std::get<0>(Entry)), BB)) {
// If the block is not visited...
Vi... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x4d5c410
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d5c530
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d5c540
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc876a0
testb $0x1, ... | /llvm/ADT/PostOrderIterator.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, (anonymous namespace)::InstInfoType, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, (anonymous namespace)::InstInfoType>>, llvm::Instruction*, (anonymous namespace)::InstInfoType, llvm::DenseMapInfo<llvm::Instruction*, v... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x4d57240
testb $0x1, %al
jne 0x4d5d322
movb $0x0, 0x37(%rsp)
jmp 0x4d5d361
movq 0x18(%rsp), %rdi
callq 0x4d57290
callq 0x4d57230
movq %rax, 0x8(%rsp)
movq 0x18(%rsp... | /llvm/ADT/DenseMap.h |
llvm::ConstantHoistingPass::collectConstantCandidates(llvm::Function&) | void ConstantHoistingPass::collectConstantCandidates(Function &Fn) {
ConstCandMapType ConstCandMap;
for (BasicBlock &BB : Fn) {
// Ignore unreachable basic blocks.
if (!DT->isReachableFromEntry(&BB))
continue;
for (Instruction &Inst : BB)
if (!TTI->preferToKeepConstantsAttached(Inst, Fn))
... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x4d68b50
movq 0x98(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x7df3c0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x7df3f0
movq %rax, 0x68(%rsp)
... | /Transforms/Scalar/ConstantHoisting.cpp |
bool llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::ConstantInt>, 17u, 2u, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
if (Op->getOpcode() != Opcode)
return false;
if ((WrapFlags & OverflowingBinaryOperator::NoUnsignedWrap) &&
!Op->hasNoUnsignedWrap())
return false;
if ((WrapFlags & OverflowingBinaryOperator::N... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4d86960
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4d86b39
movq 0x18(%rsp), %rdi
callq 0xa98260
cmpl $0x11, %eax
je 0x4d86abc
movb $0x0, 0x37(%rsp)
jmp 0x4d86b3e
movq 0x18(%rsp), ... | /llvm/IR/PatternMatch.h |
void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::AllSwitchPaths::run()::'lambda'()>((anonymous namespace)::AllSwitchPaths::run()::'lambda'(), decltype(fp())*) | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, 0x1d0(%rsp)
movq %rdi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1c8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x4db21e7
jmp 0x4db2212
leaq 0x10(%rsp), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x4db5540
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
c... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::DenseMap<llvm::Value*, llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x4dc7b00
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x4dc7b50
testb $0x1, %al
jne 0x4dc7ad6
jmp 0x4dc7ae1
movq (%rsp), %rdi
callq 0x4dc7bc0
jmp 0x4dc7af3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<(anonymous namespace)::GEPValue, llvm::ScopedHashTableVal<(anonymous namespace)::GEPValue, llvm::Value*>*, llvm::DenseMapInfo<(anonymous namespace)::GEPValue, void>, llvm::detail::DenseMapPair<(anonymous namespace)::GEPValue, llvm::ScopedHashTableVal<(anonymous namespace)::GEPValue, llvm::Value*>*>>::all... | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x4dc85a7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x4dc85cf
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::InductiveRangeCheckElimination::isProfitableToTransform(llvm::Loop const&, llvm::LoopStructure&) | bool
InductiveRangeCheckElimination::isProfitableToTransform(const Loop &L,
LoopStructure &LS) {
if (SkipProfitabilityChecks)
return true;
if (GetBFI) {
BlockFrequencyInfo &BFI = (*GetBFI)();
uint64_t hFreq = BFI.getBlockFreq(LS.Header).getFrequenc... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x49a2f1c(%rip), %rdi # 0x97c82f0
addq $0x80, %rdi
callq 0x3f1b60
testb $0x1, %al
jne 0x4e253e6
jmp 0x4e253f0
movb $0x1, 0x67(%rsp)
jmp 0x4e25553
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
c... | /Transforms/Scalar/InductiveRangeCheckElimination.cpp |
bool llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::CmpInst, llvm::CmpInst::Predicate, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<Class>(V)) {
if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
if (Predicate)
*Predicate = I->getPredicate();
return true;
} else if (Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))) ... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7d7fa0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4e5481a
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x7d7fb0
movq 0x8(... | /llvm/IR/PatternMatch.h |
llvm::DenseMap<llvm::BasicBlockEdge, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::BasicBlockEdge, void>, llvm::detail::DenseSetPair<llvm::BasicBlockEdge>>::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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x8(%rsp)
leaq 0x... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [25], llvm::cl::desc, llvm::cl::OptionHidden>(char const (&) [25], llvm::cl::desc const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x76e5e0
movq 0x8(%rsp), %rsi
leaq 0x48610d8(%rip), %rax # 0x96defe0
addq $0x10... | /llvm/Support/CommandLine.h |
(anonymous namespace)::LoopDataPrefetchLegacyPass::runOnFunction(llvm::Function&) | bool LoopDataPrefetchLegacyPass::runOnFunction(Function &F) {
if (skipFunction(F))
return false;
DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
ScalarEvolution *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getS... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x70(%rsp), %rsi
callq 0x312ea30
testb $0x1, %al
jne 0x4e7e5db
jmp 0x4e7e5e8
movb $0x0, 0x87(%rsp)
jmp 0x4e7e6bb
movq 0x8(%rsp), %rdi
callq 0xc85b30
movq %rax, %rdi
callq 0x7e6a90
movq 0x8(%rsp), %rdi
movq %rax,... | /Transforms/Scalar/LoopDataPrefetch.cpp |
detectShiftUntilBitTestIdiom(llvm::Loop*, llvm::Value*&, llvm::Value*&, llvm::Value*&, llvm::Value*&, llvm::Instruction*&) | static bool detectShiftUntilBitTestIdiom(Loop *CurLoop, Value *&BaseX,
Value *&BitMask, Value *&BitPos,
Value *&CurrX, Instruction *&NextX) {
LLVM_DEBUG(dbgs() << DEBUG_TYPE
" Performing shift-until-bittest idiom detection.... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x198(%rsp)
movq %rsi, 0x190(%rsp)
movq %rdx, 0x188(%rsp)
movq %rcx, 0x180(%rsp)
movq %r8, 0x178(%rsp)
movq %r9, 0x170(%rsp)
jmp 0x4ea54e9
movq 0x198(%rsp), %rdi
callq 0x57bee00
cmpl $0x1, %eax
jne 0x4ea550d
movq 0x198(%rsp), %rdi
callq 0x57bf010
cmpl $0x1, %eax
je ... | /Transforms/Scalar/LoopIdiomRecognize.cpp |
llvm::LoopSimplifyCFGPass::run(llvm::Loop&, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>&, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&) | PreservedAnalyses LoopSimplifyCFGPass::run(Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR,
LPMUpdater &LPMU) {
std::optional<MemorySSAUpdater> MSSAU;
if (AR.MSSA)
MSSAU = MemorySSAUpdater(AR.MSSA);
bool De... | subq $0x598, %rsp # imm = 0x598
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x590(%rsp)
movq %rsi, 0x588(%rsp)
movq %rdx, 0x580(%rsp)
movq %rcx, 0x578(%rsp)
movq %r8, 0x570(%rsp)
movq %r9, 0x568(%rsp)
leaq 0x2e8(%rsp), %rdi
callq 0x4ea8690
movq 0x570(%rsp), %rax
cmpq $0x0, 0x48(%ra... | /Transforms/Scalar/LoopSimplifyCFG.cpp |
llvm::DenseMap<llvm::SCEV const*, (anonymous namespace)::RegSortData, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, (anonymous namespace)::RegSortData>>::shrink_and_clear() | 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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x10(%rdi), %eax
movl %eax, 0x1c(%rsp)
movl 0x8(%rdi), %eax
movl %eax, 0x18(%rsp)
callq 0x4f01aa0
movl $0x0, 0x14(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x4f01a5a
movl $0x40, 0x10(%rsp)
movl 0x18(%rsp), %edi
callq 0x91b7e0
movl %eax, %ecx
addl ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::Value*, llvm::SmallPtrSet<llvm::Value*, 2u>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::SmallPtrSet<llvm::Value*, 2u>>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x7cae90
movq %rax, 0x18(%rsp)
callq 0x7cb4a0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x4f3bd78
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4f3b4a0
... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, std::pair<unsigned int, unsigned int>>>, llvm::BasicBlock const*, std::pair<unsigned int, unsigned int>, llvm::DenseMap... | 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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x4f69f60
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x4f69f80
callq 0x3664370
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3664390
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x36643a0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::MemoryUseOrDef*, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::MemoryUseOrDef*>>, llvm::Instruction const*, llvm::MemoryUseOrDef*, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::... | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4f68a20
cmpl $0x0, %eax
jne 0x4f93ab2
jmp 0x4f93b4a
callq 0x4f68960
movq %rax, 0x28(%rsp)
callq 0x4f75150
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x4f68970
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x4f68980
movq %... | /llvm/ADT/DenseMap.h |
llvm::reassociate::ValueEntry const* llvm::SmallVectorTemplateCommon<llvm::reassociate::ValueEntry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::reassociate::ValueEntry, true>>(llvm::SmallVectorTemplateBase<llvm::reassociate::ValueEntry, true>*, llvm::reassociate::ValueEntry const&, unsig... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dca0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x4fadef4
movq 0x3... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, llvm::Function*, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, llvm::Function*>>, llvm::Type*, llvm::Function*, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, llvm::Function*>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4fcd8e0
cmpl $0x0, %eax
jne 0x4fce252
jmp 0x4fce2ea
callq 0x4fcd820
movq %rax, 0x28(%rsp)
callq 0x4fcdb20
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x4fcd830
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x4fcd840
movq %... | /llvm/ADT/DenseMap.h |
llvm::InstVisitor<(anonymous namespace)::AggLoadStoreRewriter, bool>::visit(llvm::Instruction&) | RetTy visit(Instruction &I) {
static_assert(std::is_base_of<InstVisitor, SubClass>::value,
"Must pass the derived type to this template!");
switch (I.getOpcode()) {
default: llvm_unreachable("Unknown instruction type encountered!");
// Build the switch statement using the Instructio... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x785480
decl %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq 0x34a8078(%rip), %rcx # 0x847e04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
movq 0x10(%rsp), ... | /llvm/IR/InstVisitor.h |
llvm::DenseMapIterator<llvm::DebugVariable, std::optional<llvm::DbgVariableFragmentInfo>, llvm::DenseMapInfo<llvm::DebugVariable, void>, llvm::detail::DenseMapPair<llvm::DebugVariable, std::optional<llvm::DbgVariableFragmentInfo>>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::DebugVariable, std::optional<l... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ScalarizerVisitor::finish() | bool ScalarizerVisitor::finish() {
// The presence of data in Gathered or Scattered indicates changes
// made to the Function.
if (Gathered.empty() && Scattered.empty() && !Scalarized)
return false;
for (const auto &GMI : Gathered) {
Instruction *Op = GMI.first;
ValueVector &CV = *GMI.second;
if... | subq $0x218, %rsp # imm = 0x218
movq %rdi, 0x208(%rsp)
movq 0x208(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x30, %rdi
callq 0x3a8dce0
testb $0x1, %al
jne 0x500d47b
jmp 0x500d4a6
movq 0x40(%rsp), %rdi
callq 0x50189c0
testb $0x1, %al
jne 0x500d48b
jmp 0x500d4a6
movq 0x40(%rsp), %rax
testb $0x1, 0x140(%rax)
jne ... | /Transforms/Scalar/Scalarizer.cpp |
llvm::SeparateConstOffsetFromGEPPass::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void SeparateConstOffsetFromGEPPass::printPipeline(
raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
static_cast<PassInfoMixin<SeparateConstOffsetFromGEPPass> *>(this)
->printPipeline(OS, MapClassName2PassName);
OS << '<';
if (LowerGEP)
OS << "lower-gep";
OS << '>';
} | subq $0x38, %rsp
movq %rdx, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x501ecc0
movq 0x... | /Transforms/Scalar/SeparateConstOffsetFromGEP.cpp |
(anonymous namespace)::ConstantOffsetExtractor::Extract(llvm::Value*, llvm::GetElementPtrInst*, llvm::User*&) | Value *ConstantOffsetExtractor::Extract(Value *Idx, GetElementPtrInst *GEP,
User *&UserChainTail) {
ConstantOffsetExtractor Extractor(GEP->getIterator());
// Find a non-zero constant offset first.
APInt ConstantOffset =
Extractor.find(Idx, /* SignExtended */ false, /*... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
movq %rdx, 0x148(%rsp)
movq 0x150(%rsp), %rdi
addq $0x18, %rdi
callq 0x7bc740
movq %rdx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movw 0x38(%rsp), %ax
movw %ax, 0x48(%rsp)
movq 0x40(%rsp), %rsi
m... | /Transforms/Scalar/SeparateConstOffsetFromGEP.cpp |
llvm::DenseMap<llvm::Value*, llvm::SmallVector<(anonymous namespace)::CompareDesc, 4u>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::SmallVector<(anonymous namespace)::CompareDesc, 4u>>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0x5037d40
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x5037d90
testb $0x1, %al
jne 0x5037d16
jmp 0x5037d21
movq (%rsp), %rdi
callq 0x5037e00
jmp 0x5037d33
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::BasicBlock*, llvm::Loop*, 16u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Loop*>>::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... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x180(%rsp)
movl %esi, 0x17c(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x10, 0x17c(%rsp)
jbe 0x5048080
movl $0x40, 0x178(%rsp)
movl 0x17c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x174(%rsp)
leaq 0x178(%rsp... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DenseMap<llvm::... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x505eb3e
movl $0x0, 0x14(%rsp)
jmp 0x505eb5e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::RegionNode*, llvm::SmallDenseSet<llvm::RegionNode*, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>>*>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::RegionNode*, llvm::SmallDenseSet<llvm::RegionNode*, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>>*>, void>, llvm::... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x5061e3e
movl $0x0, 0x14(%rsp)
jmp 0x5061e5e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
bool llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::PatternMatch::OneUse_match<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::FPToSIInst>>, llvm::PatternMatch::apint_match, llvm::PatternMatch::smin_pred_ty, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *II = dyn_cast<IntrinsicInst>(V)) {
Intrinsic::ID IID = II->getIntrinsicID();
if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
(IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
(IID == Intrinsic::umax && Pred_t::match(... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0x7bc090
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x507e250
movq 0x68(%rsp), %rdi
callq 0x78a430
movl %eax, 0x64(%rsp)
cmpl $0x13e, 0x64(%rsp) # imm = 0x13E
jne 0x507e18c
movl ... | /llvm/IR/PatternMatch.h |
isl_aff_involves_dims | isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
enum isl_dim_type type, unsigned first, unsigned n)
{
int i;
int *active = NULL;
isl_bool involves = isl_bool_false;
if (!aff)
return isl_bool_error;
if (n == 0)
return isl_bool_false;
if (isl_aff_check_range(aff, type, first, n) < 0)
return isl_bool... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x508f72b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x508f818
cmpl $0x0, 0x1c(%rsp)
jne 0x508f73f
movl $0x0, 0x34(%rsp)
jmp 0x508f818
mo... | /External/isl/isl_aff.c |
isl_pw_multi_aff_align_params | __isl_give PW *FN(PW,align_params)(__isl_take PW *pw, __isl_take isl_space *model)
{
isl_ctx *ctx;
isl_bool equal_params;
if (!pw || !model)
goto error;
ctx = isl_space_get_ctx(model);
if (!isl_space_has_named_params(model))
isl_die(ctx, isl_error_invalid,
"model has unnamed parameters", goto error);
if ... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x509b10e
cmpq $0x0, 0x20(%rsp)
jne 0x509b113
jmp 0x509b1e8
movq 0x20(%rsp), %rdi
callq 0x5166b10
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x516cee0
cmpl $0x0, %eax
jne 0x509b15b
jmp 0x509b133
movq 0x18(%rsp), %rdi
movl $0x5,... | /External/isl/isl_pw_templ.c |
isl_pw_multi_aff_drop_dims | __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
enum isl_dim_type type, unsigned first, unsigned n)
{
int i;
isl_size n_piece;
enum isl_dim_type set_type;
isl_space *space;
n_piece = FN(PW,n_piece)(pw);
if (n_piece < 0)
return FN(PW,free)(pw);
if (n == 0 && !isl_space_get_tuple_name(pw->dim, type))
retu... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x509c300
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x509c3ae
movq 0x38(%rsp), %rdi
callq 0x5089b20
movq %rax, 0x40(%rsp)
jmp 0x509c501
cmpl $0x0, 0x2c(%rsp)
jne 0x509c3dc
movq 0x38... | /External/isl/isl_pw_templ.c |
isl_pw_multi_aff_flat_range_product | __isl_give isl_pw_multi_aff *isl_pw_multi_aff_flat_range_product(
__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
{
isl_space *space;
isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
space = isl_space_range_product(isl_pw_multi_aff_get_space(pma1),
isl_pw_multi_aff_get_space(pma2));
spa... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x509d350
movq 0x20(%rsp), %rdi
callq 0x509aee0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x509aee0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x516a210
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq... | /External/isl/isl_aff.c |
bin_entry | static isl_stat bin_entry(__isl_take isl_pw_multi_aff *pma, void *user)
{
struct isl_union_pw_multi_aff_bin_data *data = user;
isl_stat r;
data->pma = pma;
r = isl_union_pw_multi_aff_foreach_pw_multi_aff(data->upma2,
data->fn, data);
isl_pw_multi_aff_free(pma);
return r;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x509e0c0
movl %eax, 0xc(%rsp)
movq 0... | /External/isl/isl_aff.c |
delete_row | static void delete_row(__isl_keep isl_basic_set *bset, unsigned row)
{
isl_int *t;
int r;
t = bset->eq[row];
bset->n_eq--;
for (r = row; r < bset->n_eq; ++r)
bset->eq[r] = bset->eq[r+1];
bset->eq[bset->n_eq] = t;
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movl -0xc(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%... | /External/isl/isl_affine_hull.c |
reconstruct | static __isl_give isl_ast_graft_list *reconstruct(
__isl_take isl_ast_graft_list *list,
__isl_keep isl_set_to_ast_graft_list *guard2list,
__isl_keep isl_ast_build *build)
{
list = isl_ast_graft_list_clear(list);
if (isl_set_to_ast_graft_list_foreach(guard2list,
&add_same_guard, &list) < 0)
list = isl_ast_g... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x50caef0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x723(%rip), %rsi # 0x50ce010
leaq 0x10(%rsp), %rdx
callq 0x5166110
cmpl $0x0, %eax
jge 0x50cd90b
movq 0x10(%rsp), %rdi
callq 0x50cace0
movq %rax, 0x1... | /External/isl/isl_ast_graft.c |
check_wraps | static isl_stat check_wraps(struct isl_wraps *wraps, int first,
struct isl_tab *tab, int keep)
{
int i;
for (i = wraps->mat->n_row - 1; i >= first; --i) {
enum isl_ineq_type type;
type = isl_tab_ineq_type(tab, wraps->mat->row[i]);
if (type == isl_ineq_error)
return isl_stat_error;
if (type == isl_ineq_re... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jl 0x50d2627
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%r... | /External/isl/isl_coalesce.c |
isl_set_dim_residue_class | isl_stat isl_set_dim_residue_class(__isl_keep isl_set *set,
int pos, isl_int *modulo, isl_int *residue)
{
isl_int m;
isl_int r;
int i;
if (!set || !modulo || !residue)
return isl_stat_error;
if (set->n == 0) {
isl_int_set_si(*modulo, 0);
isl_int_set_si(*residue, 0);
return isl_stat_ok;
}
if (isl_basi... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x50df3bf
cmpq $0x0, 0x28(%rsp)
je 0x50df3bf
cmpq $0x0, 0x20(%rsp)
jne 0x50df3cc
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x50df59a
movq 0x38(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne... | /External/isl/isl_equalities.c |
isl_union_pw_multi_aff_read_from_str | __isl_give TYPE *FN(isl,FN(TYPE_BASE,read_from_str))(isl_ctx *ctx,
const char *str)
{
TYPE *obj;
isl_stream *s = isl_stream_new_str(ctx, str);
if (!s)
return NULL;
obj = FN(isl_stream_read,TYPE_BASE)(s);
isl_stream_free(s);
return obj;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x516e660
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x50e9563
movq $0x0, 0x20(%rsp)
jmp 0x50e9584
movq (%rsp), %rdi
callq 0x50e9320
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0x516fa90
movq 0x8(%rsp), %rax
mov... | /External/isl/isl_read_from_str_templ.c |
obj_read_body | static struct isl_obj obj_read_body(__isl_keep isl_stream *s,
__isl_take isl_map *map, struct vars *v)
{
struct isl_token *tok;
struct isl_obj obj = { isl_obj_set, NULL };
int n = v->n;
int rational;
rational = is_rational(s);
if (rational)
map = isl_map_set_rational(map);
if (isl_stream_next_token_is(s, ':... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x463fd56(%rip), %rax # 0x972ac30
movq %rax, 0x18(%rsp)
movq 0x463fd52(%rip), %rax # 0x972ac38
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0x50eb940
movl %ea... | /External/isl/isl_input.c |
obj_add | static struct isl_obj obj_add(__isl_keep isl_stream *s,
struct isl_obj obj1, struct isl_obj obj2)
{
if (obj2.type == isl_obj_none || !obj2.v)
goto error;
if (obj1.type == isl_obj_set && obj2.type == isl_obj_union_set)
obj1 = to_union(s->ctx, obj1);
if (obj1.type == isl_obj_union_set && obj2.type == isl_obj_set)... | subq $0x138, %rsp # imm = 0x138
movq %rsi, 0x118(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x108(%rsp)
movq %r8, 0x110(%rsp)
movq %rdi, 0x100(%rsp)
leaq 0x46666f2(%rip), %rax # 0x9751868
cmpq %rax, 0x108(%rsp)
je 0x50eb18b
cmpq $0x0, 0x110(%rsp)
jne 0x50eb190
jmp 0x50eb8c0
leaq 0x4666691(%rip), %rax # 0x97... | /External/isl/isl_input.c |
next_is_fresh_ident | static int next_is_fresh_ident(__isl_keep isl_stream *s, struct vars *v)
{
int n = v->n;
int fresh;
struct isl_token *tok;
tok = isl_stream_next_token(s);
if (!tok)
return 0;
fresh = tok->type == ISL_TOKEN_IDENT && vars_pos(v, tok->u.s, -1) >= n;
isl_stream_push_token(s, tok);
vars_drop(v, v->n - n);
retu... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x516e830
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x50ef46b
movl $0x0, 0x34(%rsp)
jmp 0x50ef4db
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0x102, (%rcx) ... | /External/isl/isl_input.c |
isl_local_space_replace_divs | __isl_give isl_local_space *isl_local_space_replace_divs(
__isl_take isl_local_space *ls, __isl_take isl_mat *div)
{
ls = isl_local_space_cow(ls);
if (!ls || !div)
goto error;
isl_mat_free(ls->div);
ls->div = div;
return ls;
error:
isl_mat_free(div);
isl_local_space_free(ls);
return NULL;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x50f32b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x50f3fbb
cmpq $0x0, (%rsp)
jne 0x50f3fbd
jmp 0x50f3fe4
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x5122ae0
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0... | /External/isl/isl_local_space.c |
print_param_tuple | static __isl_give isl_printer *print_param_tuple(__isl_take isl_printer *p,
__isl_keep isl_space *space, struct isl_print_space_data *data)
{
isl_size nparam;
nparam = isl_space_dim(space, isl_dim_param);
if (!p || nparam < 0)
return isl_printer_free(p);
if (nparam == 0)
return p;
p = print_tuple(space, p, ... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x5167150
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x512c865
cmpl $0x0, 0x4(%rsp)
jge 0x512c876
movq 0x18(%rsp), %rdi
callq 0x513e570
movq %rax, 0x20(%rsp)
jmp 0x512c8d3
cmpl $0x0, 0x4(%rsp... | /External/isl/isl_output.c |
print_constraints | static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
__isl_keep isl_space *space, __isl_keep isl_mat *div,
__isl_take isl_printer *p, int latex)
{
int i;
isl_vec *c = NULL;
int rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x78(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4c(%rsp)... | /External/isl/isl_output.c |
get_n_coincident | static int get_n_coincident(struct isl_sched_graph *graph)
{
int i;
for (i = graph->band_start; i < graph->n_total_row; ++i)
if (!graph->node[0].coincident[i])
break;
return i - graph->band_start;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x51601d8
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x51601c9
jmp 0x51601d8
jmp 0x516... | /External/isl/isl_scheduler_clustering.c |
extract_node_transformation | static __isl_give isl_map *extract_node_transformation(isl_ctx *ctx,
struct isl_sched_node *node, struct isl_clustering *c,
struct isl_sched_graph *merge_graph)
{
struct isl_sched_node *scc_node, *cluster_node;
int start, n;
isl_id *id;
isl_space *space;
isl_multi_aff *ma, *ma2;
scc_node = isl_sched_graph_find... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x50(%rsp), %rax
movslq 0x5c(%rax), %rax
imulq $0xc0, %rax, %rax
addq %rax, %rsi
movq 0x50(%rsp), %rax
movq (%rax), %rdx
callq 0x51528c0
movq %ra... | /External/isl/isl_scheduler_clustering.c |
isl_space_take_nested | static __isl_give isl_space *isl_space_take_nested(__isl_keep isl_space *space,
int pos)
{
isl_space *nested;
if (!space)
return NULL;
if (space->ref != 1)
return isl_space_get_nested(space, pos);
nested = space->nested[pos];
space->nested[pos] = NULL;
return nested;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x51685c0
movq $0x0, 0x20(%rsp)
jmp 0x5168610
movq 0x18(%rsp), %rax
cmpl $0x1, (%rax)
je 0x51685df
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x516d650
movq %rax, 0x20(%rsp)
jmp 0x5168610
movq 0x18(%rsp), %rax
movslq 0x14(%rsp... | /External/isl/isl_space.c |
isl_tab_from_recession_cone | struct isl_tab *isl_tab_from_recession_cone(__isl_keep isl_basic_set *bset,
int parametric)
{
isl_int cst;
int i;
struct isl_tab *tab;
isl_size offset = 0;
isl_size total;
total = isl_basic_set_dim(bset, isl_dim_all);
if (parametric)
offset = isl_basic_set_dim(bset, isl_dim_param);
if (total < 0 || offset <... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x50f6d90
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5177922
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x50f6d90
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x5177930
cmpl $0x0, 0x14... | /External/isl/isl_tab.c |
context_gbr_best_split | static int context_gbr_best_split(struct isl_context *context,
struct isl_tab *tab)
{
struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
struct isl_tab_undo *snap;
int r;
snap = isl_tab_snap(cgbr->tab);
r = best_split(tab, cgbr->tab);
if (r >= 0 && isl_tab_rollback(cgbr->tab, snap) < 0)
retur... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x5176b30
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5182110
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x517e... | /External/isl/isl_tab_pip.c |
isl_multi_val_align_params | __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params)(
__isl_take MULTI(BASE) *multi, __isl_take isl_space *model)
{
isl_ctx *ctx;
isl_bool equal_params;
isl_space *domain_space;
isl_reordering *exp;
if (!multi || !model)
goto error;
equal_params = isl_space_has_equal_params(multi->space, model);
if (equal_p... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x519b21e
cmpq $0x0, 0x30(%rsp)
jne 0x519b223
jmp 0x519b383
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x51689f0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x519b246
jmp 0x519b383
cmpl $0x0, 0x24(%rsp)... | /External/isl/isl_multi_templ.c |
s_rat_reduce | static mp_result s_rat_reduce(mp_rat r) {
mpz_t gcd;
mp_result res = MP_OK;
if (mp_int_compare_zero(MP_NUMER_P(r)) == 0) {
mp_int_set_value(MP_DENOM_P(r), 1);
return MP_OK;
}
/* If the greatest common divisor of the numerator and denominator is greater
than 1, divide it out. */
if ((res = mp_... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x32e5048(%rip), %rax # 0x8487ed8
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
callq 0x51a2e00
movq %rax, %rdi
callq 0x519f440
cmpl $0x0, %eax
jne 0x51a2ed6
movq 0x48(%rsp), %rdi
callq 0x51a2e10
movq %rax, %rdi
movl $0x1, %esi
callq 0x519e4a0
leaq 0x32e500d... | /External/isl/imath/imrat.c |
isl_pw_qpolynomial_fold_add_piece | __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
__isl_take isl_set *set, __isl_take EL *el)
{
isl_bool skip;
skip = isl_set_plain_is_empty(set);
if (skip >= 0 && !skip)
skip = FN(EL,EL_IS_ZERO)(el);
if (skip >= 0 && !skip)
return FN(PW,add_dup_piece)(pw, set, el);
isl_set_free(set);
FN(EL,free)(el);
if... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5108060
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x51ad22d
cmpl $0x0, 0x4(%rsp)
jne 0x51ad22d
movq 0x8(%rsp), %rdi
callq 0x51ac9d0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x51ad256
cmpl $0x0, 0x4(%rs... | /External/isl/isl_pw_templ.c |
isl_local_div_is_known | isl_bool isl_local_div_is_known(__isl_keep isl_local *local, int pos)
{
isl_bool marked;
int i, off;
isl_size n, cols;
isl_mat *mat = local;
if (isl_local_check_pos(local, pos) < 0)
return isl_bool_error;
marked = isl_local_div_is_marked_unknown(local, pos);
if (marked < 0 || marked)
return isl_bool_not(ma... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x51b1250
cmpl $0x0, %eax
jge 0x51b12b7
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x51b13b1
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x51b11e0
movl... | /External/isl/isl_local.c |
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.