name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::ItaniumVTableBuilder::LayoutSecondaryVTables(clang::BaseSubobject, bool, clang::CharUnits) | void
ItaniumVTableBuilder::LayoutSecondaryVTables(BaseSubobject Base,
bool BaseIsMorallyVirtual,
CharUnits OffsetInLayoutClass) {
// Itanium C++ ABI 2.5.2:
// Following the primary virtual table of a derived class are second... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl %ecx, %ebp
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x28(%rdi), %rdi
callq 0x203026
movq %rax, 0x10(%rsp)
movq 0x48(%rax), %rax
movq 0x30(%rax), %r12
movq %rbx, %rdi
callq 0x79e56
cmpq %rdx, %r... | /AST/VTableBuilder.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned long, clang::ThunkInfo, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, clang::ThunkInfo>>, unsigned long, clang::ThunkInfo, llvm::DenseMapInfo<unsigned long, void>, llvm::detail::DenseMapPair<unsigned long, clang::ThunkInfo>>::FindAndConstru... | 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 0x241a62
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x241a57
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x241afc
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps %xm... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<clang::BaseSubobject, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseSetPair<clang::BaseSubobject>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x2443fe
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::BaseSubobject, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseSetPair<clang::BaseSubobject>>, clang::BaseSubobject, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseSetPair<clang::Bas... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0x244ae5
cmpl $0x0, 0xc(%rdi)
je 0x244b33
shll $0x2, %ecx
movl 0x10(%rdi), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
je 0x244b34
testq %rax, %rax
je 0x244b2b
movq (%rdi), %rcx
shlq $0x4, %rax
addq %rcx, %rax
movabsq $0x7fffffffffffffff, %rdx # imm = ... | /llvm/ADT/DenseMap.h |
dumpMicrosoftThunkAdjustment(clang::ThunkInfo const&, llvm::raw_ostream&, bool) | static void dumpMicrosoftThunkAdjustment(const ThunkInfo &TI, raw_ostream &Out,
bool ContinueFirstLine) {
const ReturnAdjustment &R = TI.Return;
bool Multiline = false;
const char *LinePrefix = "\n ";
if (!R.isEmpty() || TI.Method) {
if (!ContinueFirstLine)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
orq 0x18(%rdi), %rax
movq %rsi, %r14
orq 0x28(%rdi), %rax
sete %r12b
je 0x246980
testb %bpl, %bpl
jne 0x246884
leaq 0xfd4be(%rip), %rsi # 0x343d35
movl $0x8, %edx
movq %r14, %rdi
callq 0x577... | /AST/VTableBuilder.cpp |
bool clang::interp::ByteCodeEmitter::emitOp<clang::interp::IntegralAP<true>>(clang::interp::Opcode, clang::interp::IntegralAP<true> const&, clang::interp::SourceInfo const&) | bool ByteCodeEmitter::emitOp(Opcode Op, const Tys &... Args, const SourceInfo &SI) {
bool Success = true;
// The opcode is followed by arguments. The source info is
// attached to the address after the opcode.
emit(P, Code, Op, Success);
if (SI)
SrcMap.emplace_back(Code.size(), SI);
(..., emit(P, Code... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %r12
movq 0x1c0(%rdi), %rbx
subq 0x1b8(%rdi), %rbx
leaq 0x1b8(%rdi), %r15
leaq 0x4(%rbx), %rax
shrq $0x20, %rax
sete %al
movl %eax, 0xc(%rsp)
jne 0x250d97
movl %esi, %ebp
addq $0x7, %rbx
andq $-... | /AST/Interp/ByteCodeEmitter.cpp |
llvm::SmallVectorImpl<clang::interp::Scope>::clear() | void clear() {
this->destroy_range(this->begin(), this->end());
this->Size = 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x25110f
movq (%rbx), %r14
leaq -0x80(%r14), %r15
shlq $0x4, %rax
leaq (%rax,%rax,8), %r12
movq -0x90(%r14,%r12), %rdi
leaq (%r15,%r12), %rax
cmpq %rdi, %rax
je 0x251106
callq 0x3c3a0
addq $-0x90, %r12
jne 0x... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<clang::interp::Scope::Local>::assignRemote(llvm::SmallVectorImpl<clang::interp::Scope::Local>&&) | 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 0x251265
callq 0x3c3a0
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 %r1... | /llvm/ADT/SmallVector.h |
clang::interp::Compiler<clang::interp::ByteCodeEmitter>::emitConst(llvm::APSInt const&, clang::interp::PrimType, clang::Expr const*) | bool Compiler<Emitter>::emitConst(const APSInt &Value, PrimType Ty,
const Expr *E) {
if (Ty == PT_IntAPS)
return this->emitConstIntAPS(Value, E);
if (Ty == PT_IntAP)
return this->emitConstIntAP(Value, E);
if (Value.isSigned())
return this->emitConst(Value.getSExtValu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x8, %edx
je 0x25e755
cmpl $0x9, %edx
jne 0x25e772
movl 0x8(%rsi), %eax
movl %eax, 0x30(%rsp)
cmpl $0x40, %eax
ja 0x25e79e
movq (%rsi), %rax
movq %rax, 0x28(%rsp)
jmp 0x25e7a8
movl 0x8(%rsi), %eax
movl %eax, 0x20(%rsp)
cmpl $0x40, %... | /AST/Interp/Compiler.cpp |
clang::interp::Compiler<clang::interp::EvalEmitter>::visitZeroInitializer(clang::interp::PrimType, clang::QualType, clang::Expr const*) | bool Compiler<Emitter>::visitZeroInitializer(PrimType T, QualType QT,
const Expr *E) {
switch (T) {
case PT_Bool:
return this->emitZeroBool(E);
case PT_Sint8:
return this->emitZeroSint8(E);
case PT_Uint8:
return this->emitZeroUint8(E);
case PT_Sint16:
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl %esi, %eax
leaq 0xe13e0(%rip), %rcx # 0x345300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x174088
jmp 0x2640f7
orq $0x4, %r14
movq %rsp... | /AST/Interp/Compiler.cpp |
clang::interp::Compiler<clang::interp::EvalEmitter>::VisitImaginaryLiteral(clang::ImaginaryLiteral const*) | bool Compiler<Emitter>::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
assert(E->getType()->isAnyComplexType());
if (DiscardResult)
return true;
if (!Initializing) {
std::optional<unsigned> LocalIndex = allocateLocal(E);
if (!LocalIndex)
return false;
if (!this->emitGetPtrLocal(*LocalIn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %r15b
cmpb $0x0, 0x3a0(%rdi)
jne 0x264643
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x3a2(%rdi)
je 0x2645f8
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq 0x340(%rbx), %rdi
callq 0x12f47a
movq %rax, %r12
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl %r12d,... | /AST/Interp/Compiler.cpp |
void dtorArrayTy<clang::interp::Boolean>(clang::interp::Block*, std::byte*, clang::interp::Descriptor const*) | static void dtorArrayTy(Block *, std::byte *Ptr, const Descriptor *D) {
InitMapPtr &IMP = *reinterpret_cast<InitMapPtr *>(Ptr);
if (IMP)
IMP = std::nullopt;
Ptr += sizeof(InitMapPtr);
for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) {
reinterpret_cast<T *>(Ptr)[I].~T();
}
} | cmpb $0x1, 0x18(%rsi)
jne 0x274657
movb $0x0, 0x18(%rsi)
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
jne 0x5b62e
retq
| /AST/Interp/Descriptor.cpp |
llvm::FoldingSet<clang::ento::ExplodedNode>::NodeEquals(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID const&, unsigned int, llvm::FoldingSetNodeID&) | static bool NodeEquals(const FoldingSetBase *, Node *N,
const FoldingSetNodeID &ID, unsigned IDHash,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return FoldingSetTrait<T>::Equals(*TN, ID, IDHash, TempID);
} | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
leaq 0x8(%rsi), %rax
movl 0x48(%rsi), %ecx
leaq 0x38(%rsi), %rdx
andl $0x1, %ecx
movq %r8, %rdi
movq %rax, %rsi
callq 0x2766fa
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x317fa8
nop
| /llvm/ADT/FoldingSet.h |
makeRangeFromFileLocs(clang::CharSourceRange, clang::SourceManager const&, clang::LangOptions const&) | static CharSourceRange makeRangeFromFileLocs(CharSourceRange Range,
const SourceManager &SM,
const LangOptions &LangOpts) {
SourceLocation Begin = Range.getBegin();
SourceLocation End = Range.getEnd();
assert(Begin.isFileID(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq %rdi, %r14
shrq $0x20, %r14
testb $0x1, %sil
je 0x288639
xorl %r12d, %r12d
movl %r14d, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x288228
movl %eax, %r14d
testl %eax, %eax
je 0x288682
movq %r15, %rdi
movl ... | /Lex/Lexer.cpp |
GetMappedTokenLoc(clang::Preprocessor&, clang::SourceLocation, unsigned int, unsigned int) | static SourceLocation GetMappedTokenLoc(Preprocessor &PP,
SourceLocation FileLoc,
unsigned CharNo, unsigned TokLen) {
assert(FileLoc.isMacroID() && "Must be a macro expansion");
// Otherwise, we're lexing "mapped tokens". This is used... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %r15d
movq 0x58(%rdi), %r14
movl %esi, %ebp
testl %esi, %esi
jns 0x2887f3
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f60b8
movl %eax, %ebp
addl %r12d, %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f6256
movq %rax, %rcx
sh... | /Lex/Lexer.cpp |
diagnoseExtensionInIdentifier(clang::DiagnosticsEngine&, unsigned int, clang::CharSourceRange) | static void diagnoseExtensionInIdentifier(DiagnosticsEngine &Diags, uint32_t C,
CharSourceRange Range) {
static const llvm::sys::UnicodeCharSet MathStartChars(
MathematicalNotationProfileIDStartRanges);
static const llvm::sys::UnicodeCharSet MathContinueChars(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
leaq 0x8(%rsp), %rbx
movq %rdx, (%rbx)
movb %cl, 0x8(%rbx)
movl %edx, 0x170(%rdi)
movl $0x4c5, 0x174(%rdi) # imm = 0x4C5
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x38(%rsp),... | /Lex/Lexer.cpp |
clang::Lexer::codeCompleteIncludedFile(char const*, char const*, bool) | void Lexer::codeCompleteIncludedFile(const char *PathStart,
const char *CompletionPoint,
bool IsAngled) {
// Completion only applies to the filename, after the last slash.
StringRef PartialPath(PathStart, CompletionPoint - PathStart);
llvm:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rcx
movq %rdx, %rax
subq %rsi, %rax
leaq 0x28(%rsp), %rdi
movq %rsi, (%rdi)
movq %rax, 0x8(%rdi)
movq %rcx, 0x18(%rsp)
movq 0x88(%rcx), %rax
xorl %edx, %edx
testb $0x20, (%rax)
... | /Lex/Lexer.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::KnownHeader, 1u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::KnownHeader, 1u>>>, clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::Kno... | 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 0x2a4754
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2a4ca0
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2a4caa
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x18... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::KnownHeader, 1u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::KnownHeader, 1u>>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<clang::Module::UnresolvedExportDecl, false>::moveElementsForGrow(clang::Module::UnresolvedExportDecl*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
imulq $0x70, %rax, %rsi
addq %rdi, %rsi
callq 0x2a674a
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x2a6742
movq (%rbx), %rbx
addq $-0x68, %rbx
imulq $0x70, %rax, %r14
leaq (%rbx,%r14), %rdi
callq 0x280ade
addq $-0x70, ... | /llvm/ADT/SmallVector.h |
clang::Preprocessor::LookupEmbedFile(llvm::StringRef, bool, bool, clang::FileEntry const*) | OptionalFileEntryRef
Preprocessor::LookupEmbedFile(StringRef Filename, bool isAngled, bool OpenFile,
const FileEntry *LookupFromFile) {
FileManager &FM = this->getFileManager();
if (llvm::sys::path::is_absolute(Filename)) {
// lookup path or immediately fail
llvm::Expected<File... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r9, %r15
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x50(%rsp)
movq 0x50(%rdi), %r14
leaq 0x70(%rsp), %rdi
movw $0x105, 0x20(%rdi) # imm = 0x105
movq %rsi, (%rdi)
movq... | /Lex/PPDirectives.cpp |
clang::Preprocessor::HandleMacroPublicDirective(clang::Token&) | void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
Token MacroNameTok;
ReadMacroName(MacroNameTok, MU_Undef);
// Error reading macro name? If so, diagnostic already issued.
if (MacroNameTok.is(tok::eod))
return;
// Check to see if this is the last token on the #__public_macro line.
CheckEndO... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x2a91da
cmpw $0x2, 0x10(%rbx)
je 0x2ae98a
leaq 0xaab5a(%rip), %rsi # 0x3593c7
movq %r14, %rdi
xorl %edx, %edx
callq 0x2a92c8
movl 0x38(%rsp), %eax
decl %eax
cmpw $0x13, %ax
... | /Lex/PPDirectives.cpp |
clang::Preprocessor::GetIncludeFilenameSpelling(clang::SourceLocation, llvm::StringRef&) | bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
StringRef &Buffer) {
// Get the text form of the filename.
assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
// FIXME: Consider warning on some of the cases described in C11 6.4.7/3... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq (%rdx), %rcx
movb (%rcx), %dl
cmpb $0x3c, %dl
sete %al
jne 0x2af2ee
movq 0x8(%rbx), %rdx
cmpb $0x3e, -0x1(%rcx,%rdx)
je 0x2af302
movq 0x30(%rdi), %rdi
movl %esi, 0x170(%rdi)
movl $0x464, 0x174(%rdi) # imm = 0x464
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq... | /Lex/PPDirectives.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::join<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>>>> const&>(std::vector<std::__cxx11::basic_st... | inline std::string join(Range &&R, StringRef Separator) {
return join(R.begin(), R.end(), Separator);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq (%rsi), %r12
movq 0x8(%rsi), %r13
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %r13, %r12
je 0x2ba0f9
movq %rcx, %rbx
movq %rdx, %r14
movq %r13, %rsi
subq %r12, %rsi
sarq $0x5, %rsi
decq %rsi
imulq %rc... | /llvm/ADT/StringExtras.h |
clang::Preprocessor::HandleEndOfFile(clang::Token&, bool) | bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {
assert(!CurTokenLexer &&
"Ending a file when currently in a macro!");
SourceLocation UnclosedSafeBufferOptOutLoc;
if (IncludeMacroStack.empty() &&
isPPInSafeBufferOptOutRegion(UnclosedSafeBufferOptOutLoc)) {
// To warn if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
movq 0x480(%rdi), %rax
cmpq 0x488(%rdi), %rax
jne 0x2bb3f4
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x2cb0f6
testb %al, %al
je 0x2bb3f4
mov... | /Lex/PPLexerChange.cpp |
llvm::SmallVectorTemplateBase<clang::Module const*, true>::push_back(clang::Module const*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x2bcdab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jm... | /llvm/ADT/SmallVector.h |
clang::Preprocessor::appendMacroDirective(clang::IdentifierInfo*, clang::MacroDirective*) | void Preprocessor::appendMacroDirective(IdentifierInfo *II, MacroDirective *MD){
assert(MD && "MacroDirective should be non-zero!");
assert(!MD->getPrevious() && "Already attached to a MacroDirective history.");
MacroState &StoredMD = CurSubmoduleState->Macros[II];
auto *OldMD = StoredMD.getLatest();
MD->set... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq 0x698(%rdi), %rdi
movq %rax, %rsi
callq 0x27d5ea
movq 0x8(%rax), %rcx
addq $0x8, %rax
testb $0x4, %cl
sete %dl
andq $-0x8, %rcx
sete %sil
orb %dl, %sil
jne 0x2bd514
movq (%rcx), %rcx
movq %rcx, ... | /Lex/PPMacroExpansion.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::IdentifierInfo const*, llvm::TinyPtrVector<clang::ModuleMacro*>, llvm::DenseMapInfo<clang::IdentifierInfo const*, void>, llvm::detail::DenseMapPair<clang::IdentifierInfo const*, llvm::TinyPtrVector<clang::ModuleMacro*>>>, clang::IdentifierInfo const*, llvm::TinyPtrVector<clang::... | 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 0x280f92
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
testb %al, %al
movq (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
clang::Preprocessor::ReadMacroCallArgumentList(clang::Token&, clang::MacroInfo*, clang::SourceLocation&) | MacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName,
MacroInfo *MI,
SourceLocation &MacroEnd) {
// The number of fixed arguments to parse.
unsigned NumFixedArgsLeft = MI->getNumParams();
bool isVa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x878, %rsp # imm = 0x878
movq %rcx, 0x140(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl 0x18(%rdx), %eax
movl %eax, 0x38(%rsp)
movq %rdx, 0x18(%rsp)
movzwl 0x24(%rdx), %eax
movl %eax, 0x8(%rsp)
testb $0xc, %al
sete 0xd8(%rsp)
movzwl ... | /Lex/PPMacroExpansion.cpp |
clang::Preprocessor::getCurrentModule() | const LangOptions &getLangOpts() const { return LangOpts; } | movq 0x38(%rdi), %rax
testb $0x38, 0xbd(%rax)
je 0x2c8959
movq 0x68(%rdi), %rdi
movq 0x1d8(%rax), %rsi
movq 0x1e0(%rax), %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
jmp 0x282398
xorl %eax, %eax
retq
| /clang/Lex/Preprocessor.h |
clang::Preprocessor::HandlePoisonedIdentifier(clang::Token&) | void Preprocessor::HandlePoisonedIdentifier(Token & Identifier) {
assert(Identifier.getIdentifierInfo() &&
"Can't handle identifiers without identifier info!");
llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =
PoisonReasons.find(Identifier.getIdentifierInfo());
if(it == PoisonReasons.end... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0xbb0, %rdi # imm = 0xBB0
movl 0x10(%rsi), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2c8b83
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2c8b83
xorl %esi, %esi
jmp 0x2c8b87
movq 0x8(%rbx), %rsi
callq 0x280e60
movl 0x... | /Lex/Preprocessor.cpp |
clang::Token& llvm::SmallVectorTemplateBase<clang::Token, true>::growAndEmplaceBack<>() | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Use push_back with a copy in case Args has an internal reference,
// side-stepping reference invalidation problems without losing the realloc
// optimization.
push_back(T(std::forward<ArgTypes>(Args)...));
return this->back();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x1, %edx
callq 0x27fbec
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
mov... | /llvm/ADT/SmallVector.h |
clang::FileEntry::closeFile() const | void FileEntry::closeFile() const { File.reset(); } | movq %rdi, %rax
movq 0x50(%rdi), %rdi
movq $0x0, 0x50(%rax)
testq %rdi, %rdi
je 0x2ea794
movq (%rdi), %rax
jmpq *0x8(%rax)
retq
nop
| /Basic/FileEntry.cpp |
clang::FileManager::getStatValue(llvm::StringRef, llvm::vfs::Status&, bool, std::unique_ptr<llvm::vfs::File, std::default_delete<llvm::vfs::File>>*) | std::error_code
FileManager::getStatValue(StringRef Path, llvm::vfs::Status &Status,
bool isFile, std::unique_ptr<llvm::vfs::File> *F) {
// FIXME: FileSystemOpts shouldn't be passed in here, all paths should be
// absolute!
if (FileSystemOpts.WorkingDir.empty())
return FileSystemStat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x2ea8ab
addq %rsi, %rdx
leaq 0x28(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x80, -0x8(%rax)
leaq 0x10(%rsp), %r13
movq %r13, ... | /Basic/FileManager.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>, llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llv... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x2eb953
movq %rsi, %r14
movq (%rdi), %r15
leaq 0x8(%rsp), %r9
movups (%rsi), %xmm0
movaps %xmm0, -0x8(%r9)
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x... | /llvm/ADT/DenseMap.h |
llvm::StringMapEntry<llvm::ErrorOr<clang::DirectoryEntry&>>* llvm::StringMapEntry<llvm::ErrorOr<clang::DirectoryEntry&>>::create<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>, llvm::ErrorOr<clang::DirectoryEntry&>>(llvm::StringRef, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 409... | static StringMapEntry *create(StringRef key, AllocatorTy &allocator,
InitTy &&...initVals) {
return new (StringMapEntryBase::allocateWithKey(
sizeof(StringMapEntry), alignof(StringMapEntry), key, allocator))
StringMapEntry(key.size(), std::forward<InitTy>(initVals)...... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x21, %rsi
movq %rdx, %rdi
movl $0x3, %edx
callq 0x6515a
movq %rax, %r15
testq %r14, %r14
je 0x2ebc8f
leaq 0x20(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c370
movb $0x0, 0x20(%r15,%r14)
movq %r14, (%r... | /llvm/ADT/StringMapEntry.h |
clang::SourceManager::getLineTable() | LineTableInfo &SourceManager::getLineTable() {
if (!LineTable)
LineTable.reset(new LineTableInfo());
return *LineTable;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x1a0(%rdi)
jne 0x2f4dab
movl $0xc0, %edi
callq 0x3c390
movq %rax, %r14
xorl %r15d, %r15d
movl $0xc0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3c160
movl $0x10, 0x14(%r14)
leaq 0x38(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %rax, 0x28(%r... | /Basic/SourceManager.cpp |
clang::SourceManager::AddLineNote(clang::SourceLocation, unsigned int, int, bool, bool, clang::SrcMgr::CharacteristicKind) | void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo,
int FilenameID, bool IsFileEntry,
bool IsFileExit,
SrcMgr::CharacteristicKind FileKind) {
std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movl %r8d, %r15d
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
callq 0x27f254
movq %rax, %r12
leaq 0x13(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rdi
movl %r12d, %esi
callq 0x95598
cmpl $0x0, (%rax)
js 0x2f4e43
cmpb $0... | /Basic/SourceManager.cpp |
clang::SourceManager::createMemBufferContentCache(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer>>) | ContentCache &SourceManager::createMemBufferContentCache(
std::unique_ptr<llvm::MemoryBuffer> Buffer) {
// Add a new ContentCache to the MemBufferInfos list and return it.
ContentCache *Entry = ContentCacheAlloc.Allocate<ContentCache>();
new (Entry) ContentCache();
MemBufferInfos.push_back(Entry);
Entry->... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
movl $0x38, %esi
movl $0x3, %edx
callq 0x6515a
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
andb $-0x10, 0x30(%rax)
movq 0xa8(%r14), %rsi
cmpq 0xb0(%r14), %rsi
je 0x2f50a2
mov... | /Basic/SourceManager.cpp |
clang::SourceManager::getSpellingLocSlowCase(clang::SourceLocation) const | SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const {
do {
std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
Loc = Loc.getLocWithOffset(LocInfo.second);
} while (!Loc.isFileID());
return Loc;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x89632
movq %rax, %r14
incl %eax
cmpl $0x1, %eax
ja 0x2f60e0
movq 0xb8(%rbx), %rax
jmp 0x2f6110
testl %r14d, %r14d
js 0x2f60fe
movl %r14d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq (%rax,%rax,2), %r... | /Basic/SourceManager.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [30], llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::desc>(char const (&) [30], llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x5c24a
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x1b57e1(... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [33], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [33], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c190
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5d276
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
or... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [31], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [31], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c190
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5d276
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>::getValueExpectedFlagDefault() const | enum ValueExpected getValueExpectedFlagDefault() const {
// If there is an ArgStr specified, then we are of the form:
//
// -opt=O2 or -opt O2 or -optO2
//
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
// -... | movq 0xa0(%rdi), %rcx
xorl %eax, %eax
cmpq $0x1, 0x18(%rcx)
adcl $0x2, %eax
retq
| /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>, llvm::cl::OptionHidden, llvm::cl::ValueExpected, llvm::cl::initializer<llvm::ChangePrinter>, llvm::cl::ValuesClass>(llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>*, llvm::cl::OptionHi... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | movq %rdi, %rax
movl (%rsi), %esi
movzwl 0xa(%rdi), %edi
shll $0x5, %esi
andl $0x60, %esi
andl $-0x61, %edi
orl %esi, %edi
movw %di, 0xa(%rax)
movl (%rdx), %edx
andl $0x3, %edx
andl $-0x19, %edi
leal (%rdi,%rdx,8), %edx
movw %dx, 0xa(%rax)
movq (%rcx), %rcx
movl (%rcx), %edx
movl %edx, 0x80(%rax)
movb $0x1, 0x94(%rax)
... | /llvm/Support/CommandLine.h |
void llvm::cl::ValuesClass::apply<llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>>(llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>&) const | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x30f0e3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %r15
addq $0x98, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movq 0x20(%r14), %r9
movq %rbx, %rdi
callq 0x30f0e4
ad... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<(anonymous namespace)::PassRemarksOpt, true, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, llvm::cl::value_desc, llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::LocationClass<(anonymous namespace)::PassRemarksOpt>, llvm::cl::Value... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r9, %r14
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, 0x30(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x20(%rdi)
movl (%rcx), %eax
movzwl 0xa(%rdi), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%rdi)
cmpq $0x0, 0x80(%rdi... | /llvm/Support/CommandLine.h |
llvm::Registry<llvm::GCStrategy>::Add<(anonymous namespace)::StatepointGC>::CtorFn() | static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %edi
callq 0x3c390
movq %rax, %r14
movq %rax, %rdi
callq 0x30f9e4
leaq 0x1c8977(%rip), %rax # 0x4d8570
movq %rax, (%r14)
movl $0x101, 0x28(%r14) # imm = 0x101
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Support/Registry.h |
llvm::APFixedPoint::div(llvm::APFixedPoint const&, bool*) const | APFixedPoint APFixedPoint::div(const APFixedPoint &Other,
bool *Overflow) const {
auto CommonFXSema = Sema.getCommonSemantics(Other.getSemantics());
APFixedPoint ConvertedThis = convert(CommonFXSema);
APFixedPoint ConvertedOther = Other.convert(CommonFXSema);
APSInt ThisVal = Conv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0x38(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rsi), %rdi
movl 0x10(%rdx), %eax
leaq 0xb8(%rsp), %rsi
movl %eax, (%rsi)
callq 0x315b96
leaq 0x14(%rsp), %r15
movl %eax, (%r15)
xo... | /Support/APFixedPoint.cpp |
llvm::timeTraceProfilerBegin(llvm::StringRef, llvm::function_ref<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> ()>) | TimeTraceProfilerEntry *
llvm::timeTraceProfilerBegin(StringRef Name,
llvm::function_ref<std::string()> Detail) {
if (TimeTraceProfilerInstance != nullptr)
return TimeTraceProfilerInstance->begin(std::string(Name), Detail, false);
return nullptr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x1c19c3(%rip), %rdi # 0x4daf98
callq 0x3c470
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x319639
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
addq %r13, %r15
leaq 0x... | /Support/TimeProfiler.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<pybind11::str>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x279a79(%rip), %rsi # 0x37a959
leaq 0x279a81(%rip), %rdx # 0x37a968
callq 0xe2210
movq %rbx, %rdi
callq 0x1125c5
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x100f10
movq (%r1... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/detail/typeid.h |
pybind11::enum_<ImDrawCornerFlags_>::value(char const*, ImDrawCornerFlags_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x35ce76(%rip), %rsi # 0x464258
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x1f2cf(%rip), %r8 # 0x1266ca
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImGuiTableColumnFlags_>::enum_<pybind11::arithmetic>(pybind11::handle const&, char const*, pybind11::arithmetic const&) | enum_(const handle &scope, const char *name, const Extra&... extra)
: class_<Type>(scope, name, extra...), m_base(*this, scope) {
constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
constexpr bool is_convertible = std::is_convertible<Type, Scalar>::value;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x12da46
leaq 0x8(%rbx), %rdi
movq (%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movl $0x1, %esi
movl $0x1, %edx
callq 0x10e082
leaq 0x286d06(%rip), %rax # 0x38f607
leaq 0x10(%rsp), %... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImGuiTableRowFlags_>::enum_<pybind11::arithmetic>(pybind11::handle const&, char const*, pybind11::arithmetic const&) | enum_(const handle &scope, const char *name, const Extra&... extra)
: class_<Type>(scope, name, extra...), m_base(*this, scope) {
constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
constexpr bool is_convertible = std::is_convertible<Type, Scalar>::value;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x12e4c2
leaq 0x8(%rbx), %rdi
movq (%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movl $0x1, %esi
movl $0x1, %edx
callq 0x10e082
leaq 0x286b2a(%rip), %rax # 0x38f607
leaq 0x10(%rsp), %... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiStyle>& pybind11::class_<ImGuiStyle>::def_readwrite<ImGuiStyle, bool>(char const*, bool ImGuiStyle::*) | class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*thi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %rdx, (%r12)
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x1364b0
movq %r15, (%r12)
movq (%rbx), %rax
leaq 0x20(%rsp), %rdx
mov... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::arg_v::~arg_v() | arg_v(arg &&base, T &&x, const char *descr = nullptr)
: arg(base),
value(reinterpret_steal<object>(
detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
)),
descr(descr)
#if !defined(NDEBUG)
, type(type_id<T>())
#endif
{ } | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x10a60a
movq (%rax), %rsi
incq %rsi
callq 0xe6570
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x13ee80
nop
| /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h |
pybind11::module_& pybind11::module_::def<bool (*)()>(char const*, bool (*&&)()) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r15
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x35fe14(%rip), %r12 # 0x46a9a8
movq %r12, 0x18(%rsp)
incq (%r12)
callq 0xe19b0
testq %rax, %rax
je 0x10abb1
movq %rax, 0x8(%rsp)
movq %rax... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<void (*)(bool, int), pybind11::arg, pybind11::arg_v>(char const*, void (*&&)(bool, int), pybind11::arg const&, pybind11::arg_v const&) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x35f973(%rip), %rbp # 0x46a9a8
movq %rbp, 0x18(%rsp)
incq (%rbp)
callq 0xe19b0
testq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<bool (*)(char const*, int, int, ImVec2 const&, float), pybind11::arg, pybind11::arg, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v>(char const*, bool (*&&)(char const*, int, int, ImVec2 const&, float), pybind11::arg const&, pybind11::arg const&, pybind11::arg_v const&, pybi... | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rbp
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x35ec64(%rip), %r15 # 0x46a9a8
movq %r15, 0x10(%rsp)
incq (%r15)... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<void (*)(char const*), pybind11::arg>(char const*, void (*&&)(char const*), pybind11::arg const&) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq %rsi, 0x20(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x18(%rsp)
movq 0x35dd4d(%rip), %r13 # 0x46a9a8
movq %r13, 0x10(%rsp)
incq (%r13)
callq 0xe19b0
testq %rax, %rax
je 0x10cc77
mov... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<void (*)(), char [51]>(char const*, void (*&&)(), char const (&) [51]) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq %rsi, 0x20(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x18(%rsp)
movq 0x35d8b5(%rip), %r13 # 0x46a9a8
movq %r13, 0x10(%rsp)
incq (%r13)
callq 0xe19b0
testq %rax, %rax
je 0x10d10f
mov... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<ImVec2 (*)(int, float)>(char const*, ImVec2 (*&&)(int, float)) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r15
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x35cde0(%rip), %r12 # 0x46a9a8
movq %r12, 0x18(%rsp)
incq (%r12)
callq 0xe19b0
testq %rax, %rax
je 0x10dbe5
movq %rax, 0x8(%rsp)
movq %rax... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiCol_>& pybind11::class_<ImGuiCol_>::def<pybind11::enum_<ImGuiCol_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiCol_)>(char const*, pybind11::enum_<ImGuiCol_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiCol_)&&) | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x35bb12(%rip), %r12 # 0x46a9a8
movq %r12, 0x18(%rsp)
incq (%r12)
callq 0xe19b0
testq %rax, %rax
je 0x10eeb3
movq %rax, 0x8(%rsp)
movq %rax, ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::detail::make_static_property_type() | inline PyTypeObject *make_static_property_type() {
constexpr auto *name = "pybind11_static_property";
auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
/* Danger zone: from now (and until PyType_Ready), make sure to
issue no Python C API calls which could potentially invoke the
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x268465(%rip), %r14 # 0x378d94
movq %r14, %rdi
callq 0xe5510
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x35a39a(%rip), %rdi # 0x46ace0
xorl %esi, %esi
callq *0x130(%rdi)
movq %rax, %rbx
testq %rax, %rax
je 0x1109fe
testq %r15, %r15
je 0x110963
addq $0x2, (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/detail/class.h |
std::enable_if<!detail::move_never<bool>::value, bool>::type pybind11::move<bool>(pybind11::object&&) | detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
if (obj.ref_count() > 1)
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
" (compile in debug mode for details)");
#else
throw cast_error("Unabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x2, (%rax)
jge 0x112936
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x112b9c
movb (%rbx), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h |
void pybind11::cpp_function::initialize<pybind11::detail::enum_base::init(bool, bool)::'lambda9'(pybind11::object, pybind11::object), pybind11::object, pybind11::object, pybind11::object, pybind11::name, pybind11::is_method, pybind11::arg>(pybind11::detail::enum_base::init(bool, bool)::'lambda9'(pybind11::object, pybin... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
callq 0x114708
movq %rax, %r13
leaq 0x4a(%rip), %rax # 0x11ff0a
movq %rax, 0x30(%r13)
movq (%r15), %rax
movq %rax, (%r13)
orb $0x10, 0x59(%r13)
movq (%r14), %rax
movq %rax, 0x70(%r13)
movq %rbx, %... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<pybind11::detail::enum_base::init(bool, bool)::'lambda11'(pybind11::object, pybind11::object), bool, pybind11::object, pybind11::object, pybind11::name, pybind11::is_method, pybind11::arg>(pybind11::detail::enum_base::init(bool, bool)::'lambda11'(pybind11::object, pybind11::objec... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
callq 0x114708
movq %rax, %r13
leaq 0x4a(%rip), %rax # 0x1204d8
movq %rax, 0x30(%r13)
movq (%r15), %rax
movq %rax, (%r13)
orb $0x10, 0x59(%r13)
movq (%r14), %rax
movq %rax, 0x70(%r13)
movq %rbx, %... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<pybind11::detail::enum_base::init(bool, bool)::'lambda16'(pybind11::object, pybind11::object), bool, pybind11::object, pybind11::object, pybind11::name, pybind11::is_method, pybind11::arg>(pybind11::detail::enum_base::init(bool, bool)::'lambda16'(pybind11::object, pybind11::objec... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
callq 0x114708
movq %rax, %r13
leaq 0x4a(%rip), %rax # 0x120f12
movq %rax, 0x30(%r13)
movq (%r15), %rax
movq %rax, (%r13)
orb $0x10, 0x59(%r13)
movq (%r14), %rax
movq %rax, 0x70(%r13)
movq %rbx, %... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiDir_>& pybind11::class_<ImGuiDir_>::def<pybind11::enum_<ImGuiDir_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiDir_)>(char const*, pybind11::enum_<ImGuiDir_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiDir_)&&) | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x346bde(%rip), %r12 # 0x46a9a8
movq %r12, 0x18(%rsp)
incq (%r12)
callq 0xe19b0
testq %rax, %rax
je 0x123de7
movq %rax, 0x8(%rsp)
movq %rax, ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiDragDropFlags_>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rdi
callq 0xea580
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x127fc3
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x127fc6
shrb $0x2, %al
movq 0x18(%rbx), %r14
testb $0x... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiFocusedFlags_>& pybind11::class_<ImGuiFocusedFlags_>::def<pybind11::enum_<ImGuiFocusedFlags_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiFocusedFlags_)>(char const*, pybind11::enum_<ImGuiFocusedFlags_>::enum_<>(pybind11::handle const&, char const*)::'lambda0'(ImGuiFocusedFlags_... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x342194(%rip), %r12 # 0x46a9a8
movq %r12, 0x18(%rsp)
incq (%r12)
callq 0xe19b0
testq %rax, %rax
je 0x128831
movq %rax, 0x8(%rsp)
movq %rax, ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiFocusedFlags_>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::unique_ptr<ImGuiFocusedFlags_, std::default_delete<ImGuiFocusedFlags_>> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | testq %rdx, %rdx
je 0x128adb
movq 0x18(%rsi), %rax
movq (%rdx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rdx)
jmp 0x128aec
testb $0x1, 0x30(%rdi)
je 0x128b03
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rsi), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x128b04
movq 0x18(%rax), %rax
movq 0x8(%rsi... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImGuiInputTextFlags_>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rdi
callq 0xea580
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x129f37
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x129f3a
shrb $0x2, %al
movq 0x18(%rbx), %r14
testb $0x... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<ImGuiIO*, char const*>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
andl $0x1, %edx
callq 0x11bd98
testb %al, %al
je 0x1380d5
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x1380d5
movq 0x20(%r14), %rax
movq (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h |
pybind11::arg_v::arg_v<Bool const&>(pybind11::arg&&, Bool const&, char const*) | arg_v(arg &&base, T &&x, const char *descr = nullptr)
: arg(base),
value(reinterpret_steal<object>(
detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
)),
descr(descr)
#if !defined(NDEBUG)
, type(type_id<T>())
#endif
{ } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %r14
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x32c237(%rip), %rsi # 0x464758
movq %rdx, %rdi
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x7d(%rip), %r8 # 0x1385ba
leaq 0x8... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h |
void pybind11::cpp_function::initialize<bool (*&)(char const*, int, int, ImVec2 const&, float), bool, char const*, int, int, ImVec2 const&, float, pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg, pybind11::arg, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v>(bool (*&)(char const*, int, int, ImVec2 ... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x114708
movq %rax, %r14
movq (%rbp), %rax
movq %rax, 0x38(%r14)
leaq 0xe2(%rip), %rax # 0x13c1c6
movq %rax, 0x30(%r14)
movq %r14, 0x10(%rsp)
movu... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<void (*&)(), void, pybind11::name, pybind11::scope, pybind11::sibling, char [92]>(void (*&)(), void (*)(), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, char const (&) [92]) | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x114708
movq %rax, %rbp
movq (%r12), %rax
movq %rax, 0x38(%rbp)
leaq 0x5d(%rip), %rax # 0x13d19a
movq %rax, 0x30(%rbp)
movq (%r15), %rax
movq %rax, (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::detail::process_attributes<pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg, pybind11::arg, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v, pybind11::arg_v>::init(pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg const&... | static void init(const Args&... args, function_record *r) {
int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
ignore_unused(unused);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %rbp
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %r12
movq 0x58(%rsp), %rbx
movq 0x50(%rsp), %r15
movq 0x78(%rsp), %r14
movq (%rdi), %rax
movq %rax, (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/attr.h |
void pybind11::cpp_function::initialize<void (*&)(float, ImVec2 const&, char const*), void, float, ImVec2 const&, char const*, pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg, pybind11::arg_v, pybind11::arg_v>(void (*&)(float, ImVec2 const&, char const*), void (*)(float, ImVec2 const&, char const*), p... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x114708
movq %rax, %r14
movq (%rbp), %rax
movq %rax, 0x38(%r14)
leaq 0x63(%rip), %rax # 0x144a14
movq %rax, 0x30(%r14)
movq %r14, (%rsp)
movq %r13, %rd... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<char const*, float>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x147c52
movq %rdi, %rbx
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
cmpq 0x322d96(%rip), %rsi # 0x46a9a8
je 0x147c31
leaq 0x8(%rbx), %rdi
andl $0x1, %edx
callq 0x1123c2
testb %al, %al
je 0x147c52
movq 0x8(%r14), ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h |
void pybind11::cpp_function::initialize<void (*&)(bool, float), void, bool, float, pybind11::name, pybind11::scope, pybind11::sibling>(void (*&)(bool, float), void (*)(bool, float), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&) | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x114708
movq %rax, %rbp
movq (%r12), %rax
movq %rax, 0x38(%rbp)
leaq 0x57(%rip), %rax # 0x147d24
movq %rax, 0x30(%rbp)
movq (%r15), %rax
movq %rax, (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<bool (*&)(char const*, ImVec4 const&, ImVec2 const&), bool, char const*, ImVec4 const&, ImVec2 const&, pybind11::name, pybind11::scope, pybind11::sibling>(bool (*&)(char const*, ImVec4 const&, ImVec2 const&), bool (*)(char const*, ImVec4 const&, ImVec2 const&), pybind11::name con... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x114708
movq %rax, %rbp
movq (%r12), %rax
movq %rax, 0x38(%rbp)
leaq 0x57(%rip), %rax # 0x1480ea
movq %rax, 0x30(%rbp)
movq (%r15), %rax
movq %rax, (%r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<bool>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x31d7d3(%rip), %rax # 0x46d0a0
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0xeab70
movq %rbx, %rdi
callq 0x1125c5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/detail/typeid.h |
pybind11::enum_<ImPlotFlags_>::value(char const*, ImPlotFlags_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x313f86(%rip), %rsi # 0x465d58
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x6b67(%rip), %r8 # 0x158952
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImPlotAxisFlags_>::value(char const*, ImPlotAxisFlags_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x313dfa(%rip), %rsi # 0x465da8
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x740d(%rip), %r8 # 0x1593d4
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImPlotCol_>::value(char const*, ImPlotCol_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x313c72(%rip), %rsi # 0x465df8
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x7cb7(%rip), %r8 # 0x159e56
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImPlotMarker_>::value(char const*, ImPlotMarker_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x313962(%rip), %rsi # 0x465e98
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x8e0b(%rip), %r8 # 0x15b35a
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::enum_<ImPlotColormap_>::value(char const*, ImPlotColormap_, char const*) | enum_& value(char const* name, Type value, const char *doc = nullptr) {
m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
movl %edx, (%rdi)
leaq 0x8(%rbx), %r12
leaq 0x3137da(%rip), %rsi # 0x465ee8
xorl %edx, %edx
callq 0x1229f8
movq %rdx, %rcx
movq $0x0, (%rsp)
leaq 0x96b5(%rip), %r8 # 0x15bddc
leaq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImPlotPoint>& pybind11::class_<ImPlotPoint>::def_readwrite<ImPlotPoint, double>(char const*, double ImPlotPoint::*) | class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*thi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %rdx, (%r12)
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15e7a2
movq %r15, (%r12)
movq (%rbx), %rax
leaq 0x20(%rsp), %rdx
mov... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImPlotRange>& pybind11::class_<ImPlotRange>::def_readwrite<ImPlotRange, double>(char const*, double ImPlotRange::*) | class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*thi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %rdx, (%r12)
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15f19c
movq %r15, (%r12)
movq (%rbx), %rax
leaq 0x20(%rsp), %rdx
mov... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::module_& pybind11::module_::def<char const* (*)(int), pybind11::arg, char [58]>(char const*, char const* (*&&)(int), pybind11::arg const&, char const (&) [58]) | module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
sibling(getattr(*this, name_, none())), extra...);
// NB: allow overwriting here because cpp_function sets up a chain with the intention of
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x3136b9(%rip), %rbp # 0x46a9a8
movq %rbp, 0x18(%rsp)
incq (%rbp)
callq 0xe19b0
testq ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImPlotAxisFlags_>::class_<pybind11::arithmetic, char [33]>(pybind11::handle, char const*, pybind11::arithmetic const&, char const (&) [33]) | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x10ef8c
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x30d3f7(%rip), %rax # 0x465da8
movq %rax, 0x10(%rsi)
movl $0x4, %eax
movq %rax, 0x1... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImPlotStyleVar_>& pybind11::class_<ImPlotStyleVar_>::def<void pybind11::detail::initimpl::factory<pybind11::enum_<ImPlotStyleVar_>::enum_<char [24]>(pybind11::handle const&, char const*, char const (&) [24])::'lambda'(unsigned int), pybind11::detail::void_type (*)(), ImPlotStyleVar_ (unsigned int), pyb... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x31064d(%rip), %rbp # 0x46a9a8
movq %rbp, 0x18(%rsp)
incq (%rbp)
callq 0xe19b0
testq %r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
pybind11::class_<ImPlotOrientation_>& pybind11::class_<ImPlotOrientation_>::def<void pybind11::detail::initimpl::factory<pybind11::enum_<ImPlotOrientation_>::enum_<char [60]>(pybind11::handle const&, char const*, char const (&) [60])::'lambda'(unsigned int), pybind11::detail::void_type (*)(), ImPlotOrientation_ (unsign... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x30dc45(%rip), %rbp # 0x46a9a8
movq %rbp, 0x18(%rsp)
incq (%rbp)
callq 0xe19b0
testq %r... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<void pybind11::detail::initimpl::constructor<>::execute<pybind11::class_<ImPlotPoint>, 0>(pybind11::class_<ImPlotPoint>&)::'lambda'(pybind11::detail::value_and_holder&), void, pybind11::detail::value_and_holder&, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::d... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
callq 0x114708
leaq 0x56(%rip), %rcx # 0x15e124
movq %rcx, 0x30(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movzwl 0x59(%rax), %ecx
movl %ecx, %edx
orl $0x10, %edx
movw %dx, 0x59(%rax)
movq (%r14), ... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h |
ImPlotPoint (*ValueGetter::get_getter_func_y<bool>())(void*, int) const | [[nodiscard]] inline getter_func* get_getter_func_y() const {
#define VG_EMIT_RET_GETTER(__type__) \
if (PY_BUF_IS_TYPE(__type__, this->infoY)) { \
return &getValue<X, __type__>; \
}
VG_EMI... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq $0x1, 0x98(%rdi)
jne 0x166825
leaq 0xa8(%r14), %rdi
leaq 0x21b80b(%rip), %rsi # 0x382023
callq 0xe15e0
testl %eax, %eax
je 0x166953
leaq 0x90(%r14), %rbx
movq %rbx, %rdi
callq 0x1669f0
testb %al, %al
je 0x166844
leaq 0x1955(%rip), %rax # 0x168194
jmp 0x16695... | /JoelLinn[P]py-mahi-gui/src/implot.cpp |
ImPlotPoint (*ValueGetter::get_getter_func_y<short>())(void*, int) const | [[nodiscard]] inline getter_func* get_getter_func_y() const {
#define VG_EMIT_RET_GETTER(__type__) \
if (PY_BUF_IS_TYPE(__type__, this->infoY)) { \
return &getValue<X, __type__>; \
}
VG_EMI... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq $0x1, 0x98(%rdi)
jne 0x167321
leaq 0xa8(%r14), %rdi
leaq 0x21ad0f(%rip), %rsi # 0x382023
callq 0xe15e0
testl %eax, %eax
je 0x16744f
leaq 0x90(%r14), %rbx
movq %rbx, %rdi
callq 0x1669f0
testb %al, %al
je 0x167340
leaq 0x151f(%rip), %rax # 0x16885a
jmp 0x16745... | /JoelLinn[P]py-mahi-gui/src/implot.cpp |
pybind11::detail::compare_buffer_info<long, void>::compare(pybind11::buffer_info const&) | static bool compare(const buffer_info& b) {
return (size_t) b.itemsize == sizeof(T) && (b.format == format_descriptor<T>::value ||
((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned<T>::value ? "L" : "l")) ||
((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned<T>::... | pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x8, 0x8(%rdi)
jne 0x167b25
movq %rdi, %rbx
addq $0x18, %rbx
leaq 0x21a545(%rip), %rsi # 0x382031
movq %rbx, %rdi
callq 0xe15e0
movb $0x1, %bpl
testl %eax, %eax
je 0x167b27
leaq 0x217046(%rip), %rsi # 0x37eb48
movq %rbx, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x167b27
leaq 0... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/buffer_info.h |
pybind11::detail::compare_buffer_info<unsigned long, void>::compare(pybind11::buffer_info const&) | static bool compare(const buffer_info& b) {
return (size_t) b.itemsize == sizeof(T) && (b.format == format_descriptor<T>::value ||
((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned<T>::value ? "L" : "l")) ||
((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned<T>::... | pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x8, 0x8(%rdi)
jne 0x167d79
movq %rdi, %rbx
addq $0x18, %rbx
leaq 0x21a2f3(%rip), %rsi # 0x382033
movq %rbx, %rdi
callq 0xe15e0
movb $0x1, %bpl
testl %eax, %eax
je 0x167d7b
leaq 0x2670b9(%rip), %rsi # 0x3cee0f
movq %rbx, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x167d7b
leaq 0... | /JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/buffer_info.h |
ImPlotPoint ValueGetter::getValue<float, unsigned short>(void*, int) | static ImPlotPoint getValue(void* data, int idx) {
const auto* this_ = static_cast<ValueGetter*>(data);
double x, y;
if constexpr (std::is_void<X>::value) {
x = static_cast<double>(idx);
} else {
x = static_cast<double>((static_cast<X*>(this_->infoX.ptr))[idx]);
}
y = static_cast<dou... | movslq %esi, %rax
movq 0x8(%rdi), %rcx
movq 0x90(%rdi), %rdx
cvtss2sd (%rcx,%rax,4), %xmm0
movzwl (%rdx,%rax,2), %eax
cvtsi2sd %eax, %xmm1
retq
| /JoelLinn[P]py-mahi-gui/src/implot.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.