name string | code string | asm string | file string |
|---|---|---|---|
llvm::ModuloScheduleExpander::updateMemOperands(llvm::MachineInstr&, llvm::MachineInstr&, unsigned int) | void ModuloScheduleExpander::updateMemOperands(MachineInstr &NewMI,
MachineInstr &OldMI,
unsigned Num) {
if (Num == 0)
return;
// If the instruction has memory operands, then adjust the offset
// when the instruction... | testl %ecx, %ecx
je 0x1db8d59
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq 0x30(%rsi), %rcx
cmpq $0x8, %rcx
jb 0x1db8d4b
leaq 0x30(%rsi), %rax
movq %rcx, %r8
andq $0x7, %r8
je 0x1db8bb2
cmpl $0x3, %r8d
setne %r8b
andq $-0x8, %rcx
sete %r9b
orb %r8b, %r9b
jne 0x... | /CodeGen/ModuloSchedule.cpp |
void llvm::yaml::IO::processKey<llvm::MachineJumpTableInfo::JTEntryKind, llvm::yaml::EmptyContext>(char const*, llvm::MachineJumpTableInfo::JTEntryKind&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0x1dcef1b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1dcef24
movq (%rbx),... | /llvm/Support/YAMLTraits.h |
llvm::PrintMIRPass::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&) | PreservedAnalyses PrintMIRPass::run(MachineFunction &MF,
MachineFunctionAnalysisManager &) {
printMIR(OS, MF);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdx, %rsi
callq 0x1dc63ef
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
m... | /CodeGen/MIRPrintingPass.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, unsigned int, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, unsigned int>>, llvm::MachineInstr*, unsigned int, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, unsigned int>>::destroyAll() | unsigned getNumBuckets() const {
return NumBuckets;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rdi), %r12d
testq %r12, %r12
je 0x1dda25b
leaq 0x10(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x8(%rsp), %r14
movq $-0x1, (%r14)
movq (%rdi), %r15
shlq $0x4, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d1d97c
testb %al, %al
jne 0x1dda251
movq %r15, %rdi... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<unsigned int, llvm::Register>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::Register>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::Register>, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SmallVector<llvm::MachineInstr*, 4u>>>, llvm::MachineBasicBlock*, llvm::SmallVector<llvm::M... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x1de285c
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %r11d
imulq $0x38, %r11,... | /llvm/ADT/DenseMap.h |
bool llvm::any_of<llvm::SmallVector<llvm::MachineMemOperand const*, 2u>&, llvm::RAGreedy::computeStats(llvm::MachineBasicBlock&)::$_0>(llvm::SmallVector<llvm::MachineMemOperand const*, 2u>&, llvm::RAGreedy::computeStats(llvm::MachineBasicBlock&)::$_0) | iterator end() { return begin() + size(); } | movq (%rdi), %rdx
movl 0x8(%rdi), %ecx
leaq (%rdx,%rcx,8), %rax
cmpq $0x4, %rcx
jae 0x1e0c18d
movq %rax, %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x1e0c283
cmpq $0x2, %rdi
je 0x1e0c154
movq %rax, %rcx
cmpq $0x3, %rdi
jne 0x1e0c2c8
movq (%rdx), %rcx
movq (%rcx), %rcx
movq %rcx, %rdi
shlq $0x3d, %rdi
sarq ... | /llvm/ADT/SmallVector.h |
void llvm::SmallVectorImpl<std::pair<llvm::LiveInterval const*, llvm::MCRegister>>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x1e0f5b4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x1e0f5a9
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x1e0f575
leaq 0x10(%r14), %rsi
movl $0x10, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2b4ed86
movl 0x8(%r14), %eax
cmpq %rbx, %rax
je 0x1e0f5a9
movq... | /llvm/ADT/SmallVector.h |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::RenameIndependentSubregs, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rax
movl $0x50, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3b2fcce(%rip), %rdx # 0x5957195
movq %rdx, 0x10(%rax)
movl $0x2, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
leaq 0x3a68774(%rip), %rdx # 0x588fc58
movq %rdx, (%rax)
movups %xmm0, 0x38(%rax)
movq ... | /llvm/PassSupport.h |
runImpl(llvm::TargetLibraryInfo const&, llvm::Function&) | static bool runImpl(const TargetLibraryInfo &TLI, Function &F) {
SmallVector<Instruction *> ReplacedCalls;
for (auto &I : instructions(F)) {
// Process only intrinsic calls that return void or a vector.
if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
if (!II->getType()->isVectorTy() && !II->getType()->i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %rsi, %rbx
movq %rdi, 0x28(%rsp)
leaq 0x140(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%rax)
movq 0x50(%rsi), %r15
addq $0x48, %rbx
cmpq %rbx, %r1... | /CodeGen/ReplaceWithVeclib.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::PartialMapping const, std::default_delete<llvm::RegisterBankInfo::PartialMapping const>>, llvm::DenseMapInfo<llvm::hash_code, void>, llvm::detail::DenseMapPair<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::PartialMappi... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1e2b2f2
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1e2b3b8
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1e2b3c2
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::ValueMapping [], std::default_delete<llvm::RegisterBankInfo::ValueMapping []>>, llvm::DenseMapInfo<llvm::hash_code, void>, llvm::detail::DenseMapPair<llvm::hash_code, std::unique_ptr<llvm::RegisterBankInfo::ValueMapping [], std::default_delete<llvm... | 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 |
void llvm::SmallVectorImpl<llvm::RegisterBankInfo::InstructionMapping const*>::append<llvm::RegisterBankInfo::InstructionMapping const**, void>(llvm::RegisterBankInfo::InstructionMapping const**, llvm::RegisterBankInfo::InstructionMapping const**) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x1e2c472
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::SafeStack::IsSafeStackAlloca(llvm::Value const*, unsigned long) | bool SafeStack::IsSafeStackAlloca(const Value *AllocaPtr, uint64_t AllocaSize) {
// Go through all uses of this alloca and check whether all accesses to the
// allocated object are statically known to be memory safe and, hence, the
// object can be placed on the safe stack.
SmallPtrSet<const Value *, 16> Visite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, 0x18(%rsp)
movq %rsi, %rbp
movq %rdi, 0x10(%rsp)
leaq 0xa8(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x10, -0x10(%rax)
movl $0x0, -0x8(%rax)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x1... | /CodeGen/SafeStack.cpp |
llvm::SUnit::ComputeDepth() | void SUnit::ComputeDepth() {
SmallVector<SUnit*, 8> WorkList;
WorkList.push_back(this);
do {
SUnit *Cur = WorkList.back();
bool Done = true;
unsigned MaxPredDepth = 0;
for (const SDep &PredDep : Cur->Preds) {
SUnit *PredSU = PredDep.getSUnit();
if (PredSU->isDepthCurrent)
MaxP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rsi
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xad3f70
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movq -0... | /CodeGen/ScheduleDAG.cpp |
llvm::ScheduleDAGInstrs::initSUnits() | void ScheduleDAGInstrs::initSUnits() {
// We'll be allocating one SUnit for each real instruction in the region,
// which is contained within a basic block.
SUnits.reserve(NumRegionInstrs);
for (MachineInstr &MI : make_range(RegionBegin, RegionEnd)) {
if (MI.isDebugOrPseudoInstr())
continue;
SUn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
movl 0x390(%rbx), %esi
movq %rdi, 0x20(%rsp)
callq 0x1839eb6
movq 0x380(%rbx), %r15
movq 0x388(%rbx), %r12
cmpq %r12, %r15
je 0x1e35d64
leaq 0x398(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x258(%rbx), %rax
... | /CodeGen/ScheduleDAGInstrs.cpp |
llvm::UnderlyingObject& llvm::SmallVectorImpl<llvm::UnderlyingObject>::emplace_back<llvm::PseudoSourceValue const*&, bool&>(llvm::PseudoSourceValue const*&, bool&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x1e38e28
movq (%rbx), %rcx
movq (%rsi), %rsi
movzbl (%rdx), %edx
andq $-0x7, %rsi
leaq (%rsi,%rdx,2), %rdx
addq $0x4, %rdx
movq %rdx, (%rcx,%rax,8)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
movl %eax, %eax
leaq (%rcx,%... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::ShadowStackGCLoweringImpl::doInitialization(llvm::Module&) | bool ShadowStackGCLoweringImpl::doInitialization(Module &M) {
bool Active = false;
for (Function &F : M) {
if (F.hasGC() && F.getGC() == "shadow-stack") {
Active = true;
break;
}
}
if (!Active)
return false;
// struct FrameMap {
// int32_t NumRoots; // Number of roots in stack fra... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rsi), %r13
movq 0x20(%rsi), %rbp
xorl %ebx, %ebx
cmpq %r13, %rbp
je 0x1e3ffd2
leaq 0x2ca4c12(%rip), %r12 # 0x4ae4ba8
leaq -0x38(%rbp), %rdi
testq %rbp, %rbp
cmoveq %rbp, %rdi
testb $0x40, 0x3(... | /CodeGen/ShadowStackGCLowering.cpp |
llvm::iterator_range<llvm::idf_iterator<llvm::BasicBlock*, llvm::df_iterator_default_set<llvm::GraphTraits<llvm::BasicBlock*>::NodeRef, 8u>, false>> llvm::inverse_depth_first<llvm::BasicBlock*>(llvm::BasicBlock* const&) | iterator_range<idf_iterator<T>> inverse_depth_first(const T& G) {
return make_range(idf_begin(G), idf_end(G));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1e46250
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1e462cc
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1e46146
movq 0x60(%r12), %rdi
testq %rdi, %rdi
j... | /llvm/ADT/DepthFirstIterator.h |
llvm::df_iterator<llvm::Inverse<llvm::BasicBlock*>, llvm::df_iterator_default_set<llvm::BasicBlock*, 8u>, false, llvm::GraphTraits<llvm::Inverse<llvm::BasicBlock*>>>::toNext() | inline void toNext() {
do {
NodeRef Node = VisitStack.back().first;
std::optional<ChildItTy> &Opt = VisitStack.back().second;
if (!Opt)
Opt.emplace(GT::child_begin(Node));
// Notice that we directly mutate *Opt here, so that
// VisitStack.back().second actually gets updated a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq %rsp, %r15
movq 0x68(%rbx), %r13
cmpb $0x0, -0x8(%r13)
jne 0x1e46795
movq -0x18(%r13), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1e4678c
movq 0x18(%rax), %rcx
movb (%rcx), %cl
cmpb $0x1d,... | /llvm/ADT/DepthFirstIterator.h |
llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::StackColoring::BlockLifetimeInfo>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::StackColoring::BlockLifetimeInfo, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMap... | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x1e53733
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x1e53735
incl 0... | /llvm/ADT/DenseMap.h |
llvm::SSPLayoutInfo::copyToMachineFrameInfo(llvm::MachineFrameInfo&) const | [[nodiscard]] bool empty() const { return getNumEntries() == 0; } | cmpl $0x0, 0x8(%rdi)
je 0x1e58a0c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %ebp # imm = 0xCCCCCCCD
subl 0x20(%rsi), %ebp
je 0x1e58a02
movq %rdi, %r14
xorl %r15d, %r15d
movl 0x20(%rbx), %ecx
addl %r15d, %ecx... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::BitVector>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x1e5cf09
movq %rsi, %rbx
movq %rdi, %r14
jbe 0x1e5ce96
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e5cf12
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x1e5ceaa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e5cf76
movl 0x8(%... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<std::pair<llvm::MachineBasicBlock const*, llvm::Value const*>, llvm::Register, llvm::DenseMapInfo<std::pair<llvm::MachineBasicBlock const*, llvm::Value const*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MachineBasicBlock const*, llvm::Value const*>, llvm::Register>>::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 0x1e5f93a
decl %ecx
je 0x1e5f93e
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x1e5f943
xorl %ebp, %ebp
jmp 0x1e5f959
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %edx
shll %cl, %edx
cmpl $0x41, %edx
mov... | /llvm/ADT/DenseMap.h |
llvm::TargetLoweringBase::emitTrailingFence(llvm::IRBuilderBase&, llvm::Instruction*, llvm::AtomicOrdering) const | inline bool isAtLeastOrStrongerThan(AtomicOrdering AO, AtomicOrdering Other) {
static const bool lookup[8][8] = {
// NA UN RX CO AC RE AR SC
/* NotAtomic */ { true, false, false, false, false, false, false, false},
/* Unordered */ { true, true, false, false... | movl %ecx, %eax
leaq 0x158bd09(%rip), %rdx # 0x33fbd50
cmpb $0x1, 0x4(%rdx,%rax,8)
jne 0x1e70072
subq $0x28, %rsp
movq %rsp, %rax
movw $0x101, 0x20(%rax) # imm = 0x101
movq %rsi, %rdi
movl %ecx, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0xc96694
addq $0x28, %rsp
retq
xorl %eax, %eax
retq
nop
| /llvm/Support/AtomicOrdering.h |
llvm::SmallVectorTemplateBase<llvm::cl::parser<llvm::RunOutliner>::OptionInfo, 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 $0x30, %ecx
movq %r14, %rsi
callq 0x2b4ec3c
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x1e7c615
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
xorl ... | /llvm/ADT/SmallVector.h |
llvm::VirtRegMap::print(llvm::raw_ostream&, llvm::Module const*) const | void VirtRegMap::print(raw_ostream &OS, const Module*) const {
OS << "********** REGISTER MAP **********\n";
for (unsigned i = 0, e = MRI->getNumVirtRegs(); i != e; ++i) {
Register Reg = Register::index2VirtReg(i);
if (Virt2PhysMap[Reg] != (unsigned)VirtRegMap::NO_PHYS_REG) {
OS << '[' << printReg(Reg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x30c12f5(%rip), %rsi # 0x4f4db46
movl $0x23, %edx
movq %rbp, %rdi
callq 0x7f9ba8
movq 0x38(%r14), %rax
movl 0x40(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
movq %rbp, 0x10(%rsp)
je 0x1e8c9d2... | /CodeGen/VirtRegMap.cpp |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [16], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(char const (&) [16], 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 0x38b8316(%rip), %rax # 0x57479c8
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::WindowScheduler::getIssueOrder(unsigned int, unsigned int) | DenseMap<MachineInstr *, int> WindowScheduler::getIssueOrder(unsigned Offset,
unsigned II) {
// At each issue cycle, phi is placed before MIs in stage 0. So the simplest
// way is to put phi at the beginning of the current cycle.
DenseMap<int, SmallVect... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x1c(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x1914(%rsi), %eax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
callq 0x1e8fa0a
movq %rax, %r15
movq %rdx, 0x... | /CodeGen/WindowScheduler.cpp |
llvm::WindowScheduler::updateScheduleResult(unsigned int, unsigned int) | void WindowScheduler::updateScheduleResult(unsigned Offset, unsigned II) {
// At the first update, Offset is equal to SchedPhiNum. At this time, only
// BestII, BestOffset, and BaseII need to be updated.
if (Offset == SchedPhiNum) {
BestII = II;
BestOffset = SchedPhiNum;
BaseII = II;
return;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ecx
movq %rdi, %rbx
movl 0x1910(%rdi), %eax
movl %esi, 0xc(%rsp)
cmpl %esi, %eax
jne 0x1e9140c
movl %ecx, 0x1918(%rbx)
movl %eax, 0x191c(%rbx)
movl %ecx, 0x1920(%rbx)
jmp 0x1e91547
cmpl %ecx, 0x1918(%rbx)
jbe 0x1e91547
movl 0... | /CodeGen/WindowScheduler.cpp |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [16], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [16], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7802c0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<int, llvm::SmallVector<llvm::MachineInstr*, 6u>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, llvm::SmallVector<llvm::MachineInstr*, 6u>>>, int, llvm::SmallVector<llvm::MachineInstr*, 6u>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, llvm::SmallVecto... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1e91cc6
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1e91cbc
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1e91d4c
movl (%rbx), %ecx
movl %ecx, (%rax)
leaq 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BasicBlock*, llvm::TinyPtrVector<llvm::BasicBlock*>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::TinyPtrVector<llvm::BasicBlock*>>>::operator=(llvm::DenseMap<llvm::BasicBlock*, llvm::TinyPtrVector<llvm::BasicBlock*>, llvm::DenseMapInfo<llvm::Basi... | DenseMap& operator=(DenseMap &&other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
init(0);
swap(other);
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1365d42
movq (%rbx), %rdi
movl 0x10(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
xorl %eax, %eax
movl %eax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%r14), %rcx
movq %rcx, (%rbx)
movq $0x0, (%r14)
movl 0x8(%r14), %ec... | /llvm/ADT/DenseMap.h |
llvm::iterator_range<llvm::CoalescingBitVector<unsigned long>::const_iterator>::iterator_range(llvm::CoalescingBitVector<unsigned long>::const_iterator, llvm::CoalescingBitVector<unsigned long>::const_iterator) | iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
: begin_iterator(std::move(begin_iterator)),
end_iterator(std::move(end_iterator)) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movabsq $0x400000000, %r12 # imm = 0x400000000
movq %r12, 0x10(%rdi)
cmpl $0x0, 0x10(%rsi)
je 0x1ea5666
leaq 0x8(%r14), %rdi
leaq 0x8... | /llvm/ADT/iterator_range.h |
llvm::SmallVectorTemplateBase<(anonymous namespace)::VarLocBasedLDV::TransferDebugPair, true>::push_back((anonymous namespace)::VarLocBasedLDV::TransferDebugPair) | 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 0x1ea615c
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 |
LiveDebugValues::InstrRefBasedLDV::makeDepthFirstEjectionMap(llvm::SmallVectorImpl<unsigned int>&, llvm::DenseMap<llvm::LexicalScope const*, llvm::DILocation const*, llvm::DenseMapInfo<llvm::LexicalScope const*, void>, llvm::detail::DenseMapPair<llvm::LexicalScope const*, llvm::DILocation const*>> const&, llvm::DenseMa... | void InstrRefBasedLDV::makeDepthFirstEjectionMap(
SmallVectorImpl<unsigned> &EjectionMap,
const ScopeToDILocT &ScopeToDILocation,
ScopeToAssignBlocksT &ScopeToAssignBlocks) {
SmallPtrSet<const MachineBasicBlock *, 8> BlocksToExplore;
SmallVector<std::pair<LexicalScope *, ssize_t>, 4> WorkStack;
auto *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
leaq 0x88(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x8, -0x10(%rax)
movl $0x0, -0x8(%rax)
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
mova... | /CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned short, unsigned short>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned short, unsigned short>, void>, llvm::detail::DenseMapPair<std::pair<unsigned short, unsigned short>, unsigned int>>, std::pair<unsigned short, unsigned short>, unsigned int, llvm::DenseMapInf... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1eb7f5c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1eb7f51
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1eb803a
movl (%rbx), %ecx
movl %ecx, (%rax)
movl $... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<std::pair<llvm::MachineInstr*, unsigned int>, std::optional<LiveDebugValues::ValueIDNum>, llvm::DenseMapInfo<std::pair<llvm::MachineInstr*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MachineInstr*, unsigned int>, std::optional<LiveDebugValues::ValueIDNum>>, false>,... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x1ec2d8e
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x1ec2ea8
xorl %ecx, %ecx
jmp 0x1ec2ed2
movq %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, unsigned int, llvm::DenseMapInfo<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, void>, llvm::detail::DenseMapPair<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, unsigned int>>, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, unsigne... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1d1efe6
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1ede13f
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1d1f078
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $... | /llvm/ADT/DenseMap.h |
llvm::InterferenceCache::reinitPhysRegEntries() | void InterferenceCache::reinitPhysRegEntries() {
if (PhysRegEntriesCount == TRI->getNumRegs()) return;
free(PhysRegEntries);
PhysRegEntriesCount = TRI->getNumRegs();
PhysRegEntries = static_cast<unsigned char*>(
safe_calloc(PhysRegEntriesCount, sizeof(unsigned char)));
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movl 0x10(%rax), %eax
cmpq %rax, 0x20(%rdi)
je 0x1ede7b5
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x780910
movq (%rbx), %rax
movl 0x10(%rax), %r14d
movq %r14, 0x20(%rbx)
movl $0x1, %esi
movq %r14, %rdi
callq 0x780de0
testq %rax, %rax
jne 0x1ede7b1
testl %r14d, %r14d... | /CodeGen/InterferenceCache.cpp |
llvm::SmallVectorTemplateBase<llvm::InterferenceCache::Entry::RegUnitInfo, false>::push_back(llvm::InterferenceCache::Entry::RegUnitInfo&&) | void push_back(T &&Elt) {
T *EltPtr = reserveForParamAndGetAddress(Elt);
::new ((void *)this->end()) T(::std::move(*EltPtr));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x1edf3d4
movq %rax, %r14
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
imulq $0x70, %rcx, %rcx
leaq (%rax,%rcx), %r15
movq (%r14), %rdx
leaq (%rax,%rcx), %rsi
addq $0x18, %rsi
movq %rdx, -0x18(%rsi)
movq %rsi, -0x10(%rsi)
movabsq $0x400000000, %rdx #... | /llvm/ADT/SmallVector.h |
llvm::LiveIntervalUnion::Query::collectInterferingVRegs(unsigned int) | unsigned
LiveIntervalUnion::Query::collectInterferingVRegs(unsigned MaxInterferingRegs) {
// Fast path return if we already have the desired information.
if (SeenAllInterferences || InterferingVRegs.size() >= MaxInterferingRegs)
return InterferingVRegs.size();
// Set up iterators on the first call.
if (!Ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xa1(%rdi)
jne 0x1ee049c
movl %esi, %ebp
cmpl %esi, 0x78(%rbx)
jae 0x1ee049c
cmpb $0x0, 0xa0(%rbx)
jne 0x1ee029a
movb $0x1, 0xa0(%rbx)
movq 0x8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x1ee04ae
movq (%rbx), %rcx
cm... | /CodeGen/LiveIntervalUnion.cpp |
llvm::IntervalMap<llvm::SlotIndex, llvm::LiveInterval const*, 8u, llvm::IntervalMapInfo<llvm::SlotIndex>>::iterator::insertNode(unsigned int, llvm::IntervalMapImpl::NodeRef, llvm::SlotIndex) | bool IntervalMap<KeyT, ValT, N, Traits>::
iterator::insertNode(unsigned Level, IntervalMapImpl::NodeRef Node, KeyT Stop) {
assert(Level && "Cannot insert next to the root");
bool SplitRoot = false;
IntervalMap &IM = *this->map;
IntervalMapImpl::Path &P = this->path;
if (Level == 1) {
// Insert into the r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
cmpl $0x1, %esi
sete %bpl
jne 0x1ee1344
movq (%r15), %r13
movl 0xc4(%r13), %edi
cmpl $0xa, %edi
ja 0x1ee1311
movq (%rbx), %rax
movl 0xc(%rax), %eax
cmpl %eax, %edi
je 0x1ee1... | /llvm/ADT/IntervalMap.h |
llvm::LiveRangeEdit::eliminateDeadDefs(llvm::SmallVectorImpl<llvm::MachineInstr*>&, llvm::ArrayRef<llvm::Register>) | void LiveRangeEdit::eliminateDeadDefs(SmallVectorImpl<MachineInstr *> &Dead,
ArrayRef<Register> RegsBeingSpilled) {
ToShrinkSet ToShrink;
for (;;) {
// Erase all dead defs.
while (!Dead.empty())
eliminateDeadDef(Dead.pop_back_val(), ToShrink);
if (ToShrink.e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0xa8(%rsp), %rax
movaps %xmm0, -0x28(%rax)
movl $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rdx # imm = 0x800000000
movq %rdx, -0x8(%rax)
le... | /CodeGen/LiveRangeEdit.cpp |
llvm::DenseMap<llvm::LiveInterval*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::LiveInterval*, void>, llvm::detail::DenseSetPair<llvm::LiveInterval*>>::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::GenericConvergenceVerifier<llvm::GenericSSAContext<llvm::MachineFunction>>::findAndCheckConvergenceTokenUsed(llvm::MachineInstr const&) | const MachineInstr *
GenericConvergenceVerifier<MachineSSAContext>::findAndCheckConvergenceTokenUsed(
const MachineInstr &MI) {
const MachineRegisterInfo &MRI = Context.getFunction()->getRegInfo();
const MachineInstr *TokenDef = nullptr;
for (const MachineOperand &MO : MI.operands()) {
if (!MO.isReg() ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movzwl 0x28(%rsi), %eax
movzbl 0x2a(%rsi), %ebx
shll $0x10, %ebx
orl %eax, %ebx
testl %ebx, %ebx
sete %r13b
movq %rdi, 0x8(%rsp)
je 0x1ee4a5c
leaq 0x80(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rdi), %rax
movq 0x28(%ra... | /CodeGen/MachineConvergenceVerifier.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>> const*, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>> const*, void>, llvm::detail::DenseMapPair<llvm::GenericCycle<llvm::GenericSSAContext<llvm::Machine... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1ee57c2
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1ee5898
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1ee58a2
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
setDescendantEHBlocksCold(llvm::MachineFunction&) | static void setDescendantEHBlocksCold(MachineFunction &MF) {
DenseSet<MachineBasicBlock *> EHBlocks;
computeEHOnlyBlocks(MF, EHBlocks);
for (auto Block : EHBlocks) {
Block->setSectionID(MBBSectionID::ColdSectionID);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rcx
xorl %eax, %eax
movl %eax, 0x80(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movl %eax, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
leaq 0x30(%rsp), %rdi
movl %eax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq %rcx, 0x18(%rsp)
movq ... | /CodeGen/MachineFunctionSplitter.cpp |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::StripDebugMachineModule, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rax
movl $0x20, %edi
callq 0x7808d0
movb 0x3a6ef13(%rip), %cl # 0x595e598
movq $0x0, 0x8(%rax)
leaq 0x3a6ef48(%rip), %rdx # 0x595e5dc
movq %rdx, 0x10(%rax)
movl $0x4, 0x18(%rax)
leaq 0x39a48b2(%rip), %rdx # 0x5893f58
movq %rdx, (%rax)
movb %cl, 0x1c(%rax)
popq %rcx
retq
| /llvm/PassSupport.h |
llvm::DenseMap<std::tuple<llvm::StringRef, unsigned int, unsigned int, unsigned long>, unsigned int, llvm::DenseMapInfo<std::tuple<llvm::StringRef, unsigned int, unsigned int, unsigned long>, void>, llvm::detail::DenseMapPair<std::tuple<llvm::StringRef, unsigned int, unsigned int, unsigned long>, unsigned int>>::grow(u... | 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, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::IRPosition, true>::push_back(llvm::IRPosition) | 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 0x1f30d08
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 |
bool llvm::Attributor::shouldInitialize<llvm::AANoAlias>(llvm::IRPosition const&, bool&) | bool shouldInitialize(const IRPosition &IRP, bool &ShouldUpdateAA) {
if (!AAType::isValidIRPositionForInit(*this, IRP))
return false;
if (Configuration.Allowed && !Configuration.Allowed->count(&AAType::ID))
return false;
// For now we skip anything in naked and optnone functions.
const Fun... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xc02338
movl $0xfe, %ecx
andl 0x8(%rax), %ecx
cmpl $0x12, %ecx
jne 0x1f4a4e8
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpb $0xf, 0x8(%rax)
jne 0x1f4a55b
movq 0x1090(%r15), %rdi
testq %rdi, ... | /llvm/Transforms/IPO/Attributor.h |
llvm::AAGlobalValueInfo* llvm::Attributor::lookupAAFor<llvm::AAGlobalValueInfo>(llvm::IRPosition const&, llvm::AbstractAttribute const*, llvm::DepClassTy, bool) | AAType *lookupAAFor(const IRPosition &IRP,
const AbstractAttribute *QueryingAA = nullptr,
DepClassTy DepClass = DepClassTy::OPTIONAL,
bool AllowInvalidState = false) {
static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
addq $0x68, %rdi
leaq 0x2fd0bf1(%rip), %rcx # 0x4f52c0c
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0xb... | /llvm/Transforms/IPO/Attributor.h |
(anonymous namespace)::AAUndefinedBehaviorImpl::getAsStr[abi:cxx11](llvm::Attributor*) const | const std::string getAsStr(Attributor *A) const override {
return getAssumed() ? "undefined-behavior" : "no-ub";
} | pushq %rbx
movb 0x59(%rsi), %al
testb %al, %al
leaq 0x2fcc770(%rip), %rcx # 0x4f52adf
leaq 0x2fcc77c(%rip), %rsi # 0x4f52af2
cmovneq %rcx, %rsi
movq %rdi, %rbx
leaq 0x12(%rsi), %rcx
leaq 0x5(%rsi), %rdx
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
callq 0x7fa87c
movq %rbx, %rax
popq %rb... | /Transforms/IPO/AttributorAttributes.cpp |
llvm::DenseMap<llvm::Value*, llvm::Value*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Value*>>::copyFrom(llvm::DenseMap<llvm::Value*, llvm::Value*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Value*>> const&) | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
testq %r15, %r15
je 0x1fc7d37
movq %r15, %rdi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
jmp 0x1fc7d39
xorl %eax, %e... | /llvm/ADT/DenseMap.h |
llvm::OpenMPIRBuilder::getOrCreateThreadID(llvm::Value*) | Value *OpenMPIRBuilder::getOrCreateThreadID(Value *Ident) {
return Builder.CreateCall(
getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_global_thread_num), Ident,
"omp_global_thread_num");
} | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq 0x1b0(%rdi), %rsi
movl $0x5, %edx
callq 0x20abee6
xorl %esi, %esi
cmpb $0x0, (%rdx)
cmovneq %rsi, %rdx
testq %rdx, %rdx
je 0x20b21a4
movq 0x18(%rdx), %rsi
addq $0x1b8, %rbx # imm = 0x1B8
leaq 0x2eaa390(%rip), %rax # 0x4f5c542
leaq 0x18(... | /Frontend/OpenMP/OMPIRBuilder.cpp |
(anonymous namespace)::LoopPredication::isLoopInvariantValue(llvm::SCEV const*) | bool LoopPredication::isLoopInvariantValue(const SCEV* S) {
// Handling expressions which produce invariant results, but *haven't* yet
// been removed from the loop serves two important purposes.
// 1) Most importantly, it resolves a pass ordering cycle which would
// otherwise need us to iteration licm, loop-p... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rdx
callq 0x26960d2
testb %al, %al
je 0x221d023
movb $0x1, %al
jmp 0x221d0a5
xorl %eax, %eax
testq %r14, %r14
je 0x221d0a5
cmpw $0xf, 0x18(%r14)
jne 0x221d0a5
movq -0x8(%r14), %r14
cmpb $0x3d, (%r14)
jne 0x221... | /Transforms/Scalar/LoopPredication.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::RegionNode*, llvm::SmallDenseSet<llvm::RegionNode*, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>>*>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::RegionNode*, llvm::SmallDenseSet<llvm::RegionNode*, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>>*>, void>, llvm::... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x22c7746
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::MapVector<llvm::PHINode*, llvm::SmallVector<std::pair<llvm::BasicBlock*, llvm::Value*>, 2u>, llvm::DenseMap<llvm::PHINode*, unsigned int, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, unsigned int>>, llvm::SmallVector<std::pair<llvm::PHINode*, llvm::SmallVector<std::pair<llv... | ValueT &operator[](const KeyT &Key) {
std::pair<KeyT, typename MapType::mapped_type> Pair = std::make_pair(Key, 0);
std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
auto &I = Result.first->second;
if (Result.second) {
Vector.push_back(std::make_pair(Key, ValueT()));
I =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x40(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22ca624
movq (%r15), %r12
cmpb $0x1, 0x10(%r15)
jne 0x22c9c... | /llvm/ADT/MapVector.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specific_intval64<false>, 26u, false>, llvm::PatternMatch::deferredval_ty<llvm::Value>, 13u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2a, (%rsi)
jne 0x22d3a65
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq -0x40(%rsi), %rsi
callq 0x22d3a76
testb %al, %al
je 0x22d3a45
movq 0x10(%r14), %rax
movq (%rax), %rax
cmpq -0x20(%rbx), %rax
je 0x22d3a6c
movq -0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x22d3a76
testb %al, %al
je 0x22d3... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specific_intval<false>, 28u, false>, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::deferredval_ty<llvm::Value>, llvm::PatternMatch::specifi... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x2a, (%rsi)
jne 0x22d3b00
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rsi
callq 0x22d3b0a
testb %al, %al
je 0x22d3ad9
leaq 0x10(%rbx), %rdi
movq -0x20(%r14), %rsi
callq 0x22d3b3c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x22d3b02
movq -0x20(%r14), %rsi
movq %rbx, ... | /llvm/IR/PatternMatch.h |
llvm::MapVector<llvm::Instruction*, llvm::TruncInstCombine::Info, llvm::DenseMap<llvm::Instruction*, unsigned int, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned int>>, llvm::SmallVector<std::pair<llvm::Instruction*, llvm::TruncInstCombine::Info>, 0u>>::erase(std::... | typename VectorType::iterator erase(typename VectorType::iterator Iterator) {
Map.erase(Iterator->first);
auto Next = Vector.erase(Iterator);
if (Next == Vector.end())
return Next;
// Update indices in the map.
size_t Index = Next - Vector.begin();
for (auto &I : Map) {
assert(I.sec... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x22d67a0
movl 0x20(%r14), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%r14), %rax
subq %rbx, %rax
addq $-0x18, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
testq %rax, %rax
jle 0x22d66e1
mulq %rcx
shrq $0x4, %rdx
i... | /llvm/ADT/MapVector.h |
llvm::InstCombinerImpl::foldBinOpShiftWithShift(llvm::BinaryOperator&) | Instruction *InstCombinerImpl::foldBinOpShiftWithShift(BinaryOperator &I) {
const DataLayout &DL = I.getDataLayout();
auto IsValidBinOpc = [](unsigned Opc) {
switch (Opc) {
default:
return false;
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
case Instruction::Add:... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2a5128a
leaq 0x6(%rsp), %rcx
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x5(%rsp), %rsi
movq %rsi, 0x8(%rdx)
movq %rax, 0x10(%rdx)
leaq 0x20(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x7(%rsp), %r8
movq %r8, 0x8(%rdi)
movq %r14, 0x... | /Transforms/InstCombine/InstructionCombining.cpp |
llvm::InstCombinerImpl::FoldOpIntoSelect(llvm::Instruction&, llvm::SelectInst*, bool) | Instruction *InstCombinerImpl::FoldOpIntoSelect(Instruction &Op, SelectInst *SI,
bool FoldWithMultiUse) {
// Don't modify shared select instructions unless set FoldWithMultiUse
if (!SI->hasOneUse() && !FoldWithMultiUse)
return nullptr;
Value *TV = SI->getTrueVa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x22da6a4
cmpq $0x0, 0x8(%rax)
sete %al
jmp 0x22da6a6
xorl %eax, %eax
orb %cl, %al
cmpb $0x1, %al
jne 0x22da6e8
movq -0x40(%rbx), %r13
movq -0x20(%... | /Transforms/InstCombine/InstructionCombining.cpp |
llvm::InstCombinerImpl::foldBinOpIntoSelectOrPhi(llvm::BinaryOperator&) | Instruction *InstCombinerImpl::foldBinOpIntoSelectOrPhi(BinaryOperator &I) {
if (!isa<Constant>(I.getOperand(1)))
return nullptr;
if (auto *Sel = dyn_cast<SelectInst>(I.getOperand(0))) {
if (Instruction *NewSel = FoldOpIntoSelect(I, Sel))
return NewSel;
} else if (auto *PN = dyn_cast<PHINode>(I.get... | pushq %rax
movq -0x20(%rsi), %rax
cmpb $0x15, (%rax)
ja 0x22db6fe
movq -0x40(%rsi), %rdx
movzbl (%rdx), %eax
cmpl $0x54, %eax
je 0x22db6eb
cmpl $0x56, %eax
jne 0x22db6f8
xorl %ecx, %ecx
callq 0x22da67a
testq %rax, %rax
jne 0x22db700
jmp 0x22db6fe
callq 0x22da97c
testq %rax, %rax
sete %cl
jmp 0x22db6fa
movb $0x1, %cl
te... | /Transforms/InstCombine/InstructionCombining.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specific_intval64<false>, 26u, false>, llvm::PatternMatch::match_combine_or<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specificval_ty>, 17u, true>::match<llvm::Value>(llvm::Val... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2e, (%rsi)
jne 0x22f6637
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rax
cmpb $0x37, (%rax)
jne 0x22f65fe
movq (%rbx), %rcx
cmpq -0x40(%rax), %rcx
jne 0x22f65fe
leaq 0x8(%rbx), %rdi
movq -0x20(%rax), %rsi
callq 0x933312
testb %al, %al
je 0x22f65fe
movq -0x20(%r14), %rcx
m... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_one, llvm::ConstantInt, true>, 13u, false>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2a, (%rsi)
jne 0x22f6ab5
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x22f6ab5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq %rax, (%rcx)
addq $0x8, %rdi
movq -0x20(%rsi), %r14
movq %r14, %rsi
callq 0x932b34
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jn... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specific_fpval, llvm::PatternMatch::bind_ty<llvm::Value>, 16u, false>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2d, (%rsi)
jne 0x22f70ec
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rsi
callq 0x932a56
testb %al, %al
je 0x22f70ef
movq -0x20(%r14), %rax
testq %rax, %rax
je 0x22f70ef
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x22f70f1
xorl %eax, %eax
retq
xorl %eax, %ea... | /llvm/IR/PatternMatch.h |
(anonymous namespace)::FAddendCoef::convertToFpType(llvm::fltSemantics const&) | void FAddendCoef::convertToFpType(const fltSemantics &Sem) {
if (!isInt())
return;
APFloat *P = getFpValPtr();
if (IntVal > 0)
new(P) APFloat(Sem, IntVal);
else {
new(P) APFloat(Sem, 0 - IntVal);
P->changeSign();
}
IsFp = BufHasFpVal = true;
} | cmpb $0x0, (%rdi)
jne 0x22f7ac6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movswq 0x2(%rdi), %rax
testq %rax, %rax
jle 0x22f7a9d
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x10(%rbx), %rdi
callq 0x8ba670
jmp 0x22f7aba
leaq 0x8(%rbx), %r14
negl %eax
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x10(%rbx), %rdi
callq 0x8ba67... | /Transforms/InstCombine/InstCombineAddSub.cpp |
bool llvm::PatternMatch::match_combine_or<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_combine_or<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::ZExtInst>, llvm::PatternMatch::bind_ty<llvm... | bool match(ITy *V) {
if (L.match(V))
return true;
if (R.match(V))
return true;
return false;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %bpl
cmpb $0x44, %bpl
jne 0x22f88e7
movq -0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x22f8958
cmpb $0x44, %bpl
jne 0x22f88f8
testb $0x1, %al
je 0x22f88f8
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %r14
movq %r14, %rdi
movq %rb... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_unless<llvm::PatternMatch::constantexpr_match>>, 18u, false>, llvm::PatternMatch::deferredval_... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2b, (%rsi)
jne 0x22fa2bf
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq -0x40(%rsi), %rsi
callq 0x22fa2d0
testb %al, %al
je 0x22fa29f
movq 0x18(%r14), %rax
movq (%rax), %rax
cmpq -0x20(%rbx), %rax
je 0x22fa2c6
movq -0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x22fa2d0
testb %al, %al
je 0x22fa... | /llvm/IR/PatternMatch.h |
simplifyAndOrWithOpReplaced(llvm::Value*, llvm::Value*, llvm::Value*, bool, llvm::InstCombinerImpl&, unsigned int) | static Value *simplifyAndOrWithOpReplaced(Value *V, Value *Op, Value *RepOp,
bool SimplifyOnly,
InstCombinerImpl &IC,
unsigned Depth = 0) {
if (Op == RepOp)
return nullptr;
if (V == Op)... | cmpq %rdx, %rsi
je 0x2303704
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x2303707
movb (%r14), %al
cmpb $0x1d, %al
setb %dl
movzbl %al, %eax
addl $-0x3c, %eax
cmpl $-0x12, %eax
setb %al
orb %dl, %al
je 0x2303719
x... | /Transforms/InstCombine/InstCombineAndOrXor.cpp |
foldSignedTruncationCheck(llvm::ICmpInst*, llvm::ICmpInst*, llvm::Instruction&, llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>&) | static Value *foldSignedTruncationCheck(ICmpInst *ICmp0, ICmpInst *ICmp1,
Instruction &CxtI,
InstCombiner::BuilderTy &Builder) {
assert(CxtI.getOpcode() == Instruction::And);
// Match icmp ult (add %arg, C01), C1 (C1 == C01 << 1; po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x28(%rsp), %r15
movl $0x1, 0x8(%r15)
movq $0x0, (%r15)
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x230f018
testb %al, %al
je 0x2305113
movq %r13, %r1... | /Transforms/InstCombine/InstCombineAndOrXor.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 30u, true>, 29u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x3a, (%rsi)
jne 0x230ca8b
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x230ca65
movq (%rbx), %rcx
movq %rax, (%rcx)
leaq 0x8(%rbx), %rdi
movq -0x20(%r14), %rsi
callq 0xa5cd7a
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x230ca8d
movq -0x20(%r1... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::SpecificBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::Value>, true>, 30u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x3b, (%rsi)
jne 0x230cc75
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0xa5cdfe
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x230cc21
movq %r15, (%rcx)
testb %al, %al
je 0x230cc3a
leaq 0x8(%rbx), %rdi
movq -0x20(%r... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 30u, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 27u, false>::match<llvm::BinaryOperator>(llvm::BinaryOp... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x38, (%rsi)
jne 0x23124c0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rsi
callq 0xa5cd7a
testb %al, %al
je 0x23124c3
movq -0x20(%r14), %rax
testq %rax, %rax
je 0x23124c3
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x23124c5
xorl %eax, %eax
retq
xorl %eax, %e... | /llvm/IR/PatternMatch.h |
llvm::iterator_range<llvm::filter_iterator_impl<llvm::mapped_iterator<llvm::df_iterator<llvm::VPBlockDeepTraversalWrapper<llvm::VPBlockBase*>, llvm::df_iterator_default_set<llvm::VPBlockBase*, 8u>, false, llvm::GraphTraits<llvm::VPBlockDeepTraversalWrapper<llvm::VPBlockBase*>>>, auto llvm::VPBlockUtils::blocksOnly<llvm... | iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
: begin_iterator(std::move(begin_iterator)),
end_iterator(std::move(end_iterator)) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
movl $0x8, %edx
movq %r12, %rcx
callq 0x2b4e93a
movups 0x60(%r12), %xmm0
movups %xmm0, 0x60(%r14)
movq 0x70(%r12), %rax
movq %rax, 0x70(%r14)
xorl %r13d, %r13d
movq %r13, 0x70(%r12)
xorps %xmm0, ... | /llvm/ADT/iterator_range.h |
void llvm::stable_sort<llvm::SmallVector<llvm::ValueDFS, 16u>&, llvm::ValueDFS_Compare>(llvm::SmallVector<llvm::ValueDFS, 16u>&, llvm::ValueDFS_Compare) | size_t size() const { return Size; } | movl 0x8(%rdi), %edx
testq %rdx, %rdx
je 0x250c456
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
leaq (%rdx,%rdx,2), %r14
shlq $0x4, %r14
addq %r15, %r14
incq %rdx
shrq %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x250d736
movq 0x10(%r12), %rdx
testq %rdx,... | /llvm/ADT/SmallVector.h |
llvm::PredicateInfoVerifierPass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses PredicateInfoVerifierPass::run(Function &F,
FunctionAnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F);
std::make_unique<PredicateInfo>(F, DT, AC)->verifyPredicateInfo();
ret... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x3499621(%rip), %rsi # 0x59a60e0
movq %rcx, %rdi
callq 0x2a8ddb2
leaq 0x8(%rax), %r12
leaq 0x347d5be(%rip), %rsi # 0x598a090
movq %r14, %rdi
movq %r15, %rdx
callq 0x2a8ddb2
leaq 0x8(%rax), %... | /Transforms/Utils/PredicateInfo.cpp |
(anonymous namespace)::SimplifyCFGOpt::SpeculativelyExecuteBB(llvm::BranchInst*, llvm::BasicBlock*)::$_0 llvm::for_each<llvm::SmallVector<llvm::DbgVariableRecord*, 6u>, (anonymous namespace)::SimplifyCFGOpt::SpeculativelyExecuteBB(llvm::BranchInst*, llvm::BasicBlock*)::$_0>(llvm::SmallVector<llvm::DbgVariableRecord*, 6... | Callable() = default; | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r12
movl 0x8(%rdi), %r13d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %r13, %r13
je 0x254be4a
shlq $0x3, %r13
xorl %ebp, %ebp
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq (%r12,%rbp), %r15
movq %rbx, %rdi
movq %r15,... | /llvm/ADT/STLExtras.h |
llvm::iterator_range<std::reverse_iterator<llvm::filter_iterator_impl<llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::BasicBlock>, false, false>, std::function<bool (llvm::Instruction&)>, std::bidirectional_iterator_tag>>> llvm::make_range<std::reverse_ite... | iterator_range<T> make_range(T x, T y) {
return iterator_range<T>(std::move(x), std::move(y));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movups (%rsi), %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, -0x20(%r14)
movups 0x10(%rsi), %xmm0
movaps %xmm0, -0x10(%r14)
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movaps %xmm1, 0x10(%r14)
movq 0x30(%rsi), %rax
testq %rax, %rax
je ... | /llvm/ADT/iterator_range.h |
llvm::detail::DenseMapPair<llvm::PHINode*, llvm::SmallVector<std::pair<llvm::ConstantInt*, llvm::Constant*>, 4u>>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::PHINode*, llvm::SmallVector<std::pair<llvm::ConstantInt*, llvm::Constant*>, 4u>, 4u, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x254f8ad
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x254f8e4
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::PHINode*, llvm::Type*, 4u, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, llvm::Type*>>, llvm::PHINode*, llvm::Type*, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, llvm::Type*>>::LookupBucketFo... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x254fdff
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %ebx
shlq $0x4, %rbx
lea... | /llvm/ADT/DenseMap.h |
llvm::LibCallSimplifier::optimizeStrNDup(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilderBase &B) {
Value *Src = CI->getArgOperand(0);
ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
uint64_t SrcLen = GetStringLength(Src);
if (SrcLen && Size) {
annotateDereferenceableBytes(CI, 0, SrcLen);
if (SrcLen <= Size->g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %r12
movq 0x20(%rcx), %rbp
cmpb $0x11, (%rbp)
setne %r14b
movq %r12, %rdi
movl $0x8, %esi
callq 0x26fb... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizeStringNCpy(llvm::CallInst*, bool, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeStringNCpy(CallInst *CI, bool RetEnd,
IRBuilderBase &B) {
Function *Callee = CI->getCalledFunction();
Value *Dst = CI->getArgOperand(0);
Value *Src = CI->getArgOperand(1);
Value *Size = CI->getArgOperand(2);
if (isKnownNonZero(Siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rsi, %r15
movq -0x20(%rsi), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x2558d10
cmpb $0x0, (%rax)
cmoveq %rax, %r12
testq %r12, %r12
je 0x2558d20
movq 0x18(%r12), %rax
cmpq 0x50(%r15), %... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizeFls(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizeFls(CallInst *CI, IRBuilderBase &B) {
// All variants of fls return int which need not be 32 bits wide.
// fls{,l,ll}(x) -> (int)(sizeInBits(x) - llvm.ctlz(x, false))
Value *Op = CI->getArgOperand(0);
Type *ArgType = Op->getType();
Value *V = B.CreateIntrinsic(Intrinsic::ctlz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %rax
movq 0x8(%rax), %r13
leaq 0x8(%rsp), %r15
movq %r13, (%r15)
leaq 0x38(%rsp), %r12
movq %rax, (%r12)
movq 0x48(%rdx), %... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::LibCallSimplifier::optimizePuts(llvm::CallInst*, llvm::IRBuilderBase&) | Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilderBase &B) {
annotateNonNullNoUndefBasedOnAccess(CI, 0);
if (!CI->use_empty())
return nullptr;
// Check for a constant string.
// puts("") -> putchar('\n')
StringRef Str;
if (getConstantStringInfo(CI->getArgOperand(0), Str) && Str.empty()) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %rsi
movl $0x0, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2556e73
cmpq $0x0, 0x10(%rbx)
je 0x25618e9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xm... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::FortifiedLibCallSimplifier::optimizeMemSetChk(llvm::CallInst*, llvm::IRBuilderBase&) | Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
IRBuilderBase &B) {
if (isFortifiedCallFoldable(CI, 3, 2)) {
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
xorl %r15d, %r15d
movabsq $0x100000002, %rcx # imm = 0x100000002
movl $0x3, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25629a6
testb %al, %al
je 0x2562d2d
movl 0x4(%rbx), %eax
shll $0x5, %eax
movq %rbx, %rcx
subq %rax, %rcx
movq 0x... | /Transforms/Utils/SimplifyLibCalls.cpp |
llvm::SmallVectorTemplateBase<(anonymous namespace)::POTWorklistEntry, true>::push_back((anonymous namespace)::POTWorklistEntry 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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x256aeda
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
incl 0x8(%rbx... | /llvm/ADT/SmallVector.h |
llvm::AAResults::alias(llvm::MemoryLocation const&, llvm::MemoryLocation const&, llvm::AAQueryInfo&, llvm::Instruction const*) | AliasResult AAResults::alias(const MemoryLocation &LocA,
const MemoryLocation &LocB, AAQueryInfo &AAQI,
const Instruction *CtxI) {
AliasResult Result = AliasResult::MayAlias;
if (EnableAATrace) {
for (unsigned I = 0; I < AAQI.Depth; ++I)
dbgs() <<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
incl 0x158(%rcx)
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %r13
cmpq %r13, %rbp
je 0x256c82e
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
addq $0x8, %rbp
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq %r12, %rsi
movq %r15, %rdx
mov... | /Analysis/AliasAnalysis.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [28], llvm::cl::OptionHidden>(char const (&) [28], llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movb %bpl, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb %bpl, 0x91(%rbx)
leaq 0x31d924a(%rip), %rax # 0x5747988
addq $0x10, %rax
movq %ra... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::Value const*, llvm::Type*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value const*, llvm::Type*>>>, std::pair<llvm::Value const*, llvm::Type*>, llvm::detail::DenseSetEmpt... | 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), %eax
testq %rax, %rax
je 0x257059f
movq (%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, (%rcx)
movq %rdx,... | /llvm/ADT/DenseMap.h |
llvm::AliasSetTracker::add(llvm::StoreInst*) | void AliasSetTracker::add(StoreInst *SI) {
if (isStrongerThanMonotonic(SI->getOrdering()))
return addUnknown(SI);
addMemoryLocation(MemoryLocation::get(SI), AliasSet::ModAccess);
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movzwl 0x2(%rsi), %eax
shrl $0x4, %eax
andl $0x38, %eax
leaq 0xe8a7df(%rip), %rcx # 0x33fbd90
cmpb $0x1, 0x2(%rcx,%rax)
jne 0x25715c7
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x2571484
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x2659c44
movups ... | /Analysis/AliasSetTracker.cpp |
llvm::AliasSetTracker::add(llvm::BasicBlock&) | void AliasSetTracker::add(BasicBlock &BB) {
for (auto &I : BB)
add(&I);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x38(%rsi), %r15
addq $0x30, %rbx
cmpq %rbx, %r15
je 0x2571a76
movq %rdi, %r14
leaq -0x18(%r15), %rsi
testq %r15, %r15
cmoveq %r15, %rsi
movq %r14, %rdi
callq 0x25717a2
movq 0x8(%r15), %r15
cmpq %rbx, %r15
jne 0x2571a5a
popq %rbx
popq %r14
popq %r15
retq
| /Analysis/AliasSetTracker.cpp |
void llvm::SmallVectorImpl<llvm::MemoryLocation>::append<std::move_iterator<llvm::MemoryLocation*>, void>(std::move_iterator<llvm::MemoryLocation*>, std::move_iterator<llvm::MemoryLocation*>) | 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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rax
subq %rsi, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r12, %rdx
cmpq %rax, %rdx
jbe 0x2572b22
le... | /llvm/ADT/SmallVector.h |
void llvm::erase<llvm::SmallVector<llvm::AssumptionCache::ResultElem, 4u>, llvm::AssumeInst*>(llvm::SmallVector<llvm::AssumptionCache::ResultElem, 4u>&, llvm::AssumeInst*) | void erase(Container &C, ValueType V) {
C.erase(std::remove(C.begin(), C.end(), V), C.end());
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq (%rdi), %rdi
movl 0x8(%rbx), %esi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x2576f10
movl 0x8(%rbx), %edx
shlq $0x5, %rdx
addq (%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2576e8e
addq $0x10, %rsp
popq %rbx
retq
nop
| /llvm/ADT/STLExtras.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AssumptionCache::AffectedValueCallbackVH, llvm::SmallVector<llvm::AssumptionCache::ResultElem, 1u>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::AssumptionCache::AffectedValueCallbackVH, llvm::SmallVector<llvm::AssumptionCache::ResultElem, 1u>>>, llvm:... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x25769c0
movl 0x10(%rbx), %ecx
imulq $0x58, %rcx, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_delete<llvm::AssumptionCache>>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_de... | 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, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::default_delete<llvm::AssumptionCache>>, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::AssumptionCacheTracker::FunctionCallbackVH, std::unique_ptr<llvm::AssumptionCache, std::de... | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq $0x2, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq $-0x1000, 0x18(%rsp) # imm = 0xF000
leaq 0x3335800(%rip), %rcx # 0x58acdf8
addq $0x10, %rcx
movq %rcx, (%rsp)
movq %rax, 0x20(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x2577632
movl $0x1000, %edx # imm... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::TinyPtrVector<llvm::Value const*>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::TinyPtrVector<llvm::Value const*>>>, llvm::Instruction*, llvm::TinyPtrVector<llvm::Value const*>, llvm::DenseMapInfo<llvm::Ins... | 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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x257df46
movl %eax, %ebp
testb %al, %al
je 0x2577aee
movq 0x8(%rsp), %r14
leaq 0x8(%r14), %rdi
callq 0x1bfe5bc
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0xe2bb67(%rip), %xmm0 # 0x33a3650
movq %x... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.