name string | code string | asm string | file string |
|---|---|---|---|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DIObjCProperty*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIObjCProperty>, llvm::detail::DenseSetPair<llvm::DIObjCProperty*>>, llvm::DIObjCProperty*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIObjCProperty>, llvm::detail::DenseSetPair<llvm::DIObjCProper... | 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 0x2ff0d10
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x2ff0d20
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x2ff0bc2
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::DIMacroFile*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DIMacroFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIMacroFile>, llvm::detail::DenseSetPair<llvm::DIMacroFile*>>, llvm::DIMacroFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIMacroFile>, llvm::detail::Den... | 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 0x2ff6b30
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x2ff5cf0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DebugLoc::print(llvm::raw_ostream&) const | void DebugLoc::print(raw_ostream &OS) const {
if (!Loc)
return;
// Print source line info.
auto *Scope = cast<DIScope>(getScope());
OS << Scope->getFilename();
OS << ':' << getLine();
if (getCol() != 0)
OS << ':' << getCol();
if (DebugLoc InlinedAtDL = getInlinedAt()) {
OS << " @[ ";
Inl... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x7bd420
cmpq $0x0, %rax
jne 0x30012a8
jmp 0x30013b6
movq 0x20(%rsp), %rdi
callq 0x3000890
movq %rax, %rdi
callq 0x2fb6ca0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rd... | /IR/DebugLoc.cpp |
(anonymous namespace)::PassRemarksOpt::PassRemarksOpt() | void operator=(const std::string &Val) {
// Create a regexp object to match pass names for emitOptimizationRemark.
if (!Val.empty()) {
Pattern = std::make_shared<Regex>(Val);
std::string RegexError;
if (!Pattern->isValid(RegexError))
report_fatal_error(Twine("Invalid regular expression... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x3002ff0
popq %rax
retq
| /IR/DiagnosticHandler.cpp |
llvm::DominatorTreeBase<llvm::BasicBlock, false>::findNearestCommonDominator(llvm::BasicBlock*, llvm::BasicBlock*) const | NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
assert(A && B && "Pointers are not valid");
assert(NodeTrait::getParent(A) == NodeTrait::getParent(B) &&
"Two blocks are not in same function");
// If either A or B is a entry block then it is nearest common dominator
// (for forw... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3007f80
testb $0x1, %al
jne 0x3008b76
movq 0x30(%rsp), %rdi
callq 0x3008c20
movq %rax, %rdi
callq 0x3008c10
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x3008b65... | /llvm/Support/GenericDomTree.h |
llvm::DominatorTree::dominates(llvm::Value const*, llvm::Instruction const*) const | bool DominatorTree::dominates(const Value *DefV,
const Instruction *User) const {
const Instruction *Def = dyn_cast<Instruction>(DefV);
if (!Def) {
assert((isa<Argument>(DefV) || isa<Constant>(DefV)) &&
"Should be called with an instruction, argument or constant");
r... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x78c230
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x300c4fe
movb $0x1, 0x47(%rsp)
jmp 0x300c5f9
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x786310
movq %rax... | /IR/Dominators.cpp |
void llvm::SmallVectorTemplateBase<llvm::BasicBlock*, true>::uninitialized_copy<llvm::BasicBlock*, llvm::BasicBlock*>(llvm::BasicBlock**, llvm::BasicBlock**, llvm::BasicBlock**, std::enable_if<std::is_same<std::remove_const<llvm::BasicBlock*>::type, llvm::BasicBlock*>::value, void>::type*) | 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 0x300f1c8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::DenseMapIterator<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, int, llvm::DenseMapInfo<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, int>, 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 $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2e3ea00
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x2e47fa0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x301182a
movq 0x8(... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorTemplateBase<llvm::BasicBlock*, true>::uninitialized_copy<llvm::BasicBlock* const, llvm::BasicBlock*>(llvm::BasicBlock* const*, llvm::BasicBlock* const*, llvm::BasicBlock**, std::enable_if<std::is_same<std::remove_const<llvm::BasicBlock* const>::type, llvm::BasicBlock*>::value, void>::type*) | 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 0x3016ab8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::DenseMapIterator<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, false>::DeletesInserts, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GraphDiff<llvm::BasicBlock*, false>::DeletesInserts>, true>::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 0x3019a20
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x48, %rd... | /llvm/ADT/DenseMap.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::FindRoots(llvm::DominatorTreeBase<llvm::BasicBlock, true> const&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::BatchUpdateInfo*) | static RootsT FindRoots(const DomTreeT &DT, BatchUpdatePtr BUI) {
assert(DT.Parent && "Parent pointer is not set");
RootsT Roots;
// For dominators, function entry CFG node is always a tree root node.
if (!IsPostDom) {
Roots.push_back(GetEntryNode(DT));
return Roots;
}
SemiNCAInfo ... | subq $0x388, %rsp # imm = 0x388
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq %rdx, 0x370(%rsp)
movb $0x0, 0x36f(%rsp)
callq 0xb54200
movq 0x370(%rsp), %rsi
leaq 0x138(%rsp), %rdi
callq 0x300c140
leaq 0x138(%rsp), %rdi
callq 0x301e110
movl $0x1... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::InfoRec, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::InfoRec>>::allocat... | 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 0x301f5b7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x301f5df
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::SmallVector<llvm::BasicBlock*, 8u> llvm::GraphDiff<llvm::BasicBlock*, true>::getChildren<false>(llvm::BasicBlock*) const | VectRet getChildren(NodePtr N) const {
using DirectedNodeT =
std::conditional_t<InverseEdge, Inverse<NodePtr>, NodePtr>;
auto R = children<DirectedNodeT>(N);
VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));
// Remove nullptr children for clang.
llvm::erase(Res, nullptr);
aut... | subq $0xd8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x30184a0
movb $0x0, 0x9f(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x... | /llvm/Support/CFGDiff.h |
void llvm::SmallVectorTemplateBase<llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::InfoRec*, true>::uninitialized_copy<llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::InfoRec* const, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::B... | 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 0x30244c8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
unsigned int llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::runDFS<false, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::ComputeUnreachableDominators(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::Dom... | unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
unsigned AttachToNum,
const NodeOrderMap *SuccOrder = nullptr) {
assert(V);
SmallVector<std::pair<NodePtr, unsigned>, 64> WorkList = {{V, AttachToNum}};
NodeToInfo[V].Parent = AttachToNum;
while... | subq $0x548, %rsp # imm = 0x548
movq 0x550(%rsp), %rax
movq %rcx, 0x538(%rsp)
movq %r8, 0x540(%rsp)
movq %rdi, 0x530(%rsp)
movq %rsi, 0x528(%rsp)
movl %edx, 0x524(%rsp)
movl %r9d, 0x520(%rsp)
movq 0x530(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0x528(%rsp), %rsi
leaq 0x520(%rsp), %rdx
call... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::DomTreeNodeBase<llvm::BasicBlock>*, llvm::detail::DenseSetEmpty, 8u, llvm::DenseMapInfo<llvm::DomTreeNodeBase<llvm::BasicBlock>*, void>, llvm::detail::DenseSetPair<llvm::DomTreeNodeBase<llvm::BasicBlock>*>>, llvm::DomTreeNodeBase<llvm::BasicBlock>*, llvm::detail::DenseSetEmp... | 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 $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x30270e0
callq 0x30271b0
movq %rax, 0x38(%rsp)
callq 0x3027a50
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp... | /llvm/ADT/DenseMap.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::HasProperSupport(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::BatchUpdateInfo*, llvm::DomTreeNodeBase<llvm::BasicBlock>*) | static bool HasProperSupport(DomTreeT &DT, const BatchUpdatePtr BUI,
const TreeNodePtr TN) {
LLVM_DEBUG(dbgs() << "IsReachableFromIDom " << BlockNamePrinter(TN)
<< "\n");
auto TNB = TN->getBlock();
for (const NodePtr Pred : getChildren<!IsPostDom>(TNB, BU... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
jmp 0x302f0f1
movq 0x88(%rsp), %rdi
callq 0x30077b0
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x301fa60
leaq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x7e86a0
... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::DeleteUnreachable(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true>>::BatchUpdateInfo*, llvm::DomTreeNodeBase<llvm::BasicBlock>*) | static void DeleteUnreachable(DomTreeT &DT, const BatchUpdatePtr BUI,
const TreeNodePtr ToTN) {
LLVM_DEBUG(dbgs() << "Deleting unreachable subtree "
<< BlockNamePrinter(ToTN) << "\n");
assert(ToTN);
assert(ToTN->getBlock());
if (IsPostDom) {
/... | subq $0x348, %rsp # imm = 0x348
movq %rdi, 0x340(%rsp)
movq %rsi, 0x338(%rsp)
movq %rdx, 0x330(%rsp)
jmp 0x302f3e1
jmp 0x302f3e3
jmp 0x302f3e5
jmp 0x302f3e7
jmp 0x302f3e9
movq 0x340(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x330(%rsp), %rdi
callq 0x30077b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7e84e0
mov... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::canSimplifyInvokeNoUnwind(llvm::Function const*) | bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
EHPersonality Personality = classifyEHPersonality(F->getPersonalityFn());
// We can't simplify any invokes to nounwind functions if the personality
// function wants to catch asynch exceptions. The nounwind attribute only
// implies that the function do... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x304ef50
movq %rax, %rdi
callq 0x30313e0
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7fb9d0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x525ad28(%rip), %rsi # 0x828c8cc
callq 0x3ee9c0
movq 0x8(... | /IR/EHPersonalities.cpp |
getMemoryParamAllocType(llvm::AttributeSet) | static Type *getMemoryParamAllocType(AttributeSet ParamAttrs) {
// FIXME: All the type carrying attributes are mutually exclusive, so there
// should be a single query to get the stored type that handles any of them.
if (Type *ByValTy = ParamAttrs.getByValType())
return ByValTy;
if (Type *ByRefTy = ParamAtt... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2ef48f0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x30337af
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3033841
leaq 0x28(%rsp), %rdi
callq 0x2ef4840
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x30337d2
movq 0x18(%rsp), %rax
movq %rax, ... | /IR/Function.cpp |
llvm::Function::splice(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void, false, void>, false, false>, llvm::Function*, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::BasicBlock, false, false, void, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detai... | void Function::splice(Function::iterator ToIt, Function *FromF,
Function::iterator FromBeginIt,
Function::iterator FromEndIt) {
#ifdef EXPENSIVE_CHECKS
// Check that FromBeginIt is before FromEndIt.
auto FromFEnd = FromF->end();
for (auto It = FromBeginIt; It != FromEnd... | subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
addq $0x48, %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdx
addq $0x48, %rdx
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %... | /IR/Function.cpp |
llvm::Intrinsic::IITDescriptor::getArgumentNumber() const | unsigned getArgumentNumber() const {
assert(Kind == Argument || Kind == ExtendArgument ||
Kind == TruncArgument || Kind == HalfVecArgument ||
Kind == SameVecWidthArgument || Kind == VecElementArgument ||
Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
shrl $0x3, %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/IR/Intrinsics.h |
llvm::DenseMap<unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>::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 0x305e800
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x305e850
testb $0x1, %al
jne 0x305e7d6
jmp 0x305e7e1
movq (%rsp), %rdi
callq 0x305e8c0
jmp 0x305e7f3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>, unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>::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 0x305e940
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x305e960
callq 0x305e5c0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x305e5e0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x305e5f0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<unsigned long, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseSetPair<unsigned long>>::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::GlobalValue::eraseFromParent() | void GlobalValue::eraseFromParent() {
switch (getValueID()) {
#define HANDLE_GLOBAL_VALUE(NAME) \
case Value::NAME##Val: \
return static_cast<NAME *>(this)->eraseFromParent();
#include "llvm/IR/Value.def"
defaul... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x727f90
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0x3060854
movq 0x8(%rsp), %rax
leaq 0x52a27a5(%rip), %rcx # 0x8302fc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
callq 0x3034cb0
jmp 0x3060... | /IR/Globals.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::StringRef>>, llvm::GlobalValue const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPa... | 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 0x3063f80
callq 0x3063bf0
movq %rax, 0x48(%rsp)
callq 0x3063c00
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::detail::DenseMapPair<llvm::GlobalObject const*, llvm::StringRef>* llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalObject const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalObject const*, void>, llvm::detail::DenseMapPair<llvm::GlobalObject const*, llvm::StringRef>>, llvm::GlobalObject const*, llvm::StringRef, ... | 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 0x3065050
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x3064e80
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::IRBuilderBase::CreateMaskedCompressStore(llvm::Value*, llvm::Value*, llvm::Value*) | CallInst *IRBuilderBase::CreateMaskedCompressStore(Value *Val, Value *Ptr,
Value *Mask) {
Type *DataTy = Val->getType();
assert(DataTy->isVectorTy() && "Val should be a vector");
assert(Mask && "Mask should not be all-ones (null)");
Type *OverloadedTypes[] = {D... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
callq 0x782840
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rax
mo... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateConstrainedFPCmp(unsigned int, llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*, llvm::Twine const&, std::optional<llvm::fp::ExceptionBehavior>) | CallInst *IRBuilderBase::CreateConstrainedFPCmp(
Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R,
const Twine &Name, std::optional<fp::ExceptionBehavior> Except) {
Value *PredicateV = getConstrainedFPPredicate(P);
Value *ExceptV = getConstrainedFPExcept(Except);
CallInst *C = CreateIntrinsic(I... | subq $0xd8, %rsp
movw 0xe0(%rsp), %ax
movw %ax, 0xd6(%rsp)
movq %rdi, 0xc8(%rsp)
movl %esi, 0xc4(%rsp)
movl %edx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8(%rsp)
movq 0xc8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0xc0(%rsp), %esi
callq 0x306b670
movq 0x18(%rsp), %rdi
movq %rax, 0xa0(%rsp)
movw ... | /IR/IRBuilder.cpp |
llvm::IRBuilderBase::CreateSelect(llvm::Value*, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::Instruction*) | Value *IRBuilderBase::CreateSelect(Value *C, Value *True, Value *False,
const Twine &Name, Instruction *MDFrom) {
if (auto *V = Folder.FoldSelect(C, True, False))
return V;
SelectInst *Sel = SelectInst::Create(C, True, False);
if (MDFrom) {
MDNode *Prof = MDFrom->getMet... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq %r8, 0x98(%rsp)
movq %r9, 0x90(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rax), %rdi
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xa0(%rsp), %rcx
movq (%rdi), %rax
callq *0x48(%rax)
movq ... | /IR/IRBuilder.cpp |
llvm::CallInst::CallInst(llvm::CallInst const&) | CallInst::CallInst(const CallInst &CI)
: CallBase(CI.Attrs, CI.FTy, CI.getType(), Instruction::Call,
OperandTraits<CallBase>::op_end(this) - CI.getNumOperands(),
CI.getNumOperands()) {
setTailCallKind(CI.getTailCallKind());
setCallingConv(CI.getCallingConv());
std::copy(CI.op_be... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x782840
movq 0x40(%rsp), %rdi
movq %rax, 0x60(%rsp)
movl $0... | /IR/Instructions.cpp |
isSingleSourceMaskImpl(llvm::ArrayRef<int>, int) | static bool isSingleSourceMaskImpl(ArrayRef<int> Mask, int NumOpElts) {
assert(!Mask.empty() && "Shuffle mask must contain elements");
bool UsesLHS = false;
bool UsesRHS = false;
for (int I : Mask) {
if (I == -1)
continue;
assert(I >= 0 && I < (NumOpElts * 2) &&
"Out-of-bounds shuffle m... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
movb $0x0, 0x2a(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x78b010
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x78b020
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10... | /IR/Instructions.cpp |
llvm::UnaryOperator::AssertOK() | void UnaryOperator::AssertOK() {
Value *LHS = getOperand(0);
(void)LHS; // Silence warnings.
#ifndef NDEBUG
switch (getOpcode()) {
case FNeg:
assert(getType() == LHS->getType() &&
"Unary operation should return same type as operand!");
assert(getType()->isFPOrFPVectorTy() &&
"Tried... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x78d180
movq %rax, 0x8(%rsp)
addq $0x18, %rsp
retq
nop
| /IR/Instructions.cpp |
llvm::CmpInst::getPredicateName(llvm::CmpInst::Predicate) | StringRef CmpInst::getPredicateName(Predicate Pred) {
switch (Pred) {
default: return "unknown";
case FCmpInst::FCMP_FALSE: return "false";
case FCmpInst::FCMP_OEQ: return "oeq";
case FCmpInst::FCMP_OGT: return "ogt";
case FCmpInst::FCMP_OGE: return "oge";
case FCmpInst::FCMP_OLT: ... | subq $0x28, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x29, %rax
ja 0x308cf2c
movq 0x8(%rsp), %rax
leaq 0x5276ea5(%rip), %rcx # 0x8303dc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18(%rsp), %rdi
leaq 0x53f6c21(%rip), %rsi # 0x8483b59
callq 0x3ee9c0
jmp 0x308d167
... | /IR/Instructions.cpp |
llvm::CmpInst::isTrueWhenEqual(llvm::CmpInst::Predicate) | bool CmpInst::isTrueWhenEqual(Predicate predicate) {
switch(predicate) {
default: return false;
case ICMP_EQ: case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
}
} | movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x9, %eax
je 0x308db52
jmp 0x308daf3
movl -0xc(%rsp), %eax
subl $0xb, %eax
je 0x308db52
jmp 0x308dafe
movl -0xc(%rsp), %eax
subl $0xd, %eax
je 0x308db52
jmp 0x308db09
movl -0xc(%rsp), %eax
subl $0xf, %eax
je 0x308db52
jmp 0x308db14
movl -0xc(%rsp),... | /IR/Instructions.cpp |
llvm::VPIntrinsic::getDeclarationForParams(llvm::Module*, unsigned int, llvm::Type*, llvm::ArrayRef<llvm::Value*>) | Function *VPIntrinsic::getDeclarationForParams(Module *M, Intrinsic::ID VPID,
Type *ReturnType,
ArrayRef<Value *> Params) {
assert(isVPIntrinsic(VPID) && "not a VP intrinsic");
Function *VPFunc;
switch (VPID) {
default... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rcx, 0x2b8(%rsp)
movq %r8, 0x2c0(%rsp)
movq %rdi, 0x2b0(%rsp)
movl %esi, 0x2ac(%rsp)
movq %rdx, 0x2a0(%rsp)
movl 0x2ac(%rsp), %eax
movl %eax, 0xb4(%rsp)
subl $0xa0, %eax
je 0x309a548
jmp 0x3099c99
movl 0xb4(%rsp), %eax
subl $0xa2, %eax
je 0x309a198
jmp 0x3099cad
movl 0xb... | /IR/IntrinsicInst.cpp |
llvm::DenseMap<llvm::DIGlobalVariableExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGlobalVariableExpression>, llvm::detail::DenseSetPair<llvm::DIGlobalVariableExpression*>>::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 0x30acb20
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x2ff0510
testb $0x1, %al
jne 0x30acaf6
jmp 0x30acb01
movq (%rsp), %rdi
callq 0x2ff0580
jmp 0x30acb13
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::DISubprogram*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DISubprogram>, llvm::detail::DenseSetPair<llvm::DISubprogram*>>::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 0x30ad390
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x2fdc800
testb $0x1, %al
jne 0x30ad366
jmp 0x30ad371
movq (%rsp), %rdi
callq 0x2fdc870
jmp 0x30ad383
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DILocalVariable*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocalVariable>, llvm::detail::DenseSetPair<llvm::DILocalVariable*>>, llvm::DILocalVariable*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocalVariable>, llvm::detail::DenseSetPair<llvm::DILocalVaria... | 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 0x30adb2e
movl $0x0, 0x14(%rsp)
jmp 0x30adb4e
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::DenseMap<llvm::DIStringType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIStringType>, llvm::detail::DenseSetPair<llvm::DIStringType*>>::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 0x30ae1a0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x2fd0d60
testb $0x1, %al
jne 0x30ae176
jmp 0x30ae181
movq (%rsp), %rdi
callq 0x2fd0dd0
jmp 0x30ae193
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ConstantArray*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ConstantArray*, void>, llvm::detail::DenseSetPair<llvm::ConstantArray*>>, llvm::ConstantArray*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ConstantArray*, void>, llvm::detail::DenseSetPair<llvm::Cons... | 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 0x30b26de
movl $0x0, 0x14(%rsp)
jmp 0x30b26fe
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::DenseMap<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::unique_ptr<llvm::ConstantInt, std::default_delete<llvm::ConstantInt>>>>::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 0x30b3330
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x2f6d470
testb $0x1, %al
jne 0x30b3306
jmp 0x30b3311
movq (%rsp), %rdi
callq 0x2f6d4e0
jmp 0x30b3323
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Pass*, llvm::AnalysisUsage*, llvm::DenseMapInfo<llvm::Pass*, void>, llvm::detail::DenseMapPair<llvm::Pass*, llvm::AnalysisUsage*>>::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 0x30d5127
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x30d514f
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::ReplaceableMetadataImpl::SalvageDebugInfo(llvm::Constant const&) | void ReplaceableMetadataImpl::SalvageDebugInfo(const Constant &C) {
if (!C.isUsedByMetadata()) {
return;
}
LLVMContext &Context = C.getType()->getContext();
auto &Store = Context.pImpl->ValuesAsMetadata;
auto I = Store.find(&C);
ValueAsMetadata *MD = I->second;
using UseTy =
std::pair<void *, s... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x160(%rsp)
movq 0x160(%rsp), %rdi
callq 0x1bcbd80
testb $0x1, %al
jne 0x30e36f5
jmp 0x30e38ce
movq 0x160(%rsp), %rdi
callq 0x782840
movq %rax, %rdi
callq 0x7914b0
movq %rax, 0x158(%rsp)
movq 0x158(%rsp), %rax
movq (%rax), %rax
addq $0x1f8, %rax # imm = 0... | /IR/Metadata.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>, llvm::DILabel*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILabel>, llvm::detail::DenseSetPair<llvm::DILabel*>>::erase(llvm::DILabel* const&) | 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 0x2febfa0
testb $0x1, %al
jne 0x3106042
movb $0x0, 0x37(%rsp)
jmp 0x3106081
movq 0x18(%rsp), %rdi
callq 0x2fec460
callq 0x2feb640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIImportedEntity*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIImportedEntity>, llvm::detail::DenseSetPair<llvm::DIImportedEntity*>>, llvm::DIImportedEntity*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIImportedEntity>, llvm::detail::DenseSetPair<llvm::DIImpor... | 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 0x2ff3680
testb $0x1, %al
jne 0x3106202
movb $0x0, 0x37(%rsp)
jmp 0x3106241
movq 0x18(%rsp), %rdi
callq 0x2ff3b80
callq 0x2ff2940
movq %rax, 0x8(%rsp)
movq 0x18(%rsp... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::MDAttachments>>::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::getFCmpCondCode(llvm::CmpInst::Predicate) | ISD::CondCode llvm::getFCmpCondCode(FCmpInst::Predicate Pred) {
switch (Pred) {
case FCmpInst::FCMP_FALSE: return ISD::SETFALSE;
case FCmpInst::FCMP_OEQ: return ISD::SETOEQ;
case FCmpInst::FCMP_OGT: return ISD::SETOGT;
case FCmpInst::FCMP_OGE: return ISD::SETOGE;
case FCmpInst::FCMP_OLT: return ISD:... | movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
leaq 0x51289db(%rip), %rcx # 0x8317b84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x31ef25b
movl $0x1, -0x4(%rsp)
jmp 0x31ef25b
movl $0x2, -0x4(%rsp)
jmp 0x31ef25b
movl $0x3, -0x4(%rsp)
jmp 0... | /CodeGen/Analysis.cpp |
llvm::getEHScopeMembership(llvm::MachineFunction const&) | DenseMap<const MachineBasicBlock *, int>
llvm::getEHScopeMembership(const MachineFunction &MF) {
DenseMap<const MachineBasicBlock *, int> EHScopeMembership;
// We don't have anything to do if there aren't any EH pads.
if (!MF.hasEHScopes())
return EHScopeMembership;
int EntryBBNumber = MF.front().getNumbe... | subq $0x3e8, %rsp # imm = 0x3E8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x3e0(%rsp)
movq %rsi, 0x3d8(%rsp)
movb $0x0, 0x3d7(%rsp)
xorl %esi, %esi
callq 0x12a34a0
movq 0x3d8(%rsp), %rdi
callq 0x31f0790
testb $0x1, %al
jne 0x31f01fc
movb $0x1, 0x3d7(%rsp)
movl $0x1, 0x3d0(%rsp)
j... | /CodeGen/Analysis.cpp |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::Value*>>, llvm::Value*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::Value*>>::begin() | 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 0x3228cd0
testb $0x1, %al
jne 0x3228c1e
jmp 0x3228c37
movq 0x18(%rsp), %rdi
callq 0x3228cf0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x3228cbe
callq 0x14fbf70
testb $0x1, %al
jne 0x3228c42
jmp 0x3228c83
movq 0x18(%rsp), %rdi... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::Value*>>, llvm::Value*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::Value*>>::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 0x3228050
cmpl $0x0, %eax
jne 0x322aa62
jmp 0x322aafa
callq 0x3227f30
movq %rax, 0x28(%rsp)
callq 0x32285f0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3227f40
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3227f50
movq %... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorTemplateBase<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>, true>::uninitialized_copy<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>, std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>>(std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>*, std::pair<llvm... | 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 0x322c458
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x4, %rdx
shlq $0x4, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::CastInst*>* llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::CastInst*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::CastInst*>>, llvm::BasicBlock*, llvm::CastInst*, llvm::DenseMapInfo<llvm::BasicBlock*, vo... | 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 0x322d100
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x322cc90
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::TypePromotionTransaction::UsesReplacer::undo() | void undo() override {
LLVM_DEBUG(dbgs() << "Undo: UsersReplacer: " << *Inst << "\n");
for (InstructionAndIdx &Use : OriginalUses)
Use.Inst->setOperand(Use.Idx, Inst);
// RAUW has replaced all original uses with references to the new value,
// including the debug uses. Since we are undoi... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x3231235
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3231590
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3231470
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
... | /CodeGen/CodeGenPrepare.cpp |
(anonymous namespace)::TypePromotionTransaction::UsesReplacer::InstructionAndIdx const* llvm::SmallVectorTemplateCommon<(anonymous namespace)::TypePromotionTransaction::UsesReplacer::InstructionAndIdx, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<(anonymous namespace)::TypePromotionTransaction:... | 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 0x3231504
movq 0x3... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::TypePromotionTransaction::InstructionRemover::InstructionRemover(llvm::Instruction*, llvm::SmallPtrSet<llvm::Instruction*, 16u>&, llvm::Value*) | InstructionRemover(Instruction *Inst, SetOfInstrs &RemovedInsts,
Value *New = nullptr)
: TypePromotionAction(Inst), Inserter(Inst), Hider(Inst),
RemovedInsts(RemovedInsts) {
if (New)
Replacer = new UsesReplacer(Inst, New);
LLVM_DEBUG(dbgs() << "Do: Instructio... | 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, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3230050
movq 0x8(%rsp), %rdi
leaq 0x649a020(%rip), %rax # 0x96cbc28
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq 0x38(%rsp), %rs... | /CodeGen/CodeGenPrepare.cpp |
(anonymous namespace)::TypePromotionTransaction::OperandsHider::OperandsHider(llvm::Instruction*) | OperandsHider(Instruction *Inst) : TypePromotionAction(Inst) {
LLVM_DEBUG(dbgs() << "Do: OperandsHider: " << *Inst << "\n");
unsigned NumOpnds = Inst->getNumOperands();
OriginalValues.reserve(NumOpnds);
for (unsigned It = 0; It < NumOpnds; ++It) {
// Save the current operand.
Val... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rsi
callq 0x3230050
movq 0x10(%rsp), %rdi
leaq 0x6499dca(%rip), %rax # 0x96cbc58
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0xaccf20
jmp 0x3231ea0
movq 0x28(%rsp), %rdi
callq 0x785... | /CodeGen/CodeGenPrepare.cpp |
llvm::DenseMapIterator<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::... | 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 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 0x3233f50
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x10, %rd... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>>* llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::PointerIntPair... | 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 0x32345c0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x322f830
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
foldICmpWithDominatingICmp(llvm::CmpInst*, llvm::TargetLowering const&) | static bool foldICmpWithDominatingICmp(CmpInst *Cmp,
const TargetLowering &TLI) {
if (!EnableICMP_EQToICMP_ST && TLI.isEqualityCmpFoldedWithSignedCmp())
return false;
ICmpInst::Predicate Pred = Cmp->getPredicate();
if (Pred != ICmpInst::ICMP_EQ)
return false;
// ... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
leaq 0x6549802(%rip), %rdi # 0x9782640
addq $0x80, %rdi
callq 0x3f1b60
testb $0x1, %al
jne 0x3238e72
movq 0x120(%rsp), %rdi
movq (%rdi), %rax
callq *0x138(%rax)
testb $0x1, %al
jne 0x3238e65
jmp 0x3238e72
movb $0x0, 0x137(%rsp)
j... | /CodeGen/CodeGenPrepare.cpp |
swapICmpOperandsToExposeCSEOpportunities(llvm::CmpInst*) | static bool swapICmpOperandsToExposeCSEOpportunities(CmpInst *Cmp) {
Value *Op0 = Cmp->getOperand(0);
Value *Op1 = Cmp->getOperand(1);
if (!Op0->getType()->isIntegerTy() || isa<Constant>(Op0) ||
isa<Constant>(Op1) || Op0 == Op1)
return false;
// If a subtract already has the same operands as a compar... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
xorl %esi, %esi
callq 0x7d7fb0
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0x7d7fb0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x782840
movq %rax, %rdi
callq 0x793b60
testb $0x1, %al
jne 0x323928b
jmp 0x32392bf
leaq 0x90(%rsp), %r... | /CodeGen/CodeGenPrepare.cpp |
foldFCmpToFPClassTest(llvm::CmpInst*, llvm::TargetLowering const&, llvm::DataLayout const&) | static bool foldFCmpToFPClassTest(CmpInst *Cmp, const TargetLowering &TLI,
const DataLayout &DL) {
FCmpInst *FCmp = dyn_cast<FCmpInst>(Cmp);
if (!FCmp)
return false;
// Don't fold if the target offers free fabs and the predicate is legal.
EVT VT = TLI.getValueType(DL, Cmp-... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x198(%rsp)
movq %rsi, 0x190(%rsp)
movq %rdx, 0x188(%rsp)
movq 0x198(%rsp), %rdi
callq 0x323d3d0
movq %rax, 0x180(%rsp)
cmpq $0x0, 0x180(%rsp)
jne 0x32394ec
movb $0x0, 0x1a7(%rsp)
jmp 0x32397e0
movq 0x190(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x188(%rsp), %rax
movq... | /CodeGen/CodeGenPrepare.cpp |
llvm::DenseMap<llvm::BasicBlock*, llvm::CmpInst*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::CmpInst*>>::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 0x3239a00
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x3239a50
testb $0x1, %al
jne 0x32399d6
jmp 0x32399e1
movq (%rsp), %rdi
callq 0x3239ac0
jmp 0x32399f3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Instruction const*, unsigned long, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, unsigned long>>::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 0x3251470
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x32514c0
testb $0x1, %al
jne 0x3251446
jmp 0x3251451
movq (%rsp), %rdi
callq 0x3251530
jmp 0x3251463
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
getTrueOrFalseValue(llvm::SelectInst*, bool, llvm::SmallPtrSet<llvm::Instruction const*, 2u> const&) | static Value *
getTrueOrFalseValue(SelectInst *SI, bool isTrue,
const SmallPtrSet<const Instruction *, 2> &Selects) {
Value *V = nullptr;
for (SelectInst *DefSI = SI; DefSI != nullptr && Selects.count(DefSI);
DefSI = dyn_cast<SelectInst>(V)) {
assert(DefSI->getCondition() == SI->getC... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x32551a1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3255af0
cmpl $0x0, ... | /CodeGen/CodeGenPrepare.cpp |
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::less<llvm::AssertingVH<llvm::Value>>>::insert(llvm::AssertingVH<llvm::Value> const&) | std::pair<const_iterator, bool> insert(const T &V) {
if (!isSmall()) {
auto [I, Inserted] = Set.insert(V);
return std::make_pair(const_iterator(I), Inserted);
}
VIterator I = vfind(V);
if (I != Vector.end()) // Don't reinsert if it already exists.
return std::make_pair(const_iterat... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x108(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3242030
testb $0x1, %al
jne 0x325ac67
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x100(%rsp), ... | /llvm/ADT/SmallSet.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::Instruction*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Instruction*>>, llvm::Value*, llvm::Instruction*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Instruction*>>::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 0x3235ea0
cmpl $0x0, %eax
jne 0x325ed62
jmp 0x325edfa
callq 0x3235eb0
movq %rax, 0x28(%rsp)
callq 0x3235ec0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3235ca0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3235cb0
movq %... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ComplexDeinterleavingGraph::prepareCompositeNode(llvm::ComplexDeinterleavingOperation, llvm::Value*, llvm::Value*) | NodePtr prepareCompositeNode(ComplexDeinterleavingOperation Operation,
Value *R, Value *I) {
assert(((Operation != ComplexDeinterleavingOperation::ReductionPHI &&
Operation != ComplexDeinterleavingOperation::ReductionOperation) ||
(R && I)) &&
"Redu... | subq $0x38, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
leaq 0x24(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x3294c40
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)... | /CodeGen/ComplexDeinterleavingPass.cpp |
(anonymous namespace)::DeadMachineInstructionElimImpl::isDead(llvm::MachineInstr const*) const | bool DeadMachineInstructionElimImpl::isDead(const MachineInstr *MI) const {
// Technically speaking inline asm without side effects and no defs can still
// be deleted. But there is so much bad inline asm code out there, we should
// let them be.
if (MI->isInlineAsm())
return false;
// Don't delete frame... | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x7439d0
testb $0x1, %al
jne 0x329b3b7
jmp 0x329b3c4
movb $0x0, 0xe7(%rsp)
jmp 0x329b5e4
movq 0xd0(%rsp), %rdi
callq 0x72bbb0
cmpl $0x20, %eax
jne 0x329b3e3
movb $0x0, 0xe7(%rsp)
jmp 0x32... | /CodeGen/DeadMachineInstructionElim.cpp |
hasSameValue(llvm::MachineRegisterInfo const&, llvm::TargetInstrInfo const*, llvm::Register, llvm::Register) | static bool hasSameValue(const MachineRegisterInfo &MRI,
const TargetInstrInfo *TII, Register TReg,
Register FReg) {
if (TReg == FReg)
return true;
if (!TReg.isVirtual() || !FReg.isVirtual())
return false;
const MachineInstr *TDef = MRI.getUniqueVRegDef(... | subq $0x68, %rsp
movl %edx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x737fb0
testb $0x1, %al
jne 0x32aa7db
jmp 0x32aa7e5
movb $0x1, 0x67(%rsp)
jmp 0x32aa968
leaq 0x60(%rsp), %rdi
callq 0x744f60
testb $0x1, %al
jne 0x32aa7f5
jmp 0x32a... | /CodeGen/EarlyIfConversion.cpp |
(anonymous namespace)::EarlyIfPredicator::getAnalysisUsage(llvm::AnalysisUsage&) const | void EarlyIfPredicator::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<MachineBranchProbabilityInfoWrapperPass>();
AU.addRequired<MachineDominatorTreeWrapperPass>();
AU.addPreserved<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
AU.addPreserved<MachineLoopInfoWra... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x8faad0
movq 0x8(%rsp), %rdi
callq 0x88b140
movq 0x8(%rsp), %rdi
callq 0x88b160
movq 0x8(%rsp), %rdi
callq 0x8faaf0
movq 0x8(%rsp), %rdi
callq 0x8fab10
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
c... | /CodeGen/EarlyIfConversion.cpp |
llvm::ExecutionDomainFix::merge(llvm::DomainValue*, llvm::DomainValue*) | bool ExecutionDomainFix::merge(DomainValue *A, DomainValue *B) {
assert(!A->isCollapsed() && "Cannot merge into collapsed");
assert(!B->isCollapsed() && "Cannot merge from collapsed");
if (A == B)
return true;
// Restrict to the domains that A and B have in common.
unsigned common = A->getCommonDomains(B-... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jne 0x32adb23
movb $0x1, 0x47(%rsp)
jmp 0x32adc1d
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x32adc30
movl %eax, 0x24(%r... | /CodeGen/ExecutionDomainFix.cpp |
llvm::GCFunctionAnalysis::Result& llvm::AnalysisManager<llvm::Function>::getResult<llvm::GCFunctionAnalysis>(llvm::Function&) | typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {
assert(AnalysisPasses.count(PassT::ID()) &&
"This analysis pass was not registered prior to being queried");
ResultConceptT &ResultConcept =
getResultImpl(PassT::ID(), IR, ExtraArgs...);
using ResultModelT =
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x32bf160
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x3134eb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/IR/PassManager.h |
(anonymous namespace)::GCMachineCodeAnalysis::FindSafePoints(llvm::MachineFunction&) | void GCMachineCodeAnalysis::FindSafePoints(MachineFunction &MF) {
for (MachineBasicBlock &MBB : MF)
for (MachineInstr &MI : MBB)
if (MI.isCall()) {
// Do not treat tail or sibling call sites as safe points. This is
// legal since any arguments passed to the callee which live in the
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7edfc0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7edff0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7e... | /CodeGen/GCRootLowering.cpp |
bool llvm::IntervalMap<llvm::SlotIndex, (anonymous namespace)::DbgVariableValue, 4u, llvm::IntervalMapInfo<llvm::SlotIndex>>::iterator::overflow<llvm::IntervalMapImpl::BranchNode<llvm::SlotIndex, (anonymous namespace)::DbgVariableValue, 12u, llvm::IntervalMapInfo<llvm::SlotIndex>>>(unsigned int) | bool IntervalMap<KeyT, ValT, N, Traits>::
iterator::overflow(unsigned Level) {
using namespace IntervalMapImpl;
Path &P = this->path;
unsigned CurSize[4];
NodeT *Node[4];
unsigned Nodes = 0;
unsigned Elements = 0;
unsigned Offset = P.offset(Level);
// Do we have a left sibling?
NodeRef LeftSib = P.ge... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rax
movq %rax, 0xc0(%rsp)
movl $0x0, 0x8c(%rsp)
movl $0x0, 0x88(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xcc(%rsp), %esi
callq 0x3306540
movl (%rax), %eax
movl %eax, 0x84(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xcc(%... | /llvm/ADT/IntervalMap.h |
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>>>::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 0x3319dd0
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0x3319e20
testb $0x1, %al
jne 0x3319da6
jmp 0x3319db1
movq (%rsp), %rdi
callq 0x3319e90
jmp 0x3319dc3
movq (%rsp), %r... | /llvm/ADT/DenseMap.h |
llvm::LiveIntervals::print(llvm::raw_ostream&) const | void LiveIntervals::print(raw_ostream &OS) const {
OS << "********** INTERVALS **********\n";
// Dump the regunits.
for (unsigned Unit = 0, UnitE = RegUnitRanges.size(); Unit != UnitE; ++Unit)
if (LiveRange *LR = RegUnitRanges[Unit])
OS << printRegUnit(Unit, TRI) << ' ' << *LR << '\n';
// Dump the v... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x4ffdcce(%rip), %rsi # 0x831cad1
callq 0x41be30
movq 0x10(%rsp), %rdi
movl $0x0, 0x84(%rsp)
addq $0x1a8, %rdi # imm = 0x1A8
callq 0x3a8dca0
movl %eax, 0x80(%rsp)
movl 0x84(%r... | /CodeGen/LiveIntervals.cpp |
llvm::LiveIntervals::HMEditor::updateAllRanges(llvm::MachineInstr*) | void updateAllRanges(MachineInstr *MI) {
LLVM_DEBUG(dbgs() << "handleMove " << OldIdx << " -> " << NewIdx << ": "
<< *MI);
bool hasRegMask = false;
for (MachineOperand &MO : MI->operands()) {
if (MO.isRegMask())
hasRegMask = true;
if (!MO.isReg())
continue;
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x3324f56
movb $0x0, 0x1d7(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x822a90
movq %rax, 0x1b8(%rsp)
movq %rdx, 0x1c0(%rsp)
leaq 0x1b8(%rsp), %rax
movq %rax, 0x1c8(%rsp)
movq 0x1c8(%rsp), %... | /CodeGen/LiveIntervals.cpp |
llvm::LiveIntervals::repairIntervalsInRange(llvm::MachineBasicBlock*, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>, llvm::ArrayRef<llvm::Register>) | void
LiveIntervals::repairIntervalsInRange(MachineBasicBlock *MBB,
MachineBasicBlock::iterator Begin,
MachineBasicBlock::iterator End,
ArrayRef<Register> OrigRegs) {
// Find anchor points, which are at th... | subq $0x258, %rsp # imm = 0x258
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x238(%rsp)
movq %r9, 0x240(%rsp)
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x228(%rsp), %rdi
callq 0x73fe80
movq %rax, 0x220(%rsp)
leaq 0x250(%rsp), %rdi
leaq 0x220(%... | /CodeGen/LiveIntervals.cpp |
llvm::LiveIntervals::HMEditor::updateRange(llvm::LiveRange&, llvm::Register, llvm::LaneBitmask) | void updateRange(LiveRange &LR, Register Reg, LaneBitmask LaneMask) {
if (!Updated.insert(&LR).second)
return;
LLVM_DEBUG({
dbgs() << " ";
if (Reg.isVirtual()) {
dbgs() << printReg(Reg);
if (LaneMask.any())
dbgs() << " L" << PrintLaneMask(LaneMask);
} else {... | subq $0x68, %rsp
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x28, %rsi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x3327f80
movb 0x40(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3327e30
jmp 0x3327e32
jmp 0x3327eab
... | /CodeGen/LiveIntervals.cpp |
llvm::LiveRange::overlaps(llvm::LiveRange const&, llvm::CoalescerPair const&, llvm::SlotIndexes const&) const | bool LiveRange::overlaps(const LiveRange &Other, const CoalescerPair &CP,
const SlotIndexes &Indexes) const {
assert(!empty() && "empty range");
if (Other.empty())
return false;
// Use binary searches to find initial positions.
const_iterator I = find(Other.beginIndex());
const_i... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0xb3abf0
testb $0x1, %al
jne 0x332d631
jmp 0x332d63e
movb $0x0, 0x97(%rsp)
jmp 0x332d7f9
movq 0x80(%rsp), %rdi
callq 0xc9cee0
movq 0x10(%rsp), ... | /CodeGen/LiveInterval.cpp |
llvm::SmallVectorImpl<llvm::LiveInterval::SubRange*>::resize(unsigned long, llvm::LiveInterval::SubRange*) | void resize(size_type N, ValueParamT NV) {
if (N == this->size())
return;
if (N < this->size()) {
this->truncate(N);
return;
}
// N > this->size(). Defer to append.
this->append(N - this->size(), NV);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x3a8dca0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x3332d8b
jmp 0x3332de6
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %r... | /llvm/ADT/SmallVector.h |
llvm::LivePhysRegs::stepForward(llvm::MachineInstr const&, llvm::SmallVectorImpl<std::pair<unsigned short, llvm::MachineOperand const*>>&) | void LivePhysRegs::stepForward(const MachineInstr &MI,
SmallVectorImpl<std::pair<MCPhysReg, const MachineOperand*>> &Clobbers) {
// Remove killed registers from the set.
for (ConstMIBundleOperands O(MI); O.isValid(); ++O) {
if (O->isReg()) {
if (O->isDebug())
continue;
Register Reg = O->... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x76bff0
leaq 0x80(%rsp), %rdi
callq 0x955800
testb $0x1, %al
jne 0x3338bf7
jmp 0x3338d64
leaq 0x80(%rsp), %rdi
callq 0x955820
movq %rax, %rdi
... | /CodeGen/LivePhysRegs.cpp |
llvm::LiveIntervalCalc::createDeadDefs(llvm::LiveRange&, llvm::Register) | void LiveIntervalCalc::createDeadDefs(LiveRange &LR, Register Reg) {
const MachineRegisterInfo *MRI = getRegInfo();
SlotIndexes *Indexes = getIndexes();
VNInfo::Allocator *Alloc = getVNAlloc();
assert(MRI && Indexes && "call reset() first");
// Visit all def operands. If the same instruction has multiple def... | subq $0x78, %rsp
movl %edx, 0x74(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x333ec30
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
callq 0x333ec40
movq 0x8(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x333ec50
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movl 0x74(%rsp),... | /CodeGen/LiveIntervalCalc.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, std::pair<unsigned int, llvm::MachineInstr*>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::pair<unsigned int, llvm::MachineInstr*>>>, unsigned int, std::pair<unsigned int, llvm::MachineInstr*>, llvm::DenseMapInfo<unsigned int, void... | 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 $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3340f40
cmpl $0x0, %eax
jne 0x3341091
jmp 0x3341125
callq 0x3340e80
movl %eax, 0x1c(%rsp)
callq 0x3340f90
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
callq 0x3340e90
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3340ea0
movq %rax, 0x8(... | /llvm/ADT/DenseMap.h |
llvm::LiveVariables::analyzePHINodes(llvm::MachineFunction const&) | void LiveVariables::analyzePHINodes(const MachineFunction& Fn) {
for (const auto &MBB : Fn)
for (const auto &BBI : MBB) {
if (!BBI.isPHI())
break;
for (unsigned i = 1, e = BBI.getNumOperands(); i != e; i += 2)
if (BBI.getOperand(i).readsReg())
PHIVarInfo[BBI.getOperand(i + 1)... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x936a80
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x936ab0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9... | /CodeGen/LiveVariables.cpp |
void llvm::array_pod_sort<(anonymous namespace)::FrameRef*>((anonymous namespace)::FrameRef*, (anonymous namespace)::FrameRef*) | inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
// Don't inefficiently call qsort with one element or trigger undefined
// behavior with an empty sequence.
auto NElts = End - Start;
if (NElts <= 1) return;
#ifdef EXPENSIVE_CHECKS
detail::presortShuffle<IteratorTy>(Start, End);
#endif
qsort(&*... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jg 0x336bf04
jmp 0x336bf37
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%r... | /llvm/ADT/STLExtras.h |
llvm::LoopTraversal::isBlockDone(llvm::MachineBasicBlock*) | bool LoopTraversal::isBlockDone(MachineBasicBlock *MBB) {
unsigned MBBNumber = MBB->getNumber();
assert(MBBNumber < MBBInfos.size() && "Unexpected basic block number.");
return MBBInfos[MBBNumber].PrimaryCompleted &&
MBBInfos[MBBNumber].IncomingCompleted ==
MBBInfos[MBBNumber].PrimaryIncomin... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x951660
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x336c610
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, 0x13(%rsp)
je 0x336c5... | /CodeGen/LoopTraversal.cpp |
llvm::MachineBasicBlock::getEHCatchretSymbol() const | MCSymbol *MachineBasicBlock::getEHCatchretSymbol() const {
if (!CachedEHCatchretMCSymbol) {
const MachineFunction *MF = getParent();
SmallString<128> SymbolName;
raw_svector_ostream(SymbolName)
<< "$ehgcr_" << MF->getFunctionNumber() << '_' << getNumber();
CachedEHCatchretMCSymbol = MF->getCon... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0xf0(%rax)
jne 0x336f70c
movq 0x18(%rsp), %rdi
callq 0x813820
movq %rax, 0x128(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5c5d50
leaq 0x58(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4e3350
leaq 0x58(%rsp), ... | /CodeGen/MachineBasicBlock.cpp |
llvm::MachineBasicBlock::print(llvm::raw_ostream&, llvm::SlotIndexes const*, bool) const | void MachineBasicBlock::print(raw_ostream &OS, const SlotIndexes *Indexes,
bool IsStandalone) const {
const MachineFunction *MF = getParent();
if (!MF) {
OS << "Can't print out MachineBasicBlock because parent MachineFunction"
<< " is null\n";
return;
}
const Functio... | subq $0xb8, %rsp
movb %cl, %al
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
andb $0x1, %al
movb %al, 0x9f(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x813820
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x90(%rsp)
jne 0x336f907
movq 0xa8(%rsp), %rdi
leaq 0x4fadf81(%rip), %rsi # 0x831d86f
callq 0x... | /CodeGen/MachineBasicBlock.cpp |
llvm::MachineBasicBlock::getLastNonDebugInstr(bool) | MachineBasicBlock::iterator
MachineBasicBlock::getLastNonDebugInstr(bool SkipPseudoOp) {
// Skip over end-of-block dbg_value instructions.
instr_iterator B = instr_begin(), I = instr_end();
while (I != B) {
--I;
// Return instruction that starts a bundle.
if (I->isDebugInstr() || I->isInsideBundle())
... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x743a50
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x743ad0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8ffb90
testb $0x1, %al
jne 0x3370438
jmp 0x337... | /CodeGen/MachineBasicBlock.cpp |
llvm::SlotIndexes::insertMBBInMaps(llvm::MachineBasicBlock*) | void insertMBBInMaps(MachineBasicBlock *mbb) {
assert(mbb != &mbb->getParent()->front() &&
"Can't insert a new block at the beginning of a function.");
auto prevMBB = std::prev(MachineFunction::iterator(mbb));
// Create a new entry to be used for the start of mbb and the end of
// ... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x911600
movq 0xa8(%rsp), %rdi
movl $0x1, %esi
callq 0x91dda0
movq 0x28(%rsp), %rdi
movq %rax, 0xb0(%rsp)
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xca0... | /llvm/CodeGen/SlotIndexes.h |
llvm::MachineBasicBlock::findPrevDebugLoc(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::MachineInstr, true, true, void, false, void>, false, false>) | DebugLoc MachineBasicBlock::findPrevDebugLoc(instr_iterator MBBI) {
if (MBBI == instr_begin())
return {};
// Skip debug instructions, we don't want a DebugLoc from them.
MBBI = prev_nodbg(MBBI, instr_begin());
if (!MBBI->isDebugInstr())
return MBBI->getDebugLoc();
return {};
} | subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x743a50
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x745430
testb $0x1, %al
jne 0x33774c9
jmp 0x33... | /CodeGen/MachineBasicBlock.cpp |
llvm::BlockFrequencyInfoImpl<llvm::MachineBasicBlock>::setBlockFreq(llvm::MachineBasicBlock const*, llvm::BlockFrequency) | void BlockFrequencyInfoImpl<BT>::setBlockFreq(const BlockT *BB,
BlockFrequency Freq) {
if (Nodes.count(BB))
BlockFrequencyInfoImplBase::setBlockFreq(getNode(BB), Freq);
else {
// If BB is a newly added block after BFI is done, we need to create a new
// Bloc... | subq $0x48, %rsp
movq %rdx, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xa0, %rdi
movq 0x30(%rsp), %rsi
callq 0x33842b0
cmpl $0x0, %eax
je 0x337f4a6
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3381d80
movq (%rsp), %rdi
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), ... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
llvm::cl::opt<llvm::GVDAGType, false, llvm::cl::parser<llvm::GVDAGType>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | subq $0x68, %rsp
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movl $0x0, 0x30(%rsp)
movq %rsi, %rdi
addq $0x98, %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::GVDAGType, false, llvm::cl::parser<llvm::GVDAGType>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, 0x27(%rsp)
movb %al, 0x1b(%rsp)
jne 0x337fa9d
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x3380150
movq 0x10(%rsp), %rdi
movq %rax, 0x8(... | /llvm/Support/CommandLine.h |
void llvm::cl::parser<llvm::GVDAGType>::addLiteralOption<int>(llvm::StringRef, int const&, llvm::StringRef) | void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
#ifndef NDEBUG
if (findOption(Name) != Values.size())
report_fatal_error("Option '" + Name + "' already exists!");
#endif
OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
Values.push_back(X);
AddLiteralOption(Owner, Name... | subq $0x98, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %r8, 0x78(%rsp)
movq %r9, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %ecx
movq ... | /llvm/Support/CommandLine.h |
llvm::BlockFrequencyInfoImpl<llvm::MachineBasicBlock>::needIterativeInference() const | bool BlockFrequencyInfoImpl<BT>::needIterativeInference() const {
if (!UseIterativeBFIInference)
return false;
if (!F->getFunction().hasProfileData())
return false;
// Apply iterative inference only if the function contains irreducible loops;
// otherwise, computed block frequencies are reasonably corre... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x64534d7(%rip), %rdi # 0x97d7270
addq $0x80, %rdi
callq 0x3f1b60
testb $0x1, %al
jne 0x3383db3
movb $0x0, 0x27(%rsp)
jmp 0x3383e43
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x7353e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x338d010... | /llvm/Analysis/BlockFrequencyInfoImpl.h |
llvm::SmallVectorTemplateBase<llvm::BlockFrequencyInfoImplBase::BlockNode, true>::growAndAssign(unsigned long, llvm::BlockFrequencyInfoImplBase::BlockNode) | void growAndAssign(size_t NumElts, T Elt) {
// Elt has been copied in case it's an internal reference, side-stepping
// reference invalidation problems without losing the realloc optimization.
this->set_size(0);
this->grow(NumElts);
std::uninitialized_fill_n(this->begin(), NumElts, Elt);
this->s... | subq $0x28, %rsp
movl %edx, 0x24(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3a8dd00
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3388fb0
movq 0x8(%rsp), %rdi
callq 0x33815c0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
leaq 0x24(%r... | /llvm/ADT/SmallVector.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.