name string | code string | asm string | file string |
|---|---|---|---|
isSuspendReachableFrom(llvm::BasicBlock*, llvm::SmallPtrSet<llvm::BasicBlock*, 8u>&) | static bool isSuspendReachableFrom(BasicBlock *From,
VisitedBlocksSet &VisitedOrFreeBBs) {
// Eagerly try to add this block to the visited set. If it's already
// there, stop recursing; this path doesn't reach a suspend before
// either looping or reaching a freeing block.
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x8a7f76
cmpb $0x1, 0x10(%r14)
jne 0x22ead1e
movq %r12, %rdi
callq 0x22eadb8
movb $0x1, %bpl
testb %al, %al
jne 0x22ead20
movq 0x30(%r12), %rax
addq $0x30, %... | /Transforms/Coroutines/CoroFrame.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, std::optional<llvm::APInt>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, std::optional<llvm::APInt>>>, llvm::Instruction*, std::optional<llvm::APInt>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMa... | unsigned getNumBuckets() const {
return NumBuckets;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rdi), %ebx
testq %rbx, %rbx
je 0x22eb9fb
movq (%rdi), %r14
shlq $0x5, %rbx
xorl %r15d, %r15d
movl $0x1000, %r12d # imm = 0x1000
movq (%r14,%r15), %rax
orq %r12, %rax
cmpq $-0x1000, %rax # imm = 0xF000
jne 0x22eb9d4
addq $0x20, %r15
cmpq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::FrameDataInfo::getAllDefs() const | SmallVector<Value *, 8> getAllDefs() const {
SmallVector<Value *, 8> Defs;
for (const auto &P : Spills)
Defs.push_back(P.first);
for (const auto &A : Allocas)
Defs.push_back(A.Alloca);
return Defs;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x8(%rdi)
movl 0x90(%rsi), %eax
testq %rax, %rax
je 0x22ebad6
movq 0x88(%r14), %r15
shlq $0x3, %rax
leaq (%rax,%rax,4), %r12
xorl ... | /Transforms/Coroutines/CoroFrame.cpp |
(anonymous namespace)::FrameTypeBuilder::addField(llvm::Type*, llvm::MaybeAlign, bool, bool) | [[nodiscard]] FieldIDType addField(Type *Ty, MaybeAlign MaybeFieldAlignment,
bool IsHeader = false,
bool IsSpillOfValue = false) {
assert(!IsFinished && "adding fields to a finished builder");
assert(Ty && "must provide a type for a field... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebp
movl %ecx, 0x4(%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x889a8a
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb %dl, 0x8(%r14)
movq %r14, %rdi
callq 0x20a1bec
testq %rax, %rax
je 0x22ec1... | /Transforms/Coroutines/CoroFrame.cpp |
solveDIType(llvm::DIBuilder&, llvm::Type*, llvm::DataLayout const&, llvm::DIScope*, unsigned int, llvm::DenseMap<llvm::Type*, llvm::DIType*, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseMapPair<llvm::Type*, llvm::DIType*>>&) | static DIType *solveDIType(DIBuilder &Builder, Type *Ty,
const DataLayout &Layout, DIScope *Scope,
unsigned LineNum,
DenseMap<Type *, DIType *> &DITypeCache) {
if (DIType *DT = DITypeCache.lookup(Ty))
return DT;
StringRef Name = s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %r9, %rbp
movl %r8d, 0x64(%rsp)
movq %rcx, 0x78(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
leaq 0xe8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0xa0(%rsp), %r12
movq %r9, %rdi
movq %r12, %rdx
callq 0x22e... | /Transforms/Coroutines/CoroFrame.cpp |
std::pair<llvm::DenseMapIterator<llvm::Value*, unsigned int, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, unsigned int, 8u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %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 0x22f0272
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x22f0218
xorl %ecx, %ecx
jmp 0x22f0238
movq %r... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::CallBase*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::CallBase*, void>, llvm::detail::DenseSetPair<llvm::CallBase*>>::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 0x22f1640
decl %eax
je 0x22f1644
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x22f1649
xorl %ebp, %ebp
jmp 0x22f165f
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
mov... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<long, llvm::AllocaInst*, 4u, llvm::DenseMapInfo<long, void>, llvm::detail::DenseMapPair<long, llvm::AllocaInst*>>, long, llvm::AllocaInst*, llvm::DenseMapInfo<long, void>, llvm::detail::DenseMapPair<long, llvm::AllocaInst*>>::LookupBucketFor<long>(long const&, llvm::detail::D... | 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 0x22f5ee8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rsi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %ebx
xorl %r9d, %r9d
movabsq $0x7fffff... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<long, llvm::AllocaInst*, 4u, llvm::DenseMapInfo<long, void>, llvm::detail::DenseMapPair<long, llvm::AllocaInst*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x22f5fbd
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %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 %... | /llvm/ADT/DenseMap.h |
llvm::AA::isPotentiallyAffectedByBarrier(llvm::Attributor&, llvm::Instruction const&, llvm::AbstractAttribute const&) | bool AA::isPotentiallyAffectedByBarrier(Attributor &A, const Instruction &I,
const AbstractAttribute &QueryingAA) {
if (!I.mayHaveSideEffects() && !I.mayReadFromMemory())
return false;
SmallSetVector<const Value *, 8> Ptrs;
auto AddLocationPtr = [&](std::optional<Memo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1b6aa22
testb %al, %al
jne 0x22f7a6a
movq %r15, %rdi
callq 0x1b6a658
testb %al, %al
je 0x22f7c1b
xorps %xmm0, %xmm0
leaq 0x68(%rsp), %r13
movaps %xmm0... | /Transforms/IPO/Attributor.cpp |
llvm::Attributor::hasAttr(llvm::IRPosition const&, llvm::ArrayRef<llvm::Attribute::AttrKind>, bool, llvm::Attribute::AttrKind) | bool Attributor::hasAttr(const IRPosition &IRP,
ArrayRef<Attribute::AttrKind> AttrKinds,
bool IgnoreSubsumingPositions,
Attribute::AttrKind ImpliedAttributeKind) {
bool Implied = false;
bool HasAttr = false;
auto HasAttrCB = [&](const Attr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, 0x10(%rsp)
leaq 0xc(%rsp), %rax
movl %r9d, (%rax)
xorl %ecx, %ecx
leaq 0xb(%rsp), %rdx
movb %cl, (%rdx)
leaq 0xa(%rsp), %rdi
movb %cl, (%rdi)
movq %rdx, 0x20(%rsp)
movq %rax, 0x2... | /Transforms/IPO/Attributor.cpp |
llvm::Attributor::checkForAllReadWriteInstructions(llvm::function_ref<bool (llvm::Instruction&)>, llvm::AbstractAttribute&, bool&) | bool Attributor::checkForAllReadWriteInstructions(
function_ref<bool(Instruction &)> Pred, AbstractAttribute &QueryingAA,
bool &UsedAssumedInformation) {
TimeTraceScope TS("checkForAllReadWriteInstructions");
const Function *AssociatedFunction =
QueryingAA.getIRPosition().getAssociatedFunction();
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, %r15
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
callq 0x209a068
testq %rax, %rax
je 0x22fbbfe
leaq 0x2ae955f(%rip), %rdi # 0x4de5143
leaq 0x19ff18d(%rip), %rdx # 0x3cfad78
movl $... | /Transforms/IPO/Attributor.cpp |
llvm::Attributor::rememberDependences() | bool AA::isValidInScope(const Value &V, const Function *Scope) {
if (isa<Constant>(V))
return true;
if (auto *I = dyn_cast<Instruction>(&V))
return I->getFunction() == Scope;
if (auto *A = dyn_cast<Argument>(&V))
return A->getParent() == Scope;
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x150(%rdi), %rax
movl 0x158(%rdi), %ecx
movq -0x8(%rax,%rcx,8), %rax
movl 0x8(%rax), %ecx
testq %rcx, %rcx
je 0x22fed21
movq (%rax), %r14
leaq (%rcx,%rcx,2), %rax
leaq (%r14,%rax,8), %r15
leaq 0x8(%rsp), %rbx
movq (%r14), %rdi
addq $0x8, %rdi
movq 0x8(%r14), %rax
... | /Transforms/IPO/Attributor.cpp |
llvm::Attributor::internalizeFunction(llvm::Function&, bool) | Function *Attributor::internalizeFunction(Function &F, bool Force) {
if (!AllowDeepWrapper && !Force)
return nullptr;
if (!isInternalizable(F))
return nullptr;
SmallPtrSet<Function *, 2> FnSet = {&F};
DenseMap<Function *, Function *> InternalizedFns;
internalizeFunctions(FnSet, InternalizedFns);
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
orb 0x33854e5(%rip), %sil # 0x5684580
cmpb $0x1, %sil
jne 0x22ff0bb
movq %rdi, %rbx
callq 0x1b5e9ce
testb %al, %al
jne 0x22ff0bb
movl 0x20(%rbx), %eax
andl $0xf, %eax
leal -0x7(%rax), %ecx
cmpl $0x2, %ecx
jae 0x22ff0ce
xorl %r14d, %r14d
movq %r14... | /Transforms/IPO/Attributor.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function*, llvm::Function*, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, llvm::Function*>>, llvm::Function*, llvm::Function*, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, llvm::Function*>>::clear(... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x22ff611
cmpl $0x0, 0xc(%rdi)
je 0x22ff6ea
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x230b56e
testq %rcx, %rcx
je 0x22ff6e2
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::operator<<(llvm::raw_ostream&, llvm::PotentialValuesState<std::pair<llvm::AA::ValueAndContext, llvm::AA::ValueScope>> const&) | raw_ostream &llvm::operator<<(raw_ostream &OS,
const PotentialLLVMValuesState &S) {
OS << "set-state(< {";
if (!S.isValidState())
OS << "full-set";
else {
for (const auto &It : S.getAssumedSet()) {
if (auto *F = dyn_cast<Function>(It.first.getValue()))
OS << "@"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ae3f7d(%rip), %rsi # 0x4de524d
movl $0xd, %edx
callq 0x75bb50
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x23013d3
movq %r14, 0x8(%rsp)
movl 0x38(%r14), %eax
testq %rax... | /Transforms/IPO/Attributor.cpp |
non-virtual thunk to (anonymous namespace)::AAGlobalValueInfoFloating::~AAGlobalValueInfoFloating() | namespace {
struct AAGlobalValueInfoFloating : public AAGlobalValueInfo {
AAGlobalValueInfoFloating(const IRPosition &IRP, Attributor &A)
: AAGlobalValueInfo(IRP, A) {}
/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {}
bool checkUse(Attributor &A, const Use &U, bool ... | pushq %rbx
movq %rdi, %rax
leaq -0x50(%rdi), %rbx
leaq 0x32969c3(%rip), %rcx # 0x55dfb50
movq %rcx, -0x50(%rdi)
leaq 0x3296a40(%rip), %rcx # 0x55dfbd8
movq %rcx, (%rdi)
movq 0x18(%rdi), %rdi
cmpq 0x10(%rax), %rdi
je 0x23491aa
callq 0x6ea8c0
movq %rbx, %rdi
callq 0xb6c99c
movl $0xc0, %esi
movq %rbx, %rdi
popq %rbx
j... | /Transforms/IPO/AttributorAttributes.cpp |
llvm::HotColdSplitting::isSplittingBeneficial(llvm::CodeExtractor&, llvm::SmallVector<llvm::BasicBlock*, 0u> const&, llvm::TargetTransformInfo&) | bool HotColdSplitting::isSplittingBeneficial(CodeExtractor &CE,
const BlockSequence &Region,
TargetTransformInfo &TTI) {
assert(!Region.empty());
// Perform a simple cost/benefit analysis to decide whether or not to permit
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rdi
xorl %eax, %eax
leaq 0x178(%rsp), %rcx
movl %eax, -0x18(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rcx)
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
leaq 0x148(... | /Transforms/IPO/HotColdSplitting.cpp |
llvm::InstCombinerImpl::foldICmpInstWithConstant(llvm::ICmpInst&) | Instruction *InstCombinerImpl::foldICmpInstWithConstant(ICmpInst &Cmp) {
const APInt *C;
if (match(Cmp.getOperand(1), m_APInt(C))) {
if (auto *BO = dyn_cast<BinaryOperator>(Cmp.getOperand(0)))
if (Instruction *I = foldICmpBinOpWithConstant(Cmp, BO, *C))
return I;
if (auto *SI = dyn_cast<Sele... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq -0x20(%rsi), %rsi
movq %rsp, %r13
leaq 0x18(%rsp), %rdi
movq %r13, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0xbf9922
testb %al, %al
je 0x26017bd
movq -0x40(%rbx), %rdx
movb (%rdx), %al
cmpb $0x1d, %al
setb %... | /Transforms/InstCombine/InstCombineCompares.cpp |
llvm::InstCombinerImpl::computeOverflow(llvm::Instruction::BinaryOps, bool, llvm::Value*, llvm::Value*, llvm::Instruction*) const | OverflowResult
InstCombinerImpl::computeOverflow(Instruction::BinaryOps BinaryOp,
bool IsSigned, Value *LHS, Value *RHS,
Instruction *CxtI) const {
switch (BinaryOp) {
default:
llvm_unreachable("Unsupported binary op");
case Instruction... | pushq %r14
pushq %rbx
subq $0x98, %rsp
cmpl $0xd, %esi
je 0x2603627
addq $0x58, %rdi
cmpl $0xf, %esi
jne 0x26036a5
testb %dl, %dl
je 0x26036e4
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movups 0x30(%rdi), %xmm3
leaq 0x50(%rsp), %rdx
movaps %xmm2, 0x20(%rdx)
movaps %xmm3, 0x30(%rdx)
movaps %x... | /Transforms/InstCombine/InstCombineCompares.cpp |
bool llvm::PatternMatch::match<llvm::BinaryOperator, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specific_intval<true>, 13u, false>>(llvm::BinaryOperator*, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specific_intval<true>, 13u... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2a, (%rdi)
jne 0x2607020
movq (%rsi), %rax
cmpq -0x40(%rdi), %rax
jne 0x2607020
pushq %rax
addq $0x8, %rsi
movq -0x20(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x25d3fa2
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
leaq 0x8(%rsp), %rsp
jne 0x2607022
xorl %eax, %eax
retq
nop
| /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::CastInst_match<llvm::PatternMatch::OneUse_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_const_intval_ty, 26u, false>>, llvm::TruncInst>::match<llvm::Value>(llvm::Value*) | bool isValue(const APInt &C) { return C.isMaxSignedValue(); } | pushq %rbx
movb (%rsi), %bl
cmpb $0x43, %bl
jne 0x26151c7
movq -0x20(%rsi), %rsi
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x26151be
cmpq $0x0, 0x8(%rax)
je 0x26151c2
xorl %eax, %eax
jmp 0x26151c7
callq 0x26151d4
cmpb $0x43, %bl
sete %cl
andb %al, %cl
movl %ecx, %eax
popq %rbx
retq
nop
| /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::Exact_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::custom_checkfn<llvm::APInt>, llvm::ConstantInt, true>, 19u, false>>::match<llvm::Value>(llvm::Value*) | bool isValue(const APInt &C) { return C.isMaxSignedValue(); } | pushq %rbx
movzbl (%rsi), %eax
cmpl $0x1d, %eax
jb 0x2623edf
cmpl $0x38, %eax
ja 0x2623efa
movl %eax, %eax
movabsq $0x183000000000000, %rcx # imm = 0x183000000000000
btq %rax, %rcx
movq %rsi, %rbx
jb 0x2623efc
cmpq $0x5, %rax
je 0x2623ee4
jmp 0x2623efa
cmpl $0x5, %eax
jne 0x2623efa
movzwl 0x2(%rsi), %eax
cmpl $0x1b, %e... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>::match<llvm::FPMathOperator>(llvm::FPMathOp... | 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 0x262440e
testb %al, %al
je 0x2624403
movb (%r14), %al
cmpb $0x55, %al
jne 0x26243f8
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 0x26243f8
movq 0x20(... | /llvm/IR/PatternMatch.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, std::pair<llvm::WeakVH, llvm::WeakTrackingVH>, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, std::pair<llvm::WeakVH, llvm::WeakTrackingVH>>>, llvm::Value const*, std::pair<llvm::WeakVH, llvm::WeakTrackingVH>, llvm::Dens... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x267d67f
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
imulq $0x38, %rax, %r14
addq $0x20, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x20(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
jne 0x267d635
addq $0x38, %rbx
addq $-0x38, %r14
j... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::CallInst*, llvm::CallBase*>* llvm::DenseMapBase<llvm::DenseMap<llvm::CallInst*, llvm::CallBase*, llvm::DenseMapInfo<llvm::CallInst*, void>, llvm::detail::DenseMapPair<llvm::CallInst*, llvm::CallBase*>>, llvm::CallInst*, llvm::CallBase*, llvm::DenseMapInfo<llvm::CallInst*, void>, llvm::d... | 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 0x2682c5f
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
decltype(auto) llvm::dyn_cast<llvm::MemTransferInst, llvm::Instruction const>(llvm::Instruction const*) | [[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
return CastInfo<To, From *>::doCastIfPossible(Val);
} | pushq %rbx
cmpb $0x55, (%rdi)
jne 0x2694ed5
movq %rdi, %rbx
callq 0x88bf46
testb %al, %al
je 0x2694ed5
movq -0x20(%rbx), %rcx
movl $0xffffff19, %eax # imm = 0xFFFFFF19
addl 0x24(%rcx), %eax
cmpl $0x3, %eax
ja 0x2694ed5
cmpl $0x1, %eax
jne 0x2694ed7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /llvm/Support/Casting.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::sampleprof::FunctionId, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::sampleprof::FunctionId, void>, llvm::detail::DenseSetPair<llvm::sampleprof::FunctionId>>, llvm::sampleprof::FunctionId, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::sampleprof::FunctionId, void... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x2733acd
movq (%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
movq $0x0, (%rcx)
movq $-0x1, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax... | /llvm/ADT/DenseMap.h |
llvm::Error llvm::make_error<llvm::SymbolRemappingParseError, llvm::StringRef, long, llvm::Twine&>(llvm::StringRef&&, long&&, llvm::Twine&) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x50, %edi
callq 0x6ea880
movq %rax, %r13
movq (%r12), %rsi
movq (%r15), %r15
leaq 0x2eae2aa(%rip), %rax # 0x55e9f00
addq $0x10, %rax
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rax, (%r13)
leaq... | /llvm/Support/Error.h |
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... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdx
callq 0x274a676
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/ADT/DenseMap.h |
llvm::DWARFContext::DWARFContextState::parseMacroOrMacinfo(llvm::DWARFContext::DWARFContextState::MacroSecType) | std::unique_ptr<DWARFDebugMacro>
DWARFContext::DWARFContextState::parseMacroOrMacinfo(MacroSecType SectionType) {
auto Macro = std::make_unique<DWARFDebugMacro>();
auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf4(%rsp), %r15
movl %edx, (%r15)
movl $0x18, %edi
callq 0x6ea880
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movq %rbx, 0xf8(%rsp)
... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFContext::compile_units() | compile_unit_range compile_units() {
return make_filter_range(info_section_units(), isCompileUnit);
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x38(%rax), %edx
cmpl $-0x1, %edx
cmovel 0x8(%rax), %edx
movq (%rax), %rcx
leaq (%rcx,%rdx,8), %rax
testl %edx, %edx
je 0x2743dec
leaq (,%rdx,8), %rdx
movq (%rcx), %rsi
movb 0x60(%rsi), %sil
andb $-0x5, %sil
cmpb $0x2, %sil
jne 0x... | /llvm/DebugInfo/DWARF/DWARFContext.h |
llvm::DWARFContext::getDIEsForAddress(unsigned long, bool) | DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address,
bool CheckDWO) {
DIEsForAddress Result;
DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address);
if (!CU)
return Result;
if (CheckDWO) {
// We were asked to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rdi
movq %r14, %... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFContext::create(llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer>>, llvm::MallocAllocator> const&, unsigned char, bool, std::function<void (llvm::Error)>, std::function<void (llvm::Error)>, bool) | std::unique_ptr<DWARFContext>
DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
uint8_t AddrSize, bool isLittleEndian,
std::function<void(Error)> RecoverableErrorHandler,
std::function<void(Error)> WarningHandler,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
movl $0x718, %edi # imm = 0x718
callq 0x6ea880
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
movq %ra... | /DebugInfo/DWARF/DWARFContext.cpp |
llvm::DWARFListTableBase<llvm::DWARFDebugRnglist>::extract(llvm::DWARFDataExtractor, unsigned long*) | Error DWARFListTableBase<DWARFListType>::extract(DWARFDataExtractor Data,
uint64_t *OffsetPtr) {
clear();
if (Error E = extractHeaderAndOffsets(Data, OffsetPtr))
return E;
Data.setAddressSize(Header.getAddrSize());
Data = DWARFDataExtractor(Data, getHeaderOf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
leaq 0x40(%rsi), %rdi
movq 0x50(%rsi), %rsi
movq %rdi, 0x68(%rsp)
callq 0x2748ab4
leaq 0x48(%r15), %rax
xorl %r12d, %r12d
movq %r12, 0x50(%r15)
movq ... | /llvm/DebugInfo/DWARF/DWARFListTable.h |
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... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0x274a315
cmpl $0x0, 0xc(%rdi)
je 0x274a456
shll $0x2, %ecx
movl 0x10(%rdi), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
je 0x274a458
testq %rax, %rax
je 0x274a44e
movq (%rdi), %rcx
leaq (%rax,%rax,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::DWARFTypeUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFTypeUnit*>>, unsigned long, llvm::DWARFTypeUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFTypeUn... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x274d7f6
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movabsq $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq %rsi, %rax
movq %rax, %r8
shrq $0x1f, %r8
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq... | /llvm/ADT/DenseMap.h |
llvm::MapVector<llvm::object::SectionRef, (anonymous namespace)::DWARFSectionMap, std::map<llvm::object::SectionRef, unsigned int, std::less<llvm::object::SectionRef>, std::allocator<std::pair<llvm::object::SectionRef const, unsigned int>>>, llvm::SmallVector<std::pair<llvm::object::SectionRef, (anonymous namespace)::D... | ValueT &operator[](const KeyT &Key) {
std::pair<KeyT, typename MapType::mapped_type> Pair = std::make_pair(Key, 0);
std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
auto &I = Result.first->second;
if (Result.second) {
Vector.push_back(std::make_pair(Key, ValueT()));
I =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movups (%rsi), %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
callq 0x274ffee
movq %rax, %r14
testb $0x1, %dl
je 0x274f18c
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq $0x0, 0x2... | /llvm/ADT/MapVector.h |
llvm::Error llvm::createStringError<unsigned long, unsigned char>(std::error_code, char const*, unsigned long const&, unsigned char const&) | inline Error createStringError(std::error_code EC, char const *Fmt,
const Ts &... Vals) {
std::string Buffer;
raw_string_ostream(Buffer) << format(Fmt, Vals...);
return make_error<StringError>(Buffer, EC);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %r15
movl $0x0, ... | /llvm/Support/Error.h |
llvm::Error llvm::createStringError<unsigned long, unsigned char, unsigned char>(std::error_code, char const*, unsigned long const&, unsigned char const&, unsigned char const&) | inline Error createStringError(std::error_code EC, char const *Fmt,
const Ts &... Vals) {
std::string Buffer;
raw_string_ostream(Buffer) << format(Fmt, Vals...);
return make_error<StringError>(Buffer, EC);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %r15
movl $0x0, ... | /llvm/Support/Error.h |
llvm::DWARFDebugAranges::generate(llvm::DWARFContext*) | void DWARFDebugAranges::generate(DWARFContext *CTX) {
clear();
if (!CTX)
return;
// Extract aranges from .debug_aranges section.
DWARFDataExtractor ArangesData(CTX->getDWARFObj().getArangesSection(),
CTX->isLittleEndian(), 0);
extract(ArangesData, CTX->getRecoverableError... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x27540a0
testq %r14, %r14
je 0x275408e
movq 0x60(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %r15
movq %rdx, %r12
movq 0x60(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorps %xmm0... | /DebugInfo/DWARF/DWARFDebugAranges.cpp |
llvm::dwarf::operator<<(llvm::raw_ostream&, llvm::dwarf::RegisterLocations const&) | raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
const RegisterLocations &RL) {
auto DumpOpts = DIDumpOptions();
RL.dump(OS, DumpOpts);
return OS;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x10(%rsp), %rbx
xorl %r15d, %r15d
movl $0xa0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6ea240
movaps 0x26b06d4(%rip), %xmm0 # 0x4e06100
movups %xmm0, (%rbx)
leaq... | /DebugInfo/DWARF/DWARFDebugFrame.cpp |
llvm::dwarf::UnwindRow::dump(llvm::raw_ostream&, llvm::DIDumpOptions, unsigned int) const | void UnwindRow::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
unsigned IndentLevel) const {
OS.indent(2 * IndentLevel);
if (hasAddress())
OS << format("0x%" PRIx64 ": ", *Address);
OS << "CFA=";
CFAValue.dump(OS, DumpOpts);
if (RegLocs.hasLocations()) {
OS << ": ";
RegLocs.dum... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leal (%rcx,%rcx), %esi
movq %rbx, %rdi
callq 0x20be716
cmpb $0x1, 0x8(%r14)
jne 0x2755cee
leaq 0x26b07e5(%rip), %rax # 0x4e064aa
leaq 0x150(%rsp), %rsi
movq %rax... | /DebugInfo/DWARF/DWARFDebugFrame.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::dwarf::CIE*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::dwarf::CIE*>>, unsigned long, llvm::dwarf::CIE*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::dwarf::CIE*>>::Looku... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x275d328
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movabsq $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq %rsi, %rax
movq %rax, %r8
shrq $0x1f, %r8
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq... | /llvm/ADT/DenseMap.h |
llvm::DWARFDebugLine::Prologue::hasFileAtIndex(unsigned long) const | bool DWARFDebugLine::Prologue::hasFileAtIndex(uint64_t FileIndex) const {
uint16_t DwarfVersion = getVersion();
assert(DwarfVersion != 0 &&
"line table prologue has no dwarf version information");
if (DwarfVersion >= 5)
return FileIndex < FileNames.size();
return FileIndex != 0 && FileIndex <= File... | cmpw $0x5, 0x8(%rdi)
jb 0x275dabe
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F1
imulq %rax, %rcx
cmpq %rsi, %rcx
seta %al
retq
testq %rsi, %rsi
je 0x275dae4
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f,... | /DebugInfo/DWARF/DWARFDebugLine.cpp |
llvm::DWARFDebugLine::ParsingState::appendRowToMatrix() | void DWARFDebugLine::ParsingState::appendRowToMatrix() {
unsigned RowNumber = LineTable->Rows.size();
if (Sequence.Empty) {
// Record the beginning of instruction sequence.
Sequence.Empty = false;
Sequence.LowPC = Row.Address.Address;
Sequence.FirstRowIndex = RowNumber;
}
LineTable->appendRow(Ro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x80(%rdi), %r15
subq 0x78(%rdi), %r15
shrq $0x5, %r15
cmpb $0x1, 0x48(%rbx)
jne 0x2760292
movb $0x0, 0x48(%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x28(%rbx)
movl %r15d, 0x40(%rbx)
leaq 0x8(%rbx), %rdx
movq 0x80(%rdi), %rsi
cmpq 0x88(%rdi), %rsi
je 0... | /DebugInfo/DWARF/DWARFDebugLine.cpp |
llvm::DWARFDebugLine::ParsingState::advanceForOpcode(unsigned char, unsigned long) | DWARFDebugLine::ParsingState::OpcodeAdvanceResults
DWARFDebugLine::ParsingState::advanceForOpcode(uint8_t Opcode,
uint64_t OpcodeOffset) {
assert(Opcode == DW_LNS_const_add_pc ||
Opcode >= LineTable->Prologue.OpcodeBase);
if (ReportBadLineRange && LineTable->P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpb $0x1, 0x59(%rdi)
movzbl %r15b, %ebp
jne 0x2762df5
movq (%r14), %rax
cmpb $0x0, 0x25(%rax)
jne 0x2762df5
cmpb %r15b, 0x26(%rax)
jbe 0x2762cd5
movl %ebp, %edi
callq 0x292c282
movq %rax,... | /DebugInfo/DWARF/DWARFDebugLine.cpp |
llvm::DWARFLocationTable::visitAbsoluteLocationList(unsigned long, std::optional<llvm::object::SectionedAddress>, std::function<std::optional<llvm::object::SectionedAddress> (unsigned int)>, llvm::function_ref<bool (llvm::Expected<llvm::DWARFLocationExpression>)>) const | Error DWARFLocationTable::visitAbsoluteLocationList(
uint64_t Offset, std::optional<SectionedAddress> BaseAddr,
std::function<std::optional<SectionedAddress>(uint32_t)> LookupAddr,
function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const {
DWARFLocationInterpreter Interp(BaseAddr, std::move(L... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0(%rsp), %rax
movq %r8, 0x30(%rsp)
movq %r9, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x10(%rcx), %rsi
testq %rsi, %... | /DebugInfo/DWARF/DWARFDebugLoc.cpp |
llvm::DWARFDebugLoclists::dumpRange(unsigned long, unsigned long, llvm::raw_ostream&, llvm::DWARFObject const&, llvm::DIDumpOptions) | void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
raw_ostream &OS, const DWARFObject &Obj,
DIDumpOptions DumpOpts) {
if (!Data.isValidOffsetForDataOfSize(StartOffset, Size)) {
OS << "Invalid dump range\n";
return;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, 0x48(%rsp)
movq %rcx, %rbx
leaq (%rdx,%rsi), %rax
movq %rax, 0x50(%rsp)
cmpq %rsi, %rax
jb 0x2766ed0
movq %rdi, %r12
leaq (%rdx,%rsi), %rax
decq %rax
cmpq %rax, 0x10(%rdi)
jbe 0x2766ed0
movq %r9, %r14
... | /DebugInfo/DWARF/DWARFDebugLoc.cpp |
bool llvm::function_ref<bool (llvm::DWARFLocationEntry const&)>::callback_fn<llvm::DWARFLocationTable::dumpLocationList(unsigned long*, llvm::raw_ostream&, std::optional<llvm::object::SectionedAddress>, llvm::DWARFObject const&, llvm::DWARFUnit*, llvm::DIDumpOptions, unsigned int) const::$_1>(long, llvm::DWARFLocationE... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rsi, %rdx
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rsi
leaq 0x180(%rsp), %r14
movq %r14, %rdi
movq %rdx, 0x18(%rsp)
callq 0x27679ba
testb $0x1, 0x48(%r14)
jne 0x2767043
mov... | /llvm/ADT/STLFunctionalExtras.h |
bool llvm::function_ref<bool (llvm::DWARFLocationEntry const&)>::callback_fn<llvm::DWARFLocationTable::visitAbsoluteLocationList(unsigned long, std::optional<llvm::object::SectionedAddress>, std::function<std::optional<llvm::object::SectionedAddress> (unsigned int)>, llvm::function_ref<bool (llvm::Expected<llvm::DWARFL... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x27679ba
testb $0x1, 0x48(%rbx)
je 0x2767d8d
movq 0x8(%r14), %rdi
movq 0x50(%rsp), %rax
movq $0x0, 0x50(%rsp)
movq %rsp, %r14
orb $0x1, 0x40(%r14)
movq %rax, (%r14)
movq %r14,... | /llvm/ADT/STLFunctionalExtras.h |
void llvm::Expected<llvm::DWARFLocationExpression>::moveConstruct<llvm::DWARFLocationExpression>(llvm::Expected<llvm::DWARFLocationExpression>&&) | void moveConstruct(Expected<OtherT> &&Other) {
HasError = Other.HasError;
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
Unchecked = true;
Other.Unchecked = false;
#endif
if (!HasError)
new (getStorage()) storage_type(std::move(*Other.getStorage()));
else
new (getErrorStorage()) error_type(std::mo... | movb 0x40(%rsi), %al
andb $0x1, %al
movb 0x40(%rdi), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x40(%rdi)
testb %al, %al
je 0x2767ecf
movq (%rsi), %rax
movq %rax, (%rdi)
movq $0x0, (%rsi)
jmp 0x2767f09
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x38(%rdi), %rax
mov... | /llvm/Support/Error.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::DWARFUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFUnit*>>, unsigned long, llvm::DWARFUnit*, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::DWARFUnit*>>::moveFromOldBuc... | 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), %ecx
testq %rcx, %rcx
je 0x2768d4c
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx... | /llvm/ADT/DenseMap.h |
llvm::DWARFDebugMacro::Entry const* llvm::SmallVectorTemplateCommon<llvm::DWARFDebugMacro::Entry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::DWARFDebugMacro::Entry, true>>(llvm::SmallVectorTemplateBase<llvm::DWARFDebugMacro::Entry, true>*, llvm::DWARFDebugMacro::Entry const&, unsigned l... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x27690f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpq %rbx, %rax
setbe %sil... | /llvm/ADT/SmallVector.h |
llvm::DWARFDie::addressRangeContainsAddress(unsigned long) const | bool DWARFDie::addressRangeContainsAddress(const uint64_t Address) const {
auto RangesOrError = getAddressRanges();
if (!RangesOrError) {
llvm::consumeError(RangesOrError.takeError());
return false;
}
for (const auto &R : RangesOrError.get())
if (R.LowPC <= Address && Address < R.HighPC)
retu... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x276cc4c
testb $0x1, 0x18(%r14)
je 0x276cd83
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x778a50
movq (%rbx), %r... | /DebugInfo/DWARF/DWARFDie.cpp |
llvm::DWARFDie::dump(llvm::raw_ostream&, unsigned int, llvm::DIDumpOptions) const | void DWARFDie::dump(raw_ostream &OS, unsigned Indent,
DIDumpOptions DumpOpts) const {
if (!isValid())
return;
DWARFDataExtractor debug_info_data = U->getDebugInfoExtractor();
const uint64_t Offset = getOffset();
uint64_t offset = Offset;
if (DumpOpts.ShowParents) {
DIDumpOptions Pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x276e47d
movq %rdi, %rbp
cmpq $0x0, 0x8(%rdi)
je 0x276e47d
movq %rcx, %r14
leaq 0x320(%rsp), %rdi
callq 0x2779f4a
movq 0x8(%rbp), %rax
... | /DebugInfo/DWARF/DWARFDie.cpp |
llvm::DWARFDie::dump() const | LLVM_DUMP_METHOD void DWARFDie::dump() const { dump(llvm::errs(), 0); } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
callq 0x20bf2bb
movq %rax, %r14
movq %rsp, %r15
xorl %r13d, %r13d
movl $0xa0, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ea240
movaps 0x2696731(%rip), %xmm0 # 0x4e06100
movups %xmm0, (%r15)
leaq 0x30(%rsp), %r12
movq %r13, -0x20... | /DebugInfo/DWARF/DWARFDie.cpp |
llvm::DWARFFormValue::createFromUnit(llvm::dwarf::Form, llvm::DWARFUnit const*, unsigned long*) | DWARFFormValue DWARFFormValue::createFromUnit(dwarf::Form F, const DWARFUnit *U,
uint64_t *OffsetPtr) {
DWARFFormValue FormValue(F);
FormValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr,
U->getFormParams(), U);
return FormValue;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movw %si, (%rdi)
movb $0x0, 0x2(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2779f4a
movl 0x20(%r14), %eax
movzwl 0x24(%r14), ... | /DebugInfo/DWARF/DWARFFormValue.cpp |
llvm::DWARFUnit::DWARFUnit(llvm::DWARFContext&, llvm::DWARFSection const&, llvm::DWARFUnitHeader const&, llvm::DWARFDebugAbbrev const*, llvm::DWARFSection const*, llvm::DWARFSection const*, llvm::StringRef, llvm::DWARFSection const&, llvm::DWARFSection const*, llvm::DWARFSection const&, bool, bool, llvm::DWARFUnitVecto... | DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
const DWARFUnitHeader &Header, const DWARFDebugAbbrev *DA,
const DWARFSection *RS, const DWARFSection *LocSection,
StringRef SS, const DWARFSection &SOS,
const DWARFSec... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r10
movq %rdi, %rax
movq 0x60(%rsp), %r11
movb 0x58(%rsp), %bl
movb 0x50(%rsp), %bpl
movups 0x38(%rsp), %xmm0
movq 0x48(%rsp), %r14
leaq 0x2e70e95(%rip), %rcx # 0x55eab98
addq $0x10, %rcx
movq %rcx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
addq $0x18, %rdi
movl $0... | /DebugInfo/DWARF/DWARFUnit.cpp |
llvm::DWARFUnit::getAddrOffsetSectionItem(unsigned int) const | std::optional<object::SectionedAddress>
DWARFUnit::getAddrOffsetSectionItem(uint32_t Index) const {
if (!AddrOffsetSectionBase) {
auto R = Context.info_section_units();
// Surprising if a DWO file has more than one skeleton unit in it - this
// probably shouldn't be valid, but if a use case is found, here... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0xc8(%r15)
jne 0x2779fc8
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpb $0x1, 0xd1(%r15)
jne 0x2779fec
movl 0x38(%rax), %ecx
cmpl $-0x1, %ecx
jne 0x2779fbb
movl 0x8(%rax), %... | /DebugInfo/DWARF/DWARFUnit.cpp |
llvm::DWARFListTableBase<llvm::DWARFDebugRnglist>::findList(llvm::DWARFDataExtractor, unsigned long) const | Expected<DWARFListType>
DWARFListTableBase<DWARFListType>::findList(DWARFDataExtractor Data,
uint64_t Offset) const {
// Extract the list from the section and enter it into the list map.
DWARFListType List;
if (Header.length())
Data = DWARFDataExtractor(Data, getHea... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd0(%rsp), %r15
movq %rdx, 0x58(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %rsi, %rdi
callq 0x27785f2
testq %rax, %rax
je 0x277c437
movq 0x18(%r14), %r12
movq %r14, %rdi
callq 0x27785f2
a... | /llvm/DebugInfo/DWARF/DWARFListTable.h |
llvm::DWARFUnit::getPreviousSibling(llvm::DWARFDebugInfoEntry const*) | DWARFDie DWARFUnit::getPreviousSibling(const DWARFDebugInfoEntry *Die) {
if (const DWARFDebugInfoEntry *Sibling = getPreviousSiblingEntry(Die))
return DWARFDie(this, Sibling);
return DWARFDie();
} | movq %rdi, %rax
testq %rsi, %rsi
je 0x277d51c
movl 0x8(%rsi), %ecx
cmpl $-0x1, %ecx
je 0x277d51c
movq 0x120(%rax), %rdx
subq %rdx, %rsi
shrq $0x3, %rsi
imull $0xaaaaaaab, %esi, %esi # imm = 0xAAAAAAAB
decl %esi
cmpl %ecx, %esi
jne 0x277d526
xorl %edx, %edx
testq %rdx, %rdx
cmoveq %rdx, %rax
retq
movl %esi, %esi
leaq (%... | /DebugInfo/DWARF/DWARFUnit.cpp |
llvm::DWARFVerifier::handleDebugAbbrev() | bool DWARFVerifier::handleDebugAbbrev() {
OS << "Verifying .debug_abbrev...\n";
const DWARFObject &DObj = DCtx.getDWARFObj();
unsigned NumErrors = 0;
if (!DObj.getAbbrevSection().empty())
NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrev());
if (!DObj.getAbbrevDWOSection().empty())
NumErrors += ve... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x2686ba6(%rip), %rsi # 0x4e09833
movl $0x1b, %edx
callq 0x75bb50
movq 0x8(%rbx), %rax
movq 0x60(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
testq %rdx, %rdx
je 0x2782cc5
movq 0x8(%rbx), %rdi
callq 0x2741762
movq %rbx, %rdi
mo... | /DebugInfo/DWARF/DWARFVerifier.cpp |
llvm::iterator_range<llvm::AppleAcceleratorTable::SameNameIterator> llvm::make_range<llvm::AppleAcceleratorTable::SameNameIterator>(llvm::AppleAcceleratorTable::SameNameIterator, llvm::AppleAcceleratorTable::SameNameIterator) | iterator_range<T> make_range(T x, T y) {
return iterator_range<T>(std::move(x), std::move(y));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x2e54c4b(%rip), %r12 # 0x55eac28
addq $0x10, %r12
leaq 0x20(%rsp), %rax
movq %r12, -0x18(%rax)
movq %rax, -0x10(%rax)
movabsq $0x300000000, %r13 # i... | /llvm/ADT/iterator_range.h |
llvm::Error llvm::object::decodeCrel<true>(llvm::ArrayRef<unsigned char>, llvm::function_ref<void (unsigned long, bool)>, llvm::function_ref<void (llvm::object::Elf_Crel_Impl<true>)>) | Error decodeCrel(
ArrayRef<uint8_t> Content,
function_ref<void(uint64_t /*relocation count*/, bool /*explicit addends*/)>
HdrHandler,
function_ref<void(Elf_Crel_Impl<Is64>)> EntryHandler) {
DataExtractor Data(Content, true, 8); // endian and address size are unused
DataExtractor::Cursor Cur(0);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, 0x48(%rsp)
leaq 0x78(%rsp), %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movw $0x801, 0x10(%rdi) # imm = 0x801
leaq 0x28(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0x20(%rsp... | /llvm/Object/ELF.h |
llvm::object::ELFFile<llvm::object::ELFType<(llvm::endianness)0, true>>::loadVersionMap(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*, llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>> const*) const | Expected<SmallVector<std::optional<VersionEntry>, 0>>
ELFFile<ELFT>::loadVersionMap(const Elf_Shdr *VerNeedSec,
const Elf_Shdr *VerDefSec) const {
SmallVector<std::optional<VersionEntry>, 0> VersionMap;
// The first two version indexes are reserved.
// Index 0 is VER_NDX_LOCAL, inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, -0x10(%r13)
movaps %xmm0, (%r13)
mo... | /llvm/Object/ELF.h |
llvm::object::BBAddrMap::Features::decode(unsigned char) | static Expected<Features> decode(uint8_t Val) {
Features Feat{
static_cast<bool>(Val & (1 << 0)), static_cast<bool>(Val & (1 << 1)),
static_cast<bool>(Val & (1 << 2)), static_cast<bool>(Val & (1 << 3))};
if (Feat.encode() != Val)
return createStringError(
std::error_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x10, %bpl
jae 0x27dbc05
andb $-0x2, 0x8(%rbx)
movb %bpl, (%rbx)
jmp 0x27dbcdd
callq 0x6ea580
movq %rax, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb... | /llvm/Object/ELFTypes.h |
llvm::SmallVectorImpl<llvm::object::ExportEntry::NodeState>::assignRemote(llvm::SmallVectorImpl<llvm::object::ExportEntry::NodeState>&&) | 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 0x27fde7f
callq 0x6ea8c0
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::object::MachOUniversalBinary::ObjectForArch::ObjectForArch(llvm::object::MachOUniversalBinary const*, unsigned int) | MachOUniversalBinary::ObjectForArch::ObjectForArch(
const MachOUniversalBinary *Parent, uint32_t Index)
: Parent(Parent), Index(Index) {
// The iterators use Parent as a nullptr and an Index+1 == NumberOfObjects.
if (!Parent || Index >= Parent->getNumberOfObjects()) {
clear();
} else {
// Parse ob... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
testq %rsi, %rsi
je 0x27fe48a
movl %edx, %ebp
movq %rsi, %r14
cmpl %edx, 0x34(%rsi)
jbe 0x27fe48a
movq %r14, %rdi
callq 0x27a01ba
cmpl $0xcafebabe, 0x30(%r14) # imm = 0xCAFEBABE
movl %ebp, %ecx
jne 0x27fe49d
leaq (%rcx,%rcx,4), %rcx... | /Object/MachOUniversal.cpp |
llvm::object::MachOUniversalBinary::getObjectForArch(llvm::StringRef) const | Expected<MachOUniversalBinary::ObjectForArch>
MachOUniversalBinary::getObjectForArch(StringRef ArchName) const {
if (Triple(ArchName).getArch() == Triple::ArchType::UnknownArch)
return make_error<GenericBinaryError>("Unknown architecture "
"named: " +
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r12
movq %rdi, %r15
leaq 0x60(%rsp), %rsi
movw $0x105, 0x20(%rsi) # imm = 0x105
movq %rdx, 0x8(%rsp)
movq %rdx, (%rsi)
movq %rcx, 0x10(%rsp)
movq %rcx, 0x8(%rsi)
leaq 0xa0(%rsp), %r13
movq %r13,... | /Object/MachOUniversal.cpp |
void llvm::function_ref<void (llvm::RecordStreamer&)>::callback_fn<llvm::ModuleSymbolTable::CollectAsmSymbols(llvm::Module const&, llvm::function_ref<void (llvm::StringRef, llvm::object::BasicSymbolRef::Flags)>)::$_0>(long, llvm::RecordStreamer&) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2805190
movq %r15, %rdi
callq 0x2804f82
movq %rax, %r14
movq %r15, %rdi
callq 0x2804fa8
cmpq %rax, %r14
je 0x280265f
movq %rax, %r15
leaq 0x26170f8(%rip), %r12 # 0x4e19718
movq (%r14), %rsi
movl 0x8(%rsi), %... | /llvm/ADT/STLFunctionalExtras.h |
std::pair<llvm::StringRef, llvm::StringRef> const* llvm::SmallVectorTemplateCommon<std::pair<llvm::StringRef, llvm::StringRef>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::StringRef>, true>>(llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::StringR... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x2804880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rbx, %rax
set... | /llvm/ADT/SmallVector.h |
llvm::GlobalValue const& llvm::concat_iterator<llvm::GlobalValue const, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Function, false, false, void, false, void>, false, true>, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::GlobalVariable, false, false, void, false, void>, false, true>, llvm::... | ValueT &get(std::index_sequence<Ns...>) const {
// Build a sequence of functions to get from iterator if possible.
ValueT *(concat_iterator::*GetHelperFns[])() const = {
&concat_iterator::getHelper<Ns>...};
// Loop over them, and return the first result we find.
for (auto &GetHelperFn : GetHelp... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x69(%rip), %rax # 0x2805ee2
movq %rax, (%rsp)
leaq 0x78(%rip), %rax # 0x2805efc
movq %rax, 0x10(%rsp)
leaq 0x86(%rip), ... | /llvm/ADT/STLExtras.h |
llvm::object::supportsPPC32(unsigned long) | static bool supportsPPC32(uint64_t Type) {
switch (Type) {
case ELF::R_PPC_ADDR32:
case ELF::R_PPC_REL32:
return true;
default:
return false;
}
} | cmpq $0x1, %rdi
sete %cl
cmpq $0x1a, %rdi
sete %al
orb %cl, %al
retq
| /Object/RelocationResolver.cpp |
llvm::Error llvm::BinaryStreamReader::readArray<unsigned char>(llvm::ArrayRef<unsigned char>&, unsigned int) | Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
ArrayRef<uint8_t> Bytes;
if (NumElements == 0) {
Array = ArrayRef<T>();
return Error::success();
}
if (NumElements > UINT32_MAX / sizeof(T))
return make_error<BinaryStreamError>(
stream_error_code::invalid_array_siz... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %ecx, %ecx
je 0x281297b
movl %ecx, %ebp
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x20d245a
cmpq $0x0, (%rbx)
jne 0x2812986
movl %ebp, %eax
movq (%rsp), %rcx
movq %rcx, (%r14)
movq %rax, 0x8(%r14)... | /llvm/Support/BinaryStreamReader.h |
llvm::object::WindowsResourceParser::parse(llvm::object::ResourceSectionRef&, llvm::StringRef, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | Error WindowsResourceParser::parse(ResourceSectionRef &RSR, StringRef Filename,
std::vector<std::string> &Duplicates) {
UNWRAP_REF_OR_RETURN(BaseTable, RSR.getBaseTable());
uint32_t Origin = InputFilenames.size();
InputFilenames.push_back(std::string(Filename));
std::vector<St... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x40(%rsp)
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x2827df2
testb $0x1, 0x8(%rbp)
je 0x2813882
movq (%rsp), %rax
movq $0x0, (%rsp)
mo... | /Object/WindowsResource.cpp |
llvm::object::WindowsResourceCOFFWriter::writeSymbolTable() | void WindowsResourceCOFFWriter::writeSymbolTable() {
// Now write the symbol table.
// First, the feat symbol.
auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
coffnamecpy(Symbol->Name.ShortName, "@feat.00");
Symbol->Value = 0x11;
Symbol->SectionNumber = 0xffff;
Symbol->Type ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movabsq $0x30302e7461656640, %rdx # imm = 0x30302E7461656640
movq %rdx, (%rax,%rcx)
movabsq $0xffff00000011, %rdx # imm = 0xFFFF00000011
movq %rdx, 0x8(%rax,%rcx)
movw $0x3, 0x10(%rax,%rcx)
mo... | /Object/WindowsResource.cpp |
llvm::LLParser::parseDIStringType(llvm::MDNode*&, bool) | bool LLParser::parseDIStringType(MDNode *&Result, bool IsDistinct) {
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_string_type)); \
OPTIONAL(name, MDStringField, ); \
OPTION... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq $0x12, 0xa0(%rsp)
xorl %eax, %eax
movb %al, 0xa8(%rsp)
movq $0xffff, 0xb0(%rsp) # imm = 0xFFFF
movq %rax, 0x48(%rsp)
movw $0x100, %cx #... | /AsmParser/LLParser.cpp |
llvm::LLParser::PerFunctionState::resolveForwardRefBlockAddresses() | bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
ValID ID;
if (FunctionNumber == -1) {
ID.Kind = ValID::t_GlobalName;
ID.StrVal = std::string(F.getName());
} else {
ID.Kind = ValID::t_GlobalID;
ID.UIntVal = FunctionNumber;
}
auto Blocks = P.ForwardRefBlockAddresses.find(ID... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %r12
movl $0x0, -0x30(%r12)
xorl %r15d, %r15d
movq %r15, -0x28(%r12)
movq %r15, -0x18(%r12)
movq %r12, -0x10(%r12)
movq %r15, -0x8(%r12)
movb %r15b, (%r12)
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
mov... | /AsmParser/LLParser.cpp |
llvm::LLParser::parseCompare(llvm::Instruction*&, llvm::LLParser::PerFunctionState&, unsigned int) | bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc) {
// parse the integer/fp comparison predicate.
LocTy Loc;
unsigned Pred;
Value *LHS, *RHS;
if (parseCmpPredicate(Pred, Opc) || parseTypeAndValue(LHS, Loc, PFS) ||
parseToken(lltok::comma, "e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c(%rsp), %rsi
movl %ecx, %edx
callq 0x28756d4
movb $0x1, %r13b
testb %al, %al
jne 0x28723cd
movq 0xe0(%r14), %r12
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
movq %r15, %r... | /AsmParser/LLParser.cpp |
llvm::codeview::SymbolRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::AnnotationSym&) | Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR,
AnnotationSym &Annot) {
error(IO.mapInteger(Annot.CodeOffset));
error(IO.mapInteger(Annot.Segment));
error(IO.mapVectorN<uint16_t>(
Annot.Strings,
[](CodeViewRecordIO &IO, StringRef &S) { return IO.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
leaq 0x4(%rcx), %rdx
leaq 0x18(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r14, %rsi
callq 0x28ad6ee
cmpq $0x0, (%rbx)
jne 0x28b0429
leaq 0x8(%r15), %... | /DebugInfo/CodeView/SymbolRecordMapping.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned long, llvm::StringRef, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::StringRef>>, unsigned long, llvm::StringRef, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, llvm::StringRef>>::FindAndConstruct(u... | 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 0x2408904
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x28dbea5
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x240899e
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps ... | /llvm/ADT/DenseMap.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::detail::join_impl<llvm::detail::DenseSetImpl<llvm::StringRef, llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>, llvm::DenseMapInfo<llvm... | inline std::string join_impl(IteratorT Begin, IteratorT End,
StringRef Separator, std::forward_iterator_tag) {
std::string S;
if (Begin == End)
return S;
size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
for (IteratorT I = Begin; I != End; ++I)
Len += StringR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rcx, %rsi
je 0x2905f84
movq %rcx, %rbx
leaq 0x60(%rsp), %rbp
movq %rsp, %r15
movq %rsi, ... | /llvm/ADT/StringExtras.h |
llvm::msgpack::Document::readFromBlob(llvm::StringRef, bool, llvm::function_ref<int (llvm::msgpack::DocNode*, llvm::msgpack::DocNode, llvm::msgpack::DocNode)>) | bool Document::readFromBlob(
StringRef Blob, bool Multi,
function_ref<int(DocNode *DestNode, DocNode SrcNode, DocNode MapKey)>
Merger) {
msgpack::Reader MPReader(Blob);
SmallVector<StackLevel, 4> Stack;
if (Multi) {
// Create the array for multiple top-level objects.
Root = getArrayNode();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %r9, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movl %ecx, %ebx
movq %rdi, %r15
leaq 0x288(%rsp), %rdi
callq 0x292fb9c
leaq 0x168(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x40000000... | /BinaryFormat/MsgPackDocument.cpp |
llvm::ScopedPrinter::scopedBegin(char) | void scopedBegin(char Symbol) {
startLine() << Symbol << '\n';
indent();
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x120(%rax)
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x2936e6a
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb %bpl, (%rcx)
jmp 0x2936e76
movzbl %bpl, %esi
movq %rax, %rdi
callq 0x20be40a
movq 0x20(%rax), %rcx
cmpq 0x18(%ra... | /llvm/Support/ScopedPrinter.h |
void llvm::function_ref<void ()>::callback_fn<llvm::JSONScopedPrinter::printFlagsImpl(llvm::StringRef, llvm::HexNumber, llvm::ArrayRef<llvm::HexNumber>)::'lambda'()>(long) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %r12
leaq 0x80(%r12), %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rsp, %r15
movw $0x4, (%r15)
movq %rax, 0x8(%r15)
leaq 0x22a9250(%rip), %rsi # 0x4be0b2e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x20d86ec
movq %rbx, %rdi
movq... | /llvm/ADT/STLFunctionalExtras.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseFunctionParam() | Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
if (consumeIf("fpT"))
return make<NameType>("this");
if (consumeIf("fp")) {
parseCVQualifiers();
std::string_view Num = parseNumber();
if (!consumeIf('_'))
return nullptr;
return make<FunctionParam>(Num);
}
if (consum... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x24b6446(%rip), %rdx # 0x4e044b9
movl $0x3, %esi
callq 0x2949226
testb %al, %al
je 0x294e09b
leaq 0x24a5c2d(%rip), %rsi # 0x4df3cb5
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x294c752
leaq 0x24edd30... | /llvm/Demangle/ItaniumDemangle.h |
llvm::ms_demangle::Demangler::demangleFullyQualifiedTypeName(std::basic_string_view<char, std::char_traits<char>>&) | QualifiedNameNode *
Demangler::demangleFullyQualifiedTypeName(std::string_view &MangledName) {
IdentifierNode *Identifier =
demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
if (Error)
return nullptr;
assert(Identifier);
QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifie... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edx
callq 0x2954888
cmpb $0x0, 0x8(%rbx)
je 0x295150e
xorl %eax, %eax
jmp 0x2951529
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2951346
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, 0x8(%rbx)
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rb... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleFullyQualifiedSymbolName(std::basic_string_view<char, std::char_traits<char>>&) | QualifiedNameNode *
Demangler::demangleFullyQualifiedSymbolName(std::string_view &MangledName) {
// This is the final component of a symbol name (i.e. the leftmost component
// of a mangled name. Since the only possible template instantiation that
// can appear in this context is a function template, and since t... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %edx
callq 0x295374c
cmpb $0x0, 0x8(%rbx)
jne 0x2952f34
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2951346
cmpb $0x0, 0x8(%rbx)
je 0x2952f3c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0xb, 0x8(%r14)
jn... | /Demangle/MicrosoftDemangle.cpp |
llvm::ms_demangle::Demangler::demangleTemplateInstantiationName(std::basic_string_view<char, std::char_traits<char>>&, llvm::ms_demangle::NameBackrefBehavior) | IdentifierNode *
Demangler::demangleTemplateInstantiationName(std::string_view &MangledName,
NameBackrefBehavior NBB) {
assert(llvm::itanium_demangle::starts_with(MangledName, "?$"));
consumeFront(MangledName, "?$");
BackrefContext OuterContext;
std::swap(OuterConte... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %edx, 0xc(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x24f52f0(%rip), %rdx # 0x4e48902
movl $0x2, %esi
movq %r13, %rdi
callq 0x2951721
leaq 0x18(%rbx), %r15
leaq 0x68(%rsp), %rdi
movl $0xa, %ecx
movq %r15... | /Demangle/MicrosoftDemangle.cpp |
NodeList* llvm::ms_demangle::ArenaAllocator::alloc<NodeList>() | T *alloc(Args &&... ConstructorArgs) {
constexpr size_t Size = sizeof(T);
assert(Head && Head->Buf);
size_t P = (size_t)Head->Buf + Head->Used;
uintptr_t AlignedP =
(((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
uint8_t *PP = (uint8_t *)AlignedP;
size_t Adjustment = Aligned... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq (%rcx,%rax), %rdx
addq %rcx, %rax
addq $0x7, %rax
andq $-0x8, %rax
subq %rdx, %rcx
addq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%r15)
cmpq 0x10(%r15), %rcx
jbe 0x2954b24
movq %rdi, %rbx
movl $0x20, %edi
callq 0x6ea880
movq... | /llvm/Demangle/MicrosoftDemangle.h |
llvm::ms_demangle::Demangler::demangleMemberPointerType(std::basic_string_view<char, std::char_traits<char>>&) | PointerTypeNode *
Demangler::demangleMemberPointerType(std::string_view &MangledName) {
PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
std::tie(Pointer->Quals, Pointer->Affinity) =
demanglePointerCVQualifiers(MangledName);
assert(Pointer->Affinity == PointerAffinity::Pointer);
Qualifiers Ext... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %rdi
callq 0x29558ae
movq %rax, %rbx
movq %r14, %rdi
callq 0x295594b
movb %al, 0xc(%rbx)
shrq $0x20, %rax
movl %eax, 0x10(%rbx)
movq %r14, %rsi
callq 0x2953322
orb %al, 0xc(%rbx)
leaq 0x24c81cd(%rip), %rdx # 0x4e1cf90
m... | /Demangle/MicrosoftDemangle.cpp |
outputQualifiers(llvm::itanium_demangle::OutputBuffer&, llvm::ms_demangle::Qualifiers, bool, bool) | static void outputQualifiers(OutputBuffer &OB, Qualifiers Q, bool SpaceBefore,
bool SpaceAfter) {
if (Q == Q_None)
return;
size_t Pos1 = OB.getCurrentPosition();
SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Const, SpaceBefore);
SpaceBefore = outputQualifierIfPresent(OB, Q, Q... | testl %esi, %esi
je 0x29565a9
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movzbl %sil, %r14d
movzbl %dl, %ecx
movl %r14d, %esi
movl $0x1, %edx
callq 0x2958d22
movzbl %al, %ecx
movq %rbx, %rdi
movl %r14d, %esi
movl $0x2, %edx
callq 0x2958d22
movzbl %al, %ec... | /Demangle/MicrosoftDemangleNodes.cpp |
llvm::ms_demangle::LiteralOperatorIdentifierNode::output(llvm::itanium_demangle::OutputBuffer&, llvm::ms_demangle::OutputFlags) const | void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
OB << "operator \"\"" << Name;
outputTemplateParameters(OB, Flags);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0xb, %esi
movq %r14, %rdi
callq 0x2716bbe
movq (%r14), %rax
movq 0x8(%r14), %rcx
movabsq $0x726f74617265706f, %rdx # imm = 0x726F74617265706F
movq %rdx, (%rax,%rcx)
movl $0x22222072, 0x7(%rax,%rcx) # imm = 0x222... | /Demangle/MicrosoftDemangleNodes.cpp |
llava_init_context(common_params*, llama_model*) | static struct llava_context * llava_init_context(common_params * params, llama_model * model) {
const char * clip_path = params->mmproj.path.c_str();
auto prompt = params->prompt;
if (prompt.empty()) {
prompt = "describe the image in detail.";
}
auto ctx_clip = clip_model_load(clip_path, G... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1040(%rdi), %r15
leaq 0x88(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0xe20(%rdi), %rsi
movq 0xe28(%rdi), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x2c96e
cmpq $0... | /ggerganov[P]llama/examples/llava/qwen2vl-cli.cpp |
llava_free(llava_context*) | static void llava_free(struct llava_context * ctx_llava) {
if (ctx_llava->ctx_clip) {
clip_free(ctx_llava->ctx_clip);
ctx_llava->ctx_clip = NULL;
}
llama_free(ctx_llava->ctx_llama);
llama_model_free(ctx_llava->model);
llama_backend_free();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2aa16
callq 0x32058
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x23de0
movq 0x10(%rbx), %rdi
callq 0x23920
popq %rbx
jmp 0x242b0
| /ggerganov[P]llama/examples/llava/qwen2vl-cli.cpp |
_gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>> base64::decode<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocato... | static Output_iterator decode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out,
alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate)
{
//constexpr auto pad = '=';
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %ecx, 0x4(%rsp)
cmpq %rsi, %rdi
je 0x2cc28
movl %r8d, (%rsp)
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
xorl %r12d, %r12d
movq %rdi, %r13
movb (%rdi), %al
cmpb $0x3d, %al
je 0x2cc1e
movsbl %al, %esi
movq %r15, %r... | /ggerganov[P]llama/common/./base64.hpp |
llava_image_embed_make_with_bytes | struct llava_image_embed * llava_image_embed_make_with_bytes(struct clip_ctx * ctx_clip, int n_threads, const unsigned char * image_bytes, int image_bytes_length) {
clip_image_u8 * img = clip_image_u8_init();
if (!clip_image_load_from_bytes(image_bytes, image_bytes_length, img)) {
clip_image_u8_free(img... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r15d
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
callq 0x31543
movq %rax, %rbx
movslq %r15d, %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x31834
testb %al, %al
je 0x2e247
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x4(%rsp), %r8
mov... | /ggerganov[P]llama/examples/llava/llava.cpp |
llava_embd_batch::llava_embd_batch(float*, int, int, int) | llava_embd_batch(float * embd, int32_t n_tokens, llama_pos pos_0, llama_seq_id seq_id) {
pos .resize(n_tokens);
n_seq_id.resize(n_tokens);
seq_ids .resize(n_tokens + 1);
logits .resize(n_tokens);
seq_id_0.resize(1);
seq_id_0[0] = seq_id;
seq_ids [n_tokens] = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, 0xc(%rsp)
movl %edx, %r14d
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rdi), %... | /ggerganov[P]llama/examples/llava/llava.cpp |
stbi_load_from_file | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x15ebbb(%rip), %rax # 0x18da40
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x15eb9b(%rip), %xmm0 # 0x18da30
movups %xmm0, -0x28(%rcx)
movq... | /ggerganov[P]llama/examples/llava/../../common/stb_image.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.