name string | code string | asm string | file string |
|---|---|---|---|
llvm::PHITransAddr::translateWithInsertion(llvm::BasicBlock*, llvm::BasicBlock*, llvm::DominatorTree const&, llvm::SmallVectorImpl<llvm::Instruction*>&) | Value *
PHITransAddr::translateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB,
const DominatorTree &DT,
SmallVectorImpl<Instruction *> &NewInsts) {
unsigned NISize = NewInsts.size();
// Attempt to PHI translate with insertion.
Addr = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r15
movl 0x8(%rbx), %ebp
movq (%rdi), %rsi
movq %rbx, %r9
callq 0x295e174
movq %rax, %r14
movq %rax, (%r15)
testq %rax, %rax
je 0x295e151
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
p... | /Analysis/PHITransAddr.cpp |
llvm::PHITransAddr::insertTranslatedSubExpr(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::DominatorTree const&, llvm::SmallVectorImpl<llvm::Instruction*>&) | Value *PHITransAddr::insertTranslatedSubExpr(
Value *InVal, BasicBlock *CurBB, BasicBlock *PredBB,
const DominatorTree &DT, SmallVectorImpl<Instruction *> &NewInsts) {
// See if we have a version of this value already available and dominating
// PredBB. If so, there is no need to insert a new instance of i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, 0x40(%rsp)
movq %rsi, %r14
movq %rdi, %rbp
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
leaq 0x118(%rsp), %r12
movq %rsi, -0x30(%r12)
movq %rax, -0x28(%r12)... | /Analysis/PHITransAddr.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::SmallSetVector<llvm::Value*, 4u>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::SmallSetVector<llvm::Value*, 4u>>>, unsigned int, llvm::SmallSetVector<llvm::Value*, 4u>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::D... | 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 0x2960bf4
movl %eax, %ebp
testb %al, %al
je 0x295f00d
movq 0x8(%rsp), %r14
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x295efde
callq 0x751980
movq 0x8(%r14), %rdi
movl 0x18(%r14), %esi
shlq $0x3, %rsi
movl ... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::PhiValues::PhiValuesCallbackVH>* llvm::DenseMapBase<llvm::DenseMap<llvm::PhiValues::PhiValuesCallbackVH, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseSetPair<llvm::PhiValues::PhiValuesCallbackVH>>, llvm::PhiValues::PhiValuesCallbackVH, llvm::de... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x29603da
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::ProfileSummaryInfoWrapperPass::doInitialization(llvm::Module&) | bool ProfileSummaryInfoWrapperPass::doInitialization(Module &M) {
PSI.reset(new ProfileSummaryInfo(M));
return false;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x751940
movq %rax, %r15
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
xorl %eax, %eax
movb %al, 0x18(%r15)
movb %al, 0x28(%r15)
movb %al, 0x31(%r15)
movb %al, 0x33(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r15)
movl $0x0, 0x48(%r15)
mo... | /Analysis/ProfileSummaryInfo.cpp |
llvm::detail::PtrUseVisitorBase::adjustOffsetForGEP(llvm::GetElementPtrInst&) | bool detail::PtrUseVisitorBase::adjustOffsetForGEP(GetElementPtrInst &GEPI) {
if (!IsOffsetKnown)
return false;
APInt TmpOffset(DL.getIndexTypeSizeInBits(GEPI.getType()), 0);
if (GEPI.accumulateConstantOffset(DL, TmpOffset)) {
Offset += TmpOffset.sextOrTrunc(Offset.getBitWidth());
return true;
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x150(%rdi)
jne 0x2962b33
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x19e9c44
movq %rsp, %r15
movq %r15, %rdi
movl %eax, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8ef112
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
c... | /Analysis/PtrUseVisitor.cpp |
llvm::RegionBase<llvm::RegionTraits<llvm::Function>>::verifyRegion() const | void RegionBase<Tr>::verifyRegion() const {
// Only do verification when user wants to, otherwise this expensive check
// will be invoked by PMDataManager::verifyPreservedAnalysis when
// a regionpass (marked PreservedAll) finish.
if (!RegionInfoBase<Tr>::VerifyRegionInfo)
return;
std::set<BlockT *> visi... | leaq 0x2fbe049(%rip), %rax # 0x5921048
cmpb $0x1, (%rax)
jne 0x2963049
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%rdi), %rsi
andq $-0x8, %rsi
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x29... | /llvm/Analysis/RegionInfoImpl.h |
llvm::RegionBase<llvm::RegionTraits<llvm::Function>>::RegionBase(llvm::BasicBlock*, llvm::BasicBlock*, llvm::RegionInfo*, llvm::DominatorTree*, llvm::Region*) | static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {
intptr_t IntWord = static_cast<intptr_t>(Int);
assert((IntWord & ~IntMask) == 0 && "Integer too large for field");
// Preserve all bits other than the ones we are updating.
return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;
} | orq $0x4, %rsi
movq %rsi, (%rdi)
movq %r9, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
leaq 0x48(%rdi), %rcx
movl $0x0, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %rax,... | /llvm/ADT/PointerIntPair.h |
llvm::RegionBase<llvm::RegionTraits<llvm::Function>>::getExpandedRegion() const | typename Tr::RegionT *RegionBase<Tr>::getExpandedRegion() const {
unsigned NumSuccessors = Tr::getNumSuccessors(exit);
if (NumSuccessors == 0)
return nullptr;
RegionT *R = RI->getRegionFor(exit);
if (R->getEntry() != exit) {
for (BlockT *Pred : llvm::inverse_children<BlockT *>(getExit()))
if (!... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x30(%r15), %rax
leaq -0x18(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
movzbl (%rdi), %eax
addl $-0x1e, %eax
xorl %r14d, %r14d
cmpl $0xb, %eax
cmovaeq %r14, %rdi
callq 0x1a4153c
testl %eax, %eax
je 0x2... | /llvm/Analysis/RegionInfoImpl.h |
llvm::RGPassManager::runOnFunction(llvm::Function&) | bool RGPassManager::runOnFunction(Function &F) {
RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
bool Changed = false;
// Collect inherited analysis from Module level pass manager.
populateInheritedAnalysis(TPM->activeStack);
addRegionIntoQueue(*RI->getTopLevelRegion(), RQ);
if (RQ.empty()) // No re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x2fb8859(%rip), %rcx # 0x5921368
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x2968b1c
movq 0x8(%rdx), %rdi
je 0x2968b26
movq %rsi, %rdx
... | /Analysis/RegionPass.cpp |
llvm::DOTGraphTraitsPrinterWrapperPass<llvm::RegionInfoPass, false, llvm::RegionInfo*, (anonymous namespace)::RegionInfoPassGraphTraits>::~DOTGraphTraitsPrinterWrapperPass() | DOTGraphTraitsPrinterWrapperPass(StringRef GraphName, char &ID)
: FunctionPass(ID), Name(GraphName) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x2f09f03(%rip), %rax # 0x5873ef8
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x296a010
movq (%rax), %rsi
incq %rsi
callq 0x7510e0
movq %rbx, %rdi
popq %rbx
jmp 0x1a7c91e
nop
| /llvm/Analysis/DOTGraphTraitsPass.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [59], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<bool>>(char const (&) [59], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<bool> 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 0x2d75f5... | /llvm/Support/CommandLine.h |
llvm::ScalarEvolution::getOrCreateAddExpr(llvm::ArrayRef<llvm::SCEV const*>, llvm::SCEV::NoWrapFlags) | const SCEV *
ScalarEvolution::getOrCreateAddExpr(ArrayRef<const SCEV *> Ops,
SCEV::NoWrapFlags Flags) {
FoldingSetNodeID ID;
ID.AddInteger(scAddExpr);
for (const SCEV *Op : Ops)
ID.AddPointer(Op);
void *IP = nullptr;
SCEVAddExpr *S =
static_cast<SCEVAddExpr *>(Uni... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x7d... | /Analysis/ScalarEvolution.cpp |
llvm::ScalarEvolution::getOrCreateMulExpr(llvm::ArrayRef<llvm::SCEV const*>, llvm::SCEV::NoWrapFlags) | const SCEV *
ScalarEvolution::getOrCreateMulExpr(ArrayRef<const SCEV *> Ops,
SCEV::NoWrapFlags Flags) {
FoldingSetNodeID ID;
ID.AddInteger(scMulExpr);
for (const SCEV *Op : Ops)
ID.AddPointer(Op);
void *IP = nullptr;
SCEVMulExpr *S =
static_cast<SCEVMulExpr *>(Uniqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp), %rdi
movl $0x6, %esi
callq 0x7d... | /Analysis/ScalarEvolution.cpp |
llvm::ScalarEvolution::createNodeForPHI(llvm::PHINode*) | const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
if (const SCEV *S = createAddRecFromPHI(PN))
return S;
if (Value *V = simplifyInstruction(PN, {getDataLayout(), &TLI, &DT, &AC}))
return getSCEV(V);
if (const SCEV *S = createNodeFromSelectLikePHI(PN))
return S;
// If it's not a loop ph... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x297dce8
movq %rax, %r15
testq %rax, %rax
jne 0x297e778
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movdqu 0x20(%r14), %xmm0
pshufd $0x4e, %xmm0, %xmm0 # xmm... | /Analysis/ScalarEvolution.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::SmallPtrSet<llvm::SCEV const*, 8u>, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SmallPtrSet<llvm::SCEV const*, 8u>>>, llvm::SCEV const*, llvm::SmallPtrSet<llvm::SCEV const*, 8u>, llvm::DenseMapInfo<llvm::SCEV... | 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 0x29aa8ee
movl 0x10(%rbx), %ecx
imulq $0x68, %rcx, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq... | /llvm/ADT/DenseMap.h |
llvm::ScalarEvolution::computeExitLimitFromCondFromBinOp(llvm::ScalarEvolution::ExitLimitCache&, llvm::Loop const*, llvm::Value*, bool, bool, bool) | std::optional<ScalarEvolution::ExitLimit>
ScalarEvolution::computeExitLimitFromCondFromBinOp(
ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
bool ControlsOnlyExit, bool AllowPredicates) {
// Check if the controlling expression for this loop is an And or Or.
Value *Op0, *Op1;
boo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %r9d, %ebx
movq %rcx, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
leaq 0x30(%rsp), %r15
leaq 0x58(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x28(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %r8, 0x20... | /Analysis/ScalarEvolution.cpp |
llvm::operator<<(llvm::raw_ostream&, llvm::ScalarEvolution::BlockDisposition) | raw_ostream &operator<<(raw_ostream &OS, ScalarEvolution::BlockDisposition BD) {
switch (BD) {
case ScalarEvolution::DoesNotDominateBlock:
OS << "DoesNotDominate";
break;
case ScalarEvolution::DominatesBlock:
OS << "Dominates";
break;
case ScalarEvolution::ProperlyDominatesBlock:
OS << "Prop... | pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x2996ab8
cmpl $0x1, %esi
je 0x2996aaa
testl %esi, %esi
jne 0x2996acc
leaq 0x26a46d3(%rip), %rsi # 0x503b176
movl $0xf, %edx
jmp 0x2996ac4
leaq 0x26a46dd(%rip), %rsi # 0x503b18e
movl $0x9, %edx
jmp 0x2996ac4
leaq 0x26a46c7(%rip), %rsi # 0x503b186
movl $0x11, %edx
movq... | /Analysis/ScalarEvolution.cpp |
PrintLoopInfo(llvm::raw_ostream&, llvm::ScalarEvolution*, llvm::Loop const*) | static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
const Loop *L) {
// Print all inner loops first
for (Loop *I : *L)
PrintLoopInfo(OS, SE, I);
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
SmallVector<BasicBlock *, 8> Exitin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x8(%rdx), %rbx
movq 0x10(%rdx), %r14
cmpq %r14, %rbx
je 0x29974e8
movq (%rbx), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x29974ad
addq $0x8, %rbx
jmp 0x29974cf
leaq 0x26a411b(%rip),... | /Analysis/ScalarEvolution.cpp |
llvm::ScalarEvolution::computeLoopDisposition(llvm::SCEV const*, llvm::Loop const*) | ScalarEvolution::LoopDisposition
ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
switch (S->getSCEVType()) {
case scConstant:
case scVScale:
return LoopInvariant;
case scAddRecExpr: {
const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
// If L is the addrec's loop, it's comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
movzwl 0x18(%rsi), %eax
movl $0x1, %ebp
leaq 0x26a2a49(%rip), %rcx # 0x503a688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
callq 0x296daf2
testq %rdx, %rdx
sete %r13... | /Analysis/ScalarEvolution.cpp |
llvm::ScalarEvolutionWrapperPass::ScalarEvolutionWrapperPass() | ScalarEvolutionWrapperPass::ScalarEvolutionWrapperPass() : FunctionPass(ID) {
initializeScalarEvolutionWrapperPassPass(*PassRegistry::getPassRegistry());
} | pushq %rax
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x2f8731c(%rip), %rcx # 0x592239c
movq %rcx, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
leaq 0x2ed935e(%rip), %rcx # 0x58743f0
addq $0x10, %rcx
movq %rcx, (%rdi)
movq %rax, 0x20(%rdi)
callq 0x1a82116
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x2f872e9(%rip), %rdi # 0x592239... | /Analysis/ScalarEvolution.cpp |
llvm::SCEVUnionPredicate::add(llvm::SCEVPredicate const*) | void SCEVUnionPredicate::add(const SCEVPredicate *N) {
if (const auto *Set = dyn_cast<SCEVUnionPredicate>(N)) {
for (const auto *Pred : Set->Preds)
add(Pred);
return;
}
// Only add predicate if it is not already implied by this union predicate.
if (!implies(N))
Preds.push_back(N);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x20(%rsi)
setne %al
testq %rsi, %rsi
sete %bpl
orb %al, %bpl
jne 0x299b84e
movl 0x30(%rbx), %r15d
testq %r15, %r15
je 0x299b849
movq 0x28(%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13... | /Analysis/ScalarEvolution.cpp |
llvm::PredicatedScalarEvolution::PredicatedScalarEvolution(llvm::ScalarEvolution&, llvm::Loop&) | PredicatedScalarEvolution::PredicatedScalarEvolution(ScalarEvolution &SE,
Loop &L)
: SE(SE), L(L) {
SmallVector<const SCEVPredicate*, 4> Empty;
Preds = std::make_unique<SCEVUnionPredicate>(Empty);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
xorl %r13d, %r13d
movl %r13d, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x80, 0x28(%rdi)
movl $0x1800, %edi # imm = 0x1800
movl $0x8, %esi
callq 0x1cac6b... | /Analysis/ScalarEvolution.cpp |
(anonymous namespace)::BinaryOp::BinaryOp(llvm::Operator*) | unsigned getValueID() const {
return SubclassID;
} | movzbl (%rsi), %ecx
leal -0x1d(%rcx), %edx
cmpl $0x1d, %ecx
movzwl 0x2(%rsi), %eax
cmovbl %eax, %edx
movl %edx, (%rdi)
movl 0x4(%rsi), %edx
btl $0x1e, %edx
jb 0x299fe0a
shll $0x5, %edx
movq %rsi, %r8
subq %rdx, %r8
jmp 0x299fe0e
movq -0x8(%rsi), %r8
movq (%r8), %rdx
movq %rdx, 0x8(%rdi)
movl 0x4(%rsi), %edx
btl $0x1e, ... | /llvm/IR/Value.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>>, llvm::SCEV const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::S... | 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 0x20d7a0c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x29a4e96
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x20d7aec
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::APInt, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::APInt>>, llvm::SCEV const*, llvm::APInt, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::APInt>>::Looku... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x29a5822
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
leaq (%r11,%r11,2), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Loop const*, llvm::SmallVector<llvm::SCEVAddRecExpr const*, 4u>, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseMapPair<llvm::Loop const*, llvm::SmallVector<llvm::SCEVAddRecExpr const*, 4u>>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
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 %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::SCEV const*, bool, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, bool>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, bool, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, ... | 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 0x29a63e8
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x29a6506
xorl %ecx, %ecx
jmp 0x29a6526
movq %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, llvm::SmallVector<std::pair<llvm::Loop const*, llvm::SCEV const*>, 2u>, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SmallVector<std::pair<llvm::Loop const*, llvm::SCEV const*>, 2u>>>, llvm::SCEV const*, llvm::... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x29ab901
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::SmallVectorImpl<std::pair<llvm::Loop const*, llvm::SCEV const*>>::assignRemote(llvm::SmallVectorImpl<std::pair<llvm::Loop const*, llvm::SCEV const*>>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x29abd3f
callq 0x751980
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::SCEV const*, std::pair<unsigned int, llvm::SCEV const*>, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, std::pair<unsigned int, llvm::SCEV const*>>>, llvm::SCEV const*, std::pair<unsigned int, llvm::SCEV const*>, llvm::DenseMapInfo<llvm... | 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 0x29adabe
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x29adab3
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x29adb4e
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $... | /llvm/ADT/DenseMap.h |
llvm::StackLifetime::calculateLocalLiveness() | void StackLifetime::calculateLocalLiveness() {
bool Changed = true;
// LiveIn, LiveOut and BitsIn have a different meaning deppends on type.
// ::Maybe true bits represent "may be alive" allocas, ::Must true bits
// represent "may be dead". After the loop we will convert ::Must bits from
// "may be dead" to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdi, %rbx
leaq 0xb8(%rsp), %r13
leaq 0x10(%rdi), %r12
leaq 0x58(%rsp), %rbp
leaq 0x10(%rsp), %r15
movq (%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0x148(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x29b0... | /Analysis/StackLifetime.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::SmallDenseMap<llvm::IntrinsicInst const*, llvm::StackLifetime::Marker, 4u, llvm::DenseMapInfo<llvm::IntrinsicInst const*, void>, llvm::detail::DenseMapPair<llvm::IntrinsicInst const*, llvm::StackLifetime::Marker>>, llvm::DenseMapInfo<llvm::BasicBlock cons... | 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, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x29b258a
movq (%rbx), %rbx
testb %al, %al
jne 0x29b257c
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x29b2624
movq %rax, %rbx
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0... | /llvm/ADT/DenseMap.h |
int llvm::array_pod_sort_comparator<llvm::GlobalValue const*>(void const*, void const*) | inline int array_pod_sort_comparator(const void *P1, const void *P2) {
if (std::less<T>()(*reinterpret_cast<const T*>(P1),
*reinterpret_cast<const T*>(P2)))
return -1;
if (std::less<T>()(*reinterpret_cast<const T*>(P2),
*reinterpret_cast<const T*>(P1)))
return 1;
... | movq (%rdi), %rax
movq (%rsi), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
setb %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovbel %edx, %eax
retq
| /llvm/ADT/STLExtras.h |
llvm::detail::DenseMapPair<llvm::GlobalValue const*, llvm::SmallVector<llvm::GlobalValue const*, 4u>>* llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, llvm::SmallVector<llvm::GlobalValue const*, 4u>, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, llv... | 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 0x29ba88d
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::TargetLibraryInfoImpl::TargetLibraryInfoImpl(llvm::Triple const&) | TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
// Default to everything being available.
memset(AvailableArray, -1, sizeof(AvailableArray));
initialize(*this, T, StandardNames);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, 0x80(%rdi)
movl $0x0, 0x90(%rdi)
movdqu %xmm0, 0xa0(%rdi)
movdqu %xmm0, 0xb0(%rdi)
movdqu %xmm0, 0xc0(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, 0x20(%rdi)
movdqu... | /Analysis/TargetLibraryInfo.cpp |
llvm::TargetLibraryInfoImpl::addVectorizableFunctions(llvm::ArrayRef<llvm::VecDesc>) | void TargetLibraryInfoImpl::addVectorizableFunctions(ArrayRef<VecDesc> Fns) {
llvm::append_range(VectorDescs, Fns);
llvm::sort(VectorDescs, compareByScalarFnName);
llvm::append_range(ScalarDescs, Fns);
llvm::sort(ScalarDescs, compareByVectorFnName);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0xa8(%rbx), %rsi
shlq $0x6, %r14
addq %r15, %r14
movq %r15, %rdx
movq %r14, %rcx
callq 0x29c347c
movq 0xa0(%rbx), %r12
movq 0xa8(%rbx), %r13
cmpq %r13, %r12
je 0x29c17fd
mov... | /Analysis/TargetLibraryInfo.cpp |
llvm::TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass() | TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass()
: ImmutablePass(ID), TLA(TargetLibraryInfoImpl()) {
initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x2f7034a(%rip), %rax # 0x5932250
movq %rax, 0x10(%rdi)
movl $0x4, 0x18(%rdi)
leaq 0x2eb4718(%rip), %rax # 0x5876630
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x29c0... | /Analysis/TargetLibraryInfo.cpp |
llvm::TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(llvm::Triple const&) | TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(const Triple &T)
: ImmutablePass(ID), TLA(TargetLibraryInfoImpl(T)) {
initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x2f7023e(%rip), %rax # 0x5932250
movq %rax, 0x10(%rdi)
movl $0x4, 0x18(%rdi)
leaq 0x2eb460c(%rip), %rax # 0x5876630
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x29c0... | /Analysis/TargetLibraryInfo.cpp |
llvm::SmallVectorTemplateBase<llvm::cl::parser<llvm::TargetLibraryInfoImpl::VectorLibrary>::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 0x1cba3de
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x29c3301
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
xorl ... | /llvm/ADT/SmallVector.h |
llvm::IntrinsicCostAttributes::IntrinsicCostAttributes(unsigned int, llvm::Type*, llvm::ArrayRef<llvm::Value const*>) | IntrinsicCostAttributes::IntrinsicCostAttributes(Intrinsic::ID Id, Type *Ty,
ArrayRef<const Value *> Args)
: RetTy(Ty), IID(Id) {
Arguments.insert(Arguments.begin(), Args.begin(), Args.end());
ParamTys.reserve(Arguments.size());
for (const Value *Argument : Ar... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movl %esi, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movabsq $0x400000000, %rdx # imm = 0x400000000
movq %rdx, 0x20(%rdi)
addq $0x48, %rdi
leaq 0x58(%r14)... | /Analysis/TargetTransformInfo.cpp |
llvm::TargetTransformInfo::operator=(llvm::TargetTransformInfo&&) | TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
TTIImpl = std::move(RHS.TTIImpl);
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq $0x0, (%rsi)
movq (%rdi), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x29c4aed
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /Analysis/TargetTransformInfo.cpp |
llvm::TargetTransformInfoWrapperPass::getTTI(llvm::Function const&) | TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) {
FunctionAnalysisManager DummyFAM;
TTI = TIRA.run(F, DummyFAM);
return *TTI;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x1a7f062
cmpq $0x0, 0x30(%r14)
je 0x29c5e85
leaq 0x20(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq *0x38(%r14)
leaq 0x40(%r14), %rbx
cmpb $0x1, 0x48(%r14)
jne 0x29c5e00
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)... | /Analysis/TargetTransformInfo.cpp |
llvm::createTargetTransformInfoWrapperPass(llvm::TargetIRAnalysis) | ImmutablePass *
llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) {
return new TargetTransformInfoWrapperPass(std::move(TIRA));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x50, %edi
callq 0x751940
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x29c5ed8
movups (%r14), %xmm1
addq $0x10, %r14
movaps %xmm1, (%rsp)
... | /Analysis/TargetTransformInfo.cpp |
llvm::getTensorSpecFromJSON(llvm::LLVMContext&, llvm::json::Value const&) | std::optional<TensorSpec> getTensorSpecFromJSON(LLVMContext &Ctx,
const json::Value &Value) {
auto EmitError =
[&](const llvm::Twine &Message) -> std::optional<TensorSpec> {
std::string S;
llvm::raw_string_ostream OS(S);
OS << Value;
Ctx.emitError(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, 0xc0(%rsp)
movq %rsi, 0xc8(%rsp)
leaq 0x2678944(%rip), %rax # 0x503fec6
leaq 0xf0(%rsp), %rcx
movq %rax, (%rcx)
movq $0xb, 0x8(%rcx)
leaq 0x154be9c(%rip), %rax # 0x3f13438
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movup... | /Analysis/TensorSpec.cpp |
llvm::mapped_iterator<unsigned char const*, llvm::tensorValueToString[abi:cxx11](char const*, llvm::TensorSpec const&)::$_3, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator*() const | ReferenceTy operator*() const { return F(*this->I); } | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movzbl (%rax), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r14d
cmovael %eax, %r14d
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r14, %rsi
movl $0x2d, %edx
callq 0x7514a0
movq (%rbx), %rdi
movl %r14d, %esi
movl %eb... | /llvm/ADT/STLExtras.h |
llvm::Logger::writeHeader(std::optional<llvm::TensorSpec>) | void Logger::writeHeader(std::optional<TensorSpec> AdviceSpec) {
json::OStream JOS(*OS);
JOS.object([&]() {
JOS.attributeArray("features", [&]() {
for (const auto &TS : FeatureSpecs)
TS.toJSON(JOS);
});
if (IncludeReward) {
JOS.attributeBegin("score");
RewardSpec.toJSON(JOS);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%r12)
movq %rax, 0x90(%r12)
movq $0x0, 0x98(%r12)
l... | /Analysis/TrainingLogger.cpp |
llvm::Logger::switchContext(llvm::StringRef) | void Logger::switchContext(StringRef Name) {
CurrentContext = Name.str();
json::OStream JOS(*OS);
JOS.object([&]() { JOS.attribute("context", Name); });
*OS << "\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
testq %rsi, %rsi
je 0x29c967b
leaq (%r15,%r14), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x7c37bc
jmp 0x29c9689
movq $0x0, 0x8(%rsp)
movb $0x0... | /Analysis/TrainingLogger.cpp |
llvm::Logger::logRewardImpl(char const*) | void Logger::logRewardImpl(const char *RawData) {
assert(IncludeReward);
json::OStream JOS(*OS);
JOS.object([&]() {
JOS.attribute("outcome", static_cast<int64_t>(
ObservationIDs.find(CurrentContext)->second));
});
*OS << "\n";
writeTensor(RewardSpec, RawData);
*OS << "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%r14)
movq %rax, 0x90(%r... | /Analysis/TrainingLogger.cpp |
llvm::isKnownNonZero(llvm::Value const*, llvm::SimplifyQuery const&, unsigned int) | bool llvm::isKnownNonZero(const Value *V, const SimplifyQuery &Q,
unsigned Depth) {
auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
APInt DemandedElts =
FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
return ::isKnownNonZero(V, DemandedElts, Q, Depth);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x29d17a6
movzbl 0x8(%rax), %ecx
cmpl $0x12, %ecx
jne 0x29d17a6
movl 0x20(%rax), %esi
leaq 0x8(%rsp), %rdi
movq $-0x1, %rdx
movl $0x1, %ecx
callq 0x8ef112
jmp 0x29d17b7
m... | /Analysis/ValueTracking.cpp |
computeKnownBitsFromICmpCond(llvm::Value const*, llvm::ICmpInst*, llvm::KnownBits&, llvm::SimplifyQuery const&, bool) | static void computeKnownBitsFromICmpCond(const Value *V, ICmpInst *Cmp,
KnownBits &Known,
const SimplifyQuery &SQ, bool Invert) {
ICmpInst::Predicate Pred =
Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();
Value *LHS =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
movzwl 0x2(%rsi), %ebp
andl $0x3f, %ebp
testl %r8d, %r8d
je 0x29d3167
movl %ebp, %edi
callq 0x1a49f52
movl %eax, %ebp
movq -0x40(%r15), %r12
movq -0x20(%r15), %r15
cmpb $0x4... | /Analysis/ValueTracking.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::match_combine_or<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::PtrToIntSameSize_match<llvm::PatternMatch::specificval_ty>>, llvm::PatternMatch::class_match<llvm::Value>, 28u, 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 %r12
pushq %rbx
pushq %rax
cmpb $0x39, (%rsi)
jne 0x29e719a
movq %rsi, %r15
movq %rdi, %r14
movq -0x40(%rsi), %rsi
movb $0x1, %bl
cmpq %rsi, (%rdi)
je 0x29e719c
leaq 0x8(%r14), %r12
movq %r12, %rdi
callq 0x29e6d70
testb %al, %al
jne 0x29e719c
movq -0x20(%r15), %rsi
cmpq %rsi, (%r14)
je 0x29e... | /llvm/IR/PatternMatch.h |
rangeMetadataExcludesValue(llvm::MDNode const*, llvm::APInt const&) | static bool rangeMetadataExcludesValue(const MDNode* Ranges, const APInt& Value) {
const unsigned NumRanges = Ranges->getNumOperands() / 2;
assert(NumRanges >= 1);
for (unsigned i = 0; i < NumRanges; ++i) {
ConstantInt *Lower =
mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
Constant... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x30(%rsp)
movq -0x10(%rdi), %r13
testb $0x2, %r13b
jne 0x29ee9fc
shrl $0x6, %r13d
andl $0xf, %r13d
jmp 0x29eea00
movl -0x18(%rdi), %r13d
cmpl $0x2, %r13d
setb %bpl
jb 0x29eeb60
leaq -0x10(%rdi), %rbx
shrl %r13d
movq %r13, %ra... | /Analysis/ValueTracking.cpp |
getInvertibleOperands(llvm::Operator const*, llvm::Operator const*) | static std::optional<std::pair<Value*, Value*>>
getInvertibleOperands(const Operator *Op1,
const Operator *Op2) {
if (Op1->getOpcode() != Op2->getOpcode())
return std::nullopt;
auto getOperands = [&](unsigned OpNum) -> auto {
return std::make_pair(Op1->getOperand(OpNum), Op2->getOpera... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdx, 0x40(%rsp)
movzbl (%rsi), %eax
leal -0x1d(%rax), %ecx
cmpl $0x1d, %eax
movzwl 0x2(%rsi), %eax
cmovael %ecx, %eax
movq %rdi, %rbx
movzbl (%rdx), %ecx
leal -0x1d(%rcx), %edx
cmpl $0x1d, %ecx
movzwl 0x2... | /Analysis/ValueTracking.cpp |
isNonEqualMul(llvm::Value const*, llvm::Value const*, llvm::APInt const&, unsigned int, llvm::SimplifyQuery const&) | static bool isNonEqualMul(const Value *V1, const Value *V2,
const APInt &DemandedElts, unsigned Depth,
const SimplifyQuery &Q) {
if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(V2)) {
const APInt *C;
return match(OBO, m_Mul(m_Specific(V1), m_APInt(C))) &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movzbl (%rsi), %eax
cmpl $0x1d, %eax
jb 0x29ef643
leal -0x2a(%rax), %ecx
rorl %ecx
cmpl $0x6, %ecx
ja 0x29ef643
movl $0x47, %edx
btl %ecx, %edx
jb 0x29ef662
c... | /Analysis/ValueTracking.cpp |
computeKnownFPClassFromCond(llvm::Value const*, llvm::Value*, bool, llvm::Instruction const*, llvm::KnownFPClass&) | static void computeKnownFPClassFromCond(const Value *V, Value *Cond,
bool CondIsTrue,
const Instruction *CxtI,
KnownFPClass &KnownFromContext) {
CmpInst::Predicate Pred;
Value *LHS;
uint64_t Cla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, (%rsp)
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x10(%rsp)
leaq 0xc(%rsp), %r13
leaq 0x30(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x28(%rsp), %rbx
movq %rbx, 0x8(%rdi)
leaq 0x20(%rsp), %rax
movq %ra... | /Analysis/ValueTracking.cpp |
bool llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::PatternMatch::specificval_ty, llvm::PatternMatch::apint_match, llvm::PatternMatch::umax_pred_ty, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *II = dyn_cast<IntrinsicInst>(V)) {
Intrinsic::ID IID = II->getIntrinsicID();
if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
(IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
(IID == Intrinsic::umax && Pred_t::match(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x55, (%rsi)
jne 0x29f0ece
movq %r14, %rdi
callq 0x8f16ea
xorl %ecx, %ecx
testb %al, %al
cmovneq %r14, %rcx
jmp 0x29f0ed0
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x29f0f10
movq -0x20(%rcx), %rax
cmpl $0x161, 0x24(%rax) # imm =... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinOpPred_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::class_match<llvm::ConstantInt>, llvm::PatternMatch::is_bitwiselogic_op, false>::match<llvm::Value>(llvm::Value*) | unsigned getValueID() const {
return SubclassID;
} | movb (%rsi), %al
xorl %ecx, %ecx
cmpb $0x1d, %al
cmovaeq %rsi, %rcx
jb 0x29f224b
movzbl (%rcx), %edx
addl $-0x39, %edx
cmpl $0x2, %edx
ja 0x29f2249
movl 0x4(%rcx), %edx
btl $0x1e, %edx
jb 0x29f2217
shll $0x5, %edx
movq %rcx, %rsi
subq %rdx, %rsi
jmp 0x29f221b
movq -0x8(%rcx), %rsi
movq (%rsi), %rdx
testq %rdx, %rdx
je ... | /llvm/IR/Value.h |
llvm::TextInstrProfReader::readValueProfileData(llvm::InstrProfRecord&) | Error
TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
#define CHECK_LINE_END(Line) \
if (Line.is_at_end()) \
return error(instrprof_error::truncated);
#define READ_NUM(Str, Dst) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r12
movq %rdi, %r15
cmpb $0x0, 0x98(%rsi)
je 0x2a07a39
movq %rdx, 0x68(%rsp)
movq 0xa8(%r12), %rdi
movq 0xb0(%r12), %rsi
leaq 0x78(%rsp), %rbx
movl $0xa, %edx
movq %rbx, %rcx
callq 0x1cc39ba
movq (%r... | /ProfileData/InstrProfReader.cpp |
llvm::IndexedInstrProfReader::getFunctionBitmap(llvm::StringRef, unsigned long, llvm::BitVector&) | Error IndexedInstrProfReader::getFunctionBitmap(StringRef FuncName,
uint64_t FuncHash,
BitVector &Bitmap) {
Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
if (Error E = Record.takeError())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x150571f(%rip), %rax # 0x3f13438
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %ebx, %ebx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
xorl ... | /ProfileData/InstrProfReader.cpp |
llvm::IntervalMap<unsigned long, unsigned long, 4u, llvm::IntervalMapHalfOpenInfo<unsigned long>>::const_iterator::setRoot(unsigned int) | void setRoot(unsigned Offset) {
if (branched())
path.setRoot(&map->rootBranch(), map->rootSize, Offset);
else
path.setRoot(&map->rootLeaf(), map->rootSize, Offset);
} | movl %esi, %edx
movq %rdi, %rax
movq (%rdi), %rsi
addq $0x8, %rdi
cmpl $0x0, 0x60(%rsi)
je 0x2a0ebff
movl 0x64(%rsi), %ecx
addq $0x8, %rsi
jmp 0x2a0ec02
movl 0x64(%rsi), %ecx
movl $0x0, 0x10(%rax)
shlq $0x20, %rdx
orq %rcx, %rdx
jmp 0x1729884
nop
| /llvm/ADT/IntervalMap.h |
void llvm::handleAllErrors<llvm::InstrProfError::take[abi:cxx11](llvm::Error)::'lambda'(llvm::InstrProfError const&)>(llvm::Error, llvm::InstrProfError::take[abi:cxx11](llvm::Error)::'lambda'(llvm::InstrProfError const&)&&) | void handleAllErrors(Error E, HandlerTs &&... Handlers) {
cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
xorl %eax, %eax
movq %rsp, %rbx
movq %rax, (%rbx)
movq (%rdi), %rcx
movq %rcx, (%rbx)
movq %rax, (%rdi)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2a104dd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2a104d7
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/Support/Error.h |
llvm::memprof::CallStackIdConverter<llvm::OnDiskIterableChainedHashTable<llvm::memprof::CallStackLookupTrait>>::operator()(unsigned long) | std::vector<Frame> operator()(CallStackId CSId) {
std::vector<Frame> Frames;
auto CSIter = Map.find(CSId);
if (CSIter == Map.end()) {
LastUnmappedId = CSId;
} else {
llvm::SmallVector<FrameId> CS =
detail::DerefIterator<llvm::SmallVector<FrameId>>(CSIter);
Frames.reserve(CS.s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%rsi), %rsi
leaq 0x48(%rsp), %rdx
movq %r15, (%rdx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rcx
xorl %r8d, %... | /llvm/ProfileData/MemProf.h |
llvm::OnDiskIterableChainedHashTable<llvm::InstrProfLookupTrait>::iterator_base::advance() | void advance() {
using namespace llvm::support;
if (!NumItemsInBucketLeft) {
// 'Items' starts with a 16-bit unsigned integer representing the
// number of items in this bucket.
NumItemsInBucketLeft =
endian::readNext<uint16_t, llvm::endianness::little>(Ptr);
}
... | cmpq $0x0, 0x8(%rdi)
jne 0x2a138f8
movq (%rdi), %rax
movzwl (%rax), %ecx
addq $0x2, %rax
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq (%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, (%rdi)
leaq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
addq %rax, %rdx
movq %rcx, (%rdi)
movq 0x10(%rax), %rax
addq %rdx, %rax
addq $0x18, %rax
mov... | /llvm/Support/OnDiskHashTable.h |
llvm::itanium_demangle::ExprRequirement::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
OB += " ";
if (IsNoexcept || TypeConstraint)
OB.printOpen('{');
Expr->print(OB);
if (IsNoexcept || TypeConstraint)
OB.printClose('}');
if (IsNoexcept)
OB += " noexcept";
if (TypeConstraint) {
OB += " -> ";
TypeConstr... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2a1907c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x20, (%rax,%rcx)
incq 0x8(%rbx)
cmpb $0x0, 0x18(%r14)
jne 0x2a2678f
cmpq $0x0, 0x20(%r14)
je 0x2a267b2
incl 0x20(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2a... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::TypeRequirement::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
OB += " typename ";
Type->print(OB);
OB += ';';
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xa, %esi
movq %rbx, %rdi
callq 0x2a1907c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x6d616e6570797420, %rdx # imm = 0x6D616E6570797420
movq %rdx, (%rax,%rcx)
movw $0x2065, 0x8(%rax,%rcx) # imm = 0x2065
addq $0xa, 0x8(%rbx)
movq 0x10(%r14), %r... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::SubobjectExpr::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
SubExpr->print(OB);
OB += ".<";
Type->print(OB);
OB += " at offset ";
if (Offset.empty()) {
OB += "0";
} else if (Offset[0] == 'n') {
OB += "-";
OB += std::string_view(Offset.data() + 1, Offset.size() - 1);
} else {
OB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movzwl 0x9(%r15), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x2a26bbf
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movl $0x2, %esi
movq %... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseOperatorName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::Canonicaliz... | Node *
AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
if (const auto *Op = parseOperatorEncoding()) {
if (Op->getKind() == OperatorInfo::CCast) {
// ::= cv <type> # (cast)
ScopedOverride<bool> SaveTemplate(TryToParseTemplateArgs, false);
// If we're... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2a1e584
movq %rax, %r15
testq %rax, %rax
je 0x2a27e45
movb 0x2(%r15), %al
cmpb $0x8, %al
jne 0x2a27e47
movb 0x308(%rbx), %bpl
movb 0x309(%rbx), %r12b
movb $0x0, 0x308(%rbx)
testq %r14, %r14
setne %... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::PixelVectorType::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
// FIXME: This should demangle as "vector pixel".
OB += "pixel vector[";
Dimension->print(OB);
OB += "]";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xd, %esi
movq %rbx, %rdi
callq 0x2a1907c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x5b726f7463657620, %rdx # imm = 0x5B726F7463657620
movq %rdx, 0x5(%rax,%rcx)
movabsq $0x6576206c65786970, %rdx # imm = 0x6576206C65786970
movq %rdx, (%rax,%rc... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::ElaboratedTypeSpefType::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
OB += Kind;
OB += ' ';
Child->print(OB);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x2a28e96
movq 0x18(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a1907c
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x751900
addq %r15, 0x8(%rbx)
movl... | /llvm/Demangle/ItaniumDemangle.h |
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTable() | std::error_code SampleProfileReaderExtBinaryBase::readSecHdrTable() {
auto EntryNum = readUnencodedNumber<uint64_t>();
if (std::error_code EC = EntryNum.getError())
return EC;
for (uint64_t i = 0; i < (*EntryNum); i++)
if (std::error_code EC = readSecHdrTableEntry(i))
return EC;
return samplepro... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a397c4
testb $0x1, 0x10(%r14)
je 0x2a398df
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdx
jmp 0x2a398e9
xorl %ebp, %ebp
callq 0x7515e0
movq %rax, %rdx
testl %ebp, %ebp
jne 0x2a3991f
cmpq $0x0, 0x8... | /ProfileData/SampleProfReader.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DWARFUnitIndex::Entry::SectionContribution, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DWARFUnitIndex::Entry::SectionContribution>>, unsigned int, llvm::DWARFUnitIndex::Entry::SectionContribution, llvm::DenseMapInfo<unsign... | 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
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x2a4ce78
movq (%r15), %rcx
leaq (%rax,%rax,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
mov... | /llvm/ADT/DenseMap.h |
llvm::LLParser::parseUseListOrder(llvm::LLParser::PerFunctionState*) | bool LLParser::parseUseListOrder(PerFunctionState *PFS) {
SMLoc Loc = Lex.getLoc();
if (parseToken(lltok::kw_uselistorder, "expected uselistorder directive"))
return true;
Value *V;
SmallVector<unsigned, 16> Indexes;
if (parseTypeAndValue(V, PFS) ||
parseToken(lltok::comma, "expected comma in useli... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0xe0(%rdi), %rbx
leaq 0x258aa74(%rip), %rdx # 0x505ffa0
movl $0x187, %esi # imm = 0x187
callq 0x2ad5a0e
movb $0x1, %bpl
testb %al, %al
jne 0x2ad55c4
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
mova... | /AsmParser/LLParser.cpp |
llvm::dwarf::GDBIndexEntryLinkageString(llvm::dwarf::GDBIndexEntryLinkage) | StringRef
llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
switch (Linkage) {
case GIEL_EXTERNAL:
return "EXTERNAL";
case GIEL_STATIC:
return "STATIC";
}
llvm_unreachable("Unknown GDBIndexEntryLinkage value");
} | xorl %eax, %eax
testl %edi, %edi
sete %al
leaq 0x6(%rax,%rax), %rdx
leaq 0x2532ade(%rip), %rcx # 0x50685a7
leaq 0x253704a(%rip), %rax # 0x506cb1a
cmoveq %rcx, %rax
retq
| /BinaryFormat/Dwarf.cpp |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [9], llvm::itanium_demangle::Node*&>(char const (&) [9], llvm::... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbx
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x28, %esi
callq 0x2b64c28
movq (%rbx), %rcx
movb $0x15, 0x8(%rax)
movzwl 0x9(%rax), %edx
andl $0xfffff000, %edx # imm = 0xFFFFF000
orl $0x540, %edx # imm = 0x540
movw %dx, 0x9(%rax)
leaq 0x2d152a7(%rip), %rdx # 0x58799f8
add... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PointerToMemberType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x2b64c28
movq (%r14), %rcx
movq (%rbx), %rdx
movzwl 0x9(%rdx), %esi
andl $0xc0, %esi
movb $0xe, 0x8(%rax)
movzwl 0x9(%rax), %edi
andl $0xfffff000, %edi # imm = 0xFFFFF000
addl %edi, ... | /llvm/Demangle/ItaniumDemangle.h |
testing::internal::OsStackTraceGetter::UponLeavingGTest() | GTEST_LOCK_EXCLUDED_(mutex_) {
#ifdef GTEST_HAS_ABSL
void* caller_frame = nullptr;
if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
caller_frame = nullptr;
}
MutexLock lock(&mutex_);
caller_frame_ = caller_frame;
#endif // GTEST_HAS_ABSL
} | retq
nop
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
ncnn::convdw3x3s2_int8_requant_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, std::vector<float, std::allocator<float>>, ncnn::Option const&) | static void convdw3x3s2_int8_requant_sse(const Mat &bottom_blob, Mat &top_blob, const Mat &_kernel, const Mat &_bias, std::vector<float> scales_requant, const Option& opt)
{
int w = bottom_blob.w;
//int h = bottom_blob.h;
//int inch = bottom_blob.c;
int outw = top_blob.w;
int outh = top_blob.h;
... | subq $0x168, %rsp # imm = 0x168
movq %r8, 0x20(%rsp)
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movq %rcx, 0x148(%rsp)
movq %r8, 0x140(%rsp)
movq %r9, 0x138(%rsp)
movq 0x160(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x134(%rsp)
movq 0x158(%rsp), %rax
movl 0x2c(%rax), %eax
movl %e... | /xiangweizeng[P]ncnn/src/layer/x86/convolutiondepthwise_3x3_int8.h |
ncnn::Squeeze::load_param(ncnn::ParamDict const&) | int Squeeze::load_param(const ParamDict& pd)
{
squeeze_w = pd.get(0, 0);
squeeze_h = pd.get(1, 0);
squeeze_c = pd.get(2, 0);
axes = pd.get(3, Mat());
return 0;
} | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
xorl %edx, %edx
movl %edx, 0xc(%rsp)
movl %edx, %esi
callq 0x2ede0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xb8(%rax)
movq 0xb8(%rsp), %rdi
movl $0x1, %esi
callq 0... | /xiangweizeng[P]ncnn/src/layer/squeeze.cpp |
void ncnn::qsort_descent_inplace<ncnn::BBoxRect>(std::vector<ncnn::BBoxRect, std::allocator<ncnn::BBoxRect>>&, std::vector<float, std::allocator<float>>&, int, int) | static void qsort_descent_inplace(std::vector<T>& datas, std::vector<float>& scores, int left, int right)
{
int i = left;
int j = right;
float p = scores[(left + right) / 2];
while (i <= j)
{
while (scores[i] > p)
i++;
while (scores[j] < p)
j--;
if ... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
addl 0x20(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0x470... | /xiangweizeng[P]ncnn/src/layer/detectionoutput.cpp |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x16090
cmpl $0x0, %eax
je 0xaa664
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| /xiangweizeng[P]ncnn/src/allocator.h |
ncnn::set_cpu_powersave(int) | int set_cpu_powersave(int powersave)
{
if (powersave < 0 || powersave > 2)
{
fprintf(stderr, "powersave %d not supported\n", powersave);
return -1;
}
size_t thread_affinity_mask = get_cpu_thread_affinity_mask(powersave);
int ret = set_cpu_thread_affinity(thread_affinity_mask);
... | subq $0x18, %rsp
movl %edi, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0xb8356
cmpl $0x2, 0x10(%rsp)
jle 0xb837c
movq 0x27c73(%rip), %rax # 0xdffd0
movq (%rax), %rdi
movl 0x10(%rsp), %edx
leaq 0x41df(%rip), %rsi # 0xbc54a
movb $0x0, %al
callq 0x161f0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xb83bb
movl 0x... | /xiangweizeng[P]ncnn/src/cpu.cpp |
main | int main(int argc, char* argv[])
#endif
{
(void)argc;
(void)argv;
#if !defined(IUTEST_USE_GTEST)
::iutest::detail::iuConsole::SetLogger(&logger);
{
int targc = 2;
DECAL_ARGV("--feature");
IUTEST_INIT(&targc, targv);
IUTEST_EXPECT_TRUE(::iutest::TestFlag::IsEnableFlag(::i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
leaq 0x1c61c(%rip), %rax # 0x2b310
movq %rax, 0x1c65d(%rip) # 0x2b358
leaq 0x74(%rsp), %r14
movl $0x2, (%r14)
movq %rsi, 0x78(%rsp)
movq (%rsi), %rax
leaq 0x210(%rsp), %r15
movq %rax, (%r15)
leaq 0x123cf... | /srz-zumix[P]iutest/test/feature_spec_tests.cpp |
iutest::detail::iuConsole::color_output(iutest::detail::iuConsole::Color, char const*, ...) | inline void iuConsole::color_output(Color color, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
if( IsShouldUseColor(true) )
{
color_output_impl(color, fmt, va);
}
else
{
voutput(fmt, va);
}
va_end(va);
} | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xfe34
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x... | /srz-zumix[P]iutest/include/internal/iutest_console.hpp |
iutest::TestEnv::ReleaseGlobalTestEnvironment() | static iuEnvironmentList& environments() { return get_vars().m_environment_list; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x13974
movq 0xd0(%rax), %rbx
callq 0x13974
cmpq 0xd8(%rax), %rbx
je 0x15a8f
leaq 0x8(%rbx), %r14
movq (%rbx), %r15
callq 0x13974
movq %rax, %r12
movq 0xd8(%rax), %rdx
cmpq %rdx, %r14
je 0x15a67
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe4c0
mov... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::DefaultXmlGeneratorListener::SetFilePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SetFilePath(const ::std::string& path)
{
if( path.empty() )
{
m_output_path_format.clear();
m_output_path = detail::kStrings::DefaultXmlReportFileName;
}
else
{
m_output_path_format = path;
const ::std::string::size_type po... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1747f
movq %rsi, %r15
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0xe1a0
movq %r15, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0xe3e0
cmpq $-0x1, %rax
je 0x1744f
movq 0x8(%r15), %rcx
decq %rcx
cmpq %rcx, %rax
jne 0x1746b
movq %r14, %rdi
movl $0x... | /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp |
iutest::detail::iuOptionMessage::ShowSpec() | inline void iuOptionMessage::ShowSpec()
{
IIUT_SHOW_MACRO(IUTEST_PLATFORM);
IIUT_SHOW_MACRO(IUTEST_CHECK_STRICT);
IIUT_SHOW_MACRO(IUTEST_CPLUSPLUS);
IIUT_SHOW_MACRO(IUTEST_FORCE_COLORCONSOLE);
IIUT_SHOW_MACRO(IUTEST_HAS_ANALYSIS_ASSUME);
IIUT_SHOW_MACRO(IUTEST_HAS_ATTRIBUTE);
IIUT_SHOW_MACR... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x96dc(%rip), %rbx # 0x22136
leaq 0x9bec(%rip), %rsi # 0x2264d
leaq 0x9bf5(%rip), %rdx # 0x2265d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x138c8
leaq 0x9bec(%rip), %rsi # 0x22665
leaq 0x9f78(%rip), %r14 # 0x229f8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %ea... | /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::TestSuite::testsuite_name_with_where[abi:cxx11]() const | ::std::string testsuite_name_with_where() const
{
::std::string str = m_testsuite_name;
if( type_param() != NULL )
{
str += ", where TypeParam = ";
str += type_param();
}
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x13dea
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0x19389
leaq 0x9c19(%rip), %rsi # 0x22f86
movq %rbx, %rdi
callq 0... | /srz-zumix[P]iutest/include/internal/../iutest_suite.hpp |
iutest::TestSuite::Passed() const | bool Passed() const { return failed_test_count() == 0 && m_ad_hoc_testresult.Passed(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x5c(%rdi)
je 0x194bd
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r15
cmpq %r15, %r14
je 0x194bd
xorl %ebp, %ebp
movq (%r14), %rdi
cmpb $0x1, 0x98(%rdi)
movl $0x0, %eax
jne 0x194aa
addq $0x40, %rdi
callq 0x19426
movzbl %al, %eax
addl %eax, %e... | /srz-zumix[P]iutest/include/internal/../iutest_suite.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 4ul>(char const (&) [4ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x201ac
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0xe370
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20179
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe2e0
m... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 24ul>(char const (&) [24ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x20308
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0xe370
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x202d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe2e0
m... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::AssertionResult iuutil::StrNotInHelper::Assertion<char [17], char const*>(char const*, char const*, char const (&) [17], char const* const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ Assertion(const char* substr_str, const char* actual_str
, const T1& substr, const T2& actual)
{
if( Compare(substr, actual) )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Expected: " << "st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%r8), %rdi
testq %rdi, %rdi
je 0x20675
movq %r8, %r15
movq %rcx, %r14
movq %rcx, %rsi
callq 0xe080
testq %rax, %rax
je 0x20675
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
xorl... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [17]>(char const (&) [17]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x17564
movq %r15, %rdi
movq %r14, %rsi
callq 0x2079e
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xe4a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [17]>(char const (&) [17]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x17564
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0xe130
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x15862
leaq 0x38(%rsp), %rsi
leaq 0... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
iutest::AssertionResult iuutil::StrNotInHelper::Assertion<char [24], char const*>(char const*, char const*, char const (&) [24], char const* const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ Assertion(const char* substr_str, const char* actual_str
, const T1& substr, const T2& actual)
{
if( Compare(substr, actual) )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Expected: " << "st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%r8), %rdi
testq %rdi, %rdi
je 0x20a36
movq %r8, %r15
movq %rcx, %r14
movq %rcx, %rsi
callq 0xe080
testq %rax, %rax
je 0x20a36
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
xorl... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
iutest::AssertionResult iuutil::StrInHelper::Assertion<char [17], char const*>(char const*, char const*, char const (&) [17], char const* const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ Assertion(const char* substr_str, const char* actual_str
, const T1& substr, const T2& actual)
{
if( Compare(substr, actual) )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Expected: " << "st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%r8), %rdi
testq %rdi, %rdi
je 0x20acc
movq %r14, %rsi
callq 0xe080
testq %rax, %rax
je 0x20acc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0,... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
run_CALL.cold.3 | static set_t
set_load(FILE* f)
{
set_t set = (set_t)malloc(sizeof(struct set));
/* read projection (actually we don't support projection) */
int k;
if (fread(&k, sizeof(int), 1, f) != 1) Abort("Invalid input file!\n");
if (k != -1) Abort("Invalid input file!\n"); // only support full vector
/*... | pushq %rbx
movq 0x1ea85(%rip), %rbx # 0x20fd0
movq (%rbx), %rcx
leaq 0x15d6b(%rip), %rdi # 0x182c0
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
movq (%rbx), %rdi
leaq 0x15b81(%rip), %rsi # 0x180eb
movl $0x9f, %edx
xorl %eax, %eax
callq 0x2200
pushq $-0x1
popq %rdi
callq 0x2180
| /trolando[P]sylvan/examples/lddmc.c |
run_CALL.cold.4 | static set_t
set_load(FILE* f)
{
set_t set = (set_t)malloc(sizeof(struct set));
/* read projection (actually we don't support projection) */
int k;
if (fread(&k, sizeof(int), 1, f) != 1) Abort("Invalid input file!\n");
if (k != -1) Abort("Invalid input file!\n"); // only support full vector
/*... | pushq %rbx
movq 0x1ea4a(%rip), %rbx # 0x20fd0
movq (%rbx), %rcx
leaq 0x15d30(%rip), %rdi # 0x182c0
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
movq (%rbx), %rdi
leaq 0x15b46(%rip), %rsi # 0x180eb
movl $0xa4, %edx
xorl %eax, %eax
callq 0x2200
pushq $-0x1
popq %rdi
callq 0x2180
| /trolando[P]sylvan/examples/lddmc.c |
protect_up.cold.1 | static void
protect_resize(refs_table_t *tbl)
{
while (1) {
uint32_t v = tbl->refs_control;
if (v & 0xf0000000) {
// someone else started resize
// just rehash blocks until done
while (protect_resize_help(tbl)) continue;
return;
}
if (a... | pushq %rbx
movq 0x1e2c7(%rip), %rax # 0x20fd0
movq (%rax), %rbx
callq 0x2030
movl (%rax), %edi
callq 0x2070
leaq 0x1686f(%rip), %rsi # 0x1958e
movq %rax, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2200
pushq $0x1
popq %rdi
callq 0x2180
| /trolando[P]sylvan/src/sylvan_refs.c |
main | int
main(int argc, char **argv)
{
/**
* Parse command line, set locale, set startup time for INFO messages.
*/
parse_args(argc, argv);
setlocale(LC_NUMERIC, "en_US.utf-8");
t_start = wctime();
/**
* Initialize Lace.
*
* First: setup with given number of workers (0 for autod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %r13
movl $0x0, (%r13)
leaq 0x12dae(%rip), %r15 # 0x1844a
leaq 0x1b5bd(%rip), %r12 # 0x20c60
leaq 0x129be(%rip), %r14 # 0x18068
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %... | /trolando[P]sylvan/examples/lddmc.c |
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.