name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
(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 secondary
// virtual tables for each of its proper base classes, except any primary
// base(s) with which it shares its primary virtual table.
const CXXRecordDecl *RD = Base.getBase();
const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
for (const auto &B : RD->bases()) {
// Ignore virtual bases, we'll emit them later.
if (B.isVirtual())
continue;
const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
// Ignore bases that don't have a vtable.
if (!BaseDecl->isDynamicClass())
continue;
if (isBuildingConstructorVTable()) {
// Itanium C++ ABI 2.6.4:
// Some of the base class subobjects may not need construction virtual
// tables, which will therefore not be present in the construction
// virtual table group, even though the subobject virtual tables are
// present in the main virtual table group for the complete object.
if (!BaseIsMorallyVirtual && !BaseDecl->getNumVBases())
continue;
}
// Get the base offset of this base.
CharUnits RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl);
CharUnits BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
CharUnits BaseOffsetInLayoutClass =
OffsetInLayoutClass + RelativeBaseOffset;
// Don't emit a secondary vtable for a primary base. We might however want
// to emit secondary vtables for other bases of this base.
if (BaseDecl == PrimaryBase) {
LayoutSecondaryVTables(BaseSubobject(BaseDecl, BaseOffset),
BaseIsMorallyVirtual, BaseOffsetInLayoutClass);
continue;
}
// Layout the primary vtable (and any secondary vtables) for this base.
LayoutPrimaryAndSecondaryVTables(
BaseSubobject(BaseDecl, BaseOffset),
BaseIsMorallyVirtual,
/*BaseIsVirtualInLayoutClass=*/false,
BaseOffsetInLayoutClass);
}
}
|
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, %rax
je 0x23ea05
movq %rax, %r13
movq %rdx, %rbx
andq $-0x8, %r12
movzbl %bpl, %eax
movl %eax, 0xc(%rsp)
testb $0x1, 0xc(%r13)
jne 0x23e9f8
movq 0x10(%r13), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0x23e970
callq 0x225b78
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
movq %rax, %r14
movq %rax, %rdi
callq 0x93994
testb %al, %al
je 0x23e9f8
movq 0x8(%r15), %rax
cmpq 0x20(%r15), %rax
sete %al
orb %bpl, %al
jne 0x23e9b5
movq 0x68(%r14), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%r14), %rax
cmpl $0x0, 0x14(%rax)
je 0x23e9f8
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x8c0b0
movq 0x18(%rsp), %rcx
leaq (%rax,%rcx), %rdx
addq 0x20(%rsp), %rax
movq %r15, %rdi
movq %r14, %rsi
cmpq %r12, %r14
je 0x23e9ec
movl 0xc(%rsp), %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0x23d040
jmp 0x23e9f8
movl 0xc(%rsp), %ecx
movq %rax, %r8
callq 0x23e8f0
addq $0x18, %r13
cmpq %rbx, %r13
jne 0x23e949
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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>>::FindAndConstruct(unsigned long&&)
|
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 %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
orl %eax, %ebp
incl %ebp
jmp 0x244400
xorl %ebp, %ebp
movl %ebp, 0x10(%rbx)
testl %ebp, %ebp
je 0x244419
movl %ebp, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x56dc3
jmp 0x24441b
xorl %eax, %eax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
testl %ebp, %ebp
je 0x244457
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x244457
shlq $0x4, %rcx
addq %rax, %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movq $-0x1000, (%rax) # imm = 0xF000
movq %rdx, 0x8(%rax)
addq $0x10, %rax
cmpq %rcx, %rax
jne 0x244443
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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::BaseSubobject>>::clear()
|
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 = 0x7FFFFFFFFFFFFFFF
movq $-0x1000, (%rcx) # imm = 0xF000
movq %rdx, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jne 0x244b17
movq $0x0, 0x8(%rdi)
retq
|
/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)
Out << LinePrefix;
Out << "[return adjustment (to type '"
<< TI.Method->getReturnType().getCanonicalType() << "'): ";
if (R.Virtual.Microsoft.VBPtrOffset)
Out << "vbptr at offset " << R.Virtual.Microsoft.VBPtrOffset << ", ";
if (R.Virtual.Microsoft.VBIndex)
Out << "vbase #" << R.Virtual.Microsoft.VBIndex << ", ";
Out << R.NonVirtual << " non-virtual]";
Multiline = true;
}
const ThisAdjustment &T = TI.This;
if (!T.isEmpty()) {
if (Multiline || !ContinueFirstLine)
Out << LinePrefix;
Out << "[this adjustment: ";
if (!TI.This.Virtual.isEmpty()) {
assert(T.Virtual.Microsoft.VtordispOffset < 0);
Out << "vtordisp at " << T.Virtual.Microsoft.VtordispOffset << ", ";
if (T.Virtual.Microsoft.VBPtrOffset) {
Out << "vbptr at " << T.Virtual.Microsoft.VBPtrOffset
<< " to the left,";
assert(T.Virtual.Microsoft.VBOffsetOffset > 0);
Out << LinePrefix << " vboffset at "
<< T.Virtual.Microsoft.VBOffsetOffset << " in the vbtable, ";
}
}
Out << T.NonVirtual << " non-virtual]";
}
}
|
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 0x577a6
leaq 0xfd537(%rip), %rsi # 0x343dc2
movl $0x1d, %edx
movq %r14, %rdi
callq 0x577a6
movq %rax, %r15
movq 0x28(%rbx), %rax
movq 0x30(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x2468c0
callq 0x22549c
movq 0x18(%rax), %rsi
movq %rsi, %rax
andq $-0x10, %rax
andl $0x7, %esi
orq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x22f0d8
leaq 0xfd4ff(%rip), %rsi # 0x343de0
movl $0x4, %edx
movq %rax, %rdi
callq 0x577a6
cmpl $0x0, 0x20(%rbx)
je 0x246927
leaq 0xfd4ea(%rip), %rsi # 0x343de5
movl $0x10, %edx
movq %r14, %rdi
callq 0x577a6
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x57d5a
leaq 0xde711(%rip), %rsi # 0x32502b
movl $0x2, %edx
movq %rax, %rdi
callq 0x577a6
cmpl $0x0, 0x24(%rbx)
je 0x246960
leaq 0xfd4c2(%rip), %rsi # 0x343df6
movl $0x7, %edx
movq %r14, %rdi
callq 0x577a6
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x57d5a
leaq 0xde6d8(%rip), %rsi # 0x32502b
movl $0x2, %edx
movq %rax, %rdi
callq 0x577a6
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x57d6c
leaq 0xfd48b(%rip), %rsi # 0x343dfe
movl $0xd, %edx
movq %rax, %rdi
callq 0x577a6
cmpq $0x0, (%rbx)
jne 0x2469a7
pxor %xmm0, %xmm0
movdqa %xmm0, (%rsp)
movdqu 0x8(%rbx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x246ad6
testb %bpl, %r12b
jne 0x2469c0
leaq 0xfd382(%rip), %rsi # 0x343d35
movl $0x8, %edx
movq %r14, %rdi
callq 0x577a6
leaq 0xfd2d0(%rip), %rsi # 0x343c97
movl $0x12, %edx
movq %r14, %rdi
callq 0x577a6
pxor %xmm0, %xmm0
movdqa %xmm0, (%rsp)
movdqu 0x8(%rbx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x246aab
leaq 0xfd410(%rip), %rsi # 0x343e0c
movl $0xc, %edx
movq %r14, %rdi
callq 0x577a6
movslq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x57d6c
leaq 0xde60f(%rip), %rsi # 0x32502b
movl $0x2, %edx
movq %rax, %rdi
callq 0x577a6
cmpl $0x0, 0xc(%rbx)
je 0x246aab
leaq 0xfd3e3(%rip), %rsi # 0x343e19
movl $0x9, %edx
movq %r14, %rdi
callq 0x577a6
movslq 0xc(%rbx), %rsi
movq %rax, %rdi
callq 0x57d6c
leaq 0xfd3cd(%rip), %rsi # 0x343e23
movl $0xd, %edx
movq %rax, %rdi
callq 0x577a6
leaq 0xfd2cb(%rip), %rsi # 0x343d35
movl $0x8, %edx
movq %r14, %rdi
callq 0x577a6
leaq 0xfd3b3(%rip), %rsi # 0x343e31
movl $0xd, %edx
movq %rax, %rdi
callq 0x577a6
movslq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x57d6c
leaq 0xfd3a1(%rip), %rsi # 0x343e3f
movl $0x11, %edx
movq %rax, %rdi
callq 0x577a6
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x57d6c
leaq 0xfd341(%rip), %rsi # 0x343dfe
movl $0xd, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x577a6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, Args, Success));
return Success;
}
|
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 $-0x8, %rbx
leaq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x2528ea
movq (%r15), %rax
movl %ebp, (%rax,%rbx)
cmpq $0x8, (%r13)
jb 0x250dc6
leaq 0x1d0(%r12), %rdi
movq 0x1c0(%r12), %rax
subq 0x1b8(%r12), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdx
callq 0x2528b2
movl 0x8(%r14), %esi
shrl $0x3, %esi
movq 0x1c0(%r12), %r13
subq 0x1b8(%r12), %r13
leaq (%rsi,%r13), %rax
addq $0x4, %rax
shrq $0x20, %rax
je 0x250def
xorl %eax, %eax
jmp 0x250e2d
addq $0x4, %rsi
addq $0x7, %r13
andq $-0x8, %r13
addl $0x7, %esi
andl $-0x8, %esi
addq %r13, %rsi
movq %r15, %rdi
callq 0x2528ea
movq (%r15), %rax
movl 0x8(%r14), %edx
leaq (%rax,%r13), %rsi
addq $0x4, %rsi
movl %edx, -0x4(%rsi)
shrl $0x3, %edx
movq %r14, %rdi
callq 0x75327
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x2510f0
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 %r14
retq
|
/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.getSExtValue(), Ty, E);
return this->emitConst(Value.getZExtValue(), Ty, E);
}
|
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, %eax
ja 0x25e816
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
jmp 0x25e820
movl 0x8(%rsi), %eax
cmpb $0x0, 0xc(%rsi)
je 0x25e89e
cmpl $0x41, %eax
jb 0x25e787
movq (%rsi), %rsi
movq (%rsi), %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x262380
leaq 0x28(%rsp), %rdi
callq 0x70bce
movl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x25e7c1
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x25e7d0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x70bce
orq $0x4, %rbx
leaq 0x38(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x250d2e
movl %eax, %ebx
cmpl $0x41, 0x8(%r15)
jb 0x25e804
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25e804
callq 0x3c180
cmpl $0x41, 0x30(%rsp)
jb 0x25e892
movq 0x28(%rsp), %rdi
jmp 0x25e888
leaq 0x18(%rsp), %rdi
callq 0x70bce
movl 0x20(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x25e839
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x25e848
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x70bce
orq $0x4, %rbx
leaq 0x38(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x250c20
movl %eax, %ebx
cmpl $0x41, 0x8(%r15)
jb 0x25e87c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25e87c
callq 0x3c180
cmpl $0x41, 0x20(%rsp)
jb 0x25e892
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25e892
callq 0x3c180
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x40, %eax
ja 0x25e8ba
movq (%rsi), %rdi
movl %eax, %ecx
negb %cl
shlq %cl, %rdi
sarq %cl, %rdi
xorl %esi, %esi
testl %eax, %eax
cmovneq %rdi, %rsi
jmp 0x25e8c0
movq (%rsi), %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2622b6
|
/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:
return this->emitZeroSint16(E);
case PT_Uint16:
return this->emitZeroUint16(E);
case PT_Sint32:
return this->emitZeroSint32(E);
case PT_Uint32:
return this->emitZeroUint32(E);
case PT_Sint64:
return this->emitZeroSint64(E);
case PT_Uint64:
return this->emitZeroUint64(E);
case PT_IntAP:
return this->emitZeroIntAP(Ctx.getBitWidth(QT), E);
case PT_IntAPS:
return this->emitZeroIntAPS(Ctx.getBitWidth(QT), E);
case PT_Ptr:
return this->emitNullPtr(nullptr, E);
case PT_FnPtr:
return this->emitNullFnPtr(nullptr, E);
case PT_MemberPtr:
return this->emitNullMemberPtr(nullptr, E);
case PT_Float: {
return this->emitConstFloat(APFloat::getZero(Ctx.getFloatSemantics(QT)), E);
}
}
llvm_unreachable("unknown primitive type");
}
|
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, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15f49e
jmp 0x2640f7
movq 0x340(%rbx), %rdi
movq %rdx, %rsi
callq 0x12f7ac
leaq 0x30(%rsp), %r15
movq %rsp, %rdx
movl $0x0, (%rdx)
movq %r15, %rdi
movq %rax, %rsi
callq 0xe357c
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x6ee40
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x892a0
orq $0x4, %r14
leaq 0x20(%rsp), %rdx
movq %r14, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x141df4
movl %eax, %ebx
movq %r12, %rdi
callq 0x66212
movq %r15, %rdi
callq 0x66212
jmp 0x2640f9
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x17415c
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15f416
jmp 0x2640f7
movq 0x340(%rbx), %rax
movq (%rax), %rdi
movq %rdx, %rsi
callq 0x91cba
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x1742c8
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x1740f0
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x174126
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x174204
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x1740bc
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x174194
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15f462
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x1741cc
jmp 0x2640f7
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x17423c
jmp 0x2640f7
movq 0x340(%rbx), %rax
movq (%rax), %rdi
movq %rdx, %rsi
callq 0x91cba
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x174270
movl %eax, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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(*LocalIndex, E))
return false;
}
const Expr *SubExpr = E->getSubExpr();
PrimType SubExprT = classifyPrim(SubExpr->getType());
if (!this->visitZeroInitializer(SubExprT, SubExpr->getType(), SubExpr))
return false;
if (!this->emitInitElem(SubExprT, 0, SubExpr))
return false;
return this->visitArrayElemInit(1, SubExpr);
}
|
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, %esi
movq %r14, %rcx
callq 0x263f06
testb %al, %al
je 0x264640
movq %r14, %rax
orq $0x4, %rax
movq %rsp, %rcx
movq %rax, (%rcx)
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x1511b8
testb %al, %al
je 0x264643
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x263e4e
movl %eax, %r15d
jmp 0x264643
movabsq $0x100000000, %r12 # imm = 0x100000000
movq %r14, %rax
orq $0x2, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2637ec
testq %r12, %rax
je 0x264643
movq %r14, %rcx
orq $0x4, %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x130f28
testb %al, %al
jne 0x264595
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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() && End.isFileID());
if (Range.isTokenRange()) {
End = Lexer::getLocForEndOfToken(End, 0, SM,LangOpts);
if (End.isInvalid())
return {};
}
// Break down the source locations.
FileID FID;
unsigned BeginOffs;
std::tie(FID, BeginOffs) = SM.getDecomposedLoc(Begin);
if (FID.isInvalid())
return {};
unsigned EndOffs;
if (!SM.isInFileID(End, FID, &EndOffs) ||
BeginOffs > EndOffs)
return {};
return CharSourceRange::getCharRange(Begin, End);
}
|
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 %ebx, %esi
callq 0x89632
testl %eax, %eax
je 0x28867f
movq %rax, %rbp
shrq $0x20, %rbp
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
movq %r13, %rcx
callq 0x27db8c
shlq $0x20, %r14
movl %ebx, %r12d
orq %r14, %r12
xorl %ecx, %ecx
cmpl %ebp, (%r13)
cmovbq %rcx, %r12
testb %al, %al
cmoveq %rcx, %r12
jmp 0x288682
xorl %r12d, %r12d
movq %r12, %rax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 for things like
// _Pragma handling. Combine the expansion location of FileLoc with the
// spelling location.
SourceManager &SM = PP.getSourceManager();
// Create a new SLoc which is expanded from Expansion(FileLoc) but whose
// characters come from spelling(FileLoc)+Offset.
SourceLocation SpellingLoc = SM.getSpellingLoc(FileLoc);
SpellingLoc = SpellingLoc.getLocWithOffset(CharNo);
// Figure out the expansion loc range, which is the range covered by the
// original _Pragma(...) sequence.
CharSourceRange II = SM.getImmediateExpansionRange(FileLoc);
return SM.createExpansionLoc(SpellingLoc, II.getBegin(), II.getEnd(), TokLen);
}
|
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
shrq $0x20, %rcx
xorl %r10d, %r10d
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
movl %ebx, %r8d
movl $0x1, %r9d
pushq %r10
pushq %r10
callq 0x2f4e52
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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(
MathematicalNotationProfileIDContinueRanges);
(void)MathStartChars;
(void)MathContinueChars;
assert((MathStartChars.contains(C) || MathContinueChars.contains(C)) &&
"Unexpected mathematical notation codepoint");
Diags.Report(Range.getBegin(), diag::ext_mathematical_notation)
<< codepointAsHexString(C) << Range;
}
|
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), %r14
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rdi, 0x10(%r14)
movw $0x1, 0x18(%r14)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x290170
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x964fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe7ed8
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x289580
callq 0x3c3a0
leaq 0x38(%rsp), %rdi
callq 0x9646e
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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::StringRef SlashChars = LangOpts.MSVCCompat ? "/\\" : "/";
auto Slash = PartialPath.find_last_of(SlashChars);
StringRef Dir =
(Slash == StringRef::npos) ? "" : PartialPath.take_front(Slash);
const char *StartOfFilename =
(Slash == StringRef::npos) ? PathStart : PathStart + Slash + 1;
// Code completion filter range is the filename only, up to completion point.
PP->setCodeCompletionIdentifierInfo(&PP->getIdentifierTable().get(
StringRef(StartOfFilename, CompletionPoint - StartOfFilename)));
// We should replace the characters up to the closing quote or closest slash,
// if any.
while (CompletionPoint < BufferEnd) {
char Next = *(CompletionPoint + 1);
if (Next == 0 || Next == '\r' || Next == '\n')
break;
++CompletionPoint;
if (Next == (IsAngled ? '>' : '"'))
break;
if (SlashChars.contains(Next))
break;
}
PP->setCodeCompletionTokenRange(
FileLoc.getLocWithOffset(StartOfFilename - BufferStart),
FileLoc.getLocWithOffset(CompletionPoint - BufferStart));
PP->CodeCompleteIncludedFile(Dir, IsAngled);
}
|
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)
leaq 0xc60f3(%rip), %rax # 0x350fac
leaq 0x98e61(%rip), %r12 # 0x323d21
cmoveq %rax, %r12
setne %dl
incq %rdx
movq %r12, %rsi
movq %rdx, 0x20(%rsp)
movq $-0x1, %rcx
callq 0x65820
cmpq $-0x1, %rax
je 0x28af01
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x30(%rsp), %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x8(%rsp)
jmp 0x28af16
leaq 0x1049dc(%rip), %rcx # 0x38f8e4
movq %rcx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $-0x1, %rax
leaq 0x1(%r13,%rax), %rbx
cmoveq %r13, %rbx
movq 0x18(%rsp), %r13
movq 0x8(%r13), %r14
leaq 0x228(%r14), %rdi
movq %r15, %rdx
subq %rbx, %rdx
movq %rbx, %rsi
callq 0x78292
movq %rax, 0x3c0(%r14)
movq 0x78(%r13), %r13
movl %ebp, 0x4(%rsp)
testb %bpl, %bpl
movl $0x3e, %eax
movl $0x22, %r14d
cmovnel %eax, %r14d
movl $0x2401, %ebp # imm = 0x2401
cmpq %r13, %r15
jae 0x28afaf
movzbl 0x1(%r15), %eax
cmpl $0xd, %eax
ja 0x28af83
btl %eax, %ebp
jae 0x28af83
xorl %eax, %eax
testb %al, %al
jne 0x28af67
jmp 0x28afaf
incq %r15
movsbl %al, %esi
cmpl %esi, %r14d
je 0x28af7b
movq %r12, %rdi
movq 0x20(%rsp), %rdx
callq 0x3c420
testq %rax, %rax
sete %cl
subq %r12, %rax
cmpq $-0x1, %rax
sete %al
orb %cl, %al
jmp 0x28af7d
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rax
movl 0x70(%rsi), %ecx
subl %ecx, %ebx
movl 0x80(%rsi), %edx
addl %edx, %ebx
subl %ecx, %r15d
addl %edx, %r15d
shlq $0x20, %r15
orq %r15, %rbx
movq %rbx, 0x3c8(%rax)
movq 0x8(%rsi), %rdi
movzbl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2c87c4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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::KnownHeader, 1u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::ModuleMap::KnownHeader, 1u>>>::FindAndConstruct(clang::FileEntryRef const&)
|
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(%rax), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x5, %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, (%r15)
testq %r14, %r14
je 0x2a4d9e
shlq $0x5, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a4e66
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x56dc8
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x2a4e5f
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x20, %rax
xorl %edx, %edx
movdqa 0x7d218(%rip), %xmm1 # 0x322000
movdqa 0x7d220(%rip), %xmm2 # 0x322010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2a4e3c
movq $-0x1000, -0x20(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x2a4e52
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x2a4df8
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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, %r14
jne 0x2a6733
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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<FileEntryRef> ShouldBeEntry =
FM.getFileRef(Filename, OpenFile);
return llvm::expectedToOptional(std::move(ShouldBeEntry));
}
auto SeparateComponents = [](SmallVectorImpl<char> &LookupPath,
StringRef StartingFrom, StringRef FileName,
bool RemoveInitialFileComponentFromLookupPath) {
llvm::sys::path::native(StartingFrom, LookupPath);
if (RemoveInitialFileComponentFromLookupPath)
llvm::sys::path::remove_filename(LookupPath);
if (!LookupPath.empty() &&
!llvm::sys::path::is_separator(LookupPath.back())) {
LookupPath.push_back(llvm::sys::path::get_separator().front());
}
LookupPath.append(FileName.begin(), FileName.end());
};
// Otherwise, it's search time!
SmallString<512> LookupPath;
// Non-angled lookup
if (!isAngled) {
if (LookupFromFile) {
// Use file-based lookup.
StringRef FullFileDir = LookupFromFile->tryGetRealPathName();
if (!FullFileDir.empty()) {
SeparateComponents(LookupPath, FullFileDir, Filename, true);
llvm::Expected<FileEntryRef> ShouldBeEntry =
FM.getFileRef(LookupPath, OpenFile);
if (ShouldBeEntry)
return llvm::expectedToOptional(std::move(ShouldBeEntry));
llvm::consumeError(ShouldBeEntry.takeError());
}
}
// Otherwise, do working directory lookup.
LookupPath.clear();
auto MaybeWorkingDirEntry = FM.getDirectoryRef(".");
if (MaybeWorkingDirEntry) {
DirectoryEntryRef WorkingDirEntry = *MaybeWorkingDirEntry;
StringRef WorkingDir = WorkingDirEntry.getName();
if (!WorkingDir.empty()) {
SeparateComponents(LookupPath, WorkingDir, Filename, false);
llvm::Expected<FileEntryRef> ShouldBeEntry =
FM.getFileRef(LookupPath, OpenFile);
if (ShouldBeEntry)
return llvm::expectedToOptional(std::move(ShouldBeEntry));
llvm::consumeError(ShouldBeEntry.takeError());
}
}
}
for (const auto &Entry : PPOpts->EmbedEntries) {
LookupPath.clear();
SeparateComponents(LookupPath, Entry, Filename, false);
llvm::Expected<FileEntryRef> ShouldBeEntry =
FM.getFileRef(LookupPath, OpenFile);
if (ShouldBeEntry)
return llvm::expectedToOptional(std::move(ShouldBeEntry));
llvm::consumeError(ShouldBeEntry.takeError());
}
return std::nullopt;
}
|
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 %rdx, 0x8(%rdi)
xorl %esi, %esi
callq 0x5acc7
testb %al, %al
je 0x2aae45
movzbl %r13b, %r8d
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movl $0x1, %r9d
callq 0x2eabdc
movq %r15, %rdi
callq 0x27e018
xorl %ebp, %ebp
testb $0x1, %dl
cmovneq %rax, %rbp
testb $0x1, 0x8(%r15)
je 0x2ab29d
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x2aae37
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x70(%rsp)
jmp 0x2ab29d
movq %r14, 0x20(%rsp)
leaq 0x88(%rsp), %r14
movq %r14, -0x18(%r14)
movq $0x0, -0x10(%r14)
movq $0x200, -0x8(%r14) # imm = 0x200
testb %bpl, %bpl
movl %r13d, %ecx
movq %rbx, 0x60(%rsp)
jne 0x2ab125
testq %r15, %r15
movl %ecx, %r13d
je 0x2aaf66
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x2aaf66
movq (%r15), %rcx
leaq 0x28(%rsp), %rdi
movw $0x105, 0x20(%rdi) # imm = 0x105
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
leaq 0x70(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x5a73f
movq %r15, %rdi
xorl %esi, %esi
callq 0x5a437
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x2aaef0
movq 0x70(%rsp), %rcx
movsbl -0x1(%rcx,%rax), %edi
xorl %esi, %esi
callq 0x59918
testb %al, %al
jne 0x2aaef0
xorl %edi, %edi
callq 0x5abc8
movsbl (%rax), %esi
leaq 0x70(%rsp), %rdi
callq 0x57aa0
leaq (%rbx,%r12), %rdx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rbp
movq %rbx, %rsi
callq 0x58ba4
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movzbl %r13b, %r8d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %r9d
callq 0x2eabdc
movb 0x8(%r15), %bl
testb $0x1, %bl
je 0x2aaf68
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rsp)
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x5b469
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2aaf64
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2aaf7c
jmp 0x2aafab
leaq 0x28(%rsp), %rdi
callq 0x27e018
xorl %r15d, %r15d
testb $0x1, %dl
cmovneq %rax, %r15
testb $0x1, 0x30(%rsp)
je 0x2aaf9c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2aaf93
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
testb $0x1, %bl
movq %rbp, %rbx
movq %r15, %rbp
je 0x2ab28e
movq $0x0, 0x78(%rsp)
leaq 0x77502(%rip), %rdx # 0x3224bd
leaq 0x10(%rsp), %r15
movl $0x1, %ecx
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %r8d
callq 0x2ea8e2
testb $0x1, 0x8(%r15)
jne 0x2ab0fa
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x2ab0fa
addq $0x20, %rcx
leaq 0x28(%rsp), %rdi
movw $0x105, 0x20(%rdi) # imm = 0x105
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
leaq 0x70(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x5a73f
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x2ab04b
movq 0x70(%rsp), %rcx
movsbl -0x1(%rcx,%rax), %edi
xorl %esi, %esi
callq 0x59918
testb %al, %al
jne 0x2ab04b
xorl %edi, %edi
callq 0x5abc8
movsbl (%rax), %esi
leaq 0x70(%rsp), %rdi
callq 0x57aa0
leaq (%rbx,%r12), %rdx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x58ba4
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movzbl %r13b, %r8d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %r9d
callq 0x2eabdc
movb 0x8(%r15), %bl
testb $0x1, %bl
je 0x2ab0be
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rsp)
leaq 0x68(%rsp), %r15
movq %rax, (%r15)
leaq 0xf(%rsp), %rsi
movq %r15, %rdi
callq 0x5b469
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2ab0d1
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2ab0d1
leaq 0x28(%rsp), %rdi
callq 0x27e018
xorl %ebp, %ebp
testb $0x1, %dl
cmovneq %rax, %rbp
testb $0x1, 0x30(%rsp)
je 0x2ab0f1
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab0e8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
testb $0x1, %bl
je 0x2ab2b2
movl %r13d, %ecx
testb $0x1, 0x18(%rsp)
je 0x2ab120
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab114
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movl %r13d, %ecx
movq %rbp, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x120(%rax), %r14
movq 0x128(%rax), %rbx
cmpq %rbx, %r14
je 0x2ab275
addq 0x60(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x70(%rsp), %rbp
movzbl %cl, %eax
movl %eax, 0x50(%rsp)
movq $0x0, 0x78(%rsp)
movups (%r14), %xmm0
movw $0x105, 0x48(%rsp) # imm = 0x105
movups %xmm0, 0x28(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x5a73f
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x2ab1b2
movq 0x70(%rsp), %rcx
movsbl -0x1(%rcx,%rax), %edi
xorl %esi, %esi
callq 0x59918
testb %al, %al
jne 0x2ab1b2
xorl %edi, %edi
callq 0x5abc8
movsbl (%rax), %esi
movq %rbp, %rdi
callq 0x57aa0
movq %rbp, %rdi
movq 0x60(%rsp), %rsi
movq %r12, %r15
movq %r12, %rdx
callq 0x58ba4
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq %r13, %rdi
movq 0x20(%rsp), %rsi
movl 0x50(%rsp), %r8d
movl $0x1, %r9d
callq 0x2eabdc
movb 0x30(%rsp), %r12b
testb $0x1, %r12b
je 0x2ab226
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x5b469
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab23f
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2ab23f
movq %r13, %rdi
callq 0x27e018
testb $0x1, %dl
movl $0x0, %ecx
cmoveq %rcx, %rax
movq %rax, 0x58(%rsp)
testb $0x1, 0x30(%rsp)
je 0x2ab25f
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab256
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
testb $0x1, %r12b
je 0x2ab281
addq $0x20, %r14
cmpq %rbx, %r14
movq %r15, %r12
jne 0x2ab15b
xorl %ebp, %ebp
leaq 0x88(%rsp), %r14
jmp 0x2ab28e
leaq 0x88(%rsp), %r14
movq 0x58(%rsp), %rbp
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ab29d
callq 0x3c3a0
movq %rbp, %rax
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x18(%rsp)
je 0x2ab28e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab2c9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x2ab28e
|
/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.
CheckEndOfDirective("__public_macro");
IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
// Okay, we finally have a valid identifier to undef.
MacroDirective *MD = getLocalMacroDirective(II);
// If the macro is not defined, this is an error.
if (!MD) {
Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
return;
}
// Note that this macro has now been exported.
appendMacroDirective(II, AllocateVisibilityMacroDirective(
MacroNameTok.getLocation(), /*isPublic=*/true));
}
|
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
jae 0x2ae891
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2ae891
xorl %ebx, %ebx
jmp 0x2ae896
movq 0x30(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2af264
testq %rax, %rax
je 0x2ae8e9
movl 0x28(%rsp), %ebp
leaq 0x80(%r14), %rdi
movl $0x10, %esi
movl $0x4, %edx
callq 0x6515a
movq $0x0, (%rax)
movl %ebp, 0x8(%rax)
movb 0xc(%rax), %cl
andb $-0x10, %cl
orb $0xa, %cl
movb %cl, 0xc(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2bd4d0
jmp 0x2ae98a
movq 0x30(%r14), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x170(%rdi)
movl $0x499, 0x174(%rdi) # imm = 0x499
xorl %r14d, %r14d
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
leaq 0x178(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movw $0x1, 0x20(%rsp)
movb %r14b, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
cmpq %r14, 0x8(%rsp)
jne 0x2ae965
movq 0x10(%rsp), %rdi
callq 0x9658c
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %rbx, 0x10(%rax,%rcx,8)
callq 0x9646e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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 and
// C++20 [lex.header]/2:
//
// If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then
// in C: behavior is undefined
// in C++: program is conditionally-supported with implementation-defined
// semantics
// Make sure the filename is <x> or "x".
bool isAngled;
if (Buffer[0] == '<') {
if (Buffer.back() != '>') {
Diag(Loc, diag::err_pp_expects_filename);
Buffer = StringRef();
return true;
}
isAngled = true;
} else if (Buffer[0] == '"') {
if (Buffer.back() != '"') {
Diag(Loc, diag::err_pp_expects_filename);
Buffer = StringRef();
return true;
}
isAngled = false;
} else {
Diag(Loc, diag::err_pp_expects_filename);
Buffer = StringRef();
return true;
}
// Diagnose #include "" as invalid.
if (Buffer.size() <= 2) {
Diag(Loc, diag::err_pp_empty_filename);
Buffer = StringRef();
return true;
}
// Skip the brackets.
Buffer = Buffer.substr(1, Buffer.size()-2);
return isAngled;
}
|
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 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x68(%rsp), %r14
jmp 0x2af3c3
cmpb $0x22, %dl
jne 0x2af343
movq 0x8(%rbx), %rdx
cmpb $0x22, -0x1(%rcx,%rdx)
jne 0x2af391
movq 0x8(%rbx), %rdx
cmpq $0x2, %rdx
ja 0x2af377
movq 0x30(%rdi), %rdi
movl %esi, 0x170(%rdi)
movl $0x458, 0x174(%rdi) # imm = 0x458
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x8(%rsp), %r14
jmp 0x2af3c3
movq 0x30(%rdi), %rdi
movl %esi, 0x170(%rdi)
movl $0x464, 0x174(%rdi) # imm = 0x464
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x28(%rsp), %r14
jmp 0x2af3c3
leaq -0x2(%rdx), %rsi
incq %rcx
decq %rdx
cmpq %rsi, %rdx
cmovaeq %rsi, %rdx
movq %rcx, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x2af401
movq 0x30(%rdi), %rdi
movl %esi, 0x170(%rdi)
movl $0x464, 0x174(%rdi) # imm = 0x464
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x48(%rsp), %r14
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rdi, 0x10(%r14)
movw $0x1, 0x18(%r14)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r14, %rdi
callq 0x9646e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r14
retq
|
/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_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, llvm::StringRef)
|
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 %rcx, %rsi
movq %r12, %rax
addq 0x8(%rax), %rsi
addq $0x20, %rax
cmpq %r13, %rax
jne 0x2ba0ba
movq %r15, %rdi
callq 0x3c5d0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x3c590
addq $0x20, %r12
cmpq %r13, %r12
je 0x2ba0f9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c1a0
jmp 0x2ba0cf
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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 a "-Wunsafe-buffer-usage" opt-out region is still open by the
// end of a file.
Diag(UnclosedSafeBufferOptOutLoc,
diag::err_pp_unclosed_pragma_unsafe_buffer_usage);
}
// If we have an unclosed module region from a pragma at the end of a
// module, complain and close it now.
const bool LeavingSubmodule = CurLexer && CurLexerSubmodule;
if ((LeavingSubmodule || IncludeMacroStack.empty()) &&
!BuildingSubmoduleStack.empty() &&
BuildingSubmoduleStack.back().IsPragma) {
Diag(BuildingSubmoduleStack.back().ImportLoc,
diag::err_pp_module_begin_without_module_end);
Module *M = LeaveSubmodule(/*ForPragma*/true);
Result.startToken();
const char *EndPos = getCurLexerEndPos();
CurLexer->BufferPtr = EndPos;
CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_module_end);
Result.setAnnotationEndLoc(Result.getLocation());
Result.setAnnotationValue(M);
return true;
}
// See if this file had a controlling macro.
if (CurPPLexer) { // Not ending a macro, ignore it.
if (const IdentifierInfo *ControllingMacro =
CurPPLexer->MIOpt.GetControllingMacroAtEndOfFile()) {
// Okay, this has a controlling macro, remember in HeaderFileInfo.
if (OptionalFileEntryRef FE = CurPPLexer->getFileEntry()) {
HeaderInfo.SetFileControllingMacro(*FE, ControllingMacro);
if (MacroInfo *MI = getMacroInfo(ControllingMacro))
MI->setUsedForHeaderGuard(true);
if (const IdentifierInfo *DefinedMacro =
CurPPLexer->MIOpt.GetDefinedMacro()) {
if (!isMacroDefined(ControllingMacro) &&
DefinedMacro != ControllingMacro &&
CurLexer->isFirstTimeLexingFile()) {
// If the edit distance between the two macros is more than 50%,
// DefinedMacro may not be header guard, or can be header guard of
// another header file. Therefore, it maybe defining something
// completely different. This can be observed in the wild when
// handling feature macros or header guards in different files.
const StringRef ControllingMacroName = ControllingMacro->getName();
const StringRef DefinedMacroName = DefinedMacro->getName();
const size_t MaxHalfLength = std::max(ControllingMacroName.size(),
DefinedMacroName.size()) / 2;
const unsigned ED = ControllingMacroName.edit_distance(
DefinedMacroName, true, MaxHalfLength);
if (ED <= MaxHalfLength) {
// Emit a warning for a bad header guard.
Diag(CurPPLexer->MIOpt.GetMacroLocation(),
diag::warn_header_guard)
<< CurPPLexer->MIOpt.GetMacroLocation() << ControllingMacro;
Diag(CurPPLexer->MIOpt.GetDefinedLocation(),
diag::note_header_guard)
<< CurPPLexer->MIOpt.GetDefinedLocation() << DefinedMacro
<< ControllingMacro
<< FixItHint::CreateReplacement(
CurPPLexer->MIOpt.GetDefinedLocation(),
ControllingMacro->getName());
}
}
}
}
}
}
// Complain about reaching a true EOF within arc_cf_code_audited.
// We don't want to complain about reaching the end of a macro
// instantiation or a _Pragma.
if (PragmaARCCFCodeAuditedInfo.second.isValid() && !isEndOfMacro &&
!(CurLexer && CurLexer->Is_PragmaLexer)) {
Diag(PragmaARCCFCodeAuditedInfo.second,
diag::err_pp_eof_in_arc_cf_code_audited);
// Recover by leaving immediately.
PragmaARCCFCodeAuditedInfo = {nullptr, SourceLocation()};
}
// Complain about reaching a true EOF within assume_nonnull.
// We don't want to complain about reaching the end of a macro
// instantiation or a _Pragma.
if (PragmaAssumeNonNullLoc.isValid() &&
!isEndOfMacro && !(CurLexer && CurLexer->Is_PragmaLexer)) {
// If we're at the end of generating a preamble, we should record the
// unterminated \#pragma clang assume_nonnull so we can restore it later
// when the preamble is loaded into the main file.
if (isRecordingPreamble() && isInPrimaryFile())
PreambleRecordedPragmaAssumeNonNullLoc = PragmaAssumeNonNullLoc;
else
Diag(PragmaAssumeNonNullLoc, diag::err_pp_eof_in_assume_nonnull);
// Recover by leaving immediately.
PragmaAssumeNonNullLoc = SourceLocation();
}
bool LeavingPCHThroughHeader = false;
// If this is a #include'd file, pop it off the include stack and continue
// lexing the #includer file.
if (!IncludeMacroStack.empty()) {
// If we lexed the code-completion file, act as if we reached EOF.
if (isCodeCompletionEnabled() && CurPPLexer &&
SourceMgr.getLocForStartOfFile(CurPPLexer->getFileID()) ==
CodeCompletionFileLoc) {
assert(CurLexer && "Got EOF but no current lexer set!");
Result.startToken();
CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
CurLexer.reset();
CurPPLexer = nullptr;
recomputeCurLexerKind();
return true;
}
if (!isEndOfMacro && CurPPLexer &&
(SourceMgr.getIncludeLoc(CurPPLexer->getFileID()).isValid() ||
// Predefines file doesn't have a valid include location.
(PredefinesFileID.isValid() &&
CurPPLexer->getFileID() == PredefinesFileID))) {
// Notify SourceManager to record the number of FileIDs that were created
// during lexing of the #include'd file.
unsigned NumFIDs =
SourceMgr.local_sloc_entry_size() -
CurPPLexer->getInitialNumSLocEntries() + 1/*#include'd file*/;
SourceMgr.setNumCreatedFIDsForFileID(CurPPLexer->getFileID(), NumFIDs);
}
bool ExitedFromPredefinesFile = false;
FileID ExitedFID;
if (!isEndOfMacro && CurPPLexer) {
ExitedFID = CurPPLexer->getFileID();
assert(PredefinesFileID.isValid() &&
"HandleEndOfFile is called before PredefinesFileId is set");
ExitedFromPredefinesFile = (PredefinesFileID == ExitedFID);
}
if (LeavingSubmodule) {
// We're done with this submodule.
Module *M = LeaveSubmodule(/*ForPragma*/false);
// Notify the parser that we've left the module.
const char *EndPos = getCurLexerEndPos();
Result.startToken();
CurLexer->BufferPtr = EndPos;
CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_module_end);
Result.setAnnotationEndLoc(Result.getLocation());
Result.setAnnotationValue(M);
}
bool FoundPCHThroughHeader = false;
if (CurPPLexer && creatingPCHWithThroughHeader() &&
isPCHThroughHeader(
SourceMgr.getFileEntryForID(CurPPLexer->getFileID())))
FoundPCHThroughHeader = true;
// We're done with the #included file.
RemoveTopOfLexerStack();
// Propagate info about start-of-line/leading white-space/etc.
PropagateLineStartLeadingSpaceInfo(Result);
// Notify the client, if desired, that we are in a new source file.
if (Callbacks && !isEndOfMacro && CurPPLexer) {
SourceLocation Loc = CurPPLexer->getSourceLocation();
SrcMgr::CharacteristicKind FileType =
SourceMgr.getFileCharacteristic(Loc);
Callbacks->FileChanged(Loc, PPCallbacks::ExitFile, FileType, ExitedFID);
Callbacks->LexedFileChanged(CurPPLexer->getFileID(),
PPCallbacks::LexedFileChangeReason::ExitFile,
FileType, ExitedFID, Loc);
}
// Restore conditional stack as well as the recorded
// \#pragma clang assume_nonnull from the preamble right after exiting
// from the predefines file.
if (ExitedFromPredefinesFile) {
replayPreambleConditionalStack();
if (PreambleRecordedPragmaAssumeNonNullLoc.isValid())
PragmaAssumeNonNullLoc = PreambleRecordedPragmaAssumeNonNullLoc;
}
if (!isEndOfMacro && CurPPLexer && FoundPCHThroughHeader &&
(isInPrimaryFile() ||
CurPPLexer->getFileID() == getPredefinesFileID())) {
// Leaving the through header. Continue directly to end of main file
// processing.
LeavingPCHThroughHeader = true;
} else {
// Client should lex another token unless we generated an EOM.
return LeavingSubmodule;
}
}
// If this is the end of the main file, form an EOF token.
assert(CurLexer && "Got EOF but no current lexer set!");
const char *EndPos = getCurLexerEndPos();
Result.startToken();
CurLexer->BufferPtr = EndPos;
if (getLangOpts().IncrementalExtensions) {
CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_repl_input_end);
Result.setAnnotationEndLoc(Result.getLocation());
Result.setAnnotationValue(nullptr);
} else {
CurLexer->FormTokenWithChars(Result, EndPos, tok::eof);
}
if (isCodeCompletionEnabled()) {
// Inserting the code-completion point increases the source buffer by 1,
// but the main FileID was created before inserting the point.
// Compensate by reducing the EOF location by 1, otherwise the location
// will point to the next FileID.
// FIXME: This is hacky, the code-completion point should probably be
// inserted before the main FileID is created.
if (CurLexer->getFileLoc() == CodeCompletionFileLoc)
Result.setLocation(Result.getLocation().getLocWithOffset(-1));
}
if (creatingPCHWithThroughHeader() && !LeavingPCHThroughHeader) {
// Reached the end of the compilation without finding the through header.
Diag(CurLexer->getFileLoc(), diag::err_pp_through_header_not_seen)
<< PPOpts->PCHThroughHeader << 0;
}
if (!isIncrementalProcessingEnabled())
// We're done with lexing.
CurLexer.reset();
if (!isIncrementalProcessingEnabled())
CurPPLexer = nullptr;
if (TUKind == TU_Complete) {
// This is the end of the top-level file. 'WarnUnusedMacroLocs' has
// collected all macro locations that we need to warn because they are not
// used.
for (WarnUnusedMacroLocsTy::iterator
I=WarnUnusedMacroLocs.begin(), E=WarnUnusedMacroLocs.end();
I!=E; ++I)
Diag(*I, diag::pp_macro_not_used);
}
// If we are building a module that has an umbrella header, make sure that
// each of the headers within the directory, including all submodules, is
// covered by the umbrella header was actually included by the umbrella
// header.
if (Module *Mod = getCurrentModule()) {
llvm::SmallVector<const Module *, 4> AllMods;
collectAllSubModulesWithUmbrellaHeader(*Mod, AllMods);
for (auto *M : AllMods)
diagnoseMissingHeaderInUmbrellaDir(*M);
}
return true;
}
|
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
movl 0xc(%rsp), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x491, 0x174(%rdi) # imm = 0x491
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x108(%rsp), %r12
movq %rcx, (%r12)
movq %rax, 0x8(%r12)
movq %rdi, 0x10(%r12)
movw $0x1, 0x18(%r12)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
cmpq $0x0, 0x448(%rbx)
setne %al
cmpq $0x0, 0x478(%rbx)
setne %bpl
andb %al, %bpl
jne 0x2bb424
movq 0x480(%rbx), %rax
cmpq 0x488(%rbx), %rax
jne 0x2bb52b
movl 0x528(%rbx), %eax
testq %rax, %rax
je 0x2bb52b
movq 0x520(%rbx), %rcx
shlq $0x5, %rax
cmpb $0x1, -0x14(%rcx,%rax)
jne 0x2bb52b
addq %rax, %rcx
movl -0x18(%rcx), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x485, 0x174(%rdi) # imm = 0x485
xorl %r12d, %r12d
movq %r12, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r12b, (%rax)
leaq 0x178(%rdi), %rax
leaq 0xe8(%rsp), %r15
movq %rax, (%r15)
movq %r12, 0x8(%r15)
movq %rdi, 0x10(%r15)
movw $0x1, 0x18(%r15)
movb %r12b, 0x178(%rdi)
movl %r12d, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r15, %rdi
callq 0x9646e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2bc02c
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl %r12d, 0x10(%r14)
movq %rbx, %rdi
callq 0x2bad5e
movq %rax, %r12
movq 0x448(%rbx), %rax
movq %r12, 0x98(%rax)
movq 0x448(%rbx), %rbx
movq 0x98(%rbx), %rsi
movl %r12d, %edx
subl %esi, %edx
movl %edx, 0x4(%r14)
movq %rbx, %rdi
callq 0x2887ac
movl %eax, (%r14)
movw $0x1c1, 0x10(%r14) # imm = 0x1C1
movq %r12, 0x98(%rbx)
movl %eax, 0x4(%r14)
movq %r15, 0x8(%r14)
jmp 0x2bba87
movq 0x450(%rbx), %rdi
testq %rdi, %rdi
je 0x2bb83b
movq 0x28(%rdi), %r12
testq %r12, %r12
sete %al
orb 0x20(%rdi), %al
jne 0x2bb83b
callq 0x2cb830
testq %rax, %rax
je 0x2bb83b
movq 0x68(%rbx), %rdi
movq %rax, %rsi
callq 0x284b54
movq %r12, 0x8(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x27d43c
testq %rax, %rax
je 0x2bb580
orb $0x4, 0x25(%rax)
movq 0x450(%rbx), %rax
movq 0x30(%rax), %r15
testq %r15, %r15
je 0x2bb83b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x27fdf0
cmpq %r12, %r15
je 0x2bb83b
testb %al, %al
jne 0x2bb83b
movq 0x448(%rbx), %rax
cmpb $0x1, 0xa4(%rax)
jne 0x2bb83b
movl %r13d, 0x8(%rsp)
movq 0x10(%r12), %rax
movl (%rax), %r13d
addq $0x10, %rax
leaq 0x98(%rsp), %rdi
movq %rax, (%rdi)
movq %r13, 0x8(%rdi)
movq 0x10(%r15), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
cmpq %rdx, %r13
cmovbeq %rdx, %r13
shrl %r13d
movl $0x1, %ecx
movl %r13d, %r8d
callq 0x653f6
cmpl %eax, %r13d
jb 0x2bb836
movq 0x450(%rbx), %rax
movl 0x38(%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x544, 0x174(%rdi) # imm = 0x544
xorl %ecx, %ecx
movq %rcx, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %cl, (%rax)
leaq 0x178(%rdi), %rax
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq %rcx, 0x8(%r13)
movq %rdi, 0x10(%r13)
movw $0x1, 0x18(%r13)
movb %cl, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq 0x450(%rbx), %rax
movl 0x38(%rax), %eax
movq %rax, %rcx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x58(%rsp), %rsi
movq %rcx, (%rsi)
movb $0x1, 0x8(%rsi)
movq %r13, %rdi
callq 0xe7ed8
xorl %eax, %eax
cmpq %rax, (%r13)
jne 0x2bb6b8
movq 0x20(%rsp), %rdi
callq 0x9658c
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdx
movq (%rdx), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdx), %rax
movq %rdx, %rdi
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r12, 0x10(%rax,%rcx,8)
callq 0x9646e
movq 0x450(%rbx), %rax
movl 0x3c(%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4e9, 0x174(%rdi) # imm = 0x4E9
xorl %ecx, %ecx
movq %rcx, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %cl, (%rax)
leaq 0x178(%rdi), %rax
leaq 0x58(%rsp), %r13
movq %rax, (%r13)
movq %rcx, 0x8(%r13)
movq %rdi, 0x10(%r13)
movw $0x1, 0x18(%r13)
movb %cl, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq 0x450(%rbx), %rax
movl 0x3c(%rax), %eax
movabsq $0x100000001, %rcx # imm = 0x100000001
imulq %rcx, %rax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movb $0x1, 0x8(%rcx)
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
callq 0xe7ed8
xorl %eax, %eax
cmpq %rax, (%r13)
jne 0x2bb793
movq 0x60(%rsp), %rdi
callq 0x9658c
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %r13
movq (%r13), %rax
movzbl (%rax), %ecx
movb $0x5, %dl
movb %dl, 0x1(%rax,%rcx)
movq (%r13), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %esi
movb %sil, (%rax)
movq %r15, 0x10(%rax,%rcx,8)
movq (%r13), %rax
movzbl (%rax), %ecx
movb %dl, 0x1(%rax,%rcx)
movq (%r13), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r12, 0x10(%rax,%rcx,8)
movq 0x450(%rbx), %rax
movl 0x3c(%rax), %eax
movq 0x10(%r12), %rcx
movl (%rcx), %r8d
addq $0x10, %rcx
movq %rax, %rsi
shlq $0x20, %rsi
orq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl $0x1, %edx
callq 0x24a28e
movq %r13, %rdi
movq %r12, %rsi
callq 0x100668
movq 0x18(%r12), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2bb82c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3c080
leaq 0x58(%rsp), %rdi
callq 0x9646e
movl 0x8(%rsp), %r13d
movl 0x3a8(%rbx), %eax
testl %eax, %eax
sete %cl
orb %r13b, %cl
jne 0x2bb8e1
movq 0x448(%rbx), %rcx
testq %rcx, %rcx
je 0x2bb864
cmpb $0x0, 0x91(%rcx)
jne 0x2bb8e1
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x45a, 0x174(%rdi) # imm = 0x45A
xorl %r15d, %r15d
movq %r15, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r15b, (%rax)
leaq 0x178(%rdi), %rax
leaq 0xc8(%rsp), %r12
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %rdi, 0x10(%r12)
movw $0x1, 0x18(%r12)
movb %r15b, 0x178(%rdi)
movl %r15d, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
movq %r15, 0x3a0(%rbx)
movl %r15d, 0x3a8(%rbx)
movl 0x3b0(%rbx), %r15d
testl %r15d, %r15d
sete %al
orb %r13b, %al
jne 0x2bb9a8
movq 0x448(%rbx), %rax
testq %rax, %rax
je 0x2bb910
cmpb $0x0, 0x91(%rax)
jne 0x2bb9a8
cmpl $0x1, 0x440(%rbx)
jne 0x2bb92e
movq %rbx, %rdi
callq 0x2ba2d0
testb %al, %al
je 0x2bb92e
movl %r15d, 0x3b4(%rbx)
jmp 0x2bb99e
movq 0x30(%rbx), %rdi
movl %r15d, 0x170(%rdi)
movl $0x45b, 0x174(%rdi) # imm = 0x45B
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0xa8(%rsp), %r12
movq %rcx, (%r12)
movq %rax, 0x8(%r12)
movq %rdi, 0x10(%r12)
movw $0x1, 0x18(%r12)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
movl $0x0, 0x3b0(%rbx)
movq 0x480(%rbx), %rax
cmpq 0x488(%rbx), %rax
je 0x2bbb3a
cmpq $0x0, 0x2f8(%rbx)
je 0x2bba8f
movq 0x450(%rbx), %rax
testq %rax, %rax
je 0x2bba8f
movq 0x58(%rbx), %rdi
movl 0x10(%rax), %esi
leaq 0x18(%rsp), %r12
movb $0x0, (%r12)
movq %r12, %rdx
callq 0x95598
movl (%rax), %eax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
testl %eax, %eax
cmovsl %edx, %ecx
cmpb $0x0, (%r12)
cmovnel %edx, %ecx
cmpl 0x308(%rbx), %ecx
jne 0x2bba8f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq 0x448(%rbx), %r15
movq 0x78(%r15), %r12
movq 0x98(%r15), %rsi
movl %r12d, %edx
subl %esi, %edx
movl %edx, 0x4(%r14)
movq %r15, %rdi
callq 0x2887ac
movl %eax, (%r14)
movw $0x1, 0x10(%r14)
movq %r12, 0x98(%r15)
movq 0x448(%rbx), %rdi
movq $0x0, 0x448(%rbx)
testq %rdi, %rdi
je 0x2bba74
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x450(%rbx)
movq %rbx, %rdi
callq 0x2c8774
movb $0x1, %bpl
jmp 0x2bc018
movb %bpl, 0x7(%rsp)
xorl %eax, %eax
movl $0x0, %r15d
testb %r13b, %r13b
jne 0x2bbb46
movq 0x450(%rbx), %rax
testq %rax, %rax
je 0x2bbb12
movq 0x58(%rbx), %rdi
movl 0x10(%rax), %esi
leaq 0x18(%rsp), %r12
movb $0x0, (%r12)
movq %r12, %rdx
callq 0x95598
cmpb $0x0, (%r12)
jne 0x2bbadc
cmpl $0x0, (%rax)
js 0x2bbadc
cmpl $0x0, 0x8(%rax)
jne 0x2bbaf2
movl 0x948(%rbx), %eax
testl %eax, %eax
je 0x2bbb12
movq 0x450(%rbx), %rcx
cmpl %eax, 0x10(%rcx)
jne 0x2bbb12
movq 0x58(%rbx), %rdi
movl 0xc0(%rdi), %edx
movq 0x450(%rbx), %rax
subl 0x14(%rax), %edx
incl %edx
movl 0x10(%rax), %esi
xorl %ecx, %ecx
callq 0x2bc3ea
xorl %eax, %eax
movl $0x0, %r15d
testb %r13b, %r13b
jne 0x2bbb46
movq 0x450(%rbx), %rax
testq %rax, %rax
je 0x2bbb41
movl 0x10(%rax), %eax
cmpl %eax, 0x948(%rbx)
sete %r15b
jmp 0x2bbb46
xorl %ecx, %ecx
jmp 0x2bbcfd
xorl %eax, %eax
xorl %r15d, %r15d
movl %eax, 0x14(%rsp)
movl %r13d, 0x8(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x2bbbcb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2bc02c
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2bad5e
movl %r15d, %r13d
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq 0x448(%rbx), %rax
movq %r15, 0x98(%rax)
movq 0x448(%rbx), %r12
movq 0x98(%r12), %rsi
movl %r15d, %edx
subl %esi, %edx
movl %edx, 0x4(%r14)
movq %r12, %rdi
callq 0x2887ac
movl %eax, (%r14)
movw $0x1c1, 0x10(%r14) # imm = 0x1C1
movq %r15, 0x98(%r12)
movl %r13d, %r15d
movl %eax, 0x4(%r14)
movq %rbp, 0x8(%r14)
movb $0x1, %r13b
cmpq $0x0, 0x450(%rbx)
je 0x2bbc09
movq %rbx, %rdi
callq 0x2c899c
testb %al, %al
je 0x2bbc09
movq 0x58(%rbx), %rdi
movq 0x450(%rbx), %rax
movl 0x10(%rax), %esi
callq 0x27f21c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2c897e
movl %eax, %r13d
xorb $0x1, %r13b
movq %rbx, %rdi
callq 0x2bc428
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bad38
cmpq $0x0, 0x498(%rbx)
sete %al
orb 0x8(%rsp), %al
jne 0x2bbc9e
movq 0x450(%rbx), %rdi
testq %rdi, %rdi
je 0x2bbc9e
movq (%rdi), %rax
callq *0x20(%rax)
movl %r15d, 0x10(%rsp)
movl %eax, %r15d
movq 0x58(%rbx), %rdi
movl %eax, %esi
callq 0x2f6e32
movl %eax, %r12d
movq 0x498(%rbx), %rdi
movq (%rdi), %rax
movl %r15d, %esi
movl $0x1, %edx
movl %r12d, %ecx
movl 0x14(%rsp), %ebp
movl %ebp, %r8d
callq *0x10(%rax)
movq 0x450(%rbx), %rax
movq 0x498(%rbx), %rdi
movl 0x10(%rax), %esi
movq (%rdi), %rax
movl $0x1, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movl %r15d, %r9d
movl 0x10(%rsp), %r15d
callq *0x18(%rax)
testb %r15b, %r15b
je 0x2bbcbb
movq %rbx, %rdi
callq 0x2c89d2
movl 0x3b4(%rbx), %eax
testl %eax, %eax
je 0x2bbcbb
movl %eax, 0x3b0(%rbx)
movq 0x450(%rbx), %r15
testq %r15, %r15
sete %al
orb 0x8(%rsp), %r13b
orb %al, %r13b
movb 0x7(%rsp), %bpl
je 0x2bbcdb
xorl %ecx, %ecx
jmp 0x2bbcf5
movq %rbx, %rdi
callq 0x2ba2d0
movb $0x1, %cl
testb %al, %al
jne 0x2bbcf5
movl 0x10(%r15), %eax
cmpl 0x948(%rbx), %eax
jne 0x2bbcd7
testb %cl, %cl
je 0x2bc018
movl %ecx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2bad5e
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq 0x448(%rbx), %rax
movq %r15, 0x98(%rax)
movq 0x38(%rbx), %rax
movabsq $0x100000001, %rbp # imm = 0x100000001
decq %rbp
movq 0xb8(%rax), %r13
movq 0x448(%rbx), %r12
movq 0x98(%r12), %rsi
movl %r15d, %edx
subl %esi, %edx
movl %edx, 0x4(%r14)
movq %r12, %rdi
callq 0x2887ac
movl %eax, (%r14)
testq %rbp, %r13
je 0x2bbd86
movw $0x1c3, 0x10(%r14) # imm = 0x1C3
movq %r15, 0x98(%r12)
movl %eax, 0x4(%r14)
movq $0x0, 0x8(%r14)
jmp 0x2bbd95
movw $0x1, 0x10(%r14)
movq %r15, 0x98(%r12)
cmpq $0x0, 0x2f8(%rbx)
je 0x2bbdb7
movq 0x448(%rbx), %rax
movl 0x80(%rax), %eax
cmpl 0x308(%rbx), %eax
jne 0x2bbdb7
decl (%r14)
movq %rbx, %rdi
callq 0x2c899c
xorb $0x1, %al
movl 0x8(%rsp), %ecx
orb %al, %cl
jne 0x2bbe8e
movq 0x448(%rbx), %rax
movl 0x80(%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x490, 0x174(%rdi) # imm = 0x490
xorl %r15d, %r15d
movq %r15, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r15b, (%rax)
leaq 0x178(%rdi), %rax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rdi, 0x10(%r14)
movw $0x1, 0x18(%r14)
movb %r15b, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq 0x20(%rbx), %rax
movq 0x50(%rax), %rsi
movq 0x58(%rax), %rdx
movq %r14, %rdi
callq 0x964fa
cmpq %r15, (%r14)
jne 0x2bbe65
movq 0x20(%rsp), %rdi
callq 0x9658c
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x2, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq $0x0, 0x10(%rax,%rcx,8)
callq 0x9646e
cmpb $0x0, 0x2e8(%rbx)
jne 0x2bbeb4
movq 0x448(%rbx), %rdi
movq $0x0, 0x448(%rbx)
testq %rdi, %rdi
je 0x2bbeb4
movq (%rdi), %rax
callq *0x10(%rax)
cmpb $0x0, 0x2e8(%rbx)
jne 0x2bbec8
movq $0x0, 0x450(%rbx)
cmpl $0x0, 0x2ec(%rbx)
jne 0x2bbfa8
leaq 0x828(%rbx), %rdi
callq 0x2bc47c
testb $0x1, 0x828(%rbx)
leaq 0x830(%rbx), %rcx
cmoveq 0x830(%rbx), %rcx
movl $0x20, %esi
cmovel 0x838(%rbx), %esi
leaq (%rcx,%rsi,4), %r13
cmpq %r13, %rax
je 0x2bbfa8
movq %rax, %r14
movq %rdx, %r15
xorl %ebp, %ebp
leaq 0x78(%rsp), %r12
movl (%r14), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x508, 0x174(%rdi) # imm = 0x508
movq %rbp, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %bpl, (%rax)
leaq 0x178(%rdi), %rax
movq %rax, 0x78(%rsp)
movq %rbp, 0x80(%rsp)
movq %rdi, 0x88(%rsp)
movw $0x1, 0x90(%rsp)
movb %bpl, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
addq $0x4, %r14
cmpq %r15, %r14
je 0x2bbf9f
cmpl $-0x2, (%r14)
jae 0x2bbf90
cmpq %r13, %r14
jne 0x2bbf1d
movq %rbx, %rdi
callq 0x2c892a
movb $0x1, %bpl
testq %rax, %rax
je 0x2bc018
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%r15)
leaq 0x18(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x2bc4d0
movl 0x8(%r14), %r14d
testq %r14, %r14
je 0x2bc009
movq 0x18(%rsp), %r12
shlq $0x3, %r14
xorl %r13d, %r13d
movq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x2bada8
addq $0x8, %r13
cmpq %r13, %r14
jne 0x2bbff4
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bc018
callq 0x3c3a0
movl %ebp, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
jmp 0x2bcd96
nop
|
/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->setPrevious(OldMD);
StoredMD.setLatest(MD);
StoredMD.overrideActiveModuleMacros(*this, II);
if (needModuleMacros()) {
// Track that we created a new macro directive, so we know we should
// consider building a ModuleMacro for it when we get to the end of
// the module.
PendingModuleMacroNames.push_back(II);
}
// Set up the identifier as having associated macro history.
II->setHasMacroDefinition(true);
if (!MD->isDefined() && !LeafModuleMacros.contains(II))
II->setHasMacroDefinition(false);
if (II->isFromAST())
II->setChangedSinceDeserialization();
}
|
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, (%r14)
movq (%rax), %rcx
testb $0x4, %cl
sete %dl
andq $-0x8, %rcx
sete %sil
orb %dl, %sil
je 0x2bd539
movq %r14, %rcx
andq $-0x5, %rcx
movq %rcx, (%rax)
jmp 0x2bd53c
movq %r14, (%rcx)
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2bd5f2
movq %rbx, %rdi
callq 0x2bcbe4
testb %al, %al
je 0x2bd569
leaq 0x700(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x27cd06
movl $0x86000000, %r15d # imm = 0x86000000
movq 0x8(%rsp), %rax
movq (%rax), %rcx
btl $0x19, %ecx
jb 0x2bd583
orq %r15, %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x2959b8
testq %rax, %rax
setne %al
testl %edx, %edx
sete %cl
testb %cl, %al
jne 0x2bd5cb
addq $0x810, %rbx # imm = 0x810
movq 0x8(%rsp), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x280f92
testb %al, %al
jne 0x2bd5cb
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2bd69c
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x7a000000, %r15 # imm = 0x7A000000
testq %r15, %rcx
je 0x2bd5e7
btsq $0x21, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::ModuleMacro*>, llvm::DenseMapInfo<clang::IdentifierInfo const*, void>, llvm::detail::DenseMapPair<clang::IdentifierInfo const*, llvm::TinyPtrVector<clang::ModuleMacro*>>>::find(clang::IdentifierInfo const*)
|
iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
}
|
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 isVariadic = MI->isVariadic();
// Outer loop, while there are more arguments, keep reading them.
Token Tok;
// Read arguments as unexpanded tokens. This avoids issues, e.g., where
// an argument value in a macro could expand to ',' or '(' or ')'.
LexUnexpandedToken(Tok);
assert(Tok.is(tok::l_paren) && "Error computing l-paren-ness?");
// ArgTokens - Build up a list of tokens that make up each argument. Each
// argument is separated by an EOF token. Use a SmallVector so we can avoid
// heap allocations in the common case.
SmallVector<Token, 64> ArgTokens;
bool ContainsCodeCompletionTok = false;
bool FoundElidedComma = false;
SourceLocation TooManyArgsLoc;
unsigned NumActuals = 0;
while (Tok.isNot(tok::r_paren)) {
if (ContainsCodeCompletionTok && Tok.isOneOf(tok::eof, tok::eod))
break;
assert(Tok.isOneOf(tok::l_paren, tok::comma) &&
"only expect argument separators here");
size_t ArgTokenStart = ArgTokens.size();
SourceLocation ArgStartLoc = Tok.getLocation();
// C99 6.10.3p11: Keep track of the number of l_parens we have seen. Note
// that we already consumed the first one.
unsigned NumParens = 0;
while (true) {
// Read arguments as unexpanded tokens. This avoids issues, e.g., where
// an argument value in a macro could expand to ',' or '(' or ')'.
LexUnexpandedToken(Tok);
if (Tok.isOneOf(tok::eof, tok::eod)) { // "#if f(<eof>" & "#if f(\n"
if (!ContainsCodeCompletionTok) {
Diag(MacroName, diag::err_unterm_macro_invoc);
Diag(MI->getDefinitionLoc(), diag::note_macro_here)
<< MacroName.getIdentifierInfo();
// Do not lose the EOF/EOD. Return it to the client.
MacroName = Tok;
return nullptr;
}
// Do not lose the EOF/EOD.
auto Toks = std::make_unique<Token[]>(1);
Toks[0] = Tok;
EnterTokenStream(std::move(Toks), 1, true, /*IsReinject*/ false);
break;
} else if (Tok.is(tok::r_paren)) {
// If we found the ) token, the macro arg list is done.
if (NumParens-- == 0) {
MacroEnd = Tok.getLocation();
if (!ArgTokens.empty() &&
ArgTokens.back().commaAfterElided()) {
FoundElidedComma = true;
}
break;
}
} else if (Tok.is(tok::l_paren)) {
++NumParens;
} else if (Tok.is(tok::comma)) {
// In Microsoft-compatibility mode, single commas from nested macro
// expansions should not be considered as argument separators. We test
// for this with the IgnoredComma token flag.
if (Tok.getFlags() & Token::IgnoredComma) {
// However, in MSVC's preprocessor, subsequent expansions do treat
// these commas as argument separators. This leads to a common
// workaround used in macros that need to work in both MSVC and
// compliant preprocessors. Therefore, the IgnoredComma flag can only
// apply once to any given token.
Tok.clearFlag(Token::IgnoredComma);
} else if (NumParens == 0) {
// Comma ends this argument if there are more fixed arguments
// expected. However, if this is a variadic macro, and this is part of
// the variadic part, then the comma is just an argument token.
if (!isVariadic)
break;
if (NumFixedArgsLeft > 1)
break;
}
} else if (Tok.is(tok::comment) && !KeepMacroComments) {
// If this is a comment token in the argument list and we're just in
// -C mode (not -CC mode), discard the comment.
continue;
} else if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != nullptr) {
// Reading macro arguments can cause macros that we are currently
// expanding from to be popped off the expansion stack. Doing so causes
// them to be reenabled for expansion. Here we record whether any
// identifiers we lex as macro arguments correspond to disabled macros.
// If so, we mark the token as noexpand. This is a subtle aspect of
// C99 6.10.3.4p2.
if (MacroInfo *MI = getMacroInfo(Tok.getIdentifierInfo()))
if (!MI->isEnabled())
Tok.setFlag(Token::DisableExpand);
} else if (Tok.is(tok::code_completion)) {
ContainsCodeCompletionTok = true;
if (CodeComplete)
CodeComplete->CodeCompleteMacroArgument(MacroName.getIdentifierInfo(),
MI, NumActuals);
// Don't mark that we reached the code-completion point because the
// parser is going to handle the token and there will be another
// code-completion callback.
}
ArgTokens.push_back(Tok);
}
// If this was an empty argument list foo(), don't add this as an empty
// argument.
if (ArgTokens.empty() && Tok.getKind() == tok::r_paren)
break;
// If this is not a variadic macro, and too many args were specified, emit
// an error.
if (!isVariadic && NumFixedArgsLeft == 0 && TooManyArgsLoc.isInvalid()) {
if (ArgTokens.size() != ArgTokenStart)
TooManyArgsLoc = ArgTokens[ArgTokenStart].getLocation();
else
TooManyArgsLoc = ArgStartLoc;
}
// Empty arguments are standard in C99 and C++0x, and are supported as an
// extension in other modes.
if (ArgTokens.size() == ArgTokenStart && !getLangOpts().C99)
Diag(Tok, getLangOpts().CPlusPlus11
? diag::warn_cxx98_compat_empty_fnmacro_arg
: diag::ext_empty_fnmacro_arg);
// Add a marker EOF token to the end of the token list for this argument.
Token EOFTok;
EOFTok.startToken();
EOFTok.setKind(tok::eof);
EOFTok.setLocation(Tok.getLocation());
EOFTok.setLength(0);
ArgTokens.push_back(EOFTok);
++NumActuals;
if (!ContainsCodeCompletionTok && NumFixedArgsLeft != 0)
--NumFixedArgsLeft;
}
// Okay, we either found the r_paren. Check to see if we parsed too few
// arguments.
unsigned MinArgsExpected = MI->getNumParams();
// If this is not a variadic macro, and too many args were specified, emit
// an error.
if (!isVariadic && NumActuals > MinArgsExpected &&
!ContainsCodeCompletionTok) {
// Emit the diagnostic at the macro name in case there is a missing ).
// Emitting it at the , could be far away from the macro name.
Diag(TooManyArgsLoc, diag::err_too_many_args_in_macro_invoc);
Diag(MI->getDefinitionLoc(), diag::note_macro_here)
<< MacroName.getIdentifierInfo();
// Commas from braced initializer lists will be treated as argument
// separators inside macros. Attempt to correct for this with parentheses.
// TODO: See if this can be generalized to angle brackets for templates
// inside macro arguments.
SmallVector<Token, 4> FixedArgTokens;
unsigned FixedNumArgs = 0;
SmallVector<SourceRange, 4> ParenHints, InitLists;
if (!GenerateNewArgTokens(*this, ArgTokens, FixedArgTokens, FixedNumArgs,
ParenHints, InitLists)) {
if (!InitLists.empty()) {
DiagnosticBuilder DB =
Diag(MacroName,
diag::note_init_list_at_beginning_of_macro_argument);
for (SourceRange Range : InitLists)
DB << Range;
}
return nullptr;
}
if (FixedNumArgs != MinArgsExpected)
return nullptr;
DiagnosticBuilder DB = Diag(MacroName, diag::note_suggest_parens_for_macro);
for (SourceRange ParenLocation : ParenHints) {
DB << FixItHint::CreateInsertion(ParenLocation.getBegin(), "(");
DB << FixItHint::CreateInsertion(ParenLocation.getEnd(), ")");
}
ArgTokens.swap(FixedArgTokens);
NumActuals = FixedNumArgs;
}
// See MacroArgs instance var for description of this.
bool isVarargsElided = false;
if (ContainsCodeCompletionTok) {
// Recover from not-fully-formed macro invocation during code-completion.
Token EOFTok;
EOFTok.startToken();
EOFTok.setKind(tok::eof);
EOFTok.setLocation(Tok.getLocation());
EOFTok.setLength(0);
for (; NumActuals < MinArgsExpected; ++NumActuals)
ArgTokens.push_back(EOFTok);
}
if (NumActuals < MinArgsExpected) {
// There are several cases where too few arguments is ok, handle them now.
if (NumActuals == 0 && MinArgsExpected == 1) {
// #define A(X) or #define A(...) ---> A()
// If there is exactly one argument, and that argument is missing,
// then we have an empty "()" argument empty list. This is fine, even if
// the macro expects one argument (the argument is just empty).
isVarargsElided = MI->isVariadic();
} else if ((FoundElidedComma || MI->isVariadic()) &&
(NumActuals+1 == MinArgsExpected || // A(x, ...) -> A(X)
(NumActuals == 0 && MinArgsExpected == 2))) {// A(x,...) -> A()
// Varargs where the named vararg parameter is missing: OK as extension.
// #define A(x, ...)
// A("blah")
//
// If the macro contains the comma pasting extension, the diagnostic
// is suppressed; we know we'll get another diagnostic later.
if (!MI->hasCommaPasting()) {
// C++20 [cpp.replace]p15, C23 6.10.5p12
//
// C++20 and C23 allow this construct, but standards before that
// do not (we allow it as an extension).
unsigned ID;
if (getLangOpts().CPlusPlus20)
ID = diag::warn_cxx17_compat_missing_varargs_arg;
else if (getLangOpts().CPlusPlus)
ID = diag::ext_cxx_missing_varargs_arg;
else if (getLangOpts().C23)
ID = diag::warn_c17_compat_missing_varargs_arg;
else
ID = diag::ext_c_missing_varargs_arg;
Diag(Tok, ID);
Diag(MI->getDefinitionLoc(), diag::note_macro_here)
<< MacroName.getIdentifierInfo();
}
// Remember this occurred, allowing us to elide the comma when used for
// cases like:
// #define A(x, foo...) blah(a, ## foo)
// #define B(x, ...) blah(a, ## __VA_ARGS__)
// #define C(...) blah(a, ## __VA_ARGS__)
// A(x) B(x) C()
isVarargsElided = true;
} else if (!ContainsCodeCompletionTok) {
// Otherwise, emit the error.
Diag(Tok, diag::err_too_few_args_in_macro_invoc);
Diag(MI->getDefinitionLoc(), diag::note_macro_here)
<< MacroName.getIdentifierInfo();
return nullptr;
}
// Add a marker EOF token to the end of the token list for this argument.
SourceLocation EndLoc = Tok.getLocation();
Tok.startToken();
Tok.setKind(tok::eof);
Tok.setLocation(EndLoc);
Tok.setLength(0);
ArgTokens.push_back(Tok);
// If we expect two arguments, add both as empty.
if (NumActuals == 0 && MinArgsExpected == 2)
ArgTokens.push_back(Tok);
} else if (NumActuals > MinArgsExpected && !MI->isVariadic() &&
!ContainsCodeCompletionTok) {
// Emit the diagnostic at the macro name in case there is a missing ).
// Emitting it at the , could be far away from the macro name.
Diag(MacroName, diag::err_too_many_args_in_macro_invoc);
Diag(MI->getDefinitionLoc(), diag::note_macro_here)
<< MacroName.getIdentifierInfo();
return nullptr;
}
return MacroArgs::create(MI, ArgTokens, isVarargsElided, *this);
}
|
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 0x220(%rdi), %r14d
movl %r14d, %eax
orl $0x20, %eax
movw %ax, 0x220(%rdi)
leaq 0x40(%rsp), %rbp
movq %rbp, %rsi
callq 0x2c90f4
andl $0x20, %r14d
movl 0x220(%rbx), %eax
andl $-0x21, %eax
orl %r14d, %eax
movw %ax, 0x220(%rbx)
leaq 0x278(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x5c(%rsp)
xorl %r12d, %r12d
movzwl 0x50(%rsp), %eax
cmpw $0x17, %ax
je 0x2c0087
decl %eax
cmpw $0x2, %ax
setb %al
testb %r12b, %al
jne 0x2c0087
movq %r12, %r14
testb $0xc, 0x8(%rsp)
setne %al
movl 0x270(%rsp), %ecx
movq %rcx, 0x28(%rsp)
movl 0x40(%rsp), %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x2, 0x38(%rsp)
setb %r13b
andb %al, %r13b
xorl %r15d, %r15d
movzwl 0x220(%rbx), %r12d
movl %r12d, %eax
orl $0x20, %eax
movw %ax, 0x220(%rbx)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2c90f4
andl $0x20, %r12d
movl 0x220(%rbx), %ecx
movl %ecx, %eax
andl $-0x21, %eax
orl %r12d, %eax
movw %ax, 0x220(%rbx)
movzwl 0x50(%rsp), %eax
cmpl $0x4, %eax
jne 0x2bfb57
testb $0x2, %cl
je 0x2bfb0d
jmp 0x2bfba2
cmpl $0x15, %eax
jle 0x2bfb96
cmpl $0x16, %eax
je 0x2bfbf7
cmpl $0x17, %eax
je 0x2bfbfc
cmpl $0x42, %eax
jne 0x2bfba2
movzwl 0x52(%rsp), %eax
testb %al, %al
js 0x2bfc07
testl %r15d, %r15d
setne %al
orb %r13b, %al
testb $0x1, %al
jne 0x2bfc34
jmp 0x2c0075
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2bfccd
movzwl %ax, %edi
callq 0x2fe69f
testb %al, %al
jne 0x2bfbc2
movzwl 0x50(%rsp), %eax
movzwl %ax, %ecx
leal -0x7(%rcx), %edx
cmpl $0xd, %edx
jae 0x2bfc78
cmpw $0x3, 0x50(%rsp)
jne 0x2bfc34
movq 0x2f0(%rbx), %rdi
testq %rdi, %rdi
je 0x2bfc31
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2bfc13
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2bfc13
movb $0x1, %r14b
xorl %esi, %esi
jmp 0x2bfc1f
incl %r15d
jmp 0x2bfc34
subl $0x1, %r15d
jae 0x2bfc34
jmp 0x2c0037
andl $0xff7f, %eax # imm = 0xFF7F
movw %ax, 0x52(%rsp)
jmp 0x2bfc34
movb $0x1, %r14b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq *0x30(%rax)
jmp 0x2bfc34
movb $0x1, %r14b
movl $0x1, %edx
leaq 0x268(%rsp), %rdi
movq %rbp, %rsi
callq 0x27fbec
movq 0x268(%rsp), %rcx
movl 0x270(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x270(%rsp)
jmp 0x2bfb0d
cmpl $0x1, %ecx
je 0x2bfbc2
cmpq $0x0, 0x48(%rsp)
je 0x2bfbc2
decl %eax
cmpw $0x13, %ax
jae 0x2bfca3
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2bfca3
xorl %esi, %esi
jmp 0x2bfca8
movq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x27d43c
testq %rax, %rax
je 0x2bfc34
testb $0x40, 0x24(%rax)
je 0x2bfc34
orb $0x4, 0x52(%rsp)
jmp 0x2bfc34
movq %r14, %r12
testb $0x1, %r12b
je 0x2bfd85
movl $0x18, %edi
callq 0x3c450
movl $0x0, 0x14(%rax)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rax)
movl 0x50(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x2baaf0
movl 0x270(%rsp), %eax
testl %eax, %eax
jne 0x2bfd35
movl $0x3, %r15d
cmpw $0x17, 0x50(%rsp)
je 0x2c002c
cmpl $0x0, 0x38(%rsp)
sete %cl
andb 0xd8(%rsp), %cl
cmpb $0x1, %cl
jne 0x2bfefa
cmpl $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rsi
jne 0x2bfeff
movl 0xc(%rsp), %ecx
movl %ecx, 0x30(%rsp)
cmpl %esi, %eax
je 0x2bfeff
movq 0x268(%rsp), %rcx
leaq (%rsi,%rsi,2), %rdx
movl (%rcx,%rdx,8), %ecx
movl %ecx, 0x30(%rsp)
jmp 0x2bfeff
movq %r12, 0x28(%rsp)
movq 0x30(%rbx), %rdi
movq 0x10(%rsp), %r15
movl (%r15), %eax
movl %eax, 0x170(%rdi)
movl $0x4ab, 0x174(%rdi) # imm = 0x4AB
xorl %r14d, %r14d
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
movl $0x178, %r13d # imm = 0x178
leaq (%rdi,%r13), %rax
movq %rax, 0x198(%rsp)
movq %r14, 0x1a0(%rsp)
movq %rdi, 0x1a8(%rsp)
movw $0x1, %r12w
movw %r12w, 0x1b0(%rsp)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
leaq 0x198(%rsp), %rdi
callq 0x9646e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4ef, 0x174(%rdi) # imm = 0x4EF
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
leaq (%rdi,%r13), %rax
movq %rax, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %rdi, 0x70(%rsp)
movw %r12w, 0x78(%rsp)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
movl 0x10(%r15), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2bfe8d
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2bfe8d
xorl %r15d, %r15d
jmp 0x2bfe96
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r15
cmpq $0x0, 0x60(%rsp)
movq 0x28(%rsp), %r12
jne 0x2bfeb2
movq 0x68(%rsp), %rdi
callq 0x9658c
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq 0x60(%rsp), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r15, 0x10(%rax,%rcx,8)
leaq 0x60(%rsp), %rdi
callq 0x9646e
movl 0x50(%rsp), %eax
movq 0x10(%rsp), %rcx
movl %eax, 0x10(%rcx)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rcx)
movl $0x1, %r15d
jmp 0x2c002c
movq 0x28(%rsp), %rsi
cmpl %esi, %eax
jne 0x2bffa2
movq 0x38(%rbx), %rax
movq (%rax), %rax
testb $0x1, %al
jne 0x2bffa2
btl $0xb, %eax
movl $0x533, %eax # imm = 0x533
movl $0x4c1, %ecx # imm = 0x4C1
cmovael %ecx, %eax
movq 0x30(%rbx), %rdi
movl 0x40(%rsp), %ecx
movl %ecx, 0x170(%rdi)
movl %eax, 0x174(%rdi)
movl $0x0, %ecx
movq %rcx, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %cl, (%rax)
leaq 0x178(%rdi), %rax
movq %rax, 0x178(%rsp)
movq %rcx, 0x180(%rsp)
movq %rdi, 0x188(%rsp)
movw $0x1, 0x190(%rsp)
movb %cl, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
leaq 0x178(%rsp), %rdi
callq 0x9646e
xorl %r15d, %r15d
movl %r15d, 0x70(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movw $0x1, 0x70(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x60(%rsp)
movl %r15d, 0x64(%rsp)
movl $0x1, %edx
leaq 0x268(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x27fbec
movq 0x268(%rsp), %rcx
movl 0x270(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x270(%rsp)
movq 0x20(%rsp), %rax
incl %eax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %edx
testl %edx, %edx
setne %al
movl %r12d, %ecx
notb %cl
andb %al, %cl
movzbl %cl, %eax
subl %eax, %edx
movl %edx, 0x38(%rsp)
testl %r15d, %r15d
je 0x2bfabe
jmp 0x2c007d
movl 0x40(%rsp), %eax
movq 0x140(%rsp), %rcx
movl %eax, (%rcx)
movl 0x270(%rsp), %eax
testq %rax, %rax
je 0x2c0075
movq 0x268(%rsp), %rcx
leaq (%rax,%rax,2), %rax
testb $0x2, -0x5(%rcx,%rax,8)
movl 0x5c(%rsp), %eax
movzbl %al, %eax
movl $0x1, %ecx
cmovnel %ecx, %eax
movl %eax, 0x5c(%rsp)
movq %r14, %r12
jmp 0x2bfd18
cmpl $0x3, %r15d
jne 0x2c0c31
testb $0xc, 0x8(%rsp)
setne %al
movq 0x18(%rsp), %rcx
movl 0x18(%rcx), %r13d
cmpl %r13d, 0x20(%rsp)
setbe %cl
orb %al, %cl
jne 0x2c08f0
testb $0x1, %r12b
jne 0x2c08f0
movl %r13d, 0x8(%rsp)
movq %r12, 0x28(%rsp)
movq 0x30(%rbx), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0x170(%rdi)
movl $0x4a0, 0x174(%rdi) # imm = 0x4A0
xorl %r14d, %r14d
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
movl $0x178, %r15d # imm = 0x178
leaq (%rdi,%r15), %rax
leaq 0x248(%rsp), %r13
movq %rax, (%r13)
movq %r14, 0x8(%r13)
movq %rdi, 0x10(%r13)
movw $0x1, %bp
movw %bp, 0x18(%r13)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %r12d # imm = 0x388
addq %r12, %rdi
callq 0x964b2
movq %r13, %rdi
callq 0x9646e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4ef, 0x174(%rdi) # imm = 0x4EF
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
addq %rdi, %r15
movq %r15, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %rdi, 0x70(%rsp)
movw %bp, 0x78(%rsp)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
addq %r12, %rdi
callq 0x964b2
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2c01ab
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2c01ab
xorl %r14d, %r14d
jmp 0x2c01b4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r14
cmpq $0x0, 0x60(%rsp)
jne 0x2c01cb
movq 0x68(%rsp), %rdi
callq 0x9658c
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r14, 0x10(%rax,%rcx,8)
callq 0x9646e
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
leaq 0x1c8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
leaq 0x158(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
leaq 0xf0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movl 0x270(%rsp), %eax
testq %rax, %rax
je 0x2c02e9
movq 0x268(%rsp), %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %ebp, %ebp
leaq 0x99b1e(%rip), %r14 # 0x359d88
leaq 0xe0(%rsp), %r13
movzwl 0x10(%r15,%rbp), %eax
addl $-0x16, %eax
cmpl $0x3, %eax
ja 0x2c02e0
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq %r13, %rdi
movl $0x1, %esi
jmp 0x2c0298
movq %r13, %rdi
xorl %esi, %esi
callq 0x2c2c0a
jmp 0x2c02e0
movl 0xe8(%rsp), %eax
testq %rax, %rax
je 0x2c02f7
movq 0xe0(%rsp), %rcx
cmpl $0x1, -0x4(%rcx,%rax,4)
jne 0x2c02d7
jmp 0x2c02f7
movl 0xe8(%rsp), %eax
testq %rax, %rax
je 0x2c02f7
movq 0xe0(%rsp), %rcx
cmpl $0x0, -0x4(%rcx,%rax,4)
je 0x2c02f7
decl %eax
movl %eax, 0xe8(%rsp)
addq $0x18, %rbp
cmpq %rbp, %r12
jne 0x2c0272
cmpl $0x0, 0xe8(%rsp)
sete %bpl
jmp 0x2c02f9
xorl %ebp, %ebp
movq 0xe0(%rsp), %rdi
leaq 0xf0(%rsp), %rax
cmpq %rax, %rdi
movq 0x28(%rsp), %r12
movl 0x8(%rsp), %r13d
je 0x2c031d
callq 0x3c3a0
xorl %ecx, %ecx
movl $0x0, %eax
testb %bpl, %bpl
je 0x2c0614
movl 0x270(%rsp), %eax
testq %rax, %rax
je 0x2c05eb
movq 0x268(%rsp), %r8
leaq (%rax,%rax,2), %rcx
leaq (%r8,%rcx,8), %rcx
leaq 0x18(%r8), %r12
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movl $0x0, 0xc(%rsp)
xorl %eax, %eax
movq %rcx, 0xd8(%rsp)
movq %rcx, %rdx
xorl %r14d, %r14d
leaq -0x18(%r12), %rbp
movzwl -0x8(%r12), %ecx
cmpl $0x1, %ecx
je 0x2c03bb
cmpl $0x19, %ecx
je 0x2c0396
cmpl $0x18, %ecx
jne 0x2c05db
incl %eax
jmp 0x2c05db
decl %eax
jne 0x2c05db
xorl %eax, %eax
cmpq 0xd8(%rsp), %rdx
jne 0x2c05db
testb $0x1, %r14b
cmovneq %rbp, %rdx
jmp 0x2c05db
testl %eax, %eax
je 0x2c03d8
movw $0x42, -0x8(%r12)
movl $0x1, -0x14(%r12)
movb $0x1, %r14b
jmp 0x2c05db
testb $0x1, %r14b
je 0x2c0428
cmpw $0x18, 0x10(%r8)
jne 0x2c0428
movl (%r8), %r13d
movl (%rdx), %edi
movq 0x38(%rbx), %rcx
movq 0x58(%rbx), %rdx
xorl %esi, %esi
movq %r8, 0x30(%rsp)
callq 0x288228
shlq $0x20, %rax
orq %rax, %r13
leaq 0x148(%rsp), %rdi
movq %r13, %rsi
movl 0x8(%rsp), %r13d
callq 0x56d86
movq 0x30(%rsp), %r8
movq 0xd8(%rsp), %rdx
movq %rdx, 0x38(%rsp)
testb $0x1, %r14b
je 0x2c056f
xorl %r14d, %r14d
movl %r14d, 0xf0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xe0(%rsp)
movw $0x16, 0xf0(%rsp)
movl (%r8), %eax
movl %eax, 0xe0(%rsp)
movl %r14d, 0xe4(%rsp)
movl $0x1, %edx
leaq 0x60(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movq %r8, %r13
movq %r8, 0x30(%rsp)
callq 0x27fbec
movq 0x60(%rsp), %rcx
movl 0x68(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
movl 0x68(%rsp), %eax
incl %eax
movl %eax, 0x68(%rsp)
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x60(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x2c2a5e
movl -0x30(%r12), %edi
movq 0x38(%rbx), %rcx
movq 0x58(%rbx), %rdx
xorl %esi, %esi
callq 0x288228
movl %eax, %r13d
movl %r14d, 0xf0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xe0(%rsp)
movw $0x17, 0xf0(%rsp)
movl %eax, 0xe0(%rsp)
movl %r14d, 0xe4(%rsp)
leaq 0x60(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
leaq 0xe0(%rsp), %rsi
callq 0x27fbec
movq 0x60(%rsp), %rcx
movl 0x68(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x68(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
shlq $0x20, %r13
orq %rax, %r13
leaq 0x1b8(%rsp), %rdi
movq %r13, %rsi
movl 0x8(%rsp), %r13d
callq 0x56d86
jmp 0x2c0593
movl 0x68(%rsp), %eax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x60(%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r8, %rdx
movq %rbp, %rcx
callq 0x2c2a5e
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x27fbec
movq 0x60(%rsp), %rcx
movl 0x68(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x68(%rsp)
xorl %r14d, %r14d
movq %r12, %r8
xorl %eax, %eax
movq 0x38(%rsp), %rdx
addq $0x18, %r12
addq $-0x18, %r15
jne 0x2c0371
jmp 0x2c05f3
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x1c0(%rsp)
setne %cl
cmpl $0x0, 0x150(%rsp)
sete %al
andb %cl, %al
movq 0x28(%rsp), %r12
movl 0xc(%rsp), %ecx
testb %al, %al
je 0x2c07ae
cmpl %r13d, %ecx
jne 0x2c089d
movl %ecx, 0xc(%rsp)
movq 0x30(%rbx), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x170(%rdi)
movl $0x4fa, 0x174(%rdi) # imm = 0x4FA
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
movq %rcx, 0x120(%rsp)
movq %rax, 0x128(%rsp)
movq %rdi, 0x130(%rsp)
movw $0x1, 0x138(%rsp)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movl 0x1c0(%rsp), %r14d
testq %r14, %r14
je 0x2c077e
movq 0x1b8(%rsp), %rax
movq %rax, 0x38(%rsp)
shlq $0x3, %r14
xorl %r15d, %r15d
leaq 0xe0(%rsp), %r13
leaq 0x120(%rsp), %rbp
movq 0x38(%rsp), %rax
movq (%rax,%r15), %r12
movl $0x1, %ecx
movq %r13, %rdi
movl %r12d, %esi
leaq 0x8348c(%rip), %rdx # 0x343b77
xorl %r8d, %r8d
callq 0x10057a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x100668
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x2c0723
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x3c080
shrq $0x20, %r12
movl $0x1, %ecx
movq %r13, %rdi
movl %r12d, %esi
leaq 0x64b60(%rip), %rdx # 0x325299
xorl %r8d, %r8d
callq 0x10057a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x100668
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x2c0771
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x3c080
addq $0x8, %r15
cmpq %r15, %r14
jne 0x2c06d0
leaq 0x268(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x27fc7c
leaq 0x120(%rsp), %rdi
callq 0x9646e
movb $0x1, %bpl
movl 0xc(%rsp), %eax
movq %rax, 0x20(%rsp)
jmp 0x2c0891
cmpl $0x0, 0x150(%rsp)
je 0x2c089d
movq 0x30(%rbx), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x170(%rdi)
movl $0x4eb, 0x174(%rdi) # imm = 0x4EB
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
movq %rcx, 0xe0(%rsp)
movq %rax, 0xe8(%rsp)
movq %rdi, 0xf0(%rsp)
movw $0x1, 0xf8(%rsp)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movl 0x150(%rsp), %r14d
testq %r14, %r14
je 0x2c0882
movq 0x148(%rsp), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
leaq 0xe0(%rsp), %r13
leaq 0x120(%rsp), %rbp
movq (%r15,%r12), %rax
movq %rax, 0x120(%rsp)
movb $0x1, 0x128(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xe7ed8
addq $0x8, %r12
cmpq %r12, %r14
jne 0x2c085a
leaq 0xe0(%rsp), %rdi
callq 0x9646e
xorl %ebp, %ebp
movq 0x28(%rsp), %r12
movl 0x8(%rsp), %r13d
jmp 0x2c089f
xorl %ebp, %ebp
leaq 0x158(%rsp), %rax
movq 0x148(%rsp), %rdi
cmpq %rax, %rdi
je 0x2c08b9
callq 0x3c3a0
movq 0x1b8(%rsp), %rdi
leaq 0x1c8(%rsp), %rax
cmpq %rax, %rdi
je 0x2c08d3
callq 0x3c3a0
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x2c08e7
callq 0x3c3a0
testb %bpl, %bpl
je 0x2c0c31
testb $0x1, %r12b
je 0x2c0983
xorl %eax, %eax
movl %eax, 0x70(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movw $0x1, 0x70(%rsp)
movl 0x40(%rsp), %ecx
movl %ecx, 0x60(%rsp)
movl %eax, 0x64(%rsp)
movl %r13d, %ebp
subl 0x20(%rsp), %ebp
jbe 0x2c0983
movl %r13d, %r15d
movq %r12, %r14
leaq 0x268(%rsp), %r12
leaq 0x60(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x27fbec
movq 0x268(%rsp), %rcx
movl 0x270(%rsp), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x270(%rsp)
decl %ebp
jne 0x2c0937
movl %r15d, %r13d
movl %r15d, %eax
movq %rax, 0x20(%rsp)
movq %r14, %r12
cmpl %r13d, 0x20(%rsp)
jae 0x2c09b1
cmpl $0x1, %r13d
jne 0x2c0ab3
cmpl $0x0, 0x20(%rsp)
jne 0x2c0ab3
movq 0x18(%rsp), %rax
testb $0xc, 0x24(%rax)
setne %r14b
jmp 0x2c0db5
jbe 0x2c0be4
movq 0x18(%rsp), %rax
testb $0xc, 0x24(%rax)
setne %al
orb %r12b, %al
xorl %r14d, %r14d
testb $0x1, %al
jne 0x2c0e4c
movq 0x30(%rbx), %rdi
movq 0x10(%rsp), %r13
movl (%r13), %eax
movl %eax, 0x170(%rdi)
movl $0x4a0, 0x174(%rdi) # imm = 0x4A0
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
movl $0x178, %r15d # imm = 0x178
leaq (%rdi,%r15), %rax
leaq 0x1e8(%rsp), %r12
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %rdi, 0x10(%r12)
movw $0x1, %bp
movw %bp, 0x18(%r12)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4ef, 0x174(%rdi) # imm = 0x4EF
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
addq %rdi, %r15
movq %r15, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %rdi, 0x70(%rsp)
movw %bp, 0x78(%rsp)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
movl 0x10(%r13), %eax
jmp 0x2c0bce
testb $0x1, 0x5c(%rsp)
jne 0x2c0ac5
movq 0x18(%rsp), %rax
testb $0xc, 0x24(%rax)
je 0x2c0ae9
movq 0x20(%rsp), %rdx
leal 0x1(%rdx), %ecx
movl %r13d, %eax
xorl $0x2, %eax
orl %edx, %eax
sete %al
cmpl %r13d, %ecx
je 0x2c0c38
testb %al, %al
jne 0x2c0c38
xorl %r14d, %r14d
testb $0x1, %r12b
jne 0x2c0db5
movq 0x30(%rbx), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0x170(%rdi)
movl $0x49f, 0x174(%rdi) # imm = 0x49F
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
movl $0x178, %r15d # imm = 0x178
leaq (%rdi,%r15), %rax
leaq 0x208(%rsp), %r12
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %rdi, 0x10(%r12)
movw $0x1, %bp
movw %bp, 0x18(%r12)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
movl $0x388, %r13d # imm = 0x388
addq %r13, %rdi
callq 0x964b2
movq %r12, %rdi
callq 0x9646e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4ef, 0x174(%rdi) # imm = 0x4EF
movq %r14, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r14b, (%rax)
addq %rdi, %r15
movq %r15, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %rdi, 0x70(%rsp)
movw %bp, 0x78(%rsp)
movb %r14b, 0x178(%rdi)
movl %r14d, 0x320(%rdi)
addq %r13, %rdi
callq 0x964b2
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2c0bec
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2c0bec
xorl %ebx, %ebx
jmp 0x2c0bf5
xorl %r14d, %r14d
jmp 0x2c0e4c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rbx
cmpq $0x0, 0x60(%rsp)
jne 0x2c0c0c
movq 0x68(%rsp), %rdi
callq 0x9658c
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %rbx, 0x10(%rax,%rcx,8)
callq 0x9646e
xorl %ebx, %ebx
jmp 0x2c0e6f
movb $0x1, %r14b
movq 0x18(%rsp), %rax
testb $0x20, 0x24(%rax)
jne 0x2c0db5
movl %r13d, 0x8(%rsp)
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movl $0x52a, %eax # imm = 0x52A
btl $0xe, %ecx
jb 0x2c0c7c
movl $0x4bc, %eax # imm = 0x4BC
btl $0xa, %ecx
jb 0x2c0c7c
testb $0x8, %cl
movl $0x4b6, %ecx # imm = 0x4B6
movl $0x517, %eax # imm = 0x517
cmovel %ecx, %eax
movq 0x30(%rbx), %rdi
movl 0x40(%rsp), %ecx
movl %ecx, 0x170(%rdi)
movl %eax, 0x174(%rdi)
xorl %r15d, %r15d
movq %r15, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r15b, (%rax)
movl $0x178, %r12d # imm = 0x178
leaq (%rdi,%r12), %rax
leaq 0x228(%rsp), %r13
movq %rax, (%r13)
movq %r15, 0x8(%r13)
movq %rdi, 0x10(%r13)
movw $0x1, %bp
movw %bp, 0x18(%r13)
movb %r15b, 0x178(%rdi)
movl %r15d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
movq %r13, %rdi
callq 0x9646e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x30(%rbx), %rdi
movl %eax, 0x170(%rdi)
movl $0x4ef, 0x174(%rdi) # imm = 0x4EF
movq %r15, 0x158(%rdi)
movq 0x150(%rdi), %rax
movb %r15b, (%rax)
addq %rdi, %r12
movq %r12, 0x60(%rsp)
movq %r15, 0x68(%rsp)
movq %rdi, 0x70(%rsp)
movw %bp, 0x78(%rsp)
movb %r15b, 0x178(%rdi)
movl %r15d, 0x320(%rdi)
movl $0x388, %eax # imm = 0x388
addq %rax, %rdi
callq 0x964b2
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2c0d6b
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2c0d6b
xorl %r15d, %r15d
jmp 0x2c0d74
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r15
movl 0x8(%rsp), %r13d
cmpq $0x0, 0x60(%rsp)
jne 0x2c0d90
movq 0x68(%rsp), %rdi
callq 0x9658c
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r15, 0x10(%rax,%rcx,8)
callq 0x9646e
leaq 0x40(%rsp), %rsi
movl (%rsi), %eax
xorl %ecx, %ecx
movl %ecx, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movw $0x1, 0x10(%rsi)
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
leaq 0x268(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
callq 0x27fbec
movq (%r15), %rcx
movl 0x8(%r15), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%r15)
cmpl $0x2, %r13d
jne 0x2c0e4c
cmpl $0x0, 0x20(%rsp)
jne 0x2c0e4c
leaq 0x268(%rsp), %r15
leaq 0x40(%rsp), %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x27fbec
movq (%r15), %rcx
movl 0x8(%r15), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%r15)
movq 0x268(%rsp), %rsi
movl 0x270(%rsp), %edx
movzbl %r14b, %ecx
movq 0x18(%rsp), %rdi
movq %rbx, %r8
callq 0x2cda0e
movq %rax, %rbx
movq 0x268(%rsp), %rdi
leaq 0x278(%rsp), %rax
cmpq %rax, %rdi
je 0x2c0e89
callq 0x3c3a0
movq %rbx, %rax
addq $0x878, %rsp # imm = 0x878
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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())
Diag(Identifier, diag::err_pp_used_poisoned_id);
else
Diag(Identifier,it->second) << Identifier.getIdentifierInfo();
}
|
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 0xbc0(%r14), %ecx
shlq $0x4, %rcx
addq 0xbb0(%r14), %rcx
cmpq %rcx, %rax
je 0x2c8c5d
movl 0x8(%rax), %eax
movq 0x30(%r14), %rdi
movl (%rbx), %ecx
movl %ecx, 0x170(%rdi)
movl %eax, 0x174(%rdi)
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movw $0x1, 0x20(%rsp)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movl 0x10(%rbx), %eax
decl %eax
cmpw $0x13, %ax
jae 0x2c8c20
movl $0x7ffc1, %ecx # imm = 0x7FFC1
btl %eax, %ecx
jae 0x2c8c20
xorl %ebx, %ebx
jmp 0x2c8c24
movq 0x8(%rbx), %rbx
cmpq $0x0, 0x8(%rsp)
jne 0x2c8c3b
movq 0x10(%rsp), %rdi
callq 0x9658c
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movzbl (%rax), %ecx
movb $0x5, 0x1(%rax,%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %rbx, 0x10(%rax,%rcx,8)
jmp 0x2c8cc1
movq 0x30(%r14), %rdi
movl (%rbx), %eax
movl %eax, 0x170(%rdi)
movl $0x497, 0x174(%rdi) # imm = 0x497
xorl %eax, %eax
movq %rax, 0x158(%rdi)
movq 0x150(%rdi), %rcx
movb %al, (%rcx)
leaq 0x178(%rdi), %rcx
leaq 0x28(%rsp), %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rdi, 0x10(%rbx)
movw $0x1, 0x18(%rbx)
movb %al, 0x178(%rdi)
movl $0x0, 0x320(%rdi)
addq $0x388, %rdi # imm = 0x388
callq 0x964b2
movq %rbx, %rdi
callq 0x9646e
addq $0x48, %rsp
popq %rbx
popq %r14
retq
|
/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)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
addq $-0x18, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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 FileSystemStatCache::get(Path, Status, isFile, F,
StatCache.get(), *FS);
SmallString<128> FilePath(Path);
FixupRelativePath(FilePath);
return FileSystemStatCache::get(FilePath.c_str(), Status, isFile, F,
StatCache.get(), *FS);
}
|
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, %rdi
callq 0x58ba4
movq %r15, %rdi
movq %r13, %rsi
callq 0x2eb360
xorl %r12d, %r12d
movq %r13, %rdi
xorl %esi, %esi
callq 0x57aa0
decq 0x8(%r13)
movq (%r13), %r13
testq %r13, %r13
je 0x2ea867
movq %r13, %rdi
callq 0x3c190
movq %rax, %r12
movq 0x320(%r15), %r9
movq 0x8(%r15), %rax
movq %rax, (%rsp)
movzbl %bpl, %ecx
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x2ec1fa
movl %eax, %ebx
movq %rdx, %r14
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2ea8a4
callq 0x3c3a0
movl %ebx, %eax
movq %r14, %rdx
jmp 0x2ea8cf
movq 0x320(%r15), %r9
movq 0x8(%r15), %rax
movq %rax, (%rsp)
movzbl %bpl, %ecx
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x2ec1fa
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>::LookupBucketFor<llvm::sys::fs::UniqueID>(llvm::sys::fs::UniqueID const&, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*> const*&) const
|
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 whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
}
|
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, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movaps %xmm0, -0x40(%rcx)
movq $0x0, 0x30(%rcx)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
movq %rax, 0x38(%rcx)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rdi
movq %rsp, %r8
xorl %esi, %esi
movq %rdi, %rdx
callq 0x2eb972
decl %ebp
andl %ebp, %eax
movq (%r14), %rdx
movl $0x1, %esi
movl %eax, %edi
leaq (%rdi,%rdi,2), %rdi
leaq (%r15,%rdi,8), %rdi
movq (%rdi), %r9
movq 0x8(%rdi), %r8
cmpq %r9, %rdx
jne 0x2eb91a
cmpq %r8, 0x8(%r14)
jne 0x2eb91a
movq %rdi, (%rbx)
movb $0x1, %cl
xorl %edi, %edi
testb %dil, %dil
jne 0x2eb8f0
jmp 0x2eb95c
cmpq $-0x1, %r9
jne 0x2eb936
cmpq $-0x1, %r8
jne 0x2eb936
testq %r12, %r12
cmovneq %r12, %rdi
movq %rdi, (%rbx)
xorl %edi, %edi
xorl %ecx, %ecx
jmp 0x2eb913
xorq $-0x2, %r9
xorq $-0x2, %r8
orq %r9, %r8
orq %r12, %r8
cmoveq %rdi, %r12
addl %esi, %eax
incl %esi
andl %ebp, %eax
movb $0x1, %dil
jmp 0x2eb913
movq $0x0, (%rbx)
xorl %ecx, %ecx
andb $0x1, %cl
movl %ecx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, 4096ul, 128ul>&, llvm::ErrorOr<clang::DirectoryEntry&>&&)
|
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, (%r15)
movq %r15, %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x2ebcb6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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(%r14)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x30(%r14)
leaq 0x68(%r14), %rax
movq %rax, 0x58(%r14)
movups %xmm0, 0x60(%r14)
movq $0x1, 0x70(%r14)
movups %xmm0, 0x78(%r14)
movq %r15, 0x88(%r14)
leaq 0x98(%r14), %rax
movl $0x0, 0x98(%r14)
movq %r15, 0xa0(%r14)
movq %rax, 0xa8(%r14)
movq %rax, 0xb0(%r14)
movq %r15, 0xb8(%r14)
movq %r14, 0x1a0(%rbx)
movq 0x1a0(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
|
/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(Loc);
bool Invalid = false;
SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
if (!Entry.isFile() || Invalid)
return;
SrcMgr::FileInfo &FileInfo = Entry.getFile();
// Remember that this file has #line directives now if it doesn't already.
FileInfo.setHasLineDirectives();
(void) getLineTable();
unsigned EntryExit = 0;
if (IsFileEntry)
EntryExit = 1;
else if (IsFileExit)
EntryExit = 2;
LineTable->AddLineNote(LocInfo.first, LocInfo.second, LineNo, FilenameID,
EntryExit, FileKind);
}
|
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 $0x0, 0x13(%rsp)
jne 0x2f4e43
movl %ebx, 0x14(%rsp)
movq %r12, %rbx
shrq $0x20, %rbx
orb $-0x80, 0xf(%rax)
movq %r14, %rdi
callq 0x2f4cfa
movzbl %r13b, %eax
addl %eax, %eax
testb %r15b, %r15b
movl $0x1, %r9d
cmovel %eax, %r9d
movq 0x1a0(%r14), %rdi
movl 0x50(%rsp), %eax
movl %eax, (%rsp)
movl %r12d, %esi
movl %ebx, %edx
movl %ebp, %ecx
movl 0x14(%rsp), %r8d
callq 0x2f4b04
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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->setBuffer(std::move(Buffer));
return *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
movq %rax, (%rsi)
addq $0x8, 0xa8(%r14)
jmp 0x2f50b4
addq $0xa0, %r14
movq %rsp, %rdx
movq %r14, %rdi
callq 0x2f85ee
movq (%rsp), %rax
movq (%rbx), %rcx
movq $0x0, (%rbx)
andb $-0x9, 0x30(%rax)
movq (%rax), %rdi
movq %rcx, (%rax)
testq %rdi, %rdi
je 0x2f50d7
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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), %rax
shlq $0x3, %rax
addq 0xb8(%rbx), %rax
jmp 0x2f6110
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
subl %r14d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x955d4
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jne 0x2f611a
movl 0xc(%rax), %ecx
shrq $0x20, %r14
addl %ecx, %r14d
js 0x2f60c2
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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(%rip), %rax # 0x4b7c48
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x1b5b7f(%rip), %rax # 0x4b7ff8
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x1b58e9(%rip), %rax # 0x4b7d70
addq $0x10, %rax
movq %rax, 0x98(%r14)
movups %xmm0, 0xa0(%r14)
leaq -0x2a2d0d(%rip), %rax # 0x5f794
movq %rax, 0xb8(%r14)
leaq -0x2a2d19(%rip), %rax # 0x5f796
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x302ca0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5ca30
|
/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
orl %eax, %ecx
movw %cx, 0xa(%r14)
movq (%r15), %rax
movl (%rax), %ecx
movl %ecx, 0x80(%r14)
movb $0x1, 0x94(%r14)
movl (%rax), %eax
movl %eax, 0x90(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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
movb %al, 0x90(%r14)
movl (%r15), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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:
//
// -O2 or O2 or -la (where -l and -a are separate options)
//
// If this is the case, we cannot allow a value.
//
if (Owner.hasArgStr())
return ValueRequired;
else
return ValueDisallowed;
}
|
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::OptionHidden const&, llvm::cl::ValueExpected const&, llvm::cl::initializer<llvm::ChangePrinter> const&, llvm::cl::ValuesClass const&)
|
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)
movl (%rcx), %ecx
movl %ecx, 0x90(%rax)
movq %r8, %rdi
movq %rax, %rsi
jmp 0x30f098
nop
|
/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
addq $0x28, %r14
cmpq %r15, %r14
jne 0x30f0ba
popq %rbx
popq %r14
popq %r15
retq
|
/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::ValueExpected>(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 const&, llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::LocationClass<(anonymous namespace)::PassRemarksOpt> const&, llvm::cl::ValueExpected const&)
|
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)
je 0x30f99e
leaq 0x130cb(%rip), %rax # 0x322a41
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movw $0x103, 0x20(%r15) # imm = 0x103
callq 0x58b65
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x5d4fa
jmp 0x30f9a8
movq (%r8), %rax
movq %rax, 0x80(%rbx)
movl (%r14), %eax
movzwl 0xa(%rbx), %ecx
andl $0x3, %eax
andl $-0x19, %ecx
leal (%rcx,%rax,8), %eax
movw %ax, 0xa(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 = ConvertedThis.getValue();
APSInt OtherVal = ConvertedOther.getValue();
bool Overflowed = false;
// Widen the LHS and RHS so we can perform a full division.
// Also make sure that there will be enough space for the shift below to not
// overflow
unsigned Wide =
CommonFXSema.getWidth() * 2 + std::max(-CommonFXSema.getMsbWeight(), 0);
if (CommonFXSema.isSigned()) {
ThisVal = ThisVal.sext(Wide);
OtherVal = OtherVal.sext(Wide);
} else {
ThisVal = ThisVal.zext(Wide);
OtherVal = OtherVal.zext(Wide);
}
// Upscale to compensate for the loss of precision from division, and
// perform the full division.
if (CommonFXSema.getLsbWeight() < 0)
ThisVal = ThisVal.shl(-CommonFXSema.getLsbWeight());
else if (CommonFXSema.getLsbWeight() > 0)
OtherVal = OtherVal.shl(CommonFXSema.getLsbWeight());
APSInt Result;
if (CommonFXSema.isSigned()) {
APInt Rem;
APInt::sdivrem(ThisVal, OtherVal, Result, Rem);
// If the quotient is negative and the remainder is nonzero, round
// towards negative infinity by subtracting epsilon from the result.
if (ThisVal.isNegative() != OtherVal.isNegative() && !Rem.isZero())
Result = Result - 1;
} else
Result = ThisVal.udiv(OtherVal);
Result.setIsSigned(CommonFXSema.isSigned());
// If our result lies outside of the representative range of the common
// semantic, we either have overflow or saturation.
APSInt Max = APFixedPoint::getMax(CommonFXSema).getValue()
.extOrTrunc(Wide);
APSInt Min = APFixedPoint::getMin(CommonFXSema).getValue()
.extOrTrunc(Wide);
if (CommonFXSema.isSaturated()) {
if (Result < Min)
Result = Min;
else if (Result > Max)
Result = Max;
} else
Overflowed = Result < Min || Result > Max;
if (Overflow)
*Overflow = Overflowed;
return APFixedPoint(Result.sextOrTrunc(CommonFXSema.getWidth()),
CommonFXSema);
}
|
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)
xorl %ebx, %ebx
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x31521a
leaq 0x100(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x31521a
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x8719e
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x8719e
movl (%r15), %eax
movzwl %ax, %ecx
leal (,%rax,8), %edx
sarl $0x13, %edx
addl %ecx, %edx
movl $0x1, %esi
subl %edx, %esi
testl %esi, %esi
cmovlel %ebx, %esi
leal (%rsi,%rcx,2), %ebp
btl $0x1d, %eax
jb 0x316690
leaq 0x98(%rsp), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
movl %ebp, %edx
callq 0x71560
cmpl $0x41, 0x8(%r15)
jb 0x316651
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x316651
callq 0x3c180
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0xa0(%rsp)
leaq 0x118(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x71560
jmp 0x3166fa
leaq 0xa8(%rsp), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
movl %ebp, %edx
callq 0x72292
cmpl $0x41, 0x8(%r15)
jb 0x3166bd
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3166bd
callq 0x3c180
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0xb0(%rsp)
leaq 0x128(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x72292
cmpl $0x41, 0x8(%r12)
movq %r14, %r13
jae 0x31670c
movq 0x38(%rsp), %r14
jmp 0x316720
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
movq 0x38(%rsp), %r14
je 0x316720
callq 0x3c180
movq (%r15), %rax
movq %rax, 0x28(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x30(%rsp)
movl $0x0, 0x8(%r15)
movl 0x14(%rsp), %eax
shll $0x3, %eax
movl %eax, %edx
sarl $0x13, %edx
js 0x31678b
cmpl $0x80000, %eax # imm = 0x80000
jb 0x3167d7
leaq 0xe0(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0xbfb8c
cmpl $0x41, 0x8(%r15)
jb 0x31677c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x31677c
callq 0x3c180
leaq 0xe8(%rsp), %rax
leaq 0x30(%rsp), %rcx
jmp 0x3167c5
negl %edx
leaq 0xf0(%rsp), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0xbfb8c
cmpl $0x41, 0x8(%r15)
jb 0x3167b8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3167b8
callq 0x3c180
leaq 0xf8(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq -0x8(%rax), %rdx
movq %rdx, -0x8(%rcx)
movl (%rax), %edx
movl %edx, (%rcx)
movl $0x0, (%rax)
movl $0x1, 0x8(%rsp)
movq $0x0, (%rsp)
movb $0x0, 0xc(%rsp)
testb $0x20, 0x17(%rsp)
jne 0x316846
leaq 0x88(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x7288a
cmpl $0x41, 0x8(%rsp)
jb 0x31681f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31681f
callq 0x3c180
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0x90(%rsp)
jmp 0x316993
leaq 0x50(%rsp), %rcx
movl $0x1, 0x8(%rcx)
movq $0x0, (%rcx)
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r15
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x73d2a
cmpb $0x0, 0xc(%r12)
je 0x31687d
xorl %eax, %eax
jmp 0x3168a2
movl 0x20(%rsp), %eax
leal -0x1(%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $-0x8, %edx
addq 0x18(%rsp), %rdx
cmpl $0x41, %eax
cmovbq %r12, %rdx
movq (%rdx), %rax
btq %rcx, %rax
setb %al
cmpb $0x0, 0x34(%rsp)
je 0x3168ad
xorl %ecx, %ecx
jmp 0x3168d2
movl 0x30(%rsp), %ecx
leal -0x1(%rcx), %edx
movl %edx, %esi
shrl $0x3, %esi
andl $-0x8, %esi
addq 0x28(%rsp), %rsi
cmpl $0x41, %ecx
cmovbq %r15, %rsi
movq (%rsi), %rcx
btq %rdx, %rcx
setb %cl
cmpb %cl, %al
je 0x31697d
movl 0x58(%rsp), %ebx
cmpl $0x40, %ebx
ja 0x3168eb
cmpq $0x0, 0x50(%rsp)
jmp 0x3168f7
leaq 0x50(%rsp), %rdi
callq 0x71b6c
cmpl %ebx, %eax
sete %al
testb %al, %al
jne 0x31697d
movl 0x8(%rsp), %eax
movl %eax, 0x80(%rsp)
cmpl $0x40, %eax
ja 0x316919
movq (%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x316926
leaq 0x78(%rsp), %rdi
movq %rsp, %rsi
callq 0x70bce
leaq 0x78(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdi
callq 0x7107e
movl 0x8(%r15), %ebx
movq (%r15), %r12
movl $0x0, 0x8(%r15)
cmpl $0x41, 0x8(%rsp)
jb 0x31695c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31695c
callq 0x3c180
movq %r12, (%rsp)
movl %ebx, 0x8(%rsp)
cmpl $0x41, 0x80(%rsp)
jb 0x31697d
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x31697d
callq 0x3c180
cmpl $0x41, 0x58(%rsp)
jb 0x316993
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x316993
callq 0x3c180
leaq 0x14(%rsp), %rsi
btl $0x1d, (%rsi)
setae 0xc(%rsp)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x315974
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8719e
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x894e0
cmpl $0x41, 0x8(%r12)
jb 0x3169e4
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3169e4
callq 0x3c180
cmpl $0x41, 0x58(%rsp)
jb 0x3169fa
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x3169fa
callq 0x3c180
leaq 0x50(%rsp), %r15
leaq 0x14(%rsp), %rsi
movq %r15, %rdi
callq 0x315a2a
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8719e
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x894e0
cmpl $0x41, 0x8(%r12)
jb 0x316a48
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x316a48
callq 0x3c180
cmpl $0x41, 0x58(%rsp)
jb 0x316a5e
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x316a5e
callq 0x3c180
testb $0x40, 0x17(%rsp)
movb 0xc(%rsp), %bpl
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
jne 0x316a7e
testb %bpl, %bpl
je 0x316a8a
callq 0x713b0
jmp 0x316a8f
testb %bpl, %bpl
je 0x316aa7
callq 0x713b0
jmp 0x316aac
callq 0x71422
testl %eax, %eax
js 0x316ac4
movq %rsp, %rdi
leaq 0x68(%rsp), %rsi
testb %bpl, %bpl
je 0x316ad2
callq 0x713b0
jmp 0x316ad7
callq 0x71422
testl %eax, %eax
js 0x316ac8
movq %rsp, %rdi
leaq 0x68(%rsp), %rsi
testb %bpl, %bpl
je 0x316ade
callq 0x713b0
jmp 0x316ae3
movb $0x1, %al
jmp 0x316b05
movq %rsp, %r15
leaq 0x40(%rsp), %r12
jmp 0x316aef
callq 0x71422
testl %eax, %eax
setg %al
jmp 0x316b05
callq 0x71422
testl %eax, %eax
jle 0x316b03
movq %rsp, %r15
leaq 0x68(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x717ba
movb 0xc(%r12), %al
movb %al, 0xc(%r15)
xorl %eax, %eax
testq %r14, %r14
je 0x316b0d
movb %al, (%r14)
leaq 0x14(%rsp), %r14
movzwl (%r14), %edx
leaq 0x50(%rsp), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x723ce
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1080b6
cmpl $0x41, 0x8(%r15)
jb 0x316b4a
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x316b4a
callq 0x3c180
cmpl $0x41, 0x48(%rsp)
jb 0x316b60
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x316b60
callq 0x3c180
cmpl $0x41, 0x70(%rsp)
jb 0x316b76
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x316b76
callq 0x3c180
cmpl $0x41, 0x8(%rsp)
jb 0x316b8b
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x316b8b
callq 0x3c180
cmpl $0x41, 0x30(%rsp)
jb 0x316ba1
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x316ba1
callq 0x3c180
cmpl $0x41, 0x20(%rsp)
jb 0x316bb7
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x316bb7
callq 0x3c180
cmpl $0x41, 0x108(%rsp)
jb 0x316bd3
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0x316bd3
callq 0x3c180
cmpl $0x41, 0xc0(%rsp)
jb 0x316bef
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x316bef
callq 0x3c180
movq %r13, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x56cf6
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x3194e2
movq %rax, %rbx
movq (%rbp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x31963b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3c080
jmp 0x31963b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 (%r15), %rsi
incq %rsi
callq 0xe6570
movq %r14, %rdi
callq 0xeb220
|
/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 0x1f2dc(%rip), %r9 # 0x1266de
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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;
m_base.init(is_arithmetic, is_convertible);
def(init([](Scalar i) { return static_cast<Type>(i); }), arg("value"));
def("__int__", [](Type value) { return (Scalar) value; });
#if PY_MAJOR_VERSION < 3
def("__long__", [](Type value) { return (Scalar) value; });
#endif
#if PY_MAJOR_VERSION > 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 8)
def("__index__", [](Type value) { return (Scalar) value; });
#endif
attr("__setstate__") = cpp_function(
[](detail::value_and_holder &v_h, Scalar arg) {
detail::initimpl::setstate<Base>(v_h, static_cast<Type>(arg),
Py_TYPE(v_h.inst) != v_h.type->type); },
detail::is_new_style_constructor(),
pybind11::name("__setstate__"), is_method(*this), arg("state"));
}
|
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), %r8
movq %rax, (%r8)
movb $0x2, 0x8(%r8)
leaq 0x2705cb(%rip), %rsi # 0x378ee0
leaq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x12deec
leaq 0x26fefd(%rip), %rsi # 0x37882b
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12daee
leaq 0x26fef1(%rip), %rsi # 0x378833
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dbcc
leaq 0x26fee7(%rip), %r14 # 0x37883d
leaq 0x48(%rsp), %rcx
movq %r14, (%rcx)
movq (%rbx), %rax
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
leaq 0x298e1f(%rip), %rax # 0x3a178f
leaq 0x30(%rsp), %r9
movq %rax, (%r9)
movb $0x2, 0x8(%r9)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rsi
leaq 0x6(%rsp), %rdx
callq 0x12dcaa
movq (%rbx), %rdi
leaq 0x28(%rsp), %r15
movq %rdi, -0x10(%r15)
movq %r14, -0x8(%r15)
movq $0x0, (%r15)
movq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x11cc42
movq %r15, %rdi
callq 0x13ee80
leaq 0x8(%rsp), %rdi
callq 0x13ee80
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x13ee80
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x1089f3
jmp 0x1089f0
jmp 0x1089f0
jmp 0x1089f0
jmp 0x1089f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x13ee80
movq %r14, %rdi
callq 0xeb220
nop
|
/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;
m_base.init(is_arithmetic, is_convertible);
def(init([](Scalar i) { return static_cast<Type>(i); }), arg("value"));
def("__int__", [](Type value) { return (Scalar) value; });
#if PY_MAJOR_VERSION < 3
def("__long__", [](Type value) { return (Scalar) value; });
#endif
#if PY_MAJOR_VERSION > 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 8)
def("__index__", [](Type value) { return (Scalar) value; });
#endif
attr("__setstate__") = cpp_function(
[](detail::value_and_holder &v_h, Scalar arg) {
detail::initimpl::setstate<Base>(v_h, static_cast<Type>(arg),
Py_TYPE(v_h.inst) != v_h.type->type); },
detail::is_new_style_constructor(),
pybind11::name("__setstate__"), is_method(*this), arg("state"));
}
|
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), %r8
movq %rax, (%r8)
movb $0x2, 0x8(%r8)
leaq 0x2703ef(%rip), %rsi # 0x378ee0
leaq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x12e968
leaq 0x26fd21(%rip), %rsi # 0x37882b
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12e56a
leaq 0x26fd15(%rip), %rsi # 0x378833
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12e648
leaq 0x26fd0b(%rip), %r14 # 0x37883d
leaq 0x48(%rsp), %rcx
movq %r14, (%rcx)
movq (%rbx), %rax
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
leaq 0x298c43(%rip), %rax # 0x3a178f
leaq 0x30(%rsp), %r9
movq %rax, (%r9)
movb $0x2, 0x8(%r9)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rsi
leaq 0x6(%rsp), %rdx
callq 0x12e726
movq (%rbx), %rdi
leaq 0x28(%rsp), %r15
movq %rdi, -0x10(%r15)
movq %r14, -0x8(%r15)
movq $0x0, (%r15)
movq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x11cc42
movq %r15, %rdi
callq 0x13ee80
leaq 0x8(%rsp), %rdi
callq 0x13ee80
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x13ee80
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x108bcf
jmp 0x108bcc
jmp 0x108bcc
jmp 0x108bcc
jmp 0x108bcc
movq %rax, %r14
movq %rbx, %rdi
callq 0x13ee80
movq %r14, %rdi
callq 0xeb220
nop
|
/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(*this)),
fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
return *this;
}
|
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
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1364e4
leaq 0x20(%rsp), %r9
movb $0x6, (%r9)
movq (%rbx), %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x135eae
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x109c65
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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, %r12
jmp 0x10abbf
callq 0xe61d0
movq %r12, 0x8(%rsp)
incq (%r12)
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x139c9a
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x10ac41
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x10ac3c
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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 %rax, %rax
je 0x10b052
movq %rax, 0x8(%rsp)
movq %rax, %rbp
jmp 0x10b060
callq 0xe61d0
movq %rbp, 0x8(%rsp)
incq (%rbp)
leaq 0x30(%rsp), %r8
movq %rbp, (%r8)
movq %r13, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x13a49c
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x10b0ec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x10b0e7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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&, pybind11::arg_v 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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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)
callq 0xe19b0
testq %rax, %rax
je 0x10bd5f
movq %rax, (%rsp)
movq %rax, %r15
jmp 0x10bd6b
callq 0xe61d0
movq %r15, (%rsp)
incq (%r15)
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %r10
leaq 0x30(%rsp), %r8
movq %r15, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r10
pushq %r12
pushq 0x30(%rsp)
callq 0x13c050
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10be06
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13ee80
jmp 0x10be01
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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
movq %rax, (%rsp)
movq %rax, %r13
jmp 0x10cc84
callq 0xe61d0
movq %r13, (%rsp)
incq (%r13)
leaq 0x28(%rsp), %r8
movq %r13, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x13dc18
movq %rsp, %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10cd07
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13ee80
jmp 0x10cd02
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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
movq %rax, (%rsp)
movq %rax, %r13
jmp 0x10d11c
callq 0xe61d0
movq %r13, (%rsp)
incq (%r13)
leaq 0x28(%rsp), %r8
movq %r13, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x13ea42
movq %rsp, %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10d19f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13ee80
jmp 0x10d19a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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, %r12
jmp 0x10dbf3
callq 0xe61d0
movq %r12, 0x8(%rsp)
incq (%r12)
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x146002
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x10dc75
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x10dc70
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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, %r12
jmp 0x10eec1
callq 0xe61d0
movq %r12, 0x8(%rsp)
incq (%r12)
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x121cfe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x121482
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x10ef3e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x10ef39
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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
garbage collector (the GC will call type_traverse(), which will in
turn find the newly constructed type in an invalid state) */
auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
if (!heap_type)
pybind11_fail("make_static_property_type(): error allocating type!");
heap_type->ht_name = name_obj.inc_ref().ptr();
#ifdef PYBIND11_BUILTIN_QUALNAME
heap_type->ht_qualname = name_obj.inc_ref().ptr();
#endif
auto type = &heap_type->ht_type;
type->tp_name = name;
type->tp_base = type_incref(&PyProperty_Type);
type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
type->tp_descr_get = pybind11_static_get;
type->tp_descr_set = pybind11_static_set;
if (PyType_Ready(type) < 0)
pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
return type;
}
|
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, (%r15)
movq %r15, 0x350(%rbx)
movq %r15, 0x360(%rbx)
movq %r14, 0x18(%rbx)
movq 0x35b784(%rip), %rax # 0x46c100
incq (%rax)
movq %rax, 0x100(%rbx)
movq $0x600, 0xa8(%rbx) # imm = 0x600
leaq 0x26c3(%rip), %rax # 0x11305b
movq %rax, 0x110(%rbx)
leaq 0x26c8(%rip), %rax # 0x11306e
movq %rax, 0x118(%rbx)
movq %rbx, %rdi
callq 0xe8ce0
testl %eax, %eax
js 0x110a0a
leaq 0x268464(%rip), %rsi # 0x378e24
movq %rsp, %rdi
callq 0x112ec6
movq (%rsp), %rdx
leaq 0x268446(%rip), %rsi # 0x378e19
movq %rbx, %rdi
callq 0xe7fa0
testl %eax, %eax
jne 0x110a16
movq %rsp, %rdi
callq 0x13ee80
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2683a8(%rip), %rdi # 0x378dad
callq 0x10f674
leaq 0x2683d0(%rip), %rdi # 0x378de1
callq 0x10f674
movl $0x28, %edi
callq 0xe2be0
movq %rax, %r14
movq %rax, %rdi
callq 0x11127e
leaq 0x3531ee(%rip), %rsi # 0x463c20
leaq 0x913(%rip), %rdx # 0x11134c
movq %r14, %rdi
callq 0xeacb0
movq %rax, %rbx
movq %r14, %rdi
callq 0xe4570
jmp 0x110a53
jmp 0x110a5f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13ee80
jmp 0x110a62
jmp 0x110a5f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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("Unable to move from Python " + (std::string) str(type::handle_of(obj)) +
" instance to C++ " + type_id<T>() + " instance: instance has multiple references");
#endif
// Move into a temporary and return that, because the reference may be a local value of `conv`
T ret = std::move(detail::load_type<T>(obj).operator T&());
return ret;
}
|
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, %edi
callq 0xe2be0
movq %rax, %rbx
movq (%r14), %rax
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x111e76
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x111ee0
leaq 0x26634a(%rip), %rsi # 0x378cb4
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xeaa90
leaq 0x26634d(%rip), %rsi # 0x378cd0
leaq 0x90(%rsp), %rdi
callq 0xec000
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1129b1
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1129be
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rdi
callq 0x100dd4
leaq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0xe5420
leaq 0x2662e4(%rip), %rsi # 0x378ce2
leaq 0xb0(%rsp), %rdi
callq 0xec000
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x112a2e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x112a3b
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xe7c40
leaq 0x351207(%rip), %rax # 0x463c70
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x351193(%rip), %rsi # 0x463c08
movq 0x35a994(%rip), %rdx # 0x46d410
movq %rbx, %rdi
callq 0xeacb0
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x112aa6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xe6570
jmp 0x112aa6
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x112acf
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0xe6570
jmp 0x112acf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x112af8
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xe6570
jmp 0x112af8
movq %rax, %r14
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x112b17
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xe6570
jmp 0x112b17
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x112b38
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0xe6570
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x112b5c
jmp 0x112b69
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %bpl
cmpq %rax, %rdi
je 0x112b7d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xe6570
leaq 0x8(%rsp), %rdi
callq 0x13ee80
testb %bpl, %bpl
jne 0x112b8c
jmp 0x112b94
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x112b8c
movq %rax, %r14
movq %rbx, %rdi
callq 0xe4570
movq %r14, %rdi
callq 0xeb220
|
/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, pybind11::object)&&, pybind11::object (*)(pybind11::object, pybind11::object), pybind11::name const&, pybind11::is_method const&, pybind11::arg 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, %rdi
movq %r13, %rsi
callq 0x11e9c2
leaq 0x25abed(%rip), %rdx # 0x37aad6
leaq 0x344048(%rip), %rcx # 0x463f38
movl $0x2, %r8d
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11473e
|
/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::object)&&, bool (*)(pybind11::object, pybind11::object), pybind11::name const&, pybind11::is_method const&, pybind11::arg 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, %rdi
movq %r13, %rsi
callq 0x11e9c2
leaq 0x25a64a(%rip), %rdx # 0x37ab01
leaq 0x343ad2(%rip), %rcx # 0x463f90
movl $0x2, %r8d
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11473e
|
/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::object)&&, bool (*)(pybind11::object, pybind11::object), pybind11::name const&, pybind11::is_method const&, pybind11::arg 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, %rdi
movq %r13, %rsi
callq 0x11e9c2
leaq 0x259c6f(%rip), %rdx # 0x37ab60
leaq 0x343110(%rip), %rcx # 0x464008
movl $0x2, %r8d
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11473e
|
/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, %r12
jmp 0x123df5
callq 0xe61d0
movq %r12, 0x8(%rsp)
incq (%r12)
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x124556
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x121482
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x123e72
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x123e6d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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 $0x1, %al
jne 0x127fea
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x12801e
callq 0xe1080
jmp 0x12802b
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x127ffd
movl $0x4, %esi
callq 0xe6570
movq $0x0, 0x8(%r14)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x128025
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x12802b
callq 0xe6570
jmp 0x12802b
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
movq %rsp, %rdi
callq 0x111fb0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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, %r12
jmp 0x12883f
callq 0xe61d0
movq %r12, 0x8(%rsp)
incq (%r12)
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x128eba
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x121482
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x1288bc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x1288b7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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), %rcx
orb $0x1, (%rax,%rcx)
retq
orb $0x4, %cl
movb %cl, 0x30(%rax)
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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 $0x1, %al
jne 0x129f5e
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x129f92
callq 0xe1080
jmp 0x129f9f
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x129f71
movl $0x4, %esi
callq 0xe6570
movq $0x0, 0x8(%r14)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x129f99
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x129f9f
callq 0xe6570
jmp 0x129f9f
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
movq %rsp, %rdi
callq 0x111fb0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 (%rax), %rdx
cmpq 0x3328f6(%rip), %rsi # 0x46a9a8
je 0x1380c8
andl $0x2, %edx
shrl %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1123c2
testb $0x2, %dl
je 0x1380d5
movb $0x1, 0x20(%rbx)
movb $0x1, %al
jmp 0x1380d7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 0x8c(%rip), %r9 # 0x1385d0
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
movq %rax, 0x10(%r14)
movq %r15, 0x18(%r14)
leaq 0x20(%r14), %r15
leaq 0x30(%r14), %r12
movq %r12, 0x20(%r14)
movl $0x6f6f4234, 0x30(%r14) # imm = 0x6F6F4234
movw $0x6c, 0x34(%r14)
movq $0x5, 0x28(%r14)
movq %r15, %rdi
callq 0x1125c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1385a9
movq (%r12), %rsi
incq %rsi
callq 0xe6570
movq %rbx, %rdi
callq 0x13ee80
movq %r14, %rdi
callq 0xeb220
nop
|
/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 const&, float), bool (*)(char const*, int, int, ImVec2 const&, float), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::arg_v 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x13c152
leaq 0x240953(%rip), %rdx # 0x37ca6d
leaq 0x32957f(%rip), %rcx # 0x4656a0
movl $0x5, %r8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11473e
orb $0x4, 0x59(%r14)
leaq 0x329582(%rip), %rax # 0x4656c0
movq %rax, 0x40(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, (%rbp)
movq (%r14), %rax
movq %rax, 0x70(%rbp)
movq (%rbx), %rax
movq %rax, 0x78(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rbp)
leaq 0x23fa6f(%rip), %rdx # 0x37cbd5
leaq 0x23fa73(%rip), %rcx # 0x37cbe0
movq %r13, %rdi
movq %rbp, %rsi
xorl %r8d, %r8d
callq 0x11473e
orb $0x4, 0x59(%rbp)
movq 0x32be62(%rip), %rax # 0x468fe8
movq %rax, 0x40(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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&, pybind11::arg const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::arg_v const&, pybind11::detail::function_record*)
|
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, (%r14)
movq (%rsi), %rax
movq %rax, 0x70(%r14)
movq (%rdx), %rax
movq %rax, 0x78(%r14)
movq %rcx, %rdi
movq %r14, %rsi
callq 0x11e9c2
movq %rbp, %rdi
movq %r14, %rsi
callq 0x11e9c2
movq %r13, %rdi
movq %r14, %rsi
callq 0x138742
movq %r15, %rdi
movq %r14, %rsi
callq 0x138742
movq %rbx, %rdi
movq %r14, %rsi
callq 0x138742
movq %r12, %rdi
movq %r14, %rsi
callq 0x138742
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x138742
movq 0x10(%rsp), %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x138742
|
/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*), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg const&, pybind11::arg_v const&, pybind11::arg_v 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r9
callq 0x139932
leaq 0x2383fb(%rip), %rdx # 0x37cdd8
leaq 0x320ecc(%rip), %rcx # 0x4658b0
movl $0x3, %r8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11473e
orb $0x4, 0x59(%r14)
leaq 0x320ecf(%rip), %rax # 0x4658d0
movq %rax, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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), %rax
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
jmp 0x147c3a
testb $0x1, %dl
je 0x147c52
movb $0x1, 0x28(%rbx)
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x131912
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, (%rbp)
movq (%r14), %rax
movq %rax, 0x70(%rbp)
movq (%rbx), %rax
movq %rax, 0x78(%rbp)
leaq 0x235554(%rip), %rdx # 0x37d241
leaq 0x23556c(%rip), %rcx # 0x37d260
movl $0x2, %r8d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x11473e
orb $0x4, 0x59(%rbp)
movq 0x326e70(%rip), %rax # 0x46eb80
movq %rax, 0x40(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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, (%rbp)
movq (%r14), %rax
movq %rax, 0x70(%rbp)
movq (%rbx), %rax
movq %rax, 0x78(%rbp)
leaq 0x235204(%rip), %rdx # 0x37d2b7
leaq 0x31dc06(%rip), %rcx # 0x465cc0
movl $0x3, %r8d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x11473e
orb $0x4, 0x59(%rbp)
leaq 0x31dc12(%rip), %rax # 0x465ce8
movq %rax, 0x40(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 $0x10, %rbx
cmpq %rbx, %rdi
je 0x14f911
movq (%rbx), %rsi
incq %rsi
callq 0xe6570
movq %r14, %rdi
callq 0xeb220
|
/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 0x6b74(%rip), %r9 # 0x158966
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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 0x741a(%rip), %r9 # 0x1593e8
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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 0x7cc4(%rip), %r9 # 0x159e6a
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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 0x8e18(%rip), %r9 # 0x15b36e
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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 0x96c2(%rip), %r9 # 0x15bdf0
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x122554
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x121efe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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(*this)),
fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
return *this;
}
|
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
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15e7d6
leaq 0x20(%rsp), %r9
movb $0x6, (%r9)
movq (%rbx), %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15ea4c
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x152e69
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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(*this)),
fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
return *this;
}
|
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
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15f1d0
leaq 0x20(%rsp), %r9
movb $0x6, (%r9)
movq (%rbx), %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15f446
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x152fdb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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
// overwriting (and has already checked internally that it isn't overwriting non-functions).
add_object(name_, func, true /* overwrite */);
return *this;
}
|
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 %rax, %rax
je 0x15730c
movq %rax, 0x8(%rsp)
movq %rax, %rbp
jmp 0x15731a
callq 0xe61d0
movq %rbp, 0x8(%rsp)
incq (%rbp)
leaq 0x30(%rsp), %r8
movq %rbp, (%r8)
movq %r13, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x16efbe
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x138224
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x1573a6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x1573a1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
nop
|
/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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq $0x8, 0x28(%rsi)
leaq 0x253(%rip), %rax # 0x158c24
movq %rax, 0x38(%rsi)
leaq 0x34a(%rip), %rax # 0x158d26
movq %rax, 0x40(%rsi)
orb $0x8, 0x60(%rsi)
movq %r14, 0x50(%rsi)
movq %rbx, %rdi
callq 0x10f180
leaq 0x48(%rsp), %rdi
callq 0x13ee80
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x13ee80
jmp 0x158a18
movq %rax, %r14
movq %rbx, %rdi
callq 0x13ee80
movq %r14, %rdi
callq 0xeb220
|
/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), pybind11::detail::void_type ()>::execute<pybind11::class_<ImPlotStyleVar_>, pybind11::arg>(pybind11::class_<ImPlotStyleVar_>&, pybind11::arg const&) &&::'lambda'(pybind11::detail::value_and_holder&, unsigned int), pybind11::detail::is_new_style_constructor, pybind11::arg>(char const*, pybind11::class_<ImPlotStyleVar_>&&, pybind11::arg const&)
|
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 %rax, %rax
je 0x15a378
movq %rax, 0x8(%rsp)
movq %rax, %rbp
jmp 0x15a386
callq 0xe61d0
movq %rbp, 0x8(%rsp)
incq (%rbp)
leaq 0x30(%rsp), %r8
movq %rbp, (%r8)
movq %r13, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x15a41a
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x121482
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x15a40d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x15a408
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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_ (unsigned int), pybind11::detail::void_type ()>::execute<pybind11::class_<ImPlotOrientation_>, pybind11::arg>(pybind11::class_<ImPlotOrientation_>&, pybind11::arg const&) &&::'lambda'(pybind11::detail::value_and_holder&, unsigned int), pybind11::detail::is_new_style_constructor, pybind11::arg>(char const*, pybind11::class_<ImPlotOrientation_>&&, pybind11::arg const&)
|
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 %rax, %rax
je 0x15cd80
movq %rax, 0x8(%rsp)
movq %rax, %rbp
jmp 0x15cd8e
callq 0xe61d0
movq %rbp, 0x8(%rsp)
incq (%rbp)
leaq 0x30(%rsp), %r8
movq %rbp, (%r8)
movq %r13, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r15, %r9
callq 0x15ce22
leaq 0x8(%rsp), %rdi
callq 0x13ee80
leaq 0x18(%rsp), %rdi
callq 0x13ee80
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x121482
leaq 0x10(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x15ce15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13ee80
jmp 0x15ce10
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13ee80
movq %rbx, %rdi
callq 0xeb220
|
/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::detail::is_new_style_constructor>(pybind11::class_<ImPlotPoint>&&, void (*)(pybind11::detail::value_and_holder&), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor 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();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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), %rdx
movq %rdx, 0x70(%rax)
movq (%rbx), %rdx
movq %rdx, 0x78(%rax)
orl $0x12, %ecx
movw %cx, 0x59(%rax)
leaq 0x223578(%rip), %rdx # 0x381679
leaq 0x307f30(%rip), %rcx # 0x466038
movl $0x1, %r8d
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11473e
|
/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_EMIT_RET_GETTER(bool);
VG_EMIT_RET_GETTER(float);
VG_EMIT_RET_GETTER(double);
VG_EMIT_RET_GETTER(int8_t);
VG_EMIT_RET_GETTER(uint8_t);
VG_EMIT_RET_GETTER(int16_t);
VG_EMIT_RET_GETTER(uint16_t);
VG_EMIT_RET_GETTER(int32_t);
VG_EMIT_RET_GETTER(uint32_t);
VG_EMIT_RET_GETTER(int64_t);
VG_EMIT_RET_GETTER(uint64_t);
throw std::runtime_error(error_type);
#undef VG_EMIT_RET_GETTER
}
|
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 0x16695a
movq %rbx, %rdi
callq 0x166c7a
testb %al, %al
je 0x16685c
leaq 0x1959(%rip), %rax # 0x1681b0
jmp 0x16695a
movq 0x98(%r14), %rax
cmpq $0x1, %rax
jne 0x1668b2
leaq 0xa8(%r14), %r15
leaq 0x21b7ae(%rip), %rsi # 0x382025
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x166975
movq 0x98(%r14), %rax
cmpq $0x1, %rax
jne 0x1668b2
leaq 0x21b78c(%rip), %rsi # 0x382027
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x166990
movq 0x98(%r14), %rax
cmpq $0x2, %rax
jne 0x166901
leaq 0xa8(%r14), %r15
leaq 0x21b763(%rip), %rsi # 0x382029
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x16697e
movq 0x98(%r14), %rax
cmpq $0x2, %rax
jne 0x166901
leaq 0x21b741(%rip), %rsi # 0x38202b
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x166999
movq 0x98(%r14), %rax
cmpq $0x4, %rax
jne 0x16693e
leaq 0xa8(%r14), %r15
leaq 0x21b718(%rip), %rsi # 0x38202d
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x166987
cmpq $0x4, 0x98(%r14)
jne 0x16693e
leaq 0x21b6fd(%rip), %rsi # 0x38202f
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x1669a2
movq %rbx, %rdi
callq 0x167ad4
testb %al, %al
je 0x166960
leaq 0x1937(%rip), %rax # 0x168288
jmp 0x16695a
leaq 0x181a(%rip), %rax # 0x168174
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x167d28
testb %al, %al
je 0x1669ab
leaq 0x1933(%rip), %rax # 0x1682a6
jmp 0x16695a
leaq 0x1850(%rip), %rax # 0x1681cc
jmp 0x16695a
leaq 0x1887(%rip), %rax # 0x16820c
jmp 0x16695a
leaq 0x18be(%rip), %rax # 0x16824c
jmp 0x16695a
leaq 0x1855(%rip), %rax # 0x1681ec
jmp 0x16695a
leaq 0x188c(%rip), %rax # 0x16822c
jmp 0x16695a
leaq 0x18bf(%rip), %rax # 0x168268
jmp 0x16695a
movl $0x10, %edi
callq 0xe2be0
movq %rax, %rbx
leaq 0x21a840(%rip), %rsi # 0x3811ff
movq %rax, %rdi
callq 0xe2100
movq 0x30a48a(%rip), %rsi # 0x470e58
movq 0x3062f3(%rip), %rdx # 0x46ccc8
movq %rbx, %rdi
callq 0xeacb0
movq %rax, %r14
movq %rbx, %rdi
callq 0xe4570
movq %r14, %rdi
callq 0xeb220
|
/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_EMIT_RET_GETTER(bool);
VG_EMIT_RET_GETTER(float);
VG_EMIT_RET_GETTER(double);
VG_EMIT_RET_GETTER(int8_t);
VG_EMIT_RET_GETTER(uint8_t);
VG_EMIT_RET_GETTER(int16_t);
VG_EMIT_RET_GETTER(uint16_t);
VG_EMIT_RET_GETTER(int32_t);
VG_EMIT_RET_GETTER(uint32_t);
VG_EMIT_RET_GETTER(int64_t);
VG_EMIT_RET_GETTER(uint64_t);
throw std::runtime_error(error_type);
#undef VG_EMIT_RET_GETTER
}
|
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 0x167456
movq %rbx, %rdi
callq 0x166c7a
testb %al, %al
je 0x167358
leaq 0x1523(%rip), %rax # 0x168876
jmp 0x167456
movq 0x98(%r14), %rax
cmpq $0x1, %rax
jne 0x1673ae
leaq 0xa8(%r14), %r15
leaq 0x21acb2(%rip), %rsi # 0x382025
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x167471
movq 0x98(%r14), %rax
cmpq $0x1, %rax
jne 0x1673ae
leaq 0x21ac90(%rip), %rsi # 0x382027
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x16748c
movq 0x98(%r14), %rax
cmpq $0x2, %rax
jne 0x1673fd
leaq 0xa8(%r14), %r15
leaq 0x21ac67(%rip), %rsi # 0x382029
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x16747a
movq 0x98(%r14), %rax
cmpq $0x2, %rax
jne 0x1673fd
leaq 0x21ac45(%rip), %rsi # 0x38202b
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x167495
movq 0x98(%r14), %rax
cmpq $0x4, %rax
jne 0x16743a
leaq 0xa8(%r14), %r15
leaq 0x21ac1c(%rip), %rsi # 0x38202d
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x167483
cmpq $0x4, 0x98(%r14)
jne 0x16743a
leaq 0x21ac01(%rip), %rsi # 0x38202f
movq %r15, %rdi
callq 0xe15e0
testl %eax, %eax
je 0x16749e
movq %rbx, %rdi
callq 0x167ad4
testb %al, %al
je 0x16745c
leaq 0x1501(%rip), %rax # 0x16894e
jmp 0x167456
leaq 0x13e4(%rip), %rax # 0x16883a
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x167d28
testb %al, %al
je 0x1674a7
leaq 0x14fd(%rip), %rax # 0x16896c
jmp 0x167456
leaq 0x141a(%rip), %rax # 0x168892
jmp 0x167456
leaq 0x1451(%rip), %rax # 0x1688d2
jmp 0x167456
leaq 0x1488(%rip), %rax # 0x168912
jmp 0x167456
leaq 0x141f(%rip), %rax # 0x1688b2
jmp 0x167456
leaq 0x1456(%rip), %rax # 0x1688f2
jmp 0x167456
leaq 0x1489(%rip), %rax # 0x16892e
jmp 0x167456
movl $0x10, %edi
callq 0xe2be0
movq %rax, %rbx
leaq 0x219d44(%rip), %rsi # 0x3811ff
movq %rax, %rdi
callq 0xe2100
movq 0x30998e(%rip), %rsi # 0x470e58
movq 0x3057f7(%rip), %rdx # 0x46ccc8
movq %rbx, %rdi
callq 0xeacb0
movq %rax, %r14
movq %rbx, %rdi
callq 0xe4570
movq %r14, %rdi
callq 0xeb220
|
/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>::value ? "N" : "n")));
}
|
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 0x234f96(%rip), %rsi # 0x39caab
movq %rbx, %rdi
callq 0xe15e0
testl %eax, %eax
sete %bpl
jmp 0x167b27
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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>::value ? "N" : "n")));
}
|
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 0x23f6b6(%rip), %rsi # 0x3a741f
movq %rbx, %rdi
callq 0xe15e0
testl %eax, %eax
sete %bpl
jmp 0x167d7b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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<double>((static_cast<Y*>(this_->infoY.ptr))[idx]);
return ImPlotPoint(x, y);
}
|
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
No community queries yet
The top public SQL queries from the community will appear here once available.