name string | code string | asm string | file string |
|---|---|---|---|
llvm::cl::opt<llvm::InliningAdvisorMode, false, llvm::cl::parser<llvm::InliningAdvisorMode>>::opt<char [18], llvm::cl::initializer<llvm::InliningAdvisorMode>, llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::ValuesClass>(char const (&) [18], llvm::cl::initializer<llvm::InliningAdvisorMode> const&, llvm::cl::OptionHidd... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3c65889... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::AttributorRunOption, false, llvm::cl::parser<llvm::AttributorRunOption>>::opt<char [18], llvm::cl::OptionHidden, llvm::cl::initializer<llvm::AttributorRunOption>, llvm::cl::desc, llvm::cl::ValuesClass>(char const (&) [18], llvm::cl::OptionHidden const&, llvm::cl::initializer<llvm::AttributorRunOptio... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3c653cd... | /llvm/Support/CommandLine.h |
llvm::PassBuilder::addPreInlinerPasses(llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>&, llvm::OptimizationLevel, llvm::ThinOrFullLTOPhase) | void PassBuilder::addPreInlinerPasses(ModulePassManager &MPM,
OptimizationLevel Level,
ThinOrFullLTOPhase LTOPhase) {
assert(Level != OptimizationLevel::O0 && "Not expecting O0 here!");
if (DisablePreInliner)
return;
InlineParams IP;
... | cmpb $0x0, 0x3d2275d(%rip) # 0x5946a78
jne 0x1c2461f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa48, %rsp # imm = 0xA48
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x3d227f7(%rip), %edx # 0x5946b38
movq %r15, %rsi
shrq $0x20, %rsi
leaq 0x128(%rsp), %rax
movl %edx, ... | /Passes/PassBuilderPipelines.cpp |
llvm::PassBuilder::buildO0DefaultPipeline(llvm::OptimizationLevel, bool) | ModulePassManager PassBuilder::buildO0DefaultPipeline(OptimizationLevel Level,
bool LTOPreLink) {
assert(Level == OptimizationLevel::O0 &&
"buildO0DefaultPipeline should only be used with O0");
ModulePassManager MPM;
// Perform pseudo probe instrume... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp # imm = 0x3F8
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x1, 0xc0(%rsi)
jne 0x1c2750f
cmpb $0x1, 0xb5(%r15)
jne 0x1c2750f
movq (%... | /Passes/PassBuilderPipelines.cpp |
llvm::cl::opt<llvm::InliningAdvisorMode, false, llvm::cl::parser<llvm::InliningAdvisorMode>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0x1c29b04
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3c5dbf9(%rip), %r9 # 0x58876e0
addq $0x10, %r9
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x2b24cf0
addq $0x18, %rsp
retq
c... | /llvm/Support/CommandLine.h |
llvm::IRChangedTester::handleInitialIR(llvm::Any) | void IRChangedTester::handleInitialIR(Any IR) {
// Always test the initial module.
// Unwrap and print directly to avoid filtering problems in general routines.
std::string S;
generateIRRepresentation(IR, "Initial IR", S);
handleIR(S, "Initial IR");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x1c2c5ca
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c2c5d3
movq $0x0, 0x8(%rsp)
movq (%rbx), %rax
leaq 0x330c... | /Passes/StandardInstrumentations.cpp |
llvm::TextChangeReporter<llvm::IRDataT<llvm::EmptyData>>::handleFiltered(llvm::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void TextChangeReporter<T>::handleFiltered(StringRef PassID,
std::string &Name) {
SmallString<20> Banner =
formatv("*** IR Dump After {0} on {1} filtered out ***\n", PassID, Name);
Out << Banner;
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x58(%rsp), %rdx
leaq 0x330649c(%rip), %rsi # 0x4f38e0d
movq %rsi, -0x40(%rdx)
movq $0x2e, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
movq $0x2, -0x28(%rdx)
leaq 0x38(%rsp), %rdx
leaq 0x3c55453(%rip), %rsi ... | /Passes/StandardInstrumentations.cpp |
(anonymous namespace)::makeHTMLReady[abi:cxx11](llvm::StringRef) | std::string makeHTMLReady(StringRef SR) {
std::string S;
while (true) {
StringRef Clean =
SR.take_until([](char C) { return C == '<' || C == '>'; });
S.append(Clean.str());
SR = SR.drop_front(Clean.size());
if (SR.size() == 0)
return S;
S.append(SR[0] == '<' ? "<" : ">");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
movq $-0x1, %r12
testq %r15, %r15
je 0x1c389d6
x... | /Passes/StandardInstrumentations.cpp |
llvm::IRComparer<llvm::DCData>::analyzeIR(llvm::Any, llvm::IRDataT<llvm::DCData>&) | void IRComparer<T>::analyzeIR(Any IR, IRDataT<T> &Data) {
if (const Module *M = getModuleForComparison(IR)) {
// Create data for each existing/interesting function in the module.
for (const Function &F : *M)
generateFunctionData(Data, F);
return;
}
if (const auto *F = unwrapIR<Function>(IR)) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1c38ee4
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c38eed
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1c30ff4
movq %rax, %r15
movq... | /Passes/StandardInstrumentations.cpp |
llvm::SmallString<80u> llvm::formatv_object_base::sstr<80u>() const | SmallString<N> sstr() const {
SmallString<N> Result;
raw_svector_ostream Stream(Result);
Stream << *this;
return Result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x50, 0x10(%rdi)
leaq 0x8(%rsp), %r15
movl $0x2, 0x8(%r15)
movb $0x0, 0x28(%r15)
movl $0x1, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %ra... | /llvm/Support/FormatVariadic.h |
llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)> const* llvm::SmallVectorTemplateCommon<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::Pre... | 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... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x1c3d6b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rbx, %rax
set... | /llvm/ADT/SmallVector.h |
llvm::StringMap<llvm::BlockDataT<llvm::DCData>, llvm::MallocAllocator>::StringMap(llvm::StringMap<llvm::BlockDataT<llvm::DCData>, llvm::MallocAllocator> const&) | explicit StringMapImpl(unsigned itemSize) : ItemSize(itemSize) {} | xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movabsq $0x6000000000, %rax # imm = 0x6000000000
movq %rax, 0x10(%rdi)
cmpl $0x0, 0xc(%rsi)
je 0x1c435cf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %esi
callq 0x2b56054
movq (%r14), %rax
movl 0x... | /llvm/ADT/StringMap.h |
llvm::StringMapEntryStorage<llvm::FuncDataT<llvm::DCData>>::StringMapEntryStorage<llvm::FuncDataT<llvm::DCData>&>(unsigned long, llvm::FuncDataT<llvm::DCData>&) | StringMapEntryStorage(size_t keyLength, InitTy &&...initVals)
: StringMapEntryBase(keyLength),
second(std::forward<InitTy>(initVals)...) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x897b2c
leaq 0x20(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x1c43516
leaq 0x38(%r14), %rdi
leaq 0x48(%r14), %rax
movq %rax, 0x38(%r14)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
addq... | /llvm/ADT/StringMapEntry.h |
void llvm::detail::UniqueFunctionBase<void, llvm::StringRef, llvm::Any, llvm::PreservedAnalyses const&>::CallImpl<llvm::ChangeReporter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::registerRequiredCallbacks(llvm::PassInstrumentationCallbacks&)::'lambda'(llvm::StringRef, llvm::Any, llv... | static ReturnT CallImpl(void *CallableAddr,
AdjustedParamT<ParamTs>... Params) {
auto &Func = *reinterpret_cast<CalledAsT *>(CallableAddr);
return Func(std::forward<ParamTs>(Params)...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rcx), %rbx
movq $0x0, (%rcx)
movq 0x8(%rdi), %r12
testq %rbx, %rbx
je 0x1c45599
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x1c455a2
movq $0x0, 0x8(%rsp)
movq ... | /llvm/ADT/FunctionExtras.h |
llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>& llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, false>::growAndEmplaceBack<llvm::ChangeReporter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reg... | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Grow manually in case one of Args is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(0, NewCapacity);
::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
moveElementsForGrow(NewElts);
takeAllocationFor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r8
movl $0x20, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2b4ec3c
movq %rax, %r14
movl 0x8(%rbx), %ebp
shlq $0x5, %rbp
movq (%r13), %r13
movq $0x0, 0x18(%rax,%rbp)
movl $0x8, ... | /llvm/ADT/SmallVector.h |
std::pair<llvm::StringMapIterator<llvm::FuncDataT<llvm::EmptyData>>, bool> llvm::StringMap<llvm::FuncDataT<llvm::EmptyData>, llvm::MallocAllocator>::try_emplace_with_hash<llvm::FuncDataT<llvm::EmptyData>>(llvm::StringRef, unsigned int, llvm::FuncDataT<llvm::EmptyData>&&) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x2b56116
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x1c4679f
testq %rax, %rax
je 0x1c467a3
jmp 0x1c467... | /llvm/ADT/StringMap.h |
llvm::funcReturnsFirstArgOfCall(llvm::CallInst const&) | inline const ParentTy *getNodeBaseParent() const { return Parent; } | movq 0x28(%rdi), %rax
movq 0x30(%rax), %rcx
leaq -0x18(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movzbl (%rax), %edx
addl $-0x1e, %edx
xorl %ecx, %ecx
cmpl $0xb, %edx
cmovaeq %rcx, %rax
cmpb $0x1e, (%rax)
jne 0x1c481f7
movl 0x4(%rax), %ecx
andq $0x7ffffff, %rcx # imm = 0x7FFFFFF
je 0x1c481f5
shll $0x5, %ecx... | /llvm/ADT/ilist_node_base.h |
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::opt<char [25], llvm::cl::OptionHidden>(char const (&) [25], llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb $0x0, 0x94(%rbx)
leaq 0x3cae8f7(%rip), %rax # 0x58f7968
addq $0x10, %rax
movq %rax, 0x88(%rbx)
leaq 0x3b0db45(%rip), %r... | /llvm/Support/CommandLine.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>,... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c513b1
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x6, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1c51651
movq (%r15), %rax
movabsq $0x3ffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %e... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>&&) | 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... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c517e6
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c5170e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c517f0
jmp 0x1c517e6
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %ecx
cmpl %r15d, %ecx
jae 0x1c5173d
cmpl %r15d, 0xc(%rbx)... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c57365
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x5, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
FunctionVarLocsBuilder::getWedge(llvm::PointerUnion<llvm::Instruction const*, llvm::DbgRecord const*>) const | const SmallVectorImpl<VarLocInfo> *getWedge(VarLocInsertPt Before) const {
auto R = VarLocsBeforeInst.find(Before);
if (R == VarLocsBeforeInst.end())
return nullptr;
return &R->second;
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
leaq 0x8(%rsp), %r8
movq %rsi, (%r8)
leaq 0x48(%rdi), %rsi
xorl %ebx, %ebx
movq %rcx, %rax
xorl %edx, %edx
divq 0x50(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0x1c569a4
testq %rax, %rax
je 0x1c5979b
movq (%rax), %rbx
leaq 0x10(%rbx), %rax
testq %rbx, %rbx
cmo... | /CodeGen/AssignmentTrackingAnalysis.cpp |
(anonymous namespace)::AtomicExpandImpl::expandAtomicCASToLibcall(llvm::AtomicCmpXchgInst*) | void AtomicExpandImpl::expandAtomicCASToLibcall(AtomicCmpXchgInst *I) {
static const RTLIB::Libcall Libcalls[6] = {
RTLIB::ATOMIC_COMPARE_EXCHANGE, RTLIB::ATOMIC_COMPARE_EXCHANGE_1,
RTLIB::ATOMIC_COMPARE_EXCHANGE_2, RTLIB::ATOMIC_COMPARE_EXCHANGE_4,
RTLIB::ATOMIC_COMPARE_EXCHANGE_8, RTLIB::ATOMIC_... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1c6223f
movzwl 0x2(%rbx), %ecx
movl %ecx, %edx
shrl $0x8, %edx
andb $0x3f, %dl
movq -0x20(%rbx), %r9
movq -0x60(%rbx), %r8
movq -0x40(%rbx), %rsi
movl %ecx, %edi
shrl $0x2, %edi
andl $0x7, %edi
shrl $0x5, %ecx
andl $0x7, %ecx... | /CodeGen/AtomicExpandPass.cpp |
llvm::BreakFalseDeps::processDefs(llvm::MachineInstr*) | void BreakFalseDeps::processDefs(MachineInstr *MI) {
assert(!MI->isDebugInstr() && "Won't process debug values");
const MCInstrDesc &MCID = MI->getDesc();
// Break dependence on undef uses. Do this before updating LiveRegs below.
// This can remove a false dependence with no additional instructions.
for (un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movzbl 0x4(%rax), %ebp
movq %rax, 0x10(%rsp)
movzwl 0x2(%rax), %r15d
cmpl %r15d, %ebp
jne 0x1c657a2
movq 0x38(%r14), %rax
movq (%rax), %rdi
movl $0x11, %esi
callq 0x2a40a66
testb %al,... | /CodeGen/BreakFalseDeps.cpp |
llvm::DenseMap<llvm::UniqueBBID, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::UniqueBBID, void>, llvm::detail::DenseSetPair<llvm::UniqueBBID>>::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... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %eax
testl %ecx, %ecx
je 0x1c68dd8
decl %ecx
je 0x1c68ddc
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x1c68de1
xorl %ebp, %ebp
jmp 0x1c68df7
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %edx
shll %cl, %edx
cmpl $0x41, %edx
mov... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>>&&) | 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... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c7fe4e
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c7fd94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c7fe58
jmp 0x1c7fe4e
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %edi
cmpl %r15d, %edi
jae 0x1c7fdc3
cmpl %r15d, 0xc(%rbx)... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<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::Den... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c80e57
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::TargetLoweringBase::isExtLoad(llvm::LoadInst const*, llvm::Instruction const*, llvm::DataLayout const&) const | bool isExtLoad(const LoadInst *Load, const Instruction *Ext,
const DataLayout &DL) const {
EVT VT = getValueType(DL, Ext->getType());
EVT LoadVT = getValueType(DL, Load->getType());
// If the load has other users and the truncate is not free, the ext
// probably isn't free.
if (!Lo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdx), %rdx
movq %rcx, %rsi
xorl %ecx, %ecx
callq 0x920138
movl %eax, %ebp
movq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x920138
movl %eax, %r15d
movq 0x10(%r12),... | /llvm/CodeGen/TargetLowering.h |
std::pair<std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>*, bool> llvm::MapVector<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*, llvm::DenseMap<std::pair<unsigned int, unsigned int>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::Dense... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&...Args) {
auto [It, Inserted] = Map.insert(std::make_pair(Key, 0));
if (Inserted) {
It->second = Vector.size();
Vector.emplace_back(std::piecewise_construct,
std::forward_as_tuple(std::move(Key)),
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf17a36
leaq 0x18(%rbx), %rdi
cmpb $0x1, 0x10(%r1... | /llvm/ADT/MapVector.h |
llvm::SmallVectorTemplateBase<std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>, true>::push_back(std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1c8b6ea
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %r... | /llvm/ADT/SmallVector.h |
llvm::cl::opt<llvm::CodeGenFileType, false, llvm::cl::parser<llvm::CodeGenFileType>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
addq $0x98, %rdi
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x1c91a36
movl %eax, %r14d
testb %al, %al
jne 0x1c91880
movl 0xc(%rsp), %eax
movl %eax, 0x80(%rbx)
movw %bp, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::FramePointerKind, false, llvm::cl::parser<llvm::FramePointerKind>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0x1c91ca0
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3bf715d(%rip), %r9 # 0x5888de0
addq $0x10, %r9
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x2b24cf0
addq $0x18, %rsp
retq
c... | /llvm/Support/CommandLine.h |
llvm::cl::parser<llvm::DebuggerKind>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, llvm::DebuggerKind&) | bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x1c93095
movq 0x10(%rdi), %r13
shlq $0x4, %rax
leaq (%rax,%rax,2), ... | /llvm/Support/CommandLine.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::WriteGraph<llvm::EdgeBundles>(llvm::EdgeBundles const&, llvm::Twine const&, bool, llvm::Twine const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string WriteGraph(const GraphType &G, const Twine &Name,
bool ShortNames = false,
const Twine &Title = "",
std::string Filename = "") {
int FD;
if (Filename.empty()) {
Filename = createGraphFilename(Name.str(), FD);
} else {
std::er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%r9)
je 0x1ca5107
leaq 0x48(%rsp), %r12
movw $0x104, 0x20(%r12) # imm = 0x104
movq %r14, (%r12)
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
movl $0x2, %ecx
movl ... | /llvm/Support/GraphWriter.h |
llvm::VPIntrinsic::classof(llvm::Value const*) | static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
} | pushq %rbx
cmpb $0x55, (%rdi)
jne 0x1caf859
movq %rdi, %rbx
callq 0x91f89e
testb %al, %al
je 0x1caf859
movq -0x20(%rbx), %rax
movl 0x24(%rax), %edi
popq %rbx
jmp 0x2a5ec70
xorl %eax, %eax
popq %rbx
retq
| /llvm/IR/IntrinsicInst.h |
runImpl(llvm::MachineFunction&) | static std::pair<bool, bool> runImpl(MachineFunction &MF) {
bool Changed = false;
bool PreserveCFG = true;
const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
// Iterate through each instruction in the function, looking for pseudos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
movq %rax, %r14
leaq 0x140(%rbx), %rax
movq %rbx, 0x8(%rsp)
movq 0x148(%rbx), %r12
movq %... | /CodeGen/FinalizeISel.cpp |
llvm::GCFunctionInfo::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&) | bool GCFunctionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &) {
auto PAC = PA.getChecker<GCFunctionAnalysis>();
return !PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Function>>();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
leaq 0x3c9d907(%rip), %rsi # 0x594eb58
movq %rsi, 0x8(%r14)
leaq 0x30(%rdx), %rdi
callq 0x90b7be
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq 0x30(%rbx), %rcx
sete %dl
movl 0x40(%rbx,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx... | /CodeGen/GCMetadata.cpp |
llvm::DenseMap<llvm::Function const*, llvm::GCFunctionInfo*, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, llvm::GCFunctionInfo*>>::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... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
testl %eax, %eax
je 0x1cb2026
decl %eax
je 0x1cb202a
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x1cb202f
xorl %ebp, %ebp
jmp 0x1cb2045
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
std::pair<llvm::StringMapIterator<llvm::GCStrategy*>, bool> llvm::StringMap<llvm::GCStrategy*, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x2b56116
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x1cb2180
testq %rax, %rax
je 0x1cb2184
jmp 0x1cb216e
addq $0x8, %... | /llvm/ADT/StringMap.h |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::GCMachineCodeAnalysis, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rax
movl $0x48, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3c9bfd5(%rip), %rdx # 0x594eb7d
movq %rdx, 0x10(%rax)
movl $0x2, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
leaq 0x3bd76a3(%rip), %rcx # 0x588a268
movq %rcx, (%rax)
movups %xmm0, 0x38(%rax)
popq ... | /llvm/PassSupport.h |
llvm::LexicalScopes::getOrCreateLexicalScope(llvm::DILocalScope const*, llvm::DILocation const*) | LexicalScope *LexicalScopes::getOrCreateLexicalScope(const DILocalScope *Scope,
const DILocation *IA) {
if (IA) {
// Skip scopes inlined from a NoDebug compile unit.
if (Scope->getSubprogram()->getUnit()->getEmissionKind() ==
DICompileUnit::NoDebug)... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1cccc76
movq %rdx, %rbx
movq %r14, %rdi
callq 0x2a0977a
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x1cccc86
addq $-0x10, %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x1cccc8a
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
p... | /CodeGen/LexicalScopes.cpp |
llvm::DenseMap<llvm::Register, std::vector<unsigned int, std::allocator<unsigned int>>, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, std::vector<unsigned int, std::allocator<unsigned int>>>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1cd3998
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ec... | /llvm/ADT/DenseMap.h |
llvm::IntervalMap<llvm::SlotIndex, (anonymous namespace)::DbgVariableValue, 4u, llvm::IntervalMapInfo<llvm::SlotIndex>>::iterator::treeInsert(llvm::SlotIndex, llvm::SlotIndex, (anonymous namespace)::DbgVariableValue) | void IntervalMap<KeyT, ValT, N, Traits>::
iterator::treeInsert(KeyT a, KeyT b, ValT y) {
using namespace IntervalMapImpl;
Path &P = this->path;
if (!P.valid())
P.legalizeForInsert(this->map->height);
// Check if this insertion will extend the node to the left.
if (P.leafOffset() == 0 && Traits::startLes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpl $0x0, 0x10(%rdi)
movq %rcx, 0x28(%rsp)
je 0x1cd4dd8
movq (%r14), %rax
movl 0xc(%rax), %edx
cmpl 0x8(%rax), %edx
jb 0x1cd4dee
movq (%rbx), %rax
movl 0xa0(%rax... | /llvm/ADT/IntervalMap.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::LiveRange const*, llvm::LiveRange::Segment const*>, true>::push_back(std::pair<llvm::LiveRange const*, llvm::LiveRange::Segment const*>) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1cdd104
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %r... | /llvm/ADT/SmallVector.h |
llvm::LiveRegMatrix::getOneVReg(unsigned int) const | Register LiveRegMatrix::getOneVReg(unsigned PhysReg) const {
const LiveInterval *VRegInterval = nullptr;
for (MCRegUnit Unit : TRI->regunits(PhysReg)) {
if ((VRegInterval = Matrix[Unit].getOneVReg()))
return VRegInterval->reg();
}
return MCRegister::NoRegister;
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rcx
movq 0x38(%rcx), %rax
testq %rax, %rax
je 0x1ce9138
movq %rdi, %rbx
movq 0x8(%rcx), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rcx,%rdx,8), %ebp
movl %ebp, %ecx
shrl $0xc, %ecx
leaq (%rax,%rcx,2), %r14
andl $0xfff, %ebp # imm = 0xFFF
movl %... | /CodeGen/LiveRegMatrix.cpp |
llvm::LiveRegUnits::addLiveOuts(llvm::MachineBasicBlock const&) | void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
const MachineFunction &MF = *MBB.getParent();
addPristines(MF);
// To get the live-outs we simply merge the live-ins of all successors.
for (const MachineBasicBlock *Succ : MBB.successors())
addBlockLiveIns(*this, *Succ);
// For the return ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rbx
movq %rbx, %rsi
callq 0x1ce96e8
movq 0x58(%r15), %r12
movq 0x60(%r15), %r13
cmpq %r13, %r12
je 0x1ce9910
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1ce9944
addq $0x8, %r12
jmp 0x1ce98f9
movq %r15, %rdi
callq 0xbc... | /CodeGen/LiveRegUnits.cpp |
llvm::LiveVariables::FindLastRefOrPartRef(llvm::Register) | MachineInstr *LiveVariables::FindLastRefOrPartRef(Register Reg) {
MachineInstr *LastDef = PhysRegDef[Reg];
MachineInstr *LastUse = PhysRegUse[Reg];
if (!LastDef && !LastUse)
return nullptr;
MachineInstr *LastRefOrPartRef = LastUse ? LastUse : LastDef;
unsigned LastRefOrPartRefDist = DistanceMap[LastRefOr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq 0x68(%rdi), %rax
movq 0x80(%rdi), %rcx
movq (%rax,%r15,8), %r13
movq (%rcx,%r15,8), %rax
movq %r13, %rcx
orq %rax, %rcx
je 0x1ceb8a1
movl %esi, %ebp
movq %rdi, %rbx
testq %rax, %rax
cmoveq %r13, %rax
leaq 0x18(%rsp)... | /CodeGen/LiveVariables.cpp |
llvm::LLVMTargetMachine::LLVMTargetMachine(llvm::Target const&, llvm::StringRef, llvm::Triple const&, llvm::StringRef, llvm::StringRef, llvm::TargetOptions const&, llvm::Reloc::Model, llvm::CodeModel::Model, llvm::CodeGenOptLevel) | LLVMTargetMachine::LLVMTargetMachine(const Target &T,
StringRef DataLayoutString,
const Triple &TT, StringRef CPU,
StringRef FS, const TargetOptions &Options,
Reloc::Model ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x80(%rsp), %ebp
movl 0x78(%rsp), %r14d
movl 0x70(%rsp), %r15d
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x2395334
leaq 0x3b9c8df(%rip), %rax # 0x588aea8
addq $0x10, %rax
movq ... | /CodeGen/LLVMTargetMachine.cpp |
llvm::LLVMTargetMachine::addAsmPrinter(llvm::legacy::PassManagerBase&, llvm::raw_pwrite_stream&, llvm::raw_pwrite_stream*, llvm::CodeGenFileType, llvm::MCContext&) | bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
raw_pwrite_stream &Out,
raw_pwrite_stream *DwoOut,
CodeGenFileType FileType,
MCContext &Context) {
Expected... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cee71a
testb $0x1, 0x8(%r15)
je 0x1cee6a5
movq 0x8(%rsp), %rdi
movq $0x0, 0x8(%rsp)
jmp 0x1cee6a7
xorl %edi, %edi
testq %rdi, %rdi
je 0x1cee6b7
movq (%rdi), %rax
cal... | /CodeGen/LLVMTargetMachine.cpp |
llvm::TargetTransformInfo::Model<llvm::BasicTTIImpl>::simplifyDemandedVectorEltsIntrinsic(llvm::InstCombiner&, llvm::IntrinsicInst&, llvm::APInt, llvm::APInt&, llvm::APInt&, llvm::APInt&, std::function<void (llvm::Instruction*, unsigned int, llvm::APInt, llvm::APInt&)>) | std::optional<Value *> simplifyDemandedVectorEltsIntrinsic(
InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
APInt &UndefElts2, APInt &UndefElts3,
std::function<void(Instruction *, unsigned, APInt, APInt &)>
SimplifyAndSetOp) override {
return Impl.simplifyDeman... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x88(%rsp), %rbp
movl 0x8(%rcx), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x1cef16b
movq (%rcx), %rax
movq %rax, 0x8(%rsp)
jmp 0x1cef178
leaq ... | /llvm/Analysis/TargetTransformInfo.h |
llvm::TargetTransformInfoImplCRTPBase<llvm::BasicTTIImpl>::getGEPCost(llvm::Type*, llvm::Value const*, llvm::ArrayRef<llvm::Value const*>, llvm::Type*, llvm::TargetTransformInfo::TargetCostKind) | InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr,
ArrayRef<const Value *> Operands, Type *AccessType,
TTI::TargetCostKind CostKind) {
assert(PointeeType && Ptr && "can't get GEPCost of nullptr");
auto *BaseGV = dyn_cast<GlobalValue>(Ptr->st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x70(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2aa0110
movq %rax, %r12
movb (%rax), %al
cmpb $0x4, %al
setb %dl
movl %eax, %ecx
andb $0xf, %cl
movb $0xd, %sil... | /llvm/Analysis/TargetTransformInfoImpl.h |
llvm::LocalStackSlotAllocationPass::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&) | PreservedAnalyses
LocalStackSlotAllocationPass::run(MachineFunction &MF,
MachineFunctionAnalysisManager &) {
bool Changed = LocalStackSlotImpl().runOnMachineFunction(MF);
if (!Changed)
return PreservedAnalyses::all();
auto PA = getMachineFunctionPassPreservedAnalyses();
PA.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x780240
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, -0x8(%r12)
movq %r15, %rdi
... | /CodeGen/LocalStackSlotAllocation.cpp |
llvm::MachineBasicBlock::canSplitCriticalEdge(llvm::MachineBasicBlock const*) const | bool MachineBasicBlock::canSplitCriticalEdge(
const MachineBasicBlock *Succ) const {
// Splitting the critical edge to a landing pad block is non-trivial. Don't do
// it in this generic function.
if (Succ->isEHPad())
return false;
// Splitting the critical edge to a callbr's indirect block isn't advise... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
cmpb $0x0, 0xb8(%rsi)
jne 0x1cfe445
cmpb $0x0, 0xe6(%rsi)
jne 0x1cfe445
movq %rdi, %rbx
movq 0x20(%rdi), %r13
movq 0x8(%r13), %rax
testb $0x1, 0x280(%rax)
jne 0x1cfe445
movq %rbx, %rdi
callq 0x1cfe59e
movabsq $0x400000000, %r12 # im... | /CodeGen/MachineBasicBlock.cpp |
llvm::iplist_impl<llvm::simple_ilist<llvm::MachineInstr, llvm::ilist_sentinel_tracking<true>>, llvm::ilist_traits<llvm::MachineInstr>>::insert(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::MachineInstr, true, true, void, false, void>, false, false>, llvm::MachineInstr*) | iterator insert(iterator where, pointer New) {
this->addNodeToList(New); // Notify traits that we added a node...
return base_list_type::insert(where, *New);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
movq %rax, 0x18(%rdx)
movq 0x20(%rax), %r15
movq 0x28(%r15), %rsi
movq %rdx, %rdi
callq 0x1d3c84c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d33c56
movq (%r14), %rax
andq $-0x8, %rax
movq %r14, 0x8(%rbx)
movq (%rbx), %rcx
andl $0x7, %ecx
o... | /llvm/ADT/ilist.h |
llvm::MachineBasicBlock::removeFromParent() | MachineBasicBlock *MachineBasicBlock::removeFromParent() {
assert(getParent() && "Not embedded in a function!");
getParent()->remove(this);
return this;
} | movq %rdi, %rax
movq 0x20(%rdi), %rcx
movl 0x18(%rdi), %edx
movq 0x68(%rcx), %rcx
movq $0x0, (%rcx,%rdx,8)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
| /CodeGen/MachineBasicBlock.cpp |
llvm::SmallVectorImpl<llvm::BlockFrequencyInfoImplBase::BlockNode>::assign(unsigned long, llvm::BlockFrequencyInfoImplBase::BlockNode) | size_t size() const { return Size; } | movl 0xc(%rdi), %eax
cmpq %rsi, %rax
jb 0x1d04104
movq (%rdi), %rax
movl 0x8(%rdi), %ecx
cmpq %rsi, %rcx
cmovaeq %rsi, %rcx
testq %rcx, %rcx
je 0x1d03ff9
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
addq %r8, %rcx
andq %rcx, %r8
andl $0x3, %ecx
negq %rcx
addq %r8, %rcx
addq $0x4, %rcx
movq %r8, %xmm0
psh... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::MachineBlockPlacement::shouldTailDuplicate(llvm::MachineBasicBlock*) | bool MachineBlockPlacement::shouldTailDuplicate(MachineBasicBlock *BB) {
// Blocks with single successors don't create additional fallthrough
// opportunities. Don't duplicate them. TODO: When conditional exits are
// analyzable, allow them to be duplicated.
bool IsSimple = TailDup.isSimpleBB(BB);
if (BB->su... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e65c2c
movq 0x60(%rbx), %rcx
subq 0x58(%rbx), %rcx
movabsq $0x7fffffff8, %rdx # imm = 0x7FFFFFFF8
andq %rcx, %rdx
cmpq $0x8, %rdx
jne 0x1d0b8c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x1b8, %r14 ... | /CodeGen/MachineBlockPlacement.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::pr... | void grow(unsigned AtLeast) {
static_cast<DerivedT *>(this)->grow(AtLeast);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::CopyTracker::clobberRegister(llvm::MCRegister, llvm::TargetRegisterInfo const&, llvm::TargetInstrInfo const&, bool) | void clobberRegister(MCRegister Reg, const TargetRegisterInfo &TRI,
const TargetInstrInfo &TII, bool UseCopyInstr) {
for (MCRegUnit Unit : TRI.regunits(Reg)) {
auto I = Copies.find(Unit);
if (I != Copies.end()) {
// When we clobber the source of a copy, we need to clobber ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x28(%rsp)
movq 0x38(%rdx), %rax
testq %rax, %rax
je 0x1d19116
movq %rdx, %r13
movq %rdi, %r15
movq 0x8(%rdx), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rcx,%rdx,8), %r12d
movl %r12d, %ecx
shrl $0xc, %ecx
leaq (... | /CodeGen/MachineCopyPropagation.cpp |
(anonymous namespace)::MachineCopyPropagation::eraseIfRedundant(llvm::MachineInstr&, llvm::MCRegister, llvm::MCRegister) | bool MachineCopyPropagation::eraseIfRedundant(MachineInstr &Copy,
MCRegister Src, MCRegister Def) {
// Avoid eliminating a copy from/to a reserved registers as we cannot predict
// the value (Example: The sparc zero register is writable but stays zero).
if (MRI->isRes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %r13d
movq 0x48(%rdi), %rax
movq 0x180(%rax), %rax
movl %edx, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rcx
btq %r13, %rcx
jb 0x1d1af2c
movl %r12d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
... | /CodeGen/MachineCopyPropagation.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::MachineBasicBlock*>>, llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1d1db0b
cmpl $0x0, 0xc(%rdi)
je 0x1d1dbe4
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1d1dd12
testq %rcx, %rcx
je 0x1d1dbdc
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, true>::push_back(llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1d1de6d
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::MachineBasicBlock*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::De... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x1d2219d
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, int, 4u, llvm::DenseMapInfo<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, int>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x1d2a3ea
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x1... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm:... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1d2bad1
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %e... | /llvm/ADT/DenseMap.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::attachNewSubtree(llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>&, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*) | void attachNewSubtree(DomTreeT& DT, const TreeNodePtr AttachTo) {
// Attach the first unreachable block to AttachTo.
NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
// Loop over all of the discovered blocks in the function...
for (NodePtr W : llvm::drop_begin(NumToNode)) {
// Don't replace t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %r15
addq $0x210, %rdi # imm = 0x210
movq (%r14), %rsi
addq $0x8, %rsi
movq %rdi, 0x10(%rsp)
callq 0x1d2c554
movq %r15, 0x18(%rax)
movl 0x8(%r14), %ebp
cmpq $0x1, %rbp
je 0x1d2bfd7
... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::InfoRec, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBa... | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0x1d29b2a
testl %ebp, %ebp
je 0x1d30539
decl %ebp
je 0x1d3053d
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1d30542
xorl %ebp, %ebp
jmp 0x1d30558
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
llvm::GraphDiff<llvm::MachineBasicBlock*, false>::popUpdateForIncrementalUpdates() | cfg::Update<NodePtr> popUpdateForIncrementalUpdates() {
assert(!LegalizedUpdates.empty() && "No updates to apply!");
auto U = LegalizedUpdates.pop_back_val();
unsigned IsInsert =
(U.getKind() == cfg::UpdateKind::Insert) == !UpdatedAreReverseApplied;
auto &SuccDIList = Succ[U.getFrom()];
auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x258(%rdi), %rax
movl 0x260(%rdi), %ecx
leal -0x1(%rcx), %edx
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %rbp
movq -0x8(%rax,%rcx), %r14
movl %edx, 0x260(%rdi)
testb $0x4, %r14b
sete %r15b
movb 0x250(%rdi), %r12b
xorl %... | /llvm/Support/CFGDiff.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts>>, llvm::Machin... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x1d2b05c
movl %eax, %ebp
testb %al, %al
je 0x1d30f0d
movq 0x8(%rsp), %r14
leaq 0x38(%r14), %r15
xorl %r12d, %r12d
movq 0x28(%r14,%r12), %rdi
leaq (%r15,%r12), %rax
cmpq %rdi, %rax
je 0x1d30ef6
callq 0x780... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineLoop*, llvm::SmallVector<llvm::MachineBasicBlock*, 8u>, llvm::DenseMapInfo<llvm::MachineLoop*, void>, llvm::detail::DenseMapPair<llvm::MachineLoop*, llvm::SmallVector<llvm::MachineBasicBlock*, 8u>>>::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... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0x1d48444
testl %ebp, %ebp
je 0x1d4884f
decl %ebp
je 0x1d48853
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1d48858
xorl %ebp, %ebp
jmp 0x1d4886e
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::MachineLICMBase::IsLICMCandidate(llvm::MachineInstr&, llvm::MachineLoop*) | bool MachineLICMBase::IsLICMCandidate(MachineInstr &I, MachineLoop *CurLoop) {
// Check if it's safe to move the instruction.
bool DontMoveAcrossStore = !HoistConstLoads || !AllowedToHoistLoads[CurLoop];
if ((!I.isSafeToMove(AA, DontMoveAcrossStore)) &&
!(HoistConstStores && isInvariantStore(I, TRI, MRI))) ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movb $0x1, %al
cmpb $0x1, 0x3c0917f(%rip) # 0x5952218
jne 0x1d490b1
leaq 0x1a8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d48adc
movb 0x8(%rax), %al
xorb $0x1, %al
leaq 0xf(%rsp), %rdx
movb %al, (%rdx)
movq 0x180(%r14), %rsi
... | /CodeGen/MachineLICM.cpp |
(anonymous namespace)::MachineLICMBase::IsProfitableToHoist(llvm::MachineInstr&, llvm::MachineLoop*) | bool MachineLICMBase::IsProfitableToHoist(MachineInstr &MI,
MachineLoop *CurLoop) {
if (MI.isImplicitDef())
return true;
// Besides removing computation from the loop, hoisting an instruction has
// these effects:
//
// - The value defined by the instruction beco... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x30(%rsp)
movzwl 0x44(%rsi), %eax
movb $0x1, %bpl
cmpw $0xa, %ax
je 0x1d4ae70
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
cmpb $0x1, 0x3c07bf6(%rip) # 0x5952158
jne 0x1d4a60e
cmpw $0x13, %ax
jne 0x1d4a60... | /CodeGen/MachineLICM.cpp |
std::pair<llvm::DenseMapIterator<llvm::Register, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Register, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x1d4bf6c
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x1d4bf20
xorl %ecx, %ecx
jmp 0x1d4bf38
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MachineLoop const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MachineLoop const*, void>, llvm::detail::DenseSetPair<llvm::MachineLoop const*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<std::tuple<llvm::DomTreeNodeBase<llvm::MachineBasicBlock> const*, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>* const*, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>* const*>, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r8
movl $0x18, %ecx
movq %r14, %rsi
callq 0x2b4ec3c
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x1d50a89
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
xorl %edx, %... | /llvm/ADT/SmallVector.h |
llvm::MachineOperand::ChangeToTargetIndex(unsigned int, long, unsigned int) | void MachineOperand::ChangeToTargetIndex(unsigned Idx, int64_t Offset,
unsigned TargetFlags) {
assert((!isReg() || !isTied()) &&
"Cannot change a tied operand into a FrameIndex");
removeRegFromUses();
OpKind = MO_TargetIndex;
setIndex(Idx);
setOffset(Offset)... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x1d53384
movl (%r15), %eax
orl $0x7, %eax
movl %ebp, 0x10(%r15)
movl %r14d, 0x4(%r15)
shrq $0x20, %r14
movl %r14d, 0x18(%r15)
shll $0x8, %ebx
andl $0xfff00, %ebx # imm = 0xFFF00
andl $0... | /CodeGen/MachineOperand.cpp |
llvm::MachineOperand::ChangeToRegister(llvm::Register, bool, bool, bool, bool, bool, bool) | void MachineOperand::ChangeToRegister(Register Reg, bool isDef, bool isImp,
bool isKill, bool isDead, bool isUndef,
bool isDebug) {
MachineRegisterInfo *RegInfo = nullptr;
if (MachineFunction *MF = getMFIfAvailable(*this))
RegInfo = &MF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1d53632
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1d53632
movq 0x20(%rax), %rax
jmp 0x1d53634
xorl %eax, %eax
testq %rax, %ra... | /CodeGen/MachineOperand.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [28], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(char const (&) [28], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x39fc202(%rip), %rax # 0x5757030
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::SwingSchedulerDAG::calculateResMII() | unsigned SwingSchedulerDAG::calculateResMII() {
LLVM_DEBUG(dbgs() << "calculateResMII:\n");
ResourceManager RM(&MF.getSubtarget(), this);
return RM.calculateResMII();
} | pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rdx
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1d63a2e
movq %r14, %rdi
callq 0x1d63b44
movl %eax, %ebx
movq 0x150(%r14), %rdi
leaq 0x160(%rsp), %rax
cmpq %rax, %rdi
je 0x1d5f2f3
callq 0x780910
leaq 0x12... | /CodeGen/MachinePipeliner.cpp |
llvm::SmallVectorImpl<llvm::SmallPtrSet<llvm::SUnit*, 4u>>::truncate(unsigned long) | void truncate(size_type N) {
assert(this->size() >= N && "Cannot increase size with truncate");
this->destroy_range(this->begin() + N, this->end());
this->set_size(N);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %r15d
cmpq %rsi, %r15
je 0x1d6a212
movq (%r14), %r12
shlq $0x6, %r15
movq %rbx, %r13
shlq $0x6, %r13
movq -0x38(%r12,%r15), %rdi
cmpq -0x40(%r12,%r15), %rdi
je 0x1d6a209
callq 0x780910
addq $-0x40, %r15
cmpq %r15, %r1... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<llvm::SmallVector<int, 4u>, false>::moveElementsForGrow(llvm::SmallVector<int, 4u>*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
testq %r12, %r12
je 0x1d6a474
movq %rsi, %r14
movq (%rbx), %r15
shlq $0x5, %r12
movabsq $0x400000000, %r13 # imm = 0x400000000
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r13, 0x8(%r14)
cmpl $0x0, 0x8(%r15)
je 0x1d6a466
... | /llvm/ADT/SmallVector.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, true>>::RemoveRedundantRoots(llvm::DominatorTreeBase<llvm::MachineBasicBlock, true> const&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, true>>::BatchUpdateInfo*, llvm::SmallVector<llvm::MachineBasic... | static void RemoveRedundantRoots(const DomTreeT &DT, BatchUpdatePtr BUI,
RootsT &Roots) {
assert(IsPostDom && "This function is for postdominators only");
LLVM_DEBUG(dbgs() << "Removing redundant roots\n");
SemiNCAInfo SNCA(BUI);
for (unsigned i = 0; i < Roots.size()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %rdx
movq $0x0, -0x8(%rdx)
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp)... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::RegionInfoBase<llvm::RegionTraits<llvm::MachineFunction>>::getNextPostDom(llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineBasicB... | typename Tr::DomTreeNodeT *
RegionInfoBase<Tr>::getNextPostDom(DomTreeNodeT *N, BBtoBBMap *ShortCut) const {
typename BBtoBBMap::iterator e = ShortCut->find(N->getBlock());
if (e == ShortCut->end())
return N->getIDom();
return PDT->getNode(e->second)->getIDom();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq %rdx, %rdi
callq 0x1d7f82a
movl 0x10(%r15), %ecx
shlq $0x4, %rcx
addq (%r15), %rcx
cmpq %rcx, %rax
je 0x1d7f8a6
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rsi
addq $0x30, %rdi
callq 0x9a5526
movq 0x8(%rax), %rbx
movq 0x8... | /llvm/Analysis/RegionInfoImpl.h |
llvm::RegionInfoBase<llvm::RegionTraits<llvm::MachineFunction>>::findRegionsWithEntry(llvm::MachineBasicBlock*, llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>>*) | void RegionInfoBase<Tr>::findRegionsWithEntry(BlockT *entry,
BBtoBBMap *ShortCut) {
assert(entry);
DomTreeNodeT *N = PDT->getNode(entry);
if (!N)
return;
RegionT *lastRegion = nullptr;
BlockT *lastExit = entry;
// As only a BasicBlock that postdominates e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rbx
leaq 0x30(%rbx), %rdi
callq 0x9a5526
movl 0x40(%rbx), %ecx
shlq $0x4, %rcx
addq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x1d7f9b0
movq 0x8(%rax), %r12
jmp 0x1d7f9b3
... | /llvm/Analysis/RegionInfoImpl.h |
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineRegion*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineRegion*>>::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... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
testl %eax, %eax
je 0x1d81f68
decl %eax
je 0x1d81f6c
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x1d81f71
xorl %ebp, %ebp
jmp 0x1d81f87
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
llvm::MachineRegisterInfo::setType(llvm::Register, llvm::LLT) | void MachineRegisterInfo::setType(Register VReg, LLT Ty) {
VRegToType.grow(VReg);
VRegToType[VReg] = Ty;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
leaq 0x1c8(%rdi), %r14
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movl 0x1d0(%rdi), %eax
movl %esi, %r15d
cmpl %esi, %eax
ja 0x1d82d68
leaq 0x1(%r15), %rsi
movq 0x1d8(%rdi), %rdx
subq %rax, %rsi
movq %r14, %rdi
callq 0x9603a6
movq (%r14), %rax
movq %rbx, (%rax,%r15,... | /CodeGen/MachineRegisterInfo.cpp |
llvm::MachineRegisterInfo::isReservedRegUnit(unsigned int) const | bool MachineRegisterInfo::isReservedRegUnit(unsigned Unit) const {
const TargetRegisterInfo *TRI = getTargetRegisterInfo();
for (MCRegUnitRootIterator Root(Unit, TRI); Root.isValid(); ++Root) {
if (all_of(TRI->superregs_inclusive(*Root),
[&](MCPhysReg Super) { return isReserved(Super); }))
... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x28(%rcx), %rcx
movl %ebx, %edx
movzwl (%rcx,%rdx,4), %r9d
movzwl 0x2(%rcx,%rdx,4), %edx
movq 0x180(%r14), %rcx
xorl ... | /CodeGen/MachineRegisterInfo.cpp |
llvm::SmallVectorTemplateBase<std::pair<unsigned int, llvm::SmallVector<llvm::Register, 4u>>, false>::moveElementsForGrow(std::pair<unsigned int, llvm::SmallVector<llvm::Register, 4u>>*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x1d8410e
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x1d84105
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rdx
leaq (%rcx,%rdx,8), %rbx
addq $-0x10, %rbx
shlq $0x3, %r... | /llvm/ADT/SmallVector.h |
void llvm::SmallVectorImpl<unsigned short>::append<unsigned short const*, void>(unsigned short const*, unsigned short const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq %r13
movq 0x8(%rdi), %rdx
addq %r13, %rdx
cmpq %rdx, 0x10(%rdi)
jae 0x1d84694
leaq 0x18(%rbx), %rsi
movl $0x2, %ecx
movq %rbx, %rdi
callq 0x2b4efce
cmpq %r12, %r14
... | /llvm/ADT/SmallVector.h |
llvm::ScheduleDAGMILive::collectVRegUses(llvm::SUnit&) | ScheduleDAGInstrs *MachineScheduler::createMachineScheduler() {
// Select the scheduler, or set the default.
MachineSchedRegistry::ScheduleDAGCtor Ctor = MachineSchedOpt;
if (Ctor != useDefaultMachineSched)
return Ctor(this);
// Get the default scheduler set by the target for this function.
ScheduleDAGIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %rcx
movzwl 0x28(%rcx), %eax
movq %rcx, (%rsp)
movzbl 0x2a(%rcx), %ebp
shll $0x10, %ebp
orl %eax, %ebp
testl %ebp, %ebp
je 0x1d859e2
movq %rsi, %rbx
movq (%rsp), %rax
movq 0x20(%rax), %r12
shll $0x5, %ebp
addq %r12, %rbp
lea... | /CodeGen/MachineScheduler.cpp |
(anonymous namespace)::MachineSchedulerBase::scheduleRegions(llvm::ScheduleDAGInstrs&, bool) | void MachineSchedulerBase::scheduleRegions(ScheduleDAGInstrs &Scheduler,
bool FixKillFlags) {
// Visit all machine basic blocks.
//
// TODO: Visit blocks in global postorder or postorder within the bottom-up
// loop tree. Then we can optionally compute global RegPressu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movl %edx, 0x3c(%rsp)
movq %rsi, %r12
movq %rdi, 0x48(%rsp)
movq 0x8(%rdi), %rax
movq 0x148(%rax), %r15
addq $0x140, %rax # imm = 0x140
movq %rax, 0x40(%rsp)
cmpq %rax, %r15
je 0x1d8b3d7
leaq 0x68(%rs... | /CodeGen/MachineScheduler.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*>>, llvm::MachineBasicBlock*, llvm::SSAUpdate... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x1d9d4d3
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::GenericUniformityAnalysisImpl<llvm::GenericSSAContext<llvm::MachineFunction>>::pushUsers(llvm::MachineInstr const&) | void llvm::GenericUniformityAnalysisImpl<MachineSSAContext>::pushUsers(
const MachineInstr &Instr) {
assert(!isAlwaysUniform(Instr));
if (Instr.isTerminator())
return;
for (const MachineOperand &op : Instr.all_defs()) {
auto Reg = op.getReg();
if (isDivergent(Reg))
pushUsers(Reg);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
movl $0x9, %esi
movl $0x1, %edx
callq 0x90bd50
testb %al, %al
jne 0x1da1f48
movq 0x20(%r14), %r13
movzwl 0x28(%r14), %ecx
movzbl 0x2a(%r14), %eax
shll $0x10, %eax
orl %ecx, %eax
movl %... | /CodeGen/MachineUniformityAnalysis.cpp |
(anonymous namespace)::MachineVerifier::report(llvm::Twine const&, llvm::MachineInstr const*) | void MachineVerifier::report(const Twine &Msg, const MachineInstr *MI) {
report(Msg.str().c_str(), MI);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2b6085c
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1dadb76
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1db1f3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x... | /CodeGen/MachineVerifier.cpp |
(anonymous namespace)::MachineVerifier::addRegWithSubRegs(llvm::SmallVector<llvm::Register, 16u>&, llvm::Register) | void addRegWithSubRegs(RegVector &RV, Register Reg) {
RV.push_back(Reg);
if (Reg.isPhysical())
append_range(RV, TRI->subregs(Reg.asMCReg()));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq 0x962e12
leal -0x1(%r14), %eax
cmpl $0x3ffffffe, %eax # imm = 0x3FFFFFFE
ja 0x1db2681
movq 0x30(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rax), %rax
movl %r14d, %edx
leaq (%rd... | /CodeGen/MachineVerifier.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Register, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr const*>>, llvm::Register, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Regist... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1db3100
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movl (%rdi,%rbx), %ebx
cmpl %ebx, %esi
jne 0x1db30cb
movq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::MachineVerifier::report_context(llvm::LiveRange::Segment const&) const | void MachineVerifier::report_context(const LiveRange::Segment &S) const {
errs() << "- segment: " << S << '\n';
} | pushq %rbx
movq %rdi, %rbx
callq 0x2b7e53f
leaq 0x3192342(%rip), %rsi # 0x4f46c12
movl $0xf, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1ce1d48
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1db48ff
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0xa, (%rcx)
popq %rbx
retq
movq %r... | /CodeGen/MachineVerifier.cpp |
llvm::ModuloSchedule::print(llvm::raw_ostream&) | void ModuloSchedule::print(raw_ostream &OS) {
for (MachineInstr *MI : ScheduledInstrs)
OS << "[stage " << getStage(MI) << " @" << getCycle(MI) << "c] " << *MI;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x1db4c37
movq %rdi, %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %rbp
movl $0x7, %edx
movq ... | /CodeGen/ModuloSchedule.cpp |
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.