name string | code string | asm string | file string |
|---|---|---|---|
isl_map_to_basic_set_cow | __isl_give ISL_HMAP *ISL_FN(ISL_HMAP,cow)(__isl_take ISL_HMAP *hmap)
{
if (!hmap)
return NULL;
if (hmap->ref == 1)
return hmap;
hmap->ref--;
return ISL_FN(ISL_HMAP,dup)(hmap);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x51b1e7c
movq $0x0, 0x10(%rsp)
jmp 0x51b1ead
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x51b1e92
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x51b1ead
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rdi
callq ... | /External/isl/include/isl/hmap_templ.c |
canAlwaysEvaluateInType(llvm::Value*, llvm::Type*) | static bool canAlwaysEvaluateInType(Value *V, Type *Ty) {
if (isa<Constant>(V))
return match(V, m_ImmConstant());
Value *X;
if ((match(V, m_ZExtOrSExt(m_Value(X))) || match(V, m_Trunc(m_Value(X)))) &&
X->getType() == Ty)
return true;
return false;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd21a40
testb $0x1, %al
jne 0x52991be
jmp 0x52991e7
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x23ae2b0
movq 0x20(%rsp), %rdi
leaq 0x5e(%rsp), %rsi
callq 0x23ae280
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x5299299
movq 0x6... | /Transforms/InstCombine/InstCombineCasts.cpp |
bool llvm::PatternMatch::BinOpPred_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::is_logical_shift_op, false>::match<llvm::BinaryOperator>(llvm::BinaryOperator*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<Instruction>(V))
return this->isOpType(I->getOpcode()) &&
((L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))));
return false;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x529afc0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x529afa8
movq 0x18(%rsp), %rdi
callq 0x785480
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x5255550
movb %al, %cl
xorl %eax, %eax... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_unless<llvm::PatternMatch::constantexpr_match>>, 26u, false>::match<llvm::Value>(unsigned int, llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x727f90
movl 0x34(%rsp), %ecx
addl $0x1d, %ecx
cmpl %ecx, %eax
jne 0x529b52a
movq 0x28(%rsp), %rdi
callq 0x7bed70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %... | /llvm/IR/PatternMatch.h |
llvm::TruncInst::getNoWrapKind() const | unsigned getNoWrapKind() const {
unsigned NoWrapKind = 0;
if (hasNoUnsignedWrap())
NoWrapKind |= NoUnsignedWrap;
if (hasNoSignedWrap())
NoWrapKind |= NoSignedWrap;
return NoWrapKind;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x0, 0xc(%rsp)
callq 0x2edda50
testb $0x1, %al
jne 0x52a4e95
jmp 0x52a4ea0
movl 0xc(%rsp), %eax
orl $0x1, %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
callq 0x2edda70
testb $0x1, %al
jne 0x52a4eaf
jmp 0x52a4eba
movl 0xc(%rsp), %eax
orl ... | /llvm/IR/Instructions.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::BinOpPred_match<llvm::PatternMatch::class_match<llvm::Value>, llvm::PatternMatch::class_match<llvm::Value>, llvm::PatternMatch::is_logical_shift_op, false>, llvm::PatternMatch::bind_ty<llvm::Instruction>>, llvm::PatternMat... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x727f90
movl 0x44(%rsp), %ecx
addl $0x1d, %ecx
cmpl %ecx, %eax
jne 0x52db504
movq 0x38(%rsp), %rdi
callq 0x7bed70
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
xorl %... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_any_zero_fp, llvm::ConstantFP, true>, 14u, false>::match<llvm::Value>(unsigned int, llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x727f90
movl 0x34(%rsp), %ecx
addl $0x1d, %ecx
cmpl %ecx, %eax
jne 0x52e8b1a
movq 0x28(%rsp), %rdi
callq 0x7bed70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %... | /llvm/IR/PatternMatch.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::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 0x1f866e0
movl $0x0, 0x14(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x5325a9a
movl $0x40, 0x10(%rsp)
movl 0x18(%rsp), %edi
callq 0x91b7e0
movl %eax, %ecx
addl ... | /llvm/ADT/DenseMap.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specificval_ty, 15u, false>::match<llvm::Value const>(unsigned int, llvm::Value const*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x727f90
movl 0x34(%rsp), %ecx
addl $0x1d, %ecx
cmpl %ecx, %eax
jne 0x534447a
movq 0x28(%rsp), %rdi
callq 0xc83bf0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::is_zero, llvm::ICmpInst, 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 0x10811d0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x534613a
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 |
getPreferredVectorIndex(llvm::ConstantInt*) | static ConstantInt *getPreferredVectorIndex(ConstantInt *IndexC) {
const unsigned IndexBW = IndexC->getBitWidth();
if (IndexBW == 64 || IndexC->getValue().getActiveBits() > 64)
return nullptr;
return ConstantInt::get(IndexC->getContext(),
IndexC->getValue().zextOrTrunc(64));
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8184f0
movl %eax, 0x24(%rsp)
cmpl $0x40, 0x24(%rsp)
je 0x5373995
movq 0x28(%rsp), %rdi
callq 0x782b30
movq %rax, %rdi
callq 0x4398d0
cmpl $0x40, %eax
jbe 0x53739a0
movq $0x0, 0x30(%rsp)
jmp 0x53739e9
movq 0x28(%rsp), %rdi
callq 0x316d940
movq %rax, 0x... | /Transforms/InstCombine/InstCombineVectorOps.cpp |
llvm::DenseMap<llvm::Metadata const*, llvm::TrackingMDRef, llvm::DenseMapInfo<llvm::Metadata const*, void>, llvm::detail::DenseMapPair<llvm::Metadata const*, llvm::TrackingMDRef>>::swap(llvm::DenseMap<llvm::Metadata const*, llvm::TrackingMDRef, llvm::DenseMapInfo<llvm::Metadata const*, void>, llvm::detail::DenseMapPair... | void swap(DenseMap& RHS) {
this->incrementEpoch();
RHS.incrementEpoch();
std::swap(Buckets, RHS.Buckets);
std::swap(NumEntries, RHS.NumEntries);
std::swap(NumTombstones, RHS.NumTombstones);
std::swap(NumBuckets, RHS.NumBuckets);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x548460
movq 0x8(%rsp), %rdi
callq 0x548460
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x538d200
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x582e30
movq (%rsp), %rdi
addq $0xc,... | /llvm/ADT/DenseMap.h |
llvm::SetVector<llvm::MDNode*, llvm::SmallVector<llvm::MDNode*, 16u>, llvm::DenseSet<llvm::MDNode*, llvm::DenseMapInfo<llvm::MDNode*, void>>, 16u>::insert(llvm::MDNode* const&) | bool insert(const value_type &X) {
if constexpr (canBeSmall())
if (isSmall()) {
if (!llvm::is_contained(vector_, X)) {
vector_.push_back(X);
if (vector_.size() > N)
makeBig();
return true;
}
return false;
}
bool result = set_.insert(... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x53922c0
testb $0x1, %al
jne 0x5391413
jmp 0x539146c
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x30(%rsp), %rsi
callq 0x53922e0
testb $0x1, %al
jne 0x5391465
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x30(%r... | /llvm/ADT/SetVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MDString*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MDString*, void>, llvm::detail::DenseSetPair<llvm::MDString*>>, llvm::MDString*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MDString*, void>, llvm::detail::DenseSetPair<llvm::MDString*>>::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 0x53921a0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x53921c0
callq 0x53921e0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x53921f0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x5392200
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Comdat const*, std::vector<llvm::GlobalValue*, std::allocator<llvm::GlobalValue*>>, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseMapPair<llvm::Comdat const*, std::vector<llvm::GlobalValue*, std::allocator<llvm::GlobalValue*>>>>::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 0x5398bc0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x5398c10
testb $0x1, %al
jne 0x5398b96
jmp 0x5398ba1
movq (%rsp), %rdi
callq 0x5398c80
jmp 0x5398bb3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::AssumeSimplify::dropRedundantKnowledge() | void dropRedundantKnowledge() {
struct MapValue {
IntrinsicInst *Assume;
uint64_t ArgValue;
CallInst::BundleOpInfo *BOI;
};
buildMapping(false);
SmallDenseMap<std::pair<Value *, Attribute::AttrKind>,
SmallVector<MapValue, 2>, 16>
Knowledge;
for (BasicBlock... | subq $0x888, %rsp # imm = 0x888
movq %rdi, 0x880(%rsp)
movq 0x880(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
callq 0x53a7590
leaq 0x378(%rsp), %rdi
xorl %esi, %esi
callq 0x53a7760
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x278(%rsp)
leaq 0x280(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x205da... | /Transforms/Utils/AssumeBundleBuilder.cpp |
llvm::tryPromoteCall(llvm::CallBase&) | bool llvm::tryPromoteCall(CallBase &CB) {
assert(!CB.getCalledFunction());
Module *M = CB.getCaller()->getParent();
const DataLayout &DL = M->getDataLayout();
Value *Callee = CB.getCalledOperand();
LoadInst *VTableEntryLoad = dyn_cast<LoadInst>(Callee);
if (!VTableEntryLoad)
return false; // Not a vtab... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x188(%rsp)
movq 0x188(%rsp), %rdi
callq 0x3080cd0
movq %rax, %rdi
callq 0x7de790
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rdi
callq 0x797eb0
movq %rax, 0x178(%rsp)
movq 0x188(%rsp), %rdi
callq 0x78bb80
movq %rax, 0x170(%rsp)
movq 0x170(%rsp), %rdi
callq 0x7ac5c0
m... | /Transforms/Utils/CallPromotionUtils.cpp |
llvm::cloneNoAliasScopes(llvm::ArrayRef<llvm::MDNode*>, llvm::DenseMap<llvm::MDNode*, llvm::MDNode*, llvm::DenseMapInfo<llvm::MDNode*, void>, llvm::detail::DenseMapPair<llvm::MDNode*, llvm::MDNode*>>&, llvm::StringRef, llvm::LLVMContext&) | void llvm::cloneNoAliasScopes(ArrayRef<MDNode *> NoAliasDeclScopes,
DenseMap<MDNode *, MDNode *> &ClonedScopes,
StringRef Ext, LLVMContext &Context) {
MDBuilder MDB(Context);
for (auto *ScopeList : NoAliasDeclScopes) {
for (const auto &MDOperand : Sco... | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x218(%rsp)
movq %rsi, 0x220(%rsp)
movq %rcx, 0x208(%rsp)
movq %r8, 0x210(%rsp)
movq %rdx, 0x200(%rsp)
movq %r9, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0xc02a60
leaq 0x218(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rdi
callq 0x478... | /Transforms/Utils/CloneFunction.cpp |
llvm::cl::opt<double, false, llvm::cl::parser<double>>::opt<char [29], llvm::cl::OptionHidden, llvm::cl::initializer<double>, llvm::cl::desc>(char const (&) [29], llvm::cl::OptionHidden const&, llvm::cl::initializer<double> 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 0xca3a40
movq (%rsp), %rsi
leaq 0x41cdf1e(%rip), %rax # 0x95c014... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ExtTSPImpl::mergeChains((anonymous namespace)::ChainT*, (anonymous namespace)::ChainT*, unsigned long, (anonymous namespace)::MergeTypeT) | void mergeChains(ChainT *Into, ChainT *From, size_t MergeOffset,
MergeTypeT MergeType) {
assert(Into != From && "a chain cannot be merged with itself");
// Merge the nodes.
MergedNodesT MergedNodes =
mergeNodes(Into->Nodes, From->Nodes, MergeOffset, MergeType);
Into->merge(Fr... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movq %rcx, 0x148(%rsp)
movl %r8d, 0x144(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x158(%rsp), %rsi
addq $0x20, %rsi
movq 0x150(%rsp), %rdx
addq $0x20, %rdx
movq 0x148(%rsp), %rcx
movl 0x144(%rs... | /Transforms/Utils/CodeLayout.cpp |
llvm::checkDebugInfoMetadata(llvm::Module&, llvm::iterator_range<llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void, false, void>, false, false>>, DebugInfoPerPass&, llvm::StringRef, llvm::StringRef, llvm::StringRef) | bool llvm::checkDebugInfoMetadata(Module &M,
iterator_range<Module::iterator> Functions,
DebugInfoPerPass &DebugInfoBeforePass,
StringRef Banner, StringRef NameOfWrappedPass,
StringRef... | subq $0x5d8, %rsp # imm = 0x5D8
leaq 0x5f0(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x5e0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rsi, 0x5c0(%rsp)
movq %rdx, 0x5c8(%rsp)
movq %r8, 0x5b0(%rsp)
movq %r9, 0x5b8(%rsp)
movq %rdi, 0x5a8(%rsp)
movq %rcx, 0x5a0(%rsp)
jmp 0x540fbc3
movq 0x5a8(%rsp), %rax
movq %rax, 0x4... | /Transforms/Utils/Debugify.cpp |
llvm::SmallVectorImpl<llvm::ReturnInst*>::swap(llvm::SmallVectorImpl<llvm::ReturnInst*>&) | void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
if (this == &RHS) return;
// We can only avoid copying elements if neither vector is small.
if (!this->isSmall() && !RHS.isSmall()) {
std::swap(this->BeginX, RHS.BeginX);
std::swap(this->Size, RHS.Size);
std::swap(this->Capacity, RHS.Capacity);... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq 0x98(%rsp), %rax
jne 0x544bff3
jmp 0x544c395
movq 0x70(%rsp), %rdi
callq 0xcf04b0
testb $0x1, %al
jne 0x544c05d
movq 0x98(%rsp), %rdi
callq 0xcf04b0
testb $0x1, %al
jne 0x544c05d
movq 0x70(%rsp), %rdi
movq 0x98... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::SCEV const*, llvm::ScopedHashTableVal<llvm::SCEV const*, LoadValue>*, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::ScopedHashTableVal<llvm::SCEV const*, 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 0x5495c60
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x5495cb0
testb $0x1, %al
jne 0x5495c36
jmp 0x5495c41
movq (%rsp), %rdi
callq 0x5495d20
jmp 0x5495c53
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::ScopedHashTableVal<llvm::SCEV const*, LoadValue>*, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::ScopedHashTableVal<llvm::SCEV const*, LoadValue>*>>, llvm::SCEV const*, llvm::ScopedHashTableVal<llvm::SCEV const... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x54976f0
testb $0x1, %al
jne 0x549850d
jmp 0x549856b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x42dffb0
testb $0x1, %al
jne 0x5498522
jmp 0x5498533
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::findDefsUsedOutsideOfLoop(llvm::Loop*) | SmallVector<Instruction *, 8> llvm::findDefsUsedOutsideOfLoop(Loop *L) {
SmallVector<Instruction *, 8> UsedOutside;
for (auto *Block : L->getBlocks())
// FIXME: I believe that this could use copy_if if the Inst reference could
// be adapted into a pointer.
for (auto &Inst : *Block) {
auto Users =... | subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movb $0x0, 0xb7(%rsp)
callq 0xb530c0
movq 0xb8(%rsp), %rdi
callq 0x57bea10
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x7b1ae0
... | /Transforms/Utils/LoopUtils.cpp |
RewritePhi const* llvm::SmallVectorTemplateCommon<RewritePhi, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<RewritePhi, true>>(llvm::SmallVectorTemplateBase<RewritePhi, true>*, RewritePhi const&, unsigned long) | 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 $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3a8dca0
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x54b4947
movq 0... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::runImpl(llvm::LoopInfo*, llvm::LoopAccessInfoManager&, llvm::DominatorTree*, llvm::ScalarEvolution*) | bool runImpl(LoopInfo *LI, LoopAccessInfoManager &LAIs, DominatorTree *DT,
ScalarEvolution *SE) {
// Build up a worklist of inner-loops to version. This is necessary as the
// act of versioning a loop creates new loops and can invalidate iterators
// across the loops.
SmallVector<Loop *, 8> Worklis... | subq $0x3f8, %rsp # imm = 0x3F8
movq %rdi, 0x3f0(%rsp)
movq %rsi, 0x3e8(%rsp)
movq %rdx, 0x3e0(%rsp)
movq %rcx, 0x3d8(%rsp)
leaq 0x388(%rsp), %rdi
callq 0x43439b0
movq 0x3f0(%rsp), %rax
movq %rax, 0x380(%rsp)
movq 0x380(%rsp), %rdi
callq 0x57c1710
movq %rax, 0x378(%rsp)
movq 0x380(%rsp), %rdi
callq 0x57c1740... | /Transforms/Utils/LoopVersioning.cpp |
(anonymous namespace)::PromoteMem2Reg::PromoteMem2Reg(llvm::ArrayRef<llvm::AllocaInst*>, llvm::DominatorTree&, llvm::AssumptionCache*) | PromoteMem2Reg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
AssumptionCache *AC)
: Allocas(Allocas.begin(), Allocas.end()), DT(DT),
DIB(*DT.getRoot()->getParent()->getParent(), /*AllowUnresolved*/ false),
AC(AC), SQ(DT.getRoot()->getDataLayout(),
nullptr, ... | subq $0x78, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x32c2da0
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x32c2db0
movq %rax, 0x28(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x... | /Transforms/Utils/PromoteMemoryToRegister.cpp |
canBeCheaplyTransformed(llvm::ScalarEvolution&, llvm::SCEVAddRecExpr const*, llvm::SCEVAddRecExpr const*, bool&) | static bool canBeCheaplyTransformed(ScalarEvolution &SE,
const SCEVAddRecExpr *Phi,
const SCEVAddRecExpr *Requested,
bool &InvertStep) {
// We can't transform to match a pointer PHI.
Type *PhiTy = Phi->getTyp... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4321970
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4321970
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7908d0
testb $0x1, %al
jne 0x5505f64
movq 0x10(%rsp), %rdi
callq ... | /Transforms/Utils/ScalarEvolutionExpander.cpp |
llvm::SCEVExpander::isHighCostExpansionHelper(llvm::SCEVOperand const&, llvm::Loop*, llvm::Instruction const&, llvm::InstructionCost&, unsigned int, llvm::TargetTransformInfo const&, llvm::SmallPtrSetImpl<llvm::SCEV const*>&, llvm::SmallVectorImpl<llvm::SCEVOperand>&) | bool SCEVExpander::isHighCostExpansionHelper(
const SCEVOperand &WorkItem, Loop *L, const Instruction &At,
InstructionCost &Cost, unsigned Budget, const TargetTransformInfo &TTI,
SmallPtrSetImpl<const SCEV *> &Processed,
SmallVectorImpl<SCEVOperand> &Worklist) {
if (Cost > Budget)
return true; // ... | subq $0x148, %rsp # imm = 0x148
movq 0x160(%rsp), %rax
movq 0x158(%rsp), %rax
movq 0x150(%rsp), %rax
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
movq %rcx, 0x120(%rsp)
movq %r8, 0x118(%rsp)
movl %r9d, 0x114(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x118(%rsp), %rdi
mov... | /Transforms/Utils/ScalarEvolutionExpander.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::PoisoningVH<llvm::Instruction>, llvm::PoisonFlags, llvm::DenseMapInfo<llvm::PoisoningVH<llvm::Instruction>, void>, llvm::detail::DenseMapPair<llvm::PoisoningVH<llvm::Instruction>, llvm::PoisonFlags>>, llvm::PoisoningVH<llvm::Instruction>, llvm::PoisonFlags, llvm::DenseMapInfo<llv... | 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 0x551d4c0
testb $0x1, %al
jne 0x550f02e
jmp 0x550f047
movq 0x18(%rsp), %rdi
callq 0x550f0e0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x550f0ce
callq 0x5515040
testb $0x1, %al
jne 0x550f052
jmp 0x550f093
movq 0x18(%rsp), %rdi... | /llvm/ADT/DenseMap.h |
bool llvm::PatternMatch::AnyBinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::class_match<llvm::Value>, true>::match<llvm::Instruction>(llvm::Instruction*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<BinaryOperator>(V))
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
return false;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1705260
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x5513891
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x7bf0a0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x7c0f70
testb $0x1, %a... | /llvm/IR/PatternMatch.h |
(anonymous namespace)::SCEVFindUnsafe::follow(llvm::SCEV const*) | bool follow(const SCEV *S) {
if (const SCEVUDivExpr *D = dyn_cast<SCEVUDivExpr>(S)) {
if (!SE.isKnownNonZero(D->getRHS())) {
IsUnsafe = true;
return false;
}
}
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S)) {
// For non-affine addrecs or in non-canonical mode w... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4ee9970
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x551d127
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x42e1220
movq (%rsp), %rdi
movq %ra... | /Transforms/Utils/ScalarEvolutionExpander.cpp |
llvm::DenseMapIterator<llvm::Value*, llvm::ValueLatticeElement, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueLatticeElement>, true>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueLatticeElement> const*, llvm::detail::DenseMapPair<llvm::Value*, llvm::... | 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::Value*, llvm::ValueLatticeElement, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueLatticeElement>>, llvm::Value*, llvm::ValueLatticeElement, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueLa... | 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 0x5529200
testb $0x1, %al
jne 0x5533022
movb $0x0, 0x37(%rsp)
jmp 0x5533069
movq 0x18(%rsp), %rdi
callq 0x55295c0
movq %rax, %rdi
callq 0x48f85f0
callq 0x5528f20
mov... | /llvm/ADT/DenseMap.h |
llvm::FoldBranchToCommonDest(llvm::BranchInst*, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*, llvm::TargetTransformInfo const*, unsigned int) | bool llvm::FoldBranchToCommonDest(BranchInst *BI, DomTreeUpdater *DTU,
MemorySSAUpdater *MSSAU,
const TargetTransformInfo *TTI,
unsigned BonusInstThreshold) {
// If this block ends with an unconditional branch,
// ... | subq $0x328, %rsp # imm = 0x328
movq %rdi, 0x318(%rsp)
movq %rsi, 0x310(%rsp)
movq %rdx, 0x308(%rsp)
movq %rcx, 0x300(%rsp)
movl %r8d, 0x2fc(%rsp)
movq 0x318(%rsp), %rdi
callq 0xc70fb0
testb $0x1, %al
jne 0x554faad
movb $0x0, 0x327(%rsp)
jmp 0x555048d
movq 0x318(%rsp), %rdi
addq $0x18, %rdi
callq 0x7bc720
mo... | /Transforms/Utils/SimplifyCFG.cpp |
performBranchToCommonDestFolding(llvm::BranchInst*, llvm::BranchInst*, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*, llvm::TargetTransformInfo const*) | static bool performBranchToCommonDestFolding(BranchInst *BI, BranchInst *PBI,
DomTreeUpdater *DTU,
MemorySSAUpdater *MSSAU,
const TargetTransformInfo *TTI) {
BasicBlock *BB = BI->getP... | subq $0x428, %rsp # imm = 0x428
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq %rdx, 0x410(%rsp)
movq %rcx, 0x408(%rsp)
movq %r8, 0x400(%rsp)
movq 0x420(%rsp), %rdi
addq $0x18, %rdi
callq 0x7bc720
movq %rax, 0x3f8(%rsp)
movq 0x418(%rsp), %rdi
addq $0x18, %rdi
callq 0x7bc720
movq %rax, 0x3f0(%rsp)
movq 0x... | /Transforms/Utils/SimplifyCFG.cpp |
llvm::DenseMap<llvm::Use const*, llvm::SmallVector<llvm::Value*, 4u>, llvm::DenseMapInfo<llvm::Use const*, void>, llvm::detail::DenseMapPair<llvm::Use const*, llvm::SmallVector<llvm::Value*, 4u>>>::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 |
(anonymous namespace)::SimplifyIndvar::eliminateSaturatingIntrinsic(llvm::SaturatingInst*) | bool SimplifyIndvar::eliminateSaturatingIntrinsic(SaturatingInst *SI) {
const SCEV *LHS = SE->getSCEV(SI->getLHS());
const SCEV *RHS = SE->getSCEV(SI->getRHS());
if (!SE->willNotOverflow(SI->getBinaryOp(), SI->isSigned(), LHS, RHS))
return false;
BinaryOperator *BO = BinaryOperator::Create(
SI->getBi... | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x4d951b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x587ba00
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xc8(%rsp)
movq 0x10(%rax), %r... | /Transforms/Utils/SimplifyIndVar.cpp |
llvm::LibCallSimplifier::optimizeSymmetric(llvm::CallInst*, llvm::LibFunc, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeSymmetric(CallInst *CI, LibFunc Func,
IRBuilderBase &B) {
switch (Func) {
case LibFunc_cos:
case LibFunc_cosf:
case LibFunc_cosl:
return optimizeSymmetricCall(CI, /*IsEven*/ true, B);
case LibFunc_sin:
case LibFunc_sinf:
ca... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
addl $0xffffff3b, %eax # imm = 0xFFFFFF3B
subl $0x2, %eax
jb 0x55b2242
jmp 0x55b21eb
movl 0xc(%rsp), %eax
subl $0xca, %eax
je 0x55b2242
jmp 0x55b21f8
movl 0xc(%rsp), ... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizeStrToInt(llvm::CallInst*, llvm::IRBuilderBase&, bool) | Value *LibCallSimplifier::optimizeStrToInt(CallInst *CI, IRBuilderBase &B,
bool AsSigned) {
Value *EndPtr = CI->getArgOperand(1);
if (isa<ConstantPointerNull>(EndPtr)) {
// With a null EndPtr, this function won't capture the main argument.
// It would be readonly t... | subq $0xa8, %rsp
movb %cl, %al
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
andb $0x1, %al
movb %al, 0x87(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0x7b2040
movq %rax, 0x78(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xf42b00
testb $0x1, %al
jne 0x55b459e
j... | /Transforms/Utils/SimplifyLibCalls.cpp |
externalize(llvm::GlobalValue*) | static void externalize(GlobalValue *GV) {
if (GV->hasLocalLinkage()) {
GV->setLinkage(GlobalValue::ExternalLinkage);
GV->setVisibility(GlobalValue::HiddenVisibility);
}
// Unnamed entities must be named consistently between modules. setName will
// give a distinct name to each such entity.
if (!GV->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7278a0
testb $0x1, %al
jne 0x55bf899
jmp 0x55bf8b4
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xb1e8b0
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0xb479f0
movq 0x30(%rsp), %rdi
callq 0x78bd50
testb $0x1, %al
jne 0x55bf8ea
movq 0x30(%rsp), %rax
movq ... | /Transforms/Utils/SplitModule.cpp |
llvm::GlobalsAAWrapperPass* llvm::Pass::getAnalysisIfAvailable<llvm::GlobalsAAWrapperPass>() const | AnalysisType *Pass::getAnalysisIfAvailable() const {
assert(Resolver && "Pass not resident in a PassManager object!");
const void *PI = &AnalysisType::ID;
Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI);
if (!ResultPass) return nullptr;
// Because the AnalysisType may not be a subclass of pass (for... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
leaq 0x41fcc23(%rip), %rcx # 0x97d9198
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x30cbc80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x55dc5a0
movq $0x0, 0x20(%rsp)
jmp 0x55dc5b5
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
mo... | /llvm/PassAnalysisSupport.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::Value const*, llvm::Type*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value const*, llvm::Type*>>>, std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpt... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | 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 0x55e12e0
testb $0x1, %al
jne 0x55e1236
jmp 0x55e12a2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::Value const*, llvm::Type*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value const*, llvm::Type*>>>, std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSe... | 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 $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x55e1510
movq 0x18(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x55e0890
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jne 0x55e13b8
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x87(%rs... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<(anonymous namespace)::VariableGEPIndex>::erase((anonymous namespace)::VariableGEPIndex const*) | iterator erase(const_iterator CI) {
// Just cast away constness because this is a non-const member function.
iterator I = const_cast<iterator>(CI);
assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
iterator N = I;
// Shift all elts down one.
std::move(I+1, this->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
callq 0x55fe3c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp... | /llvm/ADT/SmallVector.h |
llvm::BasicAAResult::aliasCheck(llvm::Value const*, llvm::LocationSize, llvm::Value const*, llvm::LocationSize, llvm::AAQueryInfo&, llvm::Instruction const*) | AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI,
const Instruction *CtxI) {
// If either of the memory references is emp... | subq $0x328, %rsp # imm = 0x328
movq 0x330(%rsp), %rax
movq %rdx, 0x318(%rsp)
movq %r8, 0x310(%rsp)
movq %rdi, 0x308(%rsp)
movq %rsi, 0x300(%rsp)
movq %rcx, 0x2f8(%rsp)
movq %r9, 0x2f0(%rsp)
movq 0x308(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x318(%rsp), %rdi
callq 0x55fbd90
testb $0x1, %al
jne 0x55f6880
leaq... | /Analysis/BasicAliasAnalysis.cpp |
llvm::BasicAAResult::constantOffsetHeuristic(llvm::BasicAAResult::DecomposedGEP const&, llvm::LocationSize, llvm::LocationSize, llvm::AssumptionCache*, llvm::DominatorTree*, llvm::AAQueryInfo const&) | bool BasicAAResult::constantOffsetHeuristic(const DecomposedGEP &GEP,
LocationSize MaybeV1Size,
LocationSize MaybeV2Size,
AssumptionCache *AC,
D... | subq $0x238, %rsp # imm = 0x238
movq 0x240(%rsp), %rax
movq %rdx, 0x228(%rsp)
movq %rcx, 0x220(%rsp)
movq %rdi, 0x218(%rsp)
movq %rsi, 0x210(%rsp)
movq %r8, 0x208(%rsp)
movq %r9, 0x200(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x210(%rsp), %rdi
addq $0x18, %rdi
callq 0x3a8dca0
cmpq $0x2, %rax
j... | /Analysis/BasicAliasAnalysis.cpp |
llvm::BlockFrequencyInfoImplBase::unwrapLoops() | void BlockFrequencyInfoImplBase::unwrapLoops() {
// Set initial frequencies from loop-local masses.
for (size_t Index = 0; Index < Working.size(); ++Index)
Freqs[Index].Scaled = Working[Index].Mass.toScaled();
for (LoopData &Loop : Loops)
unwrapLoop(*this, Loop);
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
callq 0x3386120
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x560f9e5
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq 0x58(%... | /Analysis/BlockFrequencyInfoImpl.cpp |
llvm::bfi_detail::IrreducibleGraph::addEdge(llvm::bfi_detail::IrreducibleGraph::IrrNode&, llvm::BlockFrequencyInfoImplBase::BlockNode const&, llvm::BlockFrequencyInfoImplBase::LoopData const*) | void IrreducibleGraph::addEdge(IrrNode &Irr, const BlockNode &Succ,
const BFIBase::LoopData *OuterLoop) {
if (OuterLoop && OuterLoop->isHeader(Succ))
return;
auto L = Lookup.find(Succ.Index);
if (L == Lookup.end())
return;
IrrNode &SuccIrr = *L->second;
Irr.Edges.push_ba... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x5610844
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3389630
testb $0x1, %al
jne 0x561083f
jmp 0x5610844
jmp 0x56108eb
movq 0x8(%rsp), %rd... | /Analysis/BlockFrequencyInfoImpl.cpp |
combineWeightsBySorting(llvm::SmallVector<llvm::BlockFrequencyInfoImplBase::Weight, 4u>&) | static void combineWeightsBySorting(WeightList &Weights) {
// Sort so edges to the same node are adjacent.
llvm::sort(Weights, [](const Weight &L, const Weight &R) {
return L.TargetNode < R.TargetNode;
});
// Combine adjacent edges.
WeightList::iterator O = Weights.begin();
for (WeightList::const_itera... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5612970
movq 0x40(%rsp), %rdi
callq 0x338acc0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x338acd0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x18(%rs... | /Analysis/BlockFrequencyInfoImpl.cpp |
findIrreducibleHeaders(llvm::BlockFrequencyInfoImplBase const&, llvm::bfi_detail::IrreducibleGraph const&, std::vector<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, std::allocator<llvm::bfi_detail::IrreducibleGraph::IrrNode const*>> const&, llvm::SmallVector<llvm::BlockFrequencyInfoImplBase::BlockNode, 4u>&, llvm... | static void findIrreducibleHeaders(
const BlockFrequencyInfoImplBase &BFI,
const IrreducibleGraph &G,
const std::vector<const IrreducibleGraph::IrrNode *> &SCC,
LoopData::NodeList &Headers, LoopData::NodeList &Others) {
// Map from nodes in the SCC to whether it's an entry block.
SmallDenseMap<const... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2e0(%rsp)
movq %rsi, 0x2d8(%rsp)
movq %rdx, 0x2d0(%rsp)
movq %rcx, 0x2c8(%rsp)
movq %r8, 0x2c0(%rsp)
leaq 0x238(%rsp), %rdi
xorl %esi, %esi
callq 0x5616450
movq 0x2d0(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rdi
callq 0x5616490
movq %rax, 0x228(%rsp)
... | /Analysis/BlockFrequencyInfoImpl.cpp |
llvm::SmallDenseMap<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, bool, 8u, llvm::DenseMapInfo<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, void>, llvm::detail::DenseMapPair<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, bool>>::deallocateBuckets() | void deallocateBuckets() {
if (Small)
return;
deallocate_buffer(getLargeRep()->Buckets,
sizeof(BucketT) * getLargeRep()->NumBuckets,
alignof(BucketT));
getLargeRep()->~LargeRep();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x561805f
jmp 0x561809b
movq 0x8(%rsp), %rdi
callq 0x5616b50
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x5616b50
movq (%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, %... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorTemplateBase<llvm::BlockFrequencyInfoImplBase::BlockNode, true>::uninitialized_copy<llvm::BlockFrequencyInfoImplBase::BlockNode, llvm::BlockFrequencyInfoImplBase::BlockNode>(llvm::BlockFrequencyInfoImplBase::BlockNode*, llvm::BlockFrequencyInfoImplBase::BlockNode*, llvm::BlockFrequencyInfoImplBase... | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// u... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x5618878
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x2, %rdx
shlq $0x2, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, unsigned int, llvm::DenseMapInfo<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, void>, llvm::detail::DenseMapPair<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, unsigned int>>, llvm::bfi_detail::IrreducibleGraph::IrrNode con... | 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 0x5619420
cmpl $0x0, %eax
jne 0x5619382
jmp 0x561941a
callq 0x5619430
movq %rax, 0x28(%rsp)
callq 0x5619440
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x5619450
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x5619460
movq %... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, unsigned int, llvm::DenseMapInfo<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, void>, llvm::detail::DenseMapPair<llvm::bfi_detail::IrreducibleGraph::IrrNode const*, unsigned int>>, llvm::bfi_detail::IrreducibleGraph::IrrNode con... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x561ab20
testb $0x1, %al
jne 0x561c48d
jmp 0x561c4eb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x56177d0
testb $0x1, %al
jne 0x561c4a2
jmp 0x561c4b3
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::BranchProbabilityInfo::isLoopEnteringEdge(std::pair<llvm::BranchProbabilityInfo::LoopBlock const&, llvm::BranchProbabilityInfo::LoopBlock const&> const&) const | bool BranchProbabilityInfo::isLoopEnteringEdge(const LoopEdge &Edge) const {
const auto &SrcBlock = Edge.first;
const auto &DstBlock = Edge.second;
return (DstBlock.getLoop() &&
!DstBlock.getLoop()->contains(SrcBlock.getLoop())) ||
// Assume that SCCs can't be nested.
(DstBlock.getSccN... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x561ded0
cmpq $0x0, %rax
je 0x561de7e
movq 0x18(%rsp), %rdi
callq 0x561ded0
movq %rax, 0x8(%rsp)
movq 0... | /Analysis/BranchProbabilityInfo.cpp |
llvm::DenseMapBase<llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, unsigned int, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, unsigned int>>, std::pair<llvm::Loop*, int>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::det... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5629190
testb $0x1, %al
jne 0x561f1cd
jmp 0x561f22b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x5629470
testb $0x1, %al
jne 0x561f1e2
jmp 0x561f1f3
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::BranchProbabilityInfo::calcZeroHeuristics(llvm::BasicBlock const*, llvm::TargetLibraryInfo const*) | bool BranchProbabilityInfo::calcZeroHeuristics(const BasicBlock *BB,
const TargetLibraryInfo *TLI) {
const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI... | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xe0(%rsp), %rdi
callq 0x7dfb20
movq %rax, %rdi
callq 0xc70fa0
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
je 0x5621555
movq 0xd0(%rsp), %rdi
callq 0xc70fb0
testb $0x1, %al
jne 0x5621562
m... | /Analysis/BranchProbabilityInfo.cpp |
llvm::BranchProbabilityInfo::getEdgeProbability(llvm::BasicBlock const*, llvm::BasicBlock const*) const | BranchProbability
BranchProbabilityInfo::getEdgeProbability(const BasicBlock *Src,
const BasicBlock *Dst) const {
if (!Probs.count(std::make_pair(Src, 0)))
return BranchProbability(llvm::count(successors(Src), Dst), succ_size(Src));
auto Prob = BranchProbability::getZe... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq %rdx, 0x108(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0xe4(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0xe4(%rsp), %rsi
callq 0x56227b0
movl %edx, 0xd8(%rsp)
movq %rax, 0xd0(%rs... | /Analysis/BranchProbabilityInfo.cpp |
llvm::BranchProbabilityInfo::calculate(llvm::Function const&, llvm::LoopInfo const&, llvm::TargetLibraryInfo const*, llvm::DominatorTree*, llvm::PostDominatorTree*) | void BranchProbabilityInfo::calculate(const Function &F, const LoopInfo &LoopI,
const TargetLibraryInfo *TLI,
DominatorTree *DT,
PostDominatorTree *PDT) {
LLVM_DEBUG(dbgs() << "---- Branch Probability Inf... | subq $0x758, %rsp # imm = 0x758
movq %rdi, 0x750(%rsp)
movq %rsi, 0x748(%rsp)
movq %rdx, 0x740(%rsp)
movq %rcx, 0x738(%rsp)
movq %r8, 0x730(%rsp)
movq %r9, 0x728(%rsp)
movq 0x750(%rsp), %rax
movq %rax, (%rsp)
jmp 0x5623135
movq (%rsp), %rax
movq 0x748(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x740(%rsp), %rcx
... | /Analysis/BranchProbabilityInfo.cpp |
llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, llvm::SmallVector<llvm::BasicBlock*, 4u>>>::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 $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movl %esi, 0x1ac(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x4, 0x1ac(%rsp)
jbe 0x562b360
movl $0x40, 0x1a8(%rsp)
movl 0x1ac(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x1a4(%rsp)
leaq 0x1a8(%rsp)... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>* llvm::DenseMapBase<llvm::DenseMap<llvm::BranchProbabilityInfo::BasicBlockCallbackVH, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::BranchProbabilityInfo::BasicBlockCallbackVH>>, llvm::B... | 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 $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x548460
movq 0x20(%rsp), %rdi
callq 0x447d470
movq 0x20(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x54(%rsp)
callq 0x3212ba0
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability, llvm::DenseMapInfo<std::pair<llvm::BasicBlock const*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock const*, unsigned int>, llvm::BranchProbability>>, std::pair<llvm::BasicBlock cons... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | 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 0x562ce90
testb $0x1, %al
jne 0x562e186
jmp 0x562e1f2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<std::pair<llvm::Loop*, int>, unsigned int, 4u, llvm::DenseMapInfo<std::pair<llvm::Loop*, int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Loop*, int>, unsigned int>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldSize = this->size();
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldSize) {
NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
NewNumBuckets = ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x562e950
movq 0x10(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x3211aa0
movl $0x0, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x562e8d6
movl 0x1c(%rsp), %edi
callq 0x91b7e0
movl %eax, %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::LazyCallGraph::SCC*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResul... | 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 0x56471a0
testb $0x1, %al
jne 0x56384d2
movb $0x0, 0x37(%rsp)
jmp 0x5638519
movq 0x18(%rsp), %rdi
callq 0xc1e0d0
movq %rax, %rdi
callq 0xc1e0e0
callq 0xc1e060
movq %... | /llvm/ADT/DenseMap.h |
llvm::PreservedAnalyses::intersect(llvm::PreservedAnalyses const&) | void intersect(const PreservedAnalyses &Arg) {
if (Arg.areAllPreserved())
return;
if (areAllPreserved()) {
*this = Arg;
return;
}
// The intersection requires the *union* of the explicitly not-preserved
// IDs and the *intersection* of the preserved IDs.
for (auto *ID : Arg.Not... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xefc0b0
testb $0x1, %al
jne 0x563a077
jmp 0x563a07c
jmp 0x563a141
movq (%rsp), %rdi
callq 0xefc0b0
testb $0x1, %al
jne 0x563a08b
jmp 0x563a09e
movq (%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0... | /llvm/IR/Analysis.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Function*, llvm::DevirtSCCRepeatedPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::CallCount, 4u, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPai... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x564c440
testb $0x1, %al
jne 0x563bb2d
jmp 0x563bb8b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x7e1fb0
testb $0x1, %al
jne 0x563bb42
jmp 0x563bb53
movq 0x1... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Function*, llvm::DevirtSCCRepeatedPass::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)::CallCount, 4u, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPai... | 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 0x563fe40
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x563fe60
callq 0x563fe80
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x563fe90
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x563fea0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<llvm::AnalysisKey*, llvm::LazyCallGraph::SCC*>, std::_List_iterator<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>::Invalidator>, std::default_delete<llvm::detail::... | 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 0x5646527
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x564654d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x18, %rax,... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::Instruction*, llvm::APInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::APInt>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::APInt, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseM... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x490d030
testb $0x1, %al
jne 0x568cb63
jmp 0x568cbdd
movq 0x70(%rsp), %rax
mo... | /llvm/ADT/DenseMap.h |
llvm::DependenceInfo::banerjeeMIVtest(llvm::SCEV const*, llvm::SCEV const*, llvm::SmallBitVector const&, llvm::FullDependence&) const | bool DependenceInfo::banerjeeMIVtest(const SCEV *Src, const SCEV *Dst,
const SmallBitVector &Loops,
FullDependence &Result) const {
LLVM_DEBUG(dbgs() << "starting Banerjee\n");
++BanerjeeApplications;
LLVM_DEBUG(dbgs() << " Src = " << *S... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x569729e
leaq 0x41418b8(%rip), %rdi # 0x97d8b5d
callq 0x68a960
jmp 0x56972ac
movq 0x38(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movl $0x1, %edx
leaq 0... | /Analysis/DependenceAnalysis.cpp |
llvm::DenseMapIterator<llvm::Instruction*, unsigned long, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, 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 0x7bad00
movq %rax, 0x18(%rsp)
callq 0x7bad20
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x56a4ed8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4fde480
... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::Instruction*, llvm::DDGNode*, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::DDGNode*>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::Instruction*, llvm::DDGNode*>*, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::DDGNode*... | 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::SmallVectorImpl<llvm::BranchInst*>::operator=(llvm::SmallVectorImpl<llvm::BranchInst*>&&) | 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 0x56b2fae
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x56b3190
movq 0x50(%rsp), %rdi
callq 0x4745d60
testb $0x1, %al
jne 0x56b2fda
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x5... | /llvm/ADT/SmallVector.h |
llvm::DomTreeUpdater::forceFlushDeletedBB() | bool DomTreeUpdater::forceFlushDeletedBB() {
if (DeletedBBs.empty())
return false;
for (auto *BB : DeletedBBs) {
// After calling deleteBB or callbackDeleteBB under Lazy UpdateStrategy,
// validateDeleteBB() removes all instructions of DelBB and adds an
// UnreachableInst as its terminator. So we c... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x138, %rdi # imm = 0x138
callq 0x72b570
testb $0x1, %al
jne 0x56b4ba5
jmp 0x56b4baf
movb $0x0, 0x57(%rsp)
jmp 0x56b4c82
movq 0x10(%rsp), %rax
addq $0x138, %rax # imm = 0x138
movq %rax, 0x40(%rsp)
movq 0x40(%r... | /Analysis/DomTreeUpdater.cpp |
llvm::DomTreeUpdater::validateDeleteBB(llvm::BasicBlock*) | void DomTreeUpdater::validateDeleteBB(BasicBlock *DelBB) {
assert(DelBB && "Invalid push_back of nullptr DelBB.");
assert(pred_empty(DelBB) && "DelBB has one or more predecessors.");
// DelBB is unreachable and all its instructions are dead.
while (!DelBB->empty()) {
Instruction &I = DelBB->back();
// R... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x15d9840
xorb $-0x1, %al
testb $0x1, %al
jne 0x56b4f40
jmp 0x56b4fa4
movq 0x48(%rsp), %rdi
callq 0x7df370
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7ba180
testb $0x1, %al
jne 0x56b4f86
movq 0x40(%rsp), %rax
movq %rax, 0x... | /Analysis/DomTreeUpdater.cpp |
llvm::SmallSet<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::less<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>>>::vfind(std::pair<llvm::BasicBlock*, llvm::BasicBlock*> const&) const | VIterator vfind(const T &V) const {
for (VIterator I = Vector.begin(), E = Vector.end(); I != E; ++I)
if (*I == V)
return I;
return Vector.end();
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e4ff20
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x4e4ff30
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x56b50a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4f165a0
te... | /llvm/ADT/SmallSet.h |
llvm::FunctionPropertiesInfo::updateForBB(llvm::BasicBlock const&, long) | void FunctionPropertiesInfo::updateForBB(const BasicBlock &BB,
int64_t Direction) {
assert(Direction == 1 || Direction == -1);
BasicBlockCount += Direction;
BlocksReachedFromConditionalInstruction +=
(Direction * getNrBlocksFromCond(BB));
for (const auto &I : BB) {... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x270(%rsp), %rdx
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq 0x270(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x278(%rsp), %rdi
callq 0x56ba700
movq... | /Analysis/FunctionPropertiesAnalysis.cpp |
llvm::GlobalsAAResult::alias(llvm::MemoryLocation const&, llvm::MemoryLocation const&, llvm::AAQueryInfo&, llvm::Instruction const*) | AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
const MemoryLocation &LocB,
AAQueryInfo &AAQI, const Instruction *) {
// Get the base object these pointers point to.
const Value *UV1 =
getUnderlyingObject(LocA.Ptr->stripPoint... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
callq 0x316f940
movq %rax, %rdi
movl $0x6, %esi
callq 0x5969580
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rax
mo... | /Analysis/GlobalsModRef.cpp |
llvm::GlobalsAAResult::GlobalsAAResult(llvm::GlobalsAAResult&&) | GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg)
: AAResultBase(std::move(Arg)), DL(Arg.DL), GetTLI(std::move(Arg.GetTLI)),
NonAddressTakenGlobals(std::move(Arg.NonAddressTakenGlobals)),
IndirectGlobals(std::move(Arg.IndirectGlobals)),
AllocsForIndirectGlobals(std::move(Arg.AllocsForIndirec... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
callq 0xc5ac10
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
callq 0x4852d80
movq (%rsp), %rdi
addq $0x28, %rdi
m... | /Analysis/GlobalsModRef.cpp |
llvm::SmallDenseMap<llvm::GlobalValue const*, llvm::ModRefInfo, 16u, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::ModRefInfo>>::copyFrom(llvm::SmallDenseMap<llvm::GlobalValue const*, llvm::ModRefInfo, 16u, llvm::DenseMapInfo<llvm::GlobalValue const*, voi... | void copyFrom(const SmallDenseMap& other) {
this->destroyAll();
deallocateBuckets();
Small = true;
if (other.getNumBuckets() > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(other.getNumBuckets()));
}
this->BaseT::copyFrom(other);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56c6700
movq 0x10(%rsp), %rdi
callq 0x56c67c0
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $-0x2, %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x56c54b0
cmpl $0x10, %eax
jbe 0x56c66e2
mo... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::IRSimilarity::IRSimilarityCandidate*, unsigned int, llvm::DenseMapInfo<llvm::IRSimilarity::IRSimilarityCandidate*, void>, llvm::detail::DenseMapPair<llvm::IRSimilarity::IRSimilarityCandidate*, unsigned int>>, llvm::IRSimilarity::IRSimilarityCandidate*, unsigned int, llvm::DenseMa... | 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 0x56e302e
movl $0x0, 0x14(%rsp)
jmp 0x56e304e
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::detail::DenseMapPair<llvm::IRSimilarity::IRSimilarityCandidate*, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<llvm::IRSimilarity::IRSimilarityCandidate*, unsigned int, llvm::DenseMapInfo<llvm::IRSimilarity::IRSimilarityCandidate*, void>, llvm::detail::DenseMapPair<llvm::IRSimilarity::IRSimilarityCandidate*, u... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | 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 0x56e3820
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x56d6100
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [22], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [22], 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 0x3fec37e(%rip), %rax # 0x96df04... | /llvm/Support/CommandLine.h |
llvm::getInlineParams(int) | InlineParams llvm::getInlineParams(int Threshold) {
InlineParams Params;
// This field is the threshold to use for a callee by default. This is
// derived from one or more of:
// * optimization or size-optimization levels,
// * a value passed to createFunctionInliningPass function, or
// * the -inline-t... | subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x24(%rsp)
callq 0x44fd2d0
leaq 0x40e4390(%rip), %rdi # 0x97d9a00
callq 0x3f1b80
cmpl $0x0, %eax
jle 0x56f5697
leaq 0x40e437f(%rip), %rdi # 0x97d9a00
addq $0x80, %rdi
callq 0x772f40
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)... | /Analysis/InlineCost.cpp |
(anonymous namespace)::InlineCostCallAnalyzer::print(llvm::raw_ostream&) | void InlineCostCallAnalyzer::print(raw_ostream &OS) {
#define DEBUG_PRINT_STAT(x) OS << " " #x ": " << x << "\n"
if (PrintInstructionComments)
F.print(OS, &Writer);
DEBUG_PRINT_STAT(NumConstantArgs);
DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
DEBUG_PRINT_STAT(NumAllocaArgs);
DEBUG_PRINT_STAT(NumCons... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40e3ad2(%rip), %rdi # 0x97d9940
addq $0x80, %rdi
callq 0x3f1b60
testb $0x1, %al
jne 0x56f5e80
jmp 0x56f5e9f
movq (%rsp), %rdx
movq 0x38(%rdx), %rdi
movq 0x8(%rsp), %rsi
addq $0x2f0, %rdx # imm = 0x2F0... | /Analysis/InlineCost.cpp |
llvm::DenseMap<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>>>::allocateBuckets(unsigned int) | 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 0x56f78b7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x56f78df
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AllocaInst*, int, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst*, int>>, llvm::AllocaInst*, int, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst*, int>>::getMinBucketToReserveForEntries(unsigned i... | 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 0x56f7efe
movl $0x0, 0x14(%rsp)
jmp 0x56f7f1e
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::DenseMapBase<llvm::DenseMap<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, std::pair<llvm::Value*, llvm::APInt>>>, llvm::Value*, std::pair<llvm::Value*, llvm::APInt>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::De... | 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 0x56fc310
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x56f7a70
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x56fc1c2
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_0>((anonymous namespace)::CallAnalyzer::analyzeBlock(llvm::BasicBlock*, llvm::SmallPtrSetImpl<llvm::Value const*>&)::$_0, 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, 0x1c8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x56fc89e
jmp 0x56fc8c8
leaq 0x8(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x5702af0
movq (%rsp), %rdi
leaq 0x... | /llvm/Analysis/OptimizationRemarkEmitter.h |
void llvm::OptimizationRemarkEmitter::emit<(anonymous namespace)::MandatoryInlineAdvice::recordUnsuccessfulInliningImpl(llvm::InlineResult const&)::'lambda'()>((anonymous namespace)::MandatoryInlineAdvice::recordUnsuccessfulInliningImpl(llvm::InlineResult const&)::'lambda'(), decltype(fp())*) | void emit(T RemarkBuilder, decltype(RemarkBuilder()) * = nullptr) {
// Avoid building the remark unless we know there are at least *some*
// remarks enabled. We can't currently check whether remarks are requested
// for the calling pass since that requires actually building the remark.
if (enabled()) {... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7d9bc0
testb $0x1, %al
jne 0x570abee
jmp 0x570ac18
leaq 0x8(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x570ac20
movq (%rsp), %rdi
leaq 0x... | /llvm/Analysis/OptimizationRemarkEmitter.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::CallBase const*, (anonymous namespace)::CostBenefitPriority, llvm::DenseMapInfo<llvm::CallBase const*, void>, llvm::detail::DenseMapPair<llvm::CallBase const*, (anonymous namespace)::CostBenefitPriority>>, llvm::CallBase const*, (anonymous namespace)::CostBenefitPriority, llvm::D... | 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 0x5714eb0
cmpl $0x0, %eax
jne 0x5715c72
jmp 0x5715d12
callq 0x5714df0
movq %rax, 0x28(%rsp)
callq 0x57157f0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x5714e00
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x5714e10
movq %... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::CallBase const*, (anonymous namespace)::MLPriority, llvm::DenseMapInfo<llvm::CallBase const*, void>, llvm::detail::DenseMapPair<llvm::CallBase const*, (anonymous namespace)::MLPriority>>::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 0x5717bc0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x5717c10
testb $0x1, %al
jne 0x5717b96
jmp 0x5717ba1
movq (%rsp), %rdi
callq 0x5717c80
jmp 0x5717bb3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::InstructionPrecedenceTracking::fill(llvm::BasicBlock const*) | void InstructionPrecedenceTracking::fill(const BasicBlock *BB) {
FirstSpecialInsts.erase(BB);
for (const auto &I : *BB) {
NumInstScanned++;
if (isSpecialInstruction(&I)) {
FirstSpecialInsts[BB] = &I;
return;
}
}
// Mark this block as having no special instructions.
FirstSpecialInsts[B... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
leaq 0x68(%rsp), %rsi
callq 0x571ba90
movq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x7b8610
movq %rdx, 0x48(%rsp)
movq %rax, 0x40(%rsp)
movw 0x48(%rsp), %ax
movw %ax, 0x58(... | /Analysis/InstructionPrecedenceTracking.cpp |
isDivZero(llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int, bool) | static bool isDivZero(Value *X, Value *Y, const SimplifyQuery &Q,
unsigned MaxRecurse, bool IsSigned) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
return false;
if (IsSigned) {
// (X srem Y) sdiv Y --> 0
if (match(X, m_SRem(m... | subq $0x1f8, %rsp # imm = 0x1F8
movb %r8b, %al
movq %rdi, 0x1e8(%rsp)
movq %rsi, 0x1e0(%rsp)
movq %rdx, 0x1d8(%rsp)
movl %ecx, 0x1d4(%rsp)
andb $0x1, %al
movb %al, 0x1d3(%rsp)
movl 0x1d4(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x1d4(%rsp)
cmpl $0x0, %eax
jne 0x5733477
movb $0x0, 0x1f7(%rsp)
j... | /Analysis/InstructionSimplify.cpp |
bool llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specificval_ty, 25u, 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 0x5735759
movq 0x18(%rsp), %rdi
callq 0xa98260
cmpl $0x19, %eax
je 0x57356dc
movb $0x0, 0x37(%rsp)
jmp 0x573575e
movq 0x18(%rsp), ... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::LogicalOp_match<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 30u, true>>, llvm::PatternMa... | bool match(T *V) {
auto *I = dyn_cast<Instruction>(V);
if (!I || !I->getType()->isIntOrIntVectorTy(1))
return false;
if (I->getOpcode() == Opcode) {
auto *Op0 = I->getOperand(0);
auto *Op1 = I->getOperand(1);
return (L.match(Op0) && R.match(Op1)) ||
(Commutable && L.mat... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x7d5b40
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x573b0ca
movq 0x58(%rsp), %rdi
callq 0x782840
movq %rax, %rdi
movl $0x1, %esi
callq 0x78d3a0
testb $0x1, %al
jne 0x573b0d4
movb $0... | /llvm/IR/PatternMatch.h |
simplifyUnaryIntrinsic(llvm::Function*, llvm::Value*, llvm::SimplifyQuery const&, llvm::CallBase const*) | static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
const SimplifyQuery &Q,
const CallBase *Call) {
// Idempotent functions return the same result when called repeatedly.
Intrinsic::ID IID = F->getIntrinsicID();
if (isIdempotent(I... | subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, 0x2e8(%rsp)
movq %rsi, 0x2e0(%rsp)
movq %rdx, 0x2d8(%rsp)
movq %rcx, 0x2d0(%rsp)
movq 0x2e8(%rsp), %rdi
callq 0x78c590
movl %eax, 0x2cc(%rsp)
movl 0x2cc(%rsp), %edi
callq 0x574d700
testb $0x1, %al
jne 0x574cc0d
jmp 0x574cc5c
movq 0x2e0(%rsp), %rdi
callq 0x7bc090
mov... | /Analysis/InstructionSimplify.cpp |
llvm::DenseMap<llvm::Function const*, llvm::LazyCallGraph::Node*, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, llvm::LazyCallGraph::Node*>>::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 0x575d990
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x4596860
testb $0x1, %al
jne 0x575d966
jmp 0x575d971
movq (%rsp), %rdi
callq 0x45968d0
jmp 0x575d983
movq (%rsp), %r... | /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.