name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::DFSanFunction::getShadow(llvm::Value*) | Value *DFSanFunction::getShadow(Value *V) {
if (!isa<Argument>(V) && !isa<Instruction>(V))
return DFS.getZeroShadow(V);
if (IsForceZeroLabels)
return DFS.getZeroShadow(V);
Value *&Shadow = ValShadowMap[V];
if (!Shadow) {
if (Argument *A = dyn_cast<Argument>(V)) {
if (IsNativeABI)
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movb (%rsi), %al
cmpb $0x16, %al
sete %cl
cmpb $0x1d, %al
setae %al
orb %cl, %al
je 0x238c86a
cmpb $0x1, 0x59(%r14)
jne 0x238c887
movq (%r14), %rdi
movq 0x8(%rsi), %rsi
addq $0xd8, %rsp
popq %rbx
pop... | /Transforms/Instrumentation/DataFlowSanitizer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::Function*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Function*>>, llvm::Value*, llvm::Function*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Function*>>::find(llvm::Value const*) | 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
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rsp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x2391948
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
(anonymous namespace)::DataFlowSanitizer::buildExternWeakCheckIfNeeded(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Function*) | LinkageTypes getLinkage() const { return LinkageTypes(Linkage); } | movl 0x20(%rdx), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x2391abf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
leaq 0x30(%rsp), %r13... | /llvm/IR/GlobalValue.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::AllocaInst*, llvm::AllocaInst*, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst*, llvm::AllocaInst*>>, llvm::AllocaInst*, llvm::AllocaInst*, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst*, ll... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x23921e9
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::CFGMST<(anonymous namespace)::Edge, (anonymous namespace)::BBInfo>::unionGroups(llvm::BasicBlock const*, llvm::BasicBlock const*) | bool unionGroups(const BasicBlock *BB1, const BasicBlock *BB2) {
BBInfo *BB1G = findAndCompressGroup(&getBBInfo(BB1));
BBInfo *BB2G = findAndCompressGroup(&getBBInfo(BB2));
if (BB1G == BB2G)
return false;
// Make the smaller rank tree a direct child or the root of high rank tree.
if (BB1G->R... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %r14
leaq 0x20(%rdi), %r12
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x2399b06
testb %al, %al
je 0x239af7c
movq 0x8(%rsp), %rax
jmp 0x239af88
movl 0x30(%r14), %eax
shlq $0x4, ... | /llvm/Transforms/Instrumentation/CFGMST.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::GlobalVariable*, llvm::MDNode*>, true>::push_back(std::pair<llvm::GlobalVariable*, llvm::MDNode*>) | 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 0x239c2f8
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<unsigned long, false, llvm::cl::parser<unsigned long>>::opt<char [14], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(char const (&) [14], 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 0x7c77e2
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0, 0x98(%r14)
leaq 0x33565d9(%rip), %rax # 0x56f7be0
addq $0... | /llvm/Support/CommandLine.h |
llvm::MemorySanitizerPass::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void MemorySanitizerPass::printPipeline(
raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
static_cast<PassInfoMixin<MemorySanitizerPass> *>(this)->printPipeline(
OS, MapClassName2PassName);
OS << '<';
if (Options.Recover)
OS << "recover;";
if (Options.Kernel)
OS << ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c38298
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c4562
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x23a429a
leaq 0x1(%rax), %rcx
movq %rcx, 0x20... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::VarArgMIPS64Helper::finalizeInstrumentation() | void finalizeInstrumentation() override {
assert(!VAArgSize && !VAArgTLSCopy &&
"finalizeInstrumentation called twice");
IRBuilder<> IRB(MSV.FnPrologueEnd);
VAArgSize = IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS);
Value *CopySize =
IRB.CreateAdd(ConstantInt::get(MS.Intpt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x1c0(%rax), %rsi
leaq 0x138(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x90099c
movq 0x48(%r14), %rdi
callq 0x1a89f4e
movq 0x10(... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::Combiner<true>::Done(llvm::Instruction*) | void Done(Instruction *I) {
if (CombineShadow) {
assert(Shadow);
Shadow = MSV->CreateShadowCast(IRB, Shadow, MSV->getShadowTy(I));
MSV->setShadow(I, Shadow);
}
if (MSV->MS.TrackOrigins) {
assert(Origin);
MSV->setOrigin(I, Origin);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq (%rdi), %r12
movq 0x10(%rdi), %r13
movq 0x8(%rsi), %rsi
movq %r15, %rdi
callq 0x23a8c80
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x23ac172
movq ... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::handleLifetimeStart(llvm::IntrinsicInst&) | void handleLifetimeStart(IntrinsicInst &I) {
if (!PoisonStack)
return;
AllocaInst *AI = llvm::findAllocaForValue(I.getArgOperand(1));
if (!AI)
InstrumentLifetimeStart = false;
LifetimeStartList.push_back(std::make_pair(&I, AI));
} | cmpb $0x1, 0x25a(%rdi)
jne 0x23b0c35
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq 0x20(%rcx), %rdi
xorl %esi, %esi
callq 0x29ddae4
testq %rax, %rax
jne 0x23b0c19
movb $0x0, 0x408(%r14)
addq $0x4b8, %r14 # imm = 0x4B... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::handleStmxcsr(llvm::IntrinsicInst&) | void handleStmxcsr(IntrinsicInst &I) {
IRBuilder<> IRB(&I);
Value *Addr = I.getArgOperand(0);
Type *Ty = IRB.getInt32Ty();
Value *ShadowPtr =
getShadowOriginPtr(Addr, IRB, Ty, Align(1), /*isStore*/ true).first;
IRB.CreateStore(getCleanShadow(Ty), ShadowPtr);
if (ClCheckAccessAddress)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x90099c
movl 0x4(%rbx), %eax
shll $0x5, %eax
movq %rbx, %rcx
subq %rax, %rcx
movq (%rcx), %r15
... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::handleVectorSadIntrinsic(llvm::IntrinsicInst&) | void handleVectorSadIntrinsic(IntrinsicInst &I) {
const unsigned SignificantBitsPerResultElement = 16;
bool isX86_MMX = I.getOperand(0)->getType()->isX86_MMXTy();
Type *ResTy = isX86_MMX ? IntegerType::get(*MS.C, 64) : I.getType();
unsigned ZeroBitsPerResultElement =
ResTy->getScalarSizeInBits()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
movq (%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xa, 0x8(%rax)
jne 0x23b2b3b
movq 0x8(%r14), %rax
movq 0x48(%rax), %rdi
movl $0x40, %esi
ca... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::convertBlendvToSelectMask(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Value*) | Value *convertBlendvToSelectMask(IRBuilder<> &IRB, Value *C) {
C = CreateAppToShadowCast(IRB, C);
FixedVectorType *FVT = cast<FixedVectorType>(C->getType());
unsigned ElSize = FVT->getElementType()->getPrimitiveSizeInBits();
C = IRB.CreateAShr(C, ElSize - 1);
FVT = FixedVectorType::get(IRB.getInt1Ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
callq 0x23b41ba
movq %rax, %r14
movq 0x8(%rax), %r12
movq 0x18(%r12), %rdi
callq 0x1a89c4e
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb %dl, 0x8(%r15)
movq %r15, %rdi
callq 0x1cceb6c
leal -0x1(%rax), %esi
movw $0x101, %bp ... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::CreateAppToShadowCast(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Value*) | Value *CreateAppToShadowCast(IRBuilder<> &IRB, Value *V) {
Type *ShadowTy = getShadowTy(V);
if (V->getType() == ShadowTy)
return V;
if (V->getType()->isPtrOrPtrVectorTy())
return IRB.CreatePtrToInt(V, ShadowTy);
else
return IRB.CreateBitCast(V, ShadowTy);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdx), %rsi
callq 0x23a8c80
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x23b4227
movl $0xfe, %edx
andl 0x8(%rcx), %edx
cmpl $0x12, %edx
jne 0x23b41ed
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0xf, 0x8(%rcx)
jne 0x23b4207
movq %rsp, %r8
mov... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::MemorySanitizerVisitor::getLocalVarDescription(llvm::AllocaInst&) | Value *getLocalVarDescription(AllocaInst &I) {
return createPrivateConstGlobalForString(*F.getParent(), I.getName());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
movq 0x28(%rax), %rbx
movq %rsi, %rdi
callq 0x1a90092
movq (%rbx), %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq 0x19d84f0
movq %rax, %r14
movl $0x58, %edi
movl $0x1, %esi
callq 0x1a8f59c
movq %rax, %r15
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rax
movw $0x1... | /Transforms/Instrumentation/MemorySanitizer.cpp |
(anonymous namespace)::IndirectCallPromoter::updateFuncValueProfiles(llvm::CallBase&, llvm::ArrayRef<InstrProfValueData>, unsigned long, unsigned int) | void IndirectCallPromoter::updateFuncValueProfiles(
CallBase &CB, ArrayRef<InstrProfValueData> CallVDs, uint64_t TotalCount,
uint32_t MaxMDCount) {
// First clear the existing !prof.
CB.setMetadata(LLVMContext::MD_prof, nullptr);
// Annotate the remaining value profiles if counter is not zero.
if (Total... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a6c16a
testq %rbx, %rbx
je 0x23bfd00
movq 0x8(%r13), %rdi
movl %ebp, (%rsp)
movq %r12, %rsi... | /Transforms/Instrumentation/IndirectCallPromotion.cpp |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [34], llvm::cl::initializer<int>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [34], llvm::cl::initializer<int> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | 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, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7512e0
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c90c20
movq (%r12), %rax
movl (%rax), %ecx
movl %ecx, 0x80(%r14)
movb $0x1, 0x94(%r14)
movl (%rax)... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalVariable*, (anonymous namespace)::InstrLowerer::PerFunctionProfileData, llvm::DenseMapInfo<llvm::GlobalVariable*, void>, llvm::detail::DenseMapPair<llvm::GlobalVariable*, (anonymous namespace)::InstrLowerer::PerFunctionProfileData>>, llvm::GlobalVariable*, (anonymous namesp... | 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, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
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... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::InstrProfInstBase*, true>::push_back(llvm::InstrProfInstBase*) | 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 0x23c8c63
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 0x1cba528... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::InstrLowerer::getCounterAddress(llvm::InstrProfCntrInstBase*) | Value *InstrLowerer::getCounterAddress(InstrProfCntrInstBase *I) {
auto *Counters = getOrCreateRegionCounters(I);
IRBuilder<> Builder(I);
if (isa<InstrProfTimestampInst>(I))
Counters->setAlignment(Align(8));
auto *Addr = Builder.CreateConstInBoundsGEP2_32(
Counters->getValueType(), Counters, 0, I->g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r12
movq %rdi, %r14
callq 0x23c6d84
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x90099c
movq -0x20(%r12), %rax
cmpl $0xc4, 0x24(%rax)
... | /Transforms/Instrumentation/InstrProfiling.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function const*, llvm::LoadInst*, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, llvm::LoadInst*>>, llvm::Function const*, llvm::LoadInst*, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Functi... | 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 0x23c9553
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
getOrInsertValueProfilingCall(llvm::Module&, llvm::TargetLibraryInfo const&, (anonymous namespace)::ValueProfilingCallType) | static FunctionCallee getOrInsertValueProfilingCall(
Module &M, const TargetLibraryInfo &TLI,
ValueProfilingCallType CallType = ValueProfilingCallType::Default) {
LLVMContext &Ctx = M.getContext();
auto *ReturnTy = Type::getVoidTy(M.getContext());
AttributeList AL;
if (auto AK = TLI.getExtAttrForI32Par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, %rdi
callq 0x1a897d0
movq %rax, %r14
movq $0x0, 0x8(%rsp)
movq (%r12), %rax
xorl %ecx, %ecx
cmpb $0x0, 0x9a(%rax)
movl $0x34, %edx
cmovel %ecx, %edx
cmpb $0x0, 0x98(%rax)
... | /Transforms/Instrumentation/InstrProfiling.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [40], llvm::cl::desc>(char const (&) [40], llvm::cl::desc 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 0x7c77e2
movl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb $0x0, 0x94(%rbx)
leaq 0x332777f(%rip), %rax # 0x56f2640
addq $0x10, %rax
movq %rax, 0x88(%rbx)
leaq 0x345845d(%rip), %r... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, std::unique_ptr<(anonymous namespace)::PGOUseBBInfo, std::default_delete<(anonymous namespace)::PGOUseBBInfo>>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, std::unique_ptr<(anonymous namespace)::PGOUseB... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x23d6720
testb %al, %al
je 0x23d670f
movq (%rsp), %rax
jmp 0x23d6719
movl 0x10(%rbx), %eax
shlq $0x4, %rax
addq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
void llvm::cl::parser<llvm::PGOViewCountsType>::addLiteralOption<int>(llvm::StringRef, int const&, llvm::StringRef) | void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
#ifndef NDEBUG
if (findOption(Name) != Values.size())
report_fatal_error("Option '" + Name + "' already exists!");
#endif
OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
Values.push_back(X);
AddLiteralOption(Owner, Name... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rcx), %eax
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r8, 0x10(%rsi)
movq %r9, 0x18(%rsi)
leaq 0x348fad3(%rip), %r13 # 0x586d238
addq $0x10, %r13
leaq 0x348faa8(%rip), %r12 ... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [31], llvm::cl::desc, llvm::cl::OptionHidden>(char const (&) [31], llvm::cl::desc const&, 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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb %bpl, 0x91(%rbx)
leaq 0x330273e(%rip), %rax # 0x56e32a0
addq $0x1... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ModuleSanitizerCoverage::CreateSecStartEnd(llvm::Module&, char const*, llvm::Type*) | std::pair<Value *, Value *>
ModuleSanitizerCoverage::CreateSecStartEnd(Module &M, const char *Section,
Type *Ty) {
// Use ExternalWeak so that if all sections are discarded due to section
// garbage collection, the linker will not report undefined symbol errors.
// Windo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r13
xorl %eax, %eax
cmpl $0x1, 0x254(%rdi)
setne %al
leal (%rax,%rax,8), %r14d
movl $0x58, %edi
movl $0x1, %esi
callq 0x1a8f59c
movq %rax, %r15
leaq 0x... | /Transforms/Instrumentation/SanitizerCoverage.cpp |
llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::SmallVector<llvm::Constant*, 6u>>, false>::push_back(std::pair<llvm::StringRef, llvm::SmallVector<llvm::Constant*, 6u>>&&) | void push_back(T &&Elt) {
T *EltPtr = reserveForParamAndGetAddress(Elt);
::new ((void *)this->end()) T(::std::move(*EltPtr));
this->set_size(this->size() + 1);
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x23e6d62
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,4), %rdx
shlq $0x4, %rdx
movups (%rax), %xmm0
leaq (%rcx,%rdx), %rsi
addq $0x20, %rsi
movups %xmm0, -0x20(%rsi)
movq %rsi, -0x10(%rsi)
movabsq $0x600000000, %rdi # imm = 0x600000000
movq %rdi, -0x8(%rs... | /llvm/ADT/SmallVector.h |
llvm::HWAddressSanitizerPass::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void HWAddressSanitizerPass::printPipeline(
raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
static_cast<PassInfoMixin<HWAddressSanitizerPass> *>(this)->printPipeline(
OS, MapClassName2PassName);
OS << '<';
if (Options.CompileKernel)
OS << "kernel;";
if (Options.Recover... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c37e06
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c4562
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x23f12e2
leaq 0x1(%rax), %rcx
movq %rcx, 0x20... | /Transforms/Instrumentation/HWAddressSanitizer.cpp |
writeStringRecord(llvm::BitstreamWriter&, unsigned int, llvm::StringRef, unsigned int) | static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,
StringRef Str, unsigned AbbrevToUse) {
SmallVector<unsigned, 64> Vals;
// Code: [strchar x N]
for (char C : Str) {
if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(C))
AbbrevToUse = 0;
Vals.push_back(C);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %r15
movl %esi, 0x4(%rsp)
movq %rdi, %r14
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
testq %r15, %r15
je 0x2402cdf
movq %rd... | /Bitcode/Writer/BitcodeWriter.cpp |
void llvm::SmallVectorImpl<char>::append<unsigned int const*, void>(unsigned int const*, unsigned int 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 %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
subq %rsi, %rbx
sarq $0x2, %rbx
movq 0x8(%rdi), %rdx
addq %rbx, %rdx
cmpq %rdx, 0x10(%rdi)
jae 0x2403277
leaq 0x18(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
callq 0x1cba770
testq %rbx, %rbx
jle 0x240329d
movq (%r14), %rax
addq 0x8(%r14),... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::ModuleBitcodeWriter::writeDICompositeType(llvm::DICompositeType const*, llvm::SmallVectorImpl<unsigned long>&, unsigned int) | void ModuleBitcodeWriter::writeDICompositeType(
const DICompositeType *N, SmallVectorImpl<uint64_t> &Record,
unsigned Abbrev) {
const unsigned IsNotUsedInOldTypeRef = 0x2;
Record.push_back(IsNotUsedInOldTypeRef | (unsigned)N->isDistinct());
Record.push_back(N->getTag());
Record.push_back(VE.getMetadataO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb 0x1(%rsi), %al
andb $0x7f, %al
xorl %esi, %esi
cmpb $0x1, %al
sete %sil
orq $0x2, %rsi
movq %rdx, %rdi
callq 0x8e0f0a
movq %r15, %rdi
callq 0x19f4066
movzwl %ax, %esi
m... | /Bitcode/Writer/BitcodeWriter.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, std::pair<unsigned int, bool>, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, std::pair<unsigned int, bool>>>, llvm::Value const*, std::pair<unsigned int, bool>, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::d... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2410381
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::DenseMapBase<llvm::SmallDenseMap<unsigned int, llvm::ValueEnumerator::MDRange, 1u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::ValueEnumerator::MDRange>>, unsigned int, llvm::ValueEnumerator::MDRange, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<uns... | 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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rax
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rax
movl $0x1, %ecx
cmovel 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2413c98
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFF... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Type*, unsigned int, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | 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::DenseMap<std::pair<unsigned int, llvm::AttributeSet>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::AttributeSet>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::AttributeSet>, 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 |
llvm::OpenMPIRBuilder::emitFlush(llvm::OpenMPIRBuilder::LocationDescription const&) | void OpenMPIRBuilder::emitFlush(const LocationDescription &Loc) {
// Build call void __kmpc_flush(ident_t *loc)
uint32_t SrcLocStrSize;
Constant *SrcLocStr = getOrCreateSrcLocStr(Loc, SrcLocStrSize);
Value *Args[] = {getOrCreateIdent(SrcLocStr, SrcLocStrSize)};
Builder.CreateCall(getOrCreateRuntimeFunctionPt... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1c(%rsp), %r14
movq %r14, %rdx
callq 0x242870a
movl (%r14), %edx
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x24280b4
movq %rax, 0x10(%rsp)
movq 0x1b0(%rbx), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x24224e8
cm... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::createReductionsGPU(llvm::OpenMPIRBuilder::LocationDescription const&, llvm::IRBuilderBase::InsertPoint, llvm::IRBuilderBase::InsertPoint, llvm::ArrayRef<llvm::OpenMPIRBuilder::ReductionInfo>, bool, bool, bool, llvm::OpenMPIRBuilder::ReductionGenCBKind, std::optional<llvm::omp::GV>, unsigned int,... | OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createReductionsGPU(
const LocationDescription &Loc, InsertPointTy AllocaIP,
InsertPointTy CodeGenIP, ArrayRef<ReductionInfo> ReductionInfos,
bool IsNoWait, bool IsTeamsReduction, bool HasDistribute,
ReductionGenCBKind ReductionGenCBKind, std::optional<omp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2230408
testb %al, %al
je 0x2432a4f
movq %rbx, 0x60(%rsp)
movq 0x2d0(%rsp), %rbx
leaq 0x278(... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::createMaster(llvm::OpenMPIRBuilder::LocationDescription const&, llvm::function_ref<void (llvm::IRBuilderBase::InsertPoint, llvm::IRBuilderBase::InsertPoint)>, std::function<void (llvm::IRBuilderBase::InsertPoint)>) | OpenMPIRBuilder::InsertPointTy
OpenMPIRBuilder::createMaster(const LocationDescription &Loc,
BodyGenCallbackTy BodyGenCB,
FinalizeCallbackTy FiniCB) {
if (!updateToLocation(Loc))
return Loc.IP;
Directive OMPD = Directive::OMPD_master;
uint32_t SrcL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2230408
testb %al, %al
je 0x2434982
movq %rbp, 0x48(%rsp)
movq %r13, 0x50(%rsp)
leaq 0x5c(%rsp), %r13
m... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::createSingle(llvm::OpenMPIRBuilder::LocationDescription const&, llvm::function_ref<void (llvm::IRBuilderBase::InsertPoint, llvm::IRBuilderBase::InsertPoint)>, std::function<void (llvm::IRBuilderBase::InsertPoint)>, bool, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::Function*>) | OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createSingle(
const LocationDescription &Loc, BodyGenCallbackTy BodyGenCB,
FinalizeCallbackTy FiniCB, bool IsNowait, ArrayRef<llvm::Value *> CPVars,
ArrayRef<llvm::Function *> CPFuncs) {
if (!updateToLocation(Loc))
return Loc.IP;
// If needed allocat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2230408
testb %al, %al
je 0x243b991
movq %r13, 0x88(%rsp)
movq %r12, 0x38(%rsp)
leaq 0x128(%rsp), %rax
... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::createOMPAlloc(llvm::OpenMPIRBuilder::LocationDescription const&, llvm::Value*, llvm::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | CallInst *OpenMPIRBuilder::createOMPAlloc(const LocationDescription &Loc,
Value *Size, Value *Allocator,
std::string Name) {
IRBuilder<>::InsertPointGuard IPG(Builder);
updateToLocation(Loc);
uint32_t SrcLocStrSize;
Constant *S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1b8(%rdi), %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, -0x20(%rdi)
movzwl 0x1f8(%r12), %eax
movups 0x1e8(%r12), %xmm0
movups %xmm0, -0x18(%rdi)
movw %a... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::writeThreadBoundsForKernel(llvm::Triple const&, llvm::Function&, int, int) | void OpenMPIRBuilder::writeThreadBoundsForKernel(const Triple &T,
Function &Kernel, int32_t LB,
int32_t UB) {
Kernel.addFnAttr("omp_target_thread_limit", std::to_string(UB));
if (T.isAMDGPU()) {
Kernel.addFnAttr("... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %ebp
movl %edx, 0x24(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movl %ecx, %r12d
negl %r12d
cmovsl %ecx, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
jb 0x243dce7
movl $0x4, %r13d
movl $0xd1b71759, %eax # imm = 0xD1B71... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::setOutlinedTargetRegionFunctionAttributes(llvm::Function*) | void OpenMPIRBuilder::setOutlinedTargetRegionFunctionAttributes(
Function *OutlinedFn) {
if (Config.isTargetDevice()) {
OutlinedFn->setLinkage(GlobalValue::WeakODRLinkage);
// TODO: Determine if DSO local can be set to true.
OutlinedFn->setDSOLocal(false);
OutlinedFn->setVisibility(GlobalValue::Pr... | cmpb $0x1, 0x150(%rdi)
jne 0x243e5e6
movl $0xffffbfc0, %eax # imm = 0xFFFFBFC0
andl 0x20(%rsi), %eax
orl $0x4025, %eax # imm = 0x4025
movl %eax, 0x20(%rsi)
cmpl $0x1a, 0x320(%rdi)
jne 0x243e5e6
movzwl 0x2(%rsi), %eax
andl $0xffffc00f, %eax # imm = 0xFFFFC00F
orl $0x5b0, %eax # imm = 0x5... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::emitAtomicUpdate(llvm::IRBuilderBase::InsertPoint, llvm::Value*, llvm::Type*, llvm::Value*, llvm::AtomicOrdering, llvm::AtomicRMWInst::BinOp, llvm::function_ref<llvm::Value* (llvm::Value*, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&)> const&, bool, bool) | std::pair<Value *, Value *> OpenMPIRBuilder::emitAtomicUpdate(
InsertPointTy AllocaIP, Value *X, Type *XElemTy, Value *Expr,
AtomicOrdering AO, AtomicRMWInst::BinOp RMWOp,
AtomicUpdateCallbackTy &UpdateOp, bool VolatileX, bool IsXBinopExpr) {
// TODO: handle the case where XElemTy is not byte-sized or not... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebx
movl %r8d, %r12d
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r15
cmpl $0x6, %r9d
ja 0x2442cea
cmpl $0x2, %ebx
je 0x2442cf1
testq %rdx, %rdx
setne %al
testb %al, %al
je 0x2442841
movzbl 0x8(%rdx), %eax
cmpl $0xd, %eax
jne ... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OffloadEntriesInfoManager::actOnTargetRegionEntriesInfo(llvm::function_ref<void (llvm::TargetRegionEntryInfo const&, llvm::OffloadEntriesInfoManager::OffloadEntryInfoTargetRegion const&)> const&) | void OffloadEntriesInfoManager::actOnTargetRegionEntriesInfo(
const OffloadTargetRegionEntryInfoActTy &Action) {
// Scan all target region entries and perform the provided action.
for (const auto &It : OffloadEntriesTargetRegion) {
Action(It.first, It.second);
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x58(%rdi), %r15
addq $0x48, %r14
cmpq %r14, %r15
je 0x244405a
movq %rsi, %rbx
leaq 0x20(%r15), %rsi
leaq 0x50(%r15), %rdx
movq 0x8(%rbx), %rdi
callq *(%rbx)
movq %r15, %rdi
callq 0x7517f0
movq %rax, %r15
cmpq %r14, %rax
jne 0x244403c
popq %rbx
popq %r14
popq %r15
r... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OffloadEntriesInfoManager::actOnDeviceGlobalVarEntriesInfo(llvm::function_ref<void (llvm::StringRef, llvm::OffloadEntriesInfoManager::OffloadEntryInfoDeviceGlobalVar const&)> const&) | void OffloadEntriesInfoManager::actOnDeviceGlobalVarEntriesInfo(
const OffloadDeviceGlobalVarEntryInfoActTy &Action) {
// Scan all target region entries and perform the provided action.
for (const auto &E : OffloadEntriesDeviceGlobalVar)
Action(E.getKey(), E.getValue());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x70(%rdi), %rax
movl 0x78(%rdi), %ecx
movq %rax, %r14
testq %rcx, %rcx
je 0x244408e
movq %rax, %r14
movq (%r14), %rdx
testq %rdx, %rdx
je 0x2444088
cmpq $-0x8, %rdx
jne 0x244408e
addq $0x8, %r14
jmp 0x244407a
leaq (%rax,%rcx,8), %r15
cmpq %r15, %r14
je 0x24440bf
mo... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OpenMPIRBuilder::registerTargetGlobalVariable(llvm::OffloadEntriesInfoManager::OMPTargetGlobalVarEntryKind, llvm::OffloadEntriesInfoManager::OMPTargetDeviceClauseKind, bool, bool, llvm::TargetRegionEntryInfo, llvm::StringRef, std::vector<llvm::GlobalVariable*, std::allocator<llvm::GlobalVariable*>>&, bool, std::v... | void OpenMPIRBuilder::registerTargetGlobalVariable(
OffloadEntriesInfoManager::OMPTargetGlobalVarEntryKind CaptureClause,
OffloadEntriesInfoManager::OMPTargetDeviceClauseKind DeviceClause,
bool IsDeclaration, bool IsExternallyVisible,
TargetRegionEntryInfo EntryInfo, StringRef MangledName,
std::vect... | testl %edx, %edx
je 0x244480b
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %rbp
movl %ecx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x170(%rsp), %r12
movq (%r12), %rax
cmpq 0x8(%r12), %rax
jne 0x2444848
cmpb $0x1, 0x150(%rbx)
jne 0x2444af... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::OffloadEntriesInfoManager::initializeTargetRegionEntryInfo(llvm::TargetRegionEntryInfo const&, unsigned int) | void OffloadEntriesInfoManager::initializeTargetRegionEntryInfo(
const TargetRegionEntryInfo &EntryInfo, unsigned Order) {
OffloadEntriesTargetRegion[EntryInfo] =
OffloadEntryInfoTargetRegion(Order, /*Addr=*/nullptr, /*ID=*/nullptr,
OMPTargetRegionEntryTargetRegion);
++O... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq $0x6, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
xorl %eax, %eax
movl %eax, 0x18(%r14)
movl %edx, 0x1c(%r14)
movl %eax, 0x20(%r14)
movq $0x0, 0x28(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0xaf13d0
leaq 0x40(... | /Frontend/OpenMP/OMPIRBuilder.cpp |
llvm::SmallVectorTemplateBase<std::pair<llvm::ICmpInst*, unsigned int>, true>::push_back(std::pair<llvm::ICmpInst*, unsigned int>) | 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
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x2453906
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movl %ebx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %r... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, std::pair<llvm::SetVector<llvm::BasicBlock*, llvm::SmallVector<llvm::BasicBlock*, 0u>, llvm::DenseSet<llvm::BasicBlock*, llvm::DenseMapInfo<llvm::BasicBlock*, void>>, 0u>, llvm::BlockFrequency>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<... | 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), %eax
testq %rax, %rax
je 0x24570e5
movq (%r15), %rcx
imulq $0x38, %rax, %rax
addq $-0x38, %rax
shrq $0x3, %rax
movabsq $0x2492492492492493, %rdx # imm = 0x2492492... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, std::pair<llvm::SetVector<llvm::BasicBlock*, llvm::SmallVector<llvm::BasicBlock*, 0u>, llvm::DenseSet<llvm::BasicBlock*, llvm::DenseMapInfo<llvm::BasicBlock*, void>>, 0u>, llvm::BlockFrequency>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<... | 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 0x24571d6
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x24572bb
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x24572c6
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::BasicBlock>, false, false>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::Basic... | 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::ConstraintSystem::ConstraintSystem(llvm::ArrayRef<llvm::Value*>) | void *getFirstEl() const {
return const_cast<void *>(reinterpret_cast<const void *>(
reinterpret_cast<const char *>(this) +
offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)));
} | leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x258(%rdi)
movl $0x0, 0x268(%rdi)
movq %rdx, (%rdi)
testq %rdx, %rdx
je 0x245e310
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq... | /llvm/ADT/SmallVector.h |
bool llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::ConstantInt>, 17u, 1u, false>::match<llvm::Value>(llvm::Value*) | unsigned getValueID() const {
return SubclassID;
} | movzbl (%rsi), %eax
cmpl $0x1d, %eax
jb 0x2462d5c
leal -0x2a(%rax), %ecx
rorl %ecx
cmpl $0x6, %ecx
ja 0x2462d5c
movl $0x47, %edx
btl %ecx, %edx
jb 0x2462d7b
cmpl $0x5, %eax
jne 0x2462d79
movzwl 0x2(%rsi), %eax
addl $-0xd, %eax
rorl %eax
cmpl $0x6, %eax
ja 0x2462d79
movl $0x47, %ecx
btl %eax, %ecx
jb 0x2462d7b
xorl %esi... | /llvm/IR/Value.h |
llvm::RedundantDbgInstEliminationPass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses
RedundantDbgInstEliminationPass::run(Function &F, FunctionAnalysisManager &AM) {
bool Changed = false;
for (auto &BB : F)
Changed |= RemoveRedundantDbgInstrs(&BB);
if (!Changed)
return PreservedAnalyses::all();
PreservedAnalyses PA;
PA.preserveSet<CFGAnalyses>();
return PA;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x50(%rdx), %r15
addq $0x48, %r14
cmpq %r14, %r15
je 0x24690c8
xorl %ebp, %ebp
leaq -0x18(%r15), %rdi
testq %r15, %r15
cmoveq %r15, %rdi
callq 0x2770805
orb %al, %bpl
movq 0x8(%r15), %r15
cmpq %r14, %r15
jne 0x2469069
test... | /Transforms/Scalar/DCE.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [38], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [38], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | 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 %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x3279c1... | /llvm/Support/CommandLine.h |
bool llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_const_intval_ty>>, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>::match<llvm::Instruction>(llvm::Instruction... | bool match(ITy *V) {
if (L.match(V))
if (R.match(V))
return true;
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x246e36c
testb %al, %al
je 0x246e361
movb (%r14), %al
cmpb $0x55, %al
jne 0x246e356
movl 0x18(%rbx), %ecx
movl 0x4(%r14), %edx
shll $0x5, %edx
subq %rdx, %r14
shlq $0x5, %rcx
movq (%r14,%rcx), %rdx
testq %rdx, %rdx
setne %cl
je 0x246e356
movq 0x20(... | /llvm/IR/PatternMatch.h |
shortenAssignment(llvm::Instruction*, llvm::Value*, unsigned long, unsigned long, unsigned long, bool) | static void shortenAssignment(Instruction *Inst, Value *OriginalDest,
uint64_t OldOffsetInBits, uint64_t OldSizeInBits,
uint64_t NewSizeInBits, bool IsOverwriteEnd) {
const DataLayout &DL = Inst->getDataLayout();
uint64_t DeadSliceSizeInBits = OldSizeInBit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, %r12d
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdi, %r13
callq 0x1a3f4d6
movq %rax, 0x50(%rsp)
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %eax
cmovneq %rbp, %rax
movq %rax, 0x40(%rs... | /Transforms/Scalar/DeadStoreElimination.cpp |
llvm::EarlyCSEPass::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void EarlyCSEPass::printPipeline(
raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
static_cast<PassInfoMixin<EarlyCSEPass> *>(this)->printPipeline(
OS, MapClassName2PassName);
OS << '<';
if (UseMemorySSA)
OS << "memssa";
OS << '>';
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c4162c
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c4562
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x247d626
leaq 0x1(%rax), %rcx
movq %rcx, 0x20... | /Transforms/Scalar/EarlyCSE.cpp |
(anonymous namespace)::EarlyCSELegacyCommonPass<true>::EarlyCSELegacyCommonPass() | EarlyCSELegacyCommonPass() : FunctionPass(ID) {
if (UseMemorySSA)
initializeEarlyCSEMemSSALegacyPassPass(*PassRegistry::getPassRegistry());
else
initializeEarlyCSELegacyPassPass(*PassRegistry::getPassRegistry());
} | pushq %rax
movq $0x0, 0x8(%rdi)
leaq 0x348dbdf(%rip), %rax # 0x590b361
movq %rax, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
leaq 0x33efeec(%rip), %rax # 0x586d680
movq %rax, (%rdi)
callq 0x1a82116
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x348dbb3(%rip), %rdi # 0x590b35c
leaq 0x69(%rip), %rsi # 0x247d819
callq 0x90ae... | /Transforms/Scalar/EarlyCSE.cpp |
llvm::ScopedHashTable<(anonymous namespace)::CallValue, std::pair<llvm::Instruction*, unsigned int>, llvm::DenseMapInfo<(anonymous namespace)::CallValue, void>, llvm::MallocAllocator>::insert((anonymous namespace)::CallValue const&, std::pair<llvm::Instruction*, unsigned int> const&) | void insert(const K &Key, const V &Val) {
insertIntoScope(CurScope, Key, Val);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r12
callq 0x248136a
movq %rax, %r15
movq 0x10(%r12), %r13
movq (%rax), %rbp
movl $0x28, %edi
movl $0x8, %esi
callq 0x1cac6bd
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movups (%rbx), %xmm0
movups ... | /llvm/ADT/ScopedHashTable.h |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Value*>(unsigned long&, char*, char*, llvm::Value*) | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
if (!store_and_advance(buffer_ptr, buffer_end, data)) {
// Check for skew which prevents the buffer from being packed, and do
// a partial store into the buffer to fill it. This is only a concern
// with the variadic ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %r8, (%rsp)
leaq 0x8(%rdx), %rax
cmpq %rcx, %rax
ja 0x247f89f
movq (%rsp), %rcx
movq %rcx, (%r13)
movq %rax, %r13
cmpq %r14, %rax
jbe 0x247f938
movq %r14, %r12
subq %r13, %r12
mov... | /llvm/ADT/Hashing.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ScopedHashTableVal<llvm::Value*, (anonymous namespace)::EarlyCSE::LoadValue>*>>, llvm::Value*, llvm:... | 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 |
llvm::ScopedHashTableScope<llvm::MemoryLocation, unsigned int, llvm::DenseMapInfo<llvm::MemoryLocation, void>, llvm::RecyclingAllocator<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>, llvm::ScopedHashTableVal<llvm::MemoryLocation, unsigned int>, 72ul, 8ul>>::~ScopedHashTableScope() | ScopedHashTableScope<K, V, KInfo, Allocator>::~ScopedHashTableScope() {
assert(HT.CurScope == this && "Scope imbalance!");
HT.CurScope = PrevScope;
// Pop and delete all values corresponding to this scope.
while (ScopedHashTableVal<K, V> *ThisEntry = LastValInScope) {
// Pop this value out of the TopLevelM... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x80(%rax)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x2481c2a
movq (%rbx), %rdi
addq $0x68, %rdi
leaq 0x10(%r14), %rsi
cmpq $0x0, 0x8(%r14)
je 0x2481c0d
callq 0x24806d8
movq 0x8(%r14), %rcx
movq %rcx, 0x30(%rax)
jmp 0x24... | /llvm/ADT/ScopedHashTable.h |
llvm::Float2IntPass::runImpl(llvm::Function&, llvm::DominatorTree const&) | bool Float2IntPass::runImpl(Function &F, const DominatorTree &DT) {
LLVM_DEBUG(dbgs() << "F2I: Looking at function " << F.getName() << "\n");
// Clear out all state.
ECs = EquivalenceClasses<Instruction*>();
SeenInsts.clear();
ConvertedInsts.clear();
Roots.clear();
Ctx = &F.getParent()->getContext();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x90, %rdi
mov... | /Transforms/Scalar/Float2Int.cpp |
llvm::gvn::AvailableValueInBlock::MaterializeAdjustedValue(llvm::LoadInst*, llvm::GVNPass&) const | Value *MaterializeAdjustedValue(LoadInst *Load, GVNPass &gvn) const {
return AV.MaterializeAdjustedValue(Load, BB->getTerminator(), gvn);
} | movq (%rdi), %rcx
movq 0x30(%rcx), %rax
addq $0x30, %rcx
cmpq %rcx, %rax
je 0x2490c04
leaq -0x18(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movzbl (%rcx), %eax
addl $-0x1e, %eax
xorl %edx, %edx
cmpl $0xb, %eax
cmovbq %rcx, %rdx
jmp 0x2490c06
xorl %edx, %edx
addq $0x8, %rdi
jmp 0x248aa70
nop
| /Transforms/Scalar/GVN.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, std::unique_ptr<llvm::iplist<llvm::MemoryAccess, llvm::ilist_tag<llvm::MSSAHelpers::AllAccessTag>>, std::default_delete<llvm::iplist<llvm::MemoryAccess, llvm::ilist_tag<llvm::MSSAHelpers::AllAccessTag>>>>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>,... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x24911a7
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::DenseMap<llvm::GVNPass::Expression, unsigned int, llvm::DenseMapInfo<llvm::GVNPass::Expression, void>, llvm::detail::DenseMapPair<llvm::GVNPass::Expression, 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 %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x2491d14
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, %ecx
movl %ecx, %edx
shrl... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<unsigned int, llvm::PHINode*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::PHINode*>>::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 0x2491e24
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::DenseMap<unsigned int, llvm::PHINode*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::PHINode*>>::copyFrom(llvm::DenseMap<unsigned int, llvm::PHINode*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::PHINode*>> 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 0x1cac6c2
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
testq %r15, %r15
je 0x24923b7
movq %r15, %rdi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x1cac6bd
jmp 0x24923b9
xorl %eax, %e... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<std::pair<unsigned int, llvm::BasicBlock const*>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::BasicBlock const*>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::BasicBlock const*>, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<std::pa... | 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 0x2493956
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x2493a66
xorl %ecx, %ecx
jmp 0x2493a8e
movq %r... | /llvm/ADT/DenseMap.h |
llvm::GVNHoist::hasEHOrLoadsOnPath(llvm::Instruction const*, llvm::MemoryDef*, int&) | bool GVNHoist::hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
int &NBBsOnAllPaths) {
const BasicBlock *NewBB = NewPt->getParent();
const BasicBlock *OldBB = Def->getBlock();
assert(DT->dominates(NewBB, OldBB) && "invalid path");
assert(DT->dominates(Def->getDefini... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r14
movq %rdi, %r13
movq %rsi, (%rsp)
movq 0x28(%rsi), %r15
movq %rdx, 0x8(%rsp)
movq 0x40(%rdx), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
ca... | /Transforms/Scalar/GVNHoist.cpp |
llvm::GVNExpression::BasicExpression::getHashValue() const | unsigned getOpcode() const { return Opcode; } | pushq %r14
pushq %rbx
subq $0x98, %rsp
movl 0xc(%rdi), %r14d
leaq 0x28(%rdi), %rbx
movq 0x18(%rdi), %rax
movl 0x24(%rdi), %ecx
leaq (%rax,%rcx,8), %rsi
movq %rax, %rdi
callq 0x230eb50
leaq 0x8(%rsp), %r9
movq %rax, (%r9)
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rcx)
movaps %xmm0, 0x20(%rcx)
movaps ... | /llvm/Transforms/Scalar/GVNExpression.h |
llvm::BlockFrequencyAnalysis::Result* llvm::JumpThreadingPass::runExternalAnalysis<llvm::BlockFrequencyAnalysis>() | typename AnalysisT::Result *JumpThreadingPass::runExternalAnalysis() {
assert(FAM && "Can't run external analysis without FunctionAnalysisManager");
// If there were no changes since last call to 'runExternalAnalysis' then all
// analysis is either up to date or explicitly invalidated. Just go ahead and
// run... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x58(%rdi)
je 0x24b7b44
movb $0x0, 0x58(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24aef04
leaq 0x3463aee(%rip), %rsi # 0x591b568
movq %r14, %rdi
callq 0xbcfb74
leaq 0x34634c7(%rip), %r15 # 0x591af50
movq %r14, %rdi
movq... | /Transforms/Scalar/JumpThreading.cpp |
llvm::SmallDenseMap<llvm::StoreInst*, llvm::StoreInst*, 4u, llvm::DenseMapInfo<llvm::StoreInst*, void>, llvm::detail::DenseMapPair<llvm::StoreInst*, llvm::StoreInst*>>::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 0x24d8bcc
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::StoreInst*, llvm::StoreInst*, 4u, llvm::DenseMapInfo<llvm::StoreInst*, void>, llvm::detail::DenseMapPair<llvm::StoreInst*, llvm::StoreInst*>>, llvm::StoreInst*, llvm::StoreInst*, llvm::DenseMapInfo<llvm::StoreInst*, void>, llvm::detail::DenseMapPair<llvm::StoreInst*, ll... | 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 0x24d915d
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 |
bool llvm::PatternMatch::BinOpPred_match<match_LoopInvariant<llvm::PatternMatch::bind_ty<llvm::Value>>, llvm::PatternMatch::bind_ty<llvm::Instruction>, llvm::PatternMatch::is_shift_op, false>::match<llvm::Instruction>(llvm::Instruction*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<Instruction>(V))
return this->isOpType(I->getOpcode()) &&
((L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))));
return false;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x24dca97
movzbl (%rbx), %eax
addl $-0x36, %eax
cmpl $0x2, %eax
ja 0x24dcae9
movq %rdi, %r14
movl 0x4(%rbx), %eax
btl $0x1e, %eax
jb 0x24dca99
shll $0x5, %eax
movq %rbx, %rcx
subq %rax, %rcx
jmp 0x24dca9d
jmp 0x24dcaeb
movq -0x8(%rbx), %rcx
movq (%rcx... | /llvm/IR/PatternMatch.h |
verifyTripCount(llvm::Value*, llvm::Loop*, llvm::SmallPtrSetImpl<llvm::Instruction*>&, llvm::PHINode*&, llvm::Value*&, llvm::BinaryOperator*&, llvm::BranchInst*&, llvm::ScalarEvolution*, bool) | static bool verifyTripCount(Value *RHS, Loop *L,
SmallPtrSetImpl<Instruction *> &IterationInstructions,
PHINode *&InductionPHI, Value *&TripCount, BinaryOperator *&Increment,
BranchInst *&BackBranch, ScalarEvolution *SE, bool IsWidened) {
const SCEV *BackedgeTakenCount = SE->getBackedgeTakenCount(L);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
xorl %r14d, %r14d
movq %r9, %rdi
xorl %edx, %edx
callq 0x29867d6
movq %rax, %rbp
movq %rax, %rdi
callq 0x296dc16
testb %al, %a... | /Transforms/Scalar/LoopFlatten.cpp |
llvm::DenseMap<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>>>::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::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::SmallVector<llvm::WeakTrackingVH, 2u>, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SmallVector<llvm::WeakTrackingVH, 2u>>>, llvm::SCEV const*, llvm::SmallVector<llvm::WeakTrackingVH, 2u>, llvm::DenseMapInfo<l... | 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 0x252bb7a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x252bb70
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x252bc0a
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0... | /llvm/ADT/DenseMap.h |
llvm::GVNExpression::AggregateValueExpression::equals(llvm::GVNExpression::Expression const&) const | bool equals(const Expression &Other) const override {
if (!this->BasicExpression::equals(Other))
return false;
const AggregateValueExpression &OE = cast<AggregateValueExpression>(Other);
return NumIntOperands == OE.NumIntOperands &&
std::equal(int_op_begin(), int_op_end(), OE.int_op_begin()... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x249f99e
testb %al, %al
je 0x2533275
movl 0x34(%r14), %edx
cmpl 0x34(%rbx), %edx
jne 0x2533275
testq %rdx, %rdx
je 0x253327f
movq 0x38(%r14), %rdi
movq 0x38(%rbx), %rsi
shlq $0x2, %rdx
callq 0x751d10
testl %eax, %eax
sete %al
jmp 0x2533277
xorl %ea... | /llvm/Transforms/Scalar/GVNExpression.h |
(anonymous namespace)::NewGVN::performCongruenceFinding(llvm::Instruction*, llvm::GVNExpression::Expression const*) | void NewGVN::performCongruenceFinding(Instruction *I, const Expression *E) {
// This is guaranteed to return something, since it will at least find
// TOP.
CongruenceClass *IClass = ValueToClass.lookup(I);
assert(IClass && "Should have found a IClass");
// Dead classes should have been eliminated from the ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x578(%rdi), %rbp
movq %rbp, %rdi
callq 0x2539c36
movq %rax, %r13
movl 0x8(%r12), %eax
cmpl $0x2, %eax
setne %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
je 0x25387c0
cmpl $0x3, %eax
jne... | /Transforms/Scalar/NewGVN.cpp |
(anonymous namespace)::NewGVN::createExpression(llvm::Instruction*) const | NewGVN::ExprResult NewGVN::createExpression(Instruction *I) const {
auto *E = new (ExpressionAllocator) BasicExpression(I->getNumOperands());
// TODO: we need to remove context instruction after Value Tracking
// can run without context instruction
const SimplifyQuery Q = SQ.getWithInstruction(I);
bool AllCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x48(%rsi), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x8c3eba
movl $0x7ffffff, %ecx # imm = 0x7FFFFFF
andl 0x4(%r15), %ecx
movq %rax, %r14
movabsq $-0x2fffffffa, %rax # i... | /Transforms/Scalar/NewGVN.cpp |
llvm::GVNExpression::BasicExpression::deallocateOperands(llvm::ArrayRecycler<llvm::Value*, 8ul>&) | void deallocateOperands(RecyclerType &Recycler) {
Recycler.deallocate(RecyclerCapacity::get(MaxOperands), Operands);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x20(%rdi), %eax
movl %eax, %ecx
decq %rcx
je 0x2539dcc
bsrq %rcx, %rcx
xorq $0x3f, %rcx
jmp 0x2539dd1
movl $0x40, %ecx
movb $0x40, %dl
subb %cl, %dl
testl %eax, %eax
movzbl %dl, %ecx
cmovel %eax, %ecx
movq 0x18(%rdi), %r14
movzbl %cl, %r15d
cmpl %r15d, 0x8(%rbx)
ja... | /llvm/Transforms/Scalar/GVNExpression.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::IntrinsicInst const*, llvm::Value const*, llvm::DenseMapInfo<llvm::IntrinsicInst const*, void>, llvm::detail::DenseMapPair<llvm::IntrinsicInst const*, llvm::Value const*>>, llvm::IntrinsicInst const*, llvm::Value const*, llvm::DenseMapInfo<llvm::IntrinsicInst const*, void>, 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 %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 0x253b893
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::MemoryAccess const*, llvm::SmallPtrSet<llvm::MemoryAccess*, 2u>>* llvm::DenseMapBase<llvm::DenseMap<llvm::MemoryAccess const*, llvm::SmallPtrSet<llvm::MemoryAccess*, 2u>, llvm::DenseMapInfo<llvm::MemoryAccess const*, void>, llvm::detail::DenseMapPair<llvm::MemoryAccess const*, llvm::Sma... | 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 0x253ba8d
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::DenseMap<llvm::Instruction const*, llvm::MemoryUseOrDef*, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::MemoryUseOrDef*>>::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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, llvm::SmallPtrSet<llvm::Instruction*, 2u>, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::SmallPtrSet<llvm::Instruction*, 2u>>>, llvm::Value const*, llvm::SmallPtrSet<llvm::Instruction*, 2u>, llvm::DenseMapInf... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x253dfe3
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, %r11d
imulq $0x38, %r11, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::IntrinsicInst const*, llvm::Value const*, llvm::DenseMapInfo<llvm::IntrinsicInst const*, void>, llvm::detail::DenseMapPair<llvm::IntrinsicInst const*, llvm::Value const*>>::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 0x2540268
decl %eax
je 0x254026c
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x2540271
xorl %ebp, %ebp
jmp 0x2540287
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::PlaceBackedgeSafepointsLegacyPass::runOnFunction(llvm::Function&) | bool runOnFunction(Function &F) override {
SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
for (Loop *I : *LI) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x33e05e7(%rip), %rcx # 0x592239c
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x2541dc2
movq 0x8(%rdx), %rdi
je 0x2541dcc
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x2541db5
movq... | /Transforms/Scalar/PlaceSafepoints.cpp |
EmitAddTreeOfValues(llvm::ilist_iterator_w_bits<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void, true, llvm::BasicBlock>, false, false>, llvm::SmallVectorImpl<llvm::WeakTrackingVH>&) | static Value *EmitAddTreeOfValues(BasicBlock::iterator It,
SmallVectorImpl<WeakTrackingVH> &Ops) {
if (Ops.size() == 1) return Ops.back();
Value *V1 = Ops.pop_back_val();
Value *V2 = EmitAddTreeOfValues(It, Ops);
return CreateAdd(V2, V1, "reass.add", It, &*It);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl 0x8(%rdx), %eax
cmpq $0x1, %rax
jne 0x25460a6
movq (%r15), %rcx
leaq (%rax,%rax,2), %rax
movq -0x8(%rcx,%rax,8), %rax
jmp 0x2546134
movq %rsi, %rbx
movq %rdi, %r14
movq (%r15), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdx
addq $... | /Transforms/Scalar/Reassociate.cpp |
llvm::DenseMap<llvm::AssertingVH<llvm::Instruction>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Instruction>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::Instruction>>>::copyFrom(llvm::DenseMap<llvm::AssertingVH<llvm::Instruction>, llvm::detail::DenseSetEmpty, llvm::DenseMapIn... | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl 0x10(%r14), %edi
movl %edi, 0x10(%rbx)
testq %rdi, %rdi
je 0x254a96f
shlq $0x3, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<llvm::Value*, llvm::Value*>, llvm::ReassociatePass::PairMapValue, llvm::DenseMapInfo<std::pair<llvm::Value*, llvm::Value*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, llvm::Value*>, llvm::ReassociatePass::PairMapValue>>::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 0x1c1872e
testl %ebp, %ebp
je 0x254de19
decl %ebp
je 0x254de1d
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x254de22
xorl %ebp, %ebp
jmp 0x254de38
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
extractVector(llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>&, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&) | static Value *extractVector(IRBuilderTy &IRB, Value *V, unsigned BeginIndex,
unsigned EndIndex, const Twine &Name) {
auto *VecTy = cast<FixedVectorType>(V->getType());
unsigned NumElements = EndIndex - BeginIndex;
assert(NumElements <= VecTy->getNumElements() && "Too many elements!");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq 0x8(%rsi), %rdx
movl %ecx, %eax
subl %ebp, %eax
cmpl 0x20(%rdx), %eax
je 0x256b08d
movq %r8, %r15
movq %rdi, %r14
cmpl $0x1, %eax
jne 0x256af7e
movq 0x48(%r14), %rdi
callq 0x1a89f44
movl %ebp, %esi
mo... | /Transforms/Scalar/SROA.cpp |
(anonymous namespace)::AllocaSliceRewriter::visitMemSetInst(llvm::MemSetInst&) | bool visitMemSetInst(MemSetInst &II) {
LLVM_DEBUG(dbgs() << " original: " << II << "\n");
assert(II.getRawDest() == OldPtr);
AAMDNodes AATags = II.getAAMetadata();
// If the memset has a variable size, it cannot be split, just adjust the
// pointer to the new alloca.
if (!isa<ConstantInt>(I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %rdi
callq 0x1a6ca84
movl 0x4(%rbx), %eax
shll $0x5, %eax
movq %rbx, %rcx
subq %rax, %rcx
movq 0x40(%rcx), %rax
cmpb $0x11, (%rax)
jne 0x256bba5
movl $0xc8, %r15d
addq 0x10(%r14), %r15
mov... | /Transforms/Scalar/SROA.cpp |
bool llvm::is_contained<llvm::iterator_range<llvm::DbgVariableRecord::location_op_iterator>, llvm::Value*>(llvm::iterator_range<llvm::DbgVariableRecord::location_op_iterator>&&, llvm::Value* const&) | location_op_iterator(const location_op_iterator &R) : I(R.I) {} | movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
jne 0x256d0e9
movq %rcx, %rsi
jmp 0x256d12c
movq (%rsi), %rdx
movq %rcx, %rsi
andq $-0x8, %rsi
testb $0x4, %cl
je 0x256d0fb
movq (%rsi), %rsi
cmpq %rdx, 0x80(%rsi)
je 0x256d0e4
movq %rcx, %rdi
andq $-0x4, %rdi
addq $0x8, %rdi
movq %rcx, %rsi
andq $-0x8, %rsi
addq $... | /llvm/IR/DebugProgramInstruction.h |
optimizeBlock(llvm::BasicBlock&, bool&, llvm::TargetTransformInfo const&, llvm::DataLayout const&, llvm::DomTreeUpdater*) | static bool optimizeBlock(BasicBlock &BB, bool &ModifiedDT,
const TargetTransformInfo &TTI, const DataLayout &DL,
DomTreeUpdater *DTU) {
bool MadeChange = false;
BasicBlock::iterator CurInstIterator = BB.begin();
while (CurInstIterator != BB.end()) {
if (Ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %r8, 0x1b8(%rsp)
movq %rcx, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movq %rsi, %r14
movq %rdi, %r13
movq 0x38(%rdi), %rax
addq $0x30, %r13
leaq 0xf0(%rsp), %rcx
leaq 0x80(%rcx), %rdx
movq %rdx, 0xd8(%rsp)
addq $... | /Transforms/Scalar/ScalarizeMaskedMemIntrin.cpp |
void llvm::SmallVectorImpl<llvm::Loop const*>::append<__gnu_cxx::__normal_iterator<llvm::Loop* const*, std::vector<llvm::Loop*, std::allocator<llvm::Loop*>>>, void>(__gnu_cxx::__normal_iterator<llvm::Loop* const*, std::vector<llvm::Loop*, std::allocator<llvm::Loop*>>>, __gnu_cxx::__normal_iterator<llvm::Loop* const*, s... | 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 %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
subq %rsi, %rbx
sarq $0x3, %rbx
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %rbx, %rdx
cmpq %rax, %rdx
jbe 0x2581990
leaq 0x10(%r14), %rsi
movl $0x8, %ecx
movq %r14, %rdi
callq 0x1cba528
movl 0x8(%r14), %eax
testq %rbx, %rbx
jle 0x25819... | /llvm/ADT/SmallVector.h |
void llvm::SmallVectorImpl<llvm::Loop const*>::append<std::move_iterator<llvm::Loop const**>, void>(std::move_iterator<llvm::Loop const**>, std::move_iterator<llvm::Loop 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 0x2581a0a
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.