name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
llvm::DenseMap<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo>>::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, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movq (%rdi), %r14
movl %ecx, 0x10(%rdi)
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, (%rbx)
testq %r14, %r14
je 0x96983
shlq $0x3, %r15
leaq (%r15,%r15,2), %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x96a56
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x56dc8
movq %rax, %rcx
movq $0x0, 0x8(%rbx)
movl 0x10(%rbx), %eax
testq %rax, %rax
je 0x96a4f
leaq (%rax,%rax,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x2, %rdx
andq $-0x2, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
xorl %eax, %eax
movdqa 0x28b628(%rip), %xmm1 # 0x322000
movdqa 0x28b630(%rip), %xmm2 # 0x322010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rax, %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 0x96a2b
movq $-0x1000, (%rcx) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x96a42
movq $-0x1000, 0x18(%rcx) # imm = 0xF000
addq $0x2, %rax
addq $0x30, %rcx
cmpq %rax, %rdx
jne 0x969e8
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
clang::FunctionDecl::isUserProvided() const
|
bool isUserProvided() const {
auto *DeclAsWritten = this;
if (FunctionDecl *Pattern = getTemplateInstantiationPattern())
DeclAsWritten = Pattern;
return !(DeclAsWritten->isDeleted() ||
DeclAsWritten->getCanonicalDecl()->isDefaulted());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %esi
callq 0xbdb78
movq %rax, %rbx
testq %rax, %rax
cmoveq %r14, %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testb $0x40, 0x52(%rax)
jne 0x96cc4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testb $0x2, 0x53(%rax)
sete %al
jmp 0x96cc6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/clang/AST/Decl.h
|
llvm::DenseMap<clang::Module*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::Module*, void>, llvm::detail::DenseSetPair<clang::Module*>>::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 $0x3, %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, (%r15)
testq %r14, %r14
je 0x973fa
leaq (%r14,%rbx,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x974bc
shlq $0x3, %rbx
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 0x974b5
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
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]
xorl %edx, %edx
movdqa 0x28abc0(%rip), %xmm1 # 0x322000
movdqa 0x28abc8(%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 0x97494
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x974ac
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x97450
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
bool llvm::DenseMapBase<llvm::DenseMap<clang::Decl const*, llvm::SmallVector<clang::Attr*, 4u>*, llvm::DenseMapInfo<clang::Decl const*, void>, llvm::detail::DenseMapPair<clang::Decl const*, llvm::SmallVector<clang::Attr*, 4u>*>>, clang::Decl const*, llvm::SmallVector<clang::Attr*, 4u>*, llvm::DenseMapInfo<clang::Decl const*, void>, llvm::detail::DenseMapPair<clang::Decl const*, llvm::SmallVector<clang::Attr*, 4u>*>>::LookupBucketFor<clang::Decl const*>(clang::Decl const* const&, llvm::detail::DenseMapPair<clang::Decl const*, llvm::SmallVector<clang::Attr*, 4u>*> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x976b5
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0x9767c
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x97659
jmp 0x976b2
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x97696
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x97675
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x97675
popq %rbx
jmp 0x976be
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::FoldingSet<clang::AdjustedType>::ComputeNodeHash(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID&)
|
static unsigned ComputeNodeHash(const FoldingSetBase *, Node *N,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
}
|
pushq %rbx
movq %rdx, %rbx
leaq -0x18(%rsi), %rax
testq %rsi, %rsi
cmoveq %rsi, %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x8d92a
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,4), %rsi
popq %rbx
jmp 0x765d8
nop
|
/llvm/ADT/FoldingSet.h
|
llvm::ContextualFoldingSet<clang::ConstantArrayType, clang::ASTContext&>::ComputeNodeHash(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID&)
|
static unsigned ComputeNodeHash(const FoldingSetBase *Base, Node *N,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return ContextualFoldingSetTrait<T, Ctx>::ComputeHash(*TN, TempID,
getContext(Base));
}
|
pushq %rbx
movq %rdx, %rbx
leaq -0x18(%rsi), %rax
testq %rsi, %rsi
cmoveq %rsi, %rax
movq 0x10(%rdi), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x98556
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,4), %rsi
popq %rbx
jmp 0x765d8
|
/llvm/ADT/FoldingSet.h
|
llvm::FoldingSet<clang::ParenType>::ComputeNodeHash(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID&)
|
static unsigned ComputeNodeHash(const FoldingSetBase *, Node *N,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x18(%rsi), %rax
testq %rsi, %rsi
cmoveq %rsi, %rax
movq 0x20(%rax), %r14
movq %rdx, %rdi
movl %r14d, %esi
callq 0x75350
shrq $0x20, %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x75350
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,4), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x765d8
|
/llvm/ADT/FoldingSet.h
|
llvm::DenseMapBase<llvm::DenseMap<clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*, llvm::DenseMapInfo<clang::ObjCContainerDecl const*, void>, llvm::detail::DenseMapPair<clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*>>, clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*, llvm::DenseMapInfo<clang::ObjCContainerDecl const*, void>, llvm::detail::DenseMapPair<clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*>>::moveFromOldBuckets(llvm::detail::DenseMapPair<clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*>*, llvm::detail::DenseMapPair<clang::ObjCContainerDecl const*, clang::ASTRecordLayout const*>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x99be9
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
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 $0x10, %rax
xorl %edx, %edx
movdqa 0x28848e(%rip), %xmm1 # 0x322000
movdqa 0x288496(%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 0x99bc6
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x99bdc
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x99b82
cmpq %rbx, %r14
je 0x99c35
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x99c2c
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x998c2
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
incl 0x8(%r15)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x99bf9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<clang::NamedDecl const*, unsigned int, llvm::DenseMapInfo<clang::NamedDecl const*, void>, llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>>, clang::NamedDecl const*, unsigned int, llvm::DenseMapInfo<clang::NamedDecl const*, void>, llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>>::InsertIntoBucketImpl<clang::NamedDecl const*>(clang::NamedDecl const* const&, clang::NamedDecl const* const&, llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>*)
|
BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x99d25
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x99d27
incl 0x8(%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x99d1b
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x99d48
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x99c44
movq (%r15), %rax
jmp 0x99d0c
nop
|
/llvm/ADT/DenseMap.h
|
llvm::FoldingSet<clang::UnnamedGlobalConstantDecl>::ComputeNodeHash(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID&)
|
static unsigned ComputeNodeHash(const FoldingSetBase *, Node *N,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
}
|
pushq %rbx
movq %rdx, %rbx
leaq -0x38(%rsi), %rdx
testq %rsi, %rsi
cmoveq %rsi, %rdx
movq 0x30(%rdx), %rsi
addq $0x40, %rdx
movq %rbx, %rdi
callq 0x94d4c
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,4), %rsi
popq %rbx
jmp 0x765d8
nop
|
/llvm/ADT/FoldingSet.h
|
llvm::FoldingSet<clang::TemplateParamObjectDecl>::ComputeNodeHash(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID&)
|
static unsigned ComputeNodeHash(const FoldingSetBase *, Node *N,
FoldingSetNodeID &TempID) {
T *TN = static_cast<T *>(N);
return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
}
|
pushq %rbx
movq %rdx, %rbx
leaq -0x38(%rsi), %rdx
testq %rsi, %rsi
cmoveq %rsi, %rdx
movq 0x30(%rdx), %rsi
addq $0x40, %rdx
movq %rbx, %rdi
callq 0x94e42
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,4), %rsi
popq %rbx
jmp 0x765d8
nop
|
/llvm/ADT/FoldingSet.h
|
clang::ConcreteTypeLoc<clang::UnqualTypeLoc, clang::ElaboratedTypeLoc, clang::ElaboratedType, clang::ElaboratedLocInfo>::getNonLocalData() const
|
const Type *getTypePtr() const {
return reinterpret_cast<const Type*>(Ty);
}
|
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movl $0x7f80000, %edx # imm = 0x7F80000
andl 0x10(%rax), %edx
movl $0x10, %ebx
cmpl $0x300000, %edx # imm = 0x300000
jne 0xb4182
xorl %ebx, %ebx
cmpq $0x0, 0x20(%rax)
setne %bl
shll $0x4, %ebx
addq %rcx, %rbx
movq 0x28(%rax), %rdi
callq 0x22c608
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
subq %rcx, %rbx
movl %eax, %esi
movq %rbx, %rax
xorl %edx, %edx
divq %rsi
addq %rcx, %rax
imulq %rsi, %rax
popq %rbx
retq
|
/clang/AST/TypeLoc.h
|
clang::computeDependence(clang::DeclRefExpr*, clang::ASTContext const&)
|
ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
auto Deps = ExprDependence::None;
if (auto *NNS = E->getQualifier())
Deps |= toExprDependence(NNS->getDependence() &
~NestedNameSpecifierDependence::Dependent);
if (auto *FirstArg = E->getTemplateArgs()) {
unsigned NumArgs = E->getNumTemplateArgs();
for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg)
Deps |= toExprDependence(Arg->getArgument().getDependence());
}
auto *Decl = E->getDecl();
auto Type = E->getType();
if (Decl->isParameterPack())
Deps |= ExprDependence::UnexpandedPack;
Deps |= toExprDependenceForImpliedType(Type->getDependence()) &
ExprDependence::Error;
// C++ [temp.dep.expr]p3:
// An id-expression is type-dependent if it contains:
// - an identifier associated by name lookup with one or more declarations
// declared with a dependent type
// - an identifier associated by name lookup with an entity captured by
// copy ([expr.prim.lambda.capture])
// in a lambda-expression that has an explicit object parameter whose
// type is dependent ([dcl.fct]),
//
// [The "or more" case is not modeled as a DeclRefExpr. There are a bunch
// more bullets here that we handle by treating the declaration as having a
// dependent type if they involve a placeholder type that can't be deduced.]
if (Type->isDependentType())
Deps |= ExprDependence::TypeValueInstantiation;
else if (Type->isInstantiationDependentType())
Deps |= ExprDependence::Instantiation;
// - an identifier associated by name lookup with an entity captured by
// copy ([expr.prim.lambda.capture])
if (E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
Deps |= ExprDependence::Type;
// - a conversion-function-id that specifies a dependent type
if (Decl->getDeclName().getNameKind() ==
DeclarationName::CXXConversionFunctionName) {
QualType T = Decl->getDeclName().getCXXNameType();
if (T->isDependentType())
return Deps | ExprDependence::TypeValueInstantiation;
if (T->isInstantiationDependentType())
Deps |= ExprDependence::Instantiation;
}
// - a template-id that is dependent,
// - a nested-name-specifier or a qualified-id that names a member of an
// unknown specialization
// [These are not modeled as DeclRefExprs.]
// or if it names a dependent member of the current instantiation that is a
// static data member of type "array of unknown bound of T" for some T
// [handled below].
// C++ [temp.dep.constexpr]p2:
// An id-expression is value-dependent if:
// - it is type-dependent [handled above]
// - it is the name of a non-type template parameter,
if (isa<NonTypeTemplateParmDecl>(Decl))
return Deps | ExprDependence::ValueInstantiation;
// - it names a potentially-constant variable that is initialized with an
// expression that is value-dependent
if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
if (const Expr *Init = Var->getAnyInitializer()) {
if (Init->containsErrors())
Deps |= ExprDependence::Error;
if (Var->mightBeUsableInConstantExpressions(Ctx) &&
Init->isValueDependent())
Deps |= ExprDependence::ValueInstantiation;
}
// - it names a static data member that is a dependent member of the
// current instantiation and is not initialized in a member-declarator,
if (Var->isStaticDataMember() &&
Var->getDeclContext()->isDependentContext() &&
!Var->getFirstDecl()->hasInit()) {
const VarDecl *First = Var->getFirstDecl();
TypeSourceInfo *TInfo = First->getTypeSourceInfo();
if (TInfo->getType()->isIncompleteArrayType()) {
Deps |= ExprDependence::TypeValueInstantiation;
} else if (!First->hasInit()) {
Deps |= ExprDependence::ValueInstantiation;
}
}
return Deps;
}
// - it names a static member function that is a dependent member of the
// current instantiation
//
// FIXME: It's unclear that the restriction to static members here has any
// effect: any use of a non-static member function name requires either
// forming a pointer-to-member or providing an object parameter, either of
// which makes the overall expression value-dependent.
if (auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
if (MD->isStatic() && Decl->getDeclContext()->isDependentContext())
Deps |= ExprDependence::ValueInstantiation;
}
return Deps;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
testb $0x4, 0x2(%rdi)
jne 0xb44fd
xorl %edi, %edi
jmp 0xb4501
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0xb4518
callq 0x1f630e
movl %eax, %ebx
andb $0x3, %al
addb %bl, %bl
andb $0x10, %bl
orb %al, %bl
jmp 0xb451a
xorl %ebx, %ebx
movq %r15, %rdi
callq 0xb478c
testq %rax, %rax
je 0xb4573
movq %rax, %r12
movq %r15, %rdi
callq 0xb47ca
testl %eax, %eax
je 0xb4573
movl %eax, %r13d
shlq $0x5, %r13
addq %r12, %r13
movq %r12, %rdi
callq 0x222ace
movl %eax, %ebp
andb $0x3, %al
orb %bl, %al
movl %ebp, %ecx
shlb $0x5, %cl
sarb $0x7, %cl
andb $0xc, %cl
addb %bpl, %bpl
andb $0x10, %bpl
orb %al, %bpl
orb %cl, %bpl
addq $0x20, %r12
movl %ebp, %ebx
cmpq %r13, %r12
jb 0xb4540
jmp 0xb4575
movl %ebx, %ebp
movq 0x8(%r15), %r12
movq 0x10(%r15), %rbx
movq %rbx, %rdi
callq 0xc0d08
movl %eax, %ecx
orb %bpl, %cl
andq $-0x10, %r12
movq (%r12), %rax
movzwl 0x11(%rax), %edx
movl %edx, %eax
andb $0x10, %al
orb %cl, %al
movl %edx, %ecx
andb $0x2, %cl
testb $0x4, %dl
movzbl %cl, %ecx
movl $0xe, %ebp
cmovel %ecx, %ebp
movl (%r15), %ecx
shrl $0x15, %ecx
andb $0x4, %cl
orb %al, %cl
movq 0x28(%rbx), %rdx
movl %edx, %esi
andl $0x7, %esi
cmpl $0x7, %esi
jne 0xb45df
movq %rdx, %rsi
andq $-0x8, %rsi
movl (%rsi), %edi
cmpl $0x3, %edi
movl $0x3, %esi
cmovbl %edi, %esi
orl $0x8, %esi
orb %cl, %bpl
cmpl $0x5, %esi
jne 0xb461a
andq $-0x8, %rdx
movq 0x8(%rdx), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movzwl 0x11(%rcx), %edx
orb $0xe, %al
movl %edx, %ecx
andb $0x2, %cl
xorl %esi, %esi
testb $0x4, %dl
movzbl %cl, %ecx
cmovnel %esi, %ecx
testb $0x4, %dl
jne 0xb477d
orb %cl, %bpl
jmp 0xb461a
movl 0x1c(%rbx), %r12d
andl $0x7f, %r12d
cmpl $0x2c, %r12d
jne 0xb4633
orb $0xa, %bpl
movl %ebp, %eax
jmp 0xb477d
addl $-0x2c, %r12d
cmpl $-0x7, %r12d
jb 0xb472e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xbbcec
testq %rax, %rax
je 0xb4683
movq %rax, %r15
movzwl 0x1(%rax), %eax
shrl $0x5, %eax
andb $0x10, %al
orb %al, %bpl
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbbe3a
testb %al, %al
je 0xb4683
movzbl %bpl, %eax
orb $0xa, %bpl
testb $0x1, 0x2(%r15)
movzbl %bpl, %ebp
cmovel %eax, %ebp
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xb472c
movq 0x10(%rbx), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xb46a5
movq (%rax), %rax
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
addl $-0x37, %eax
cmpw $0x3, %ax
ja 0xb472c
movq 0x10(%rbx), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0xb46c7
movq (%rdi), %rdi
callq 0xc0eba
testb %al, %al
je 0xb472c
movq 0x50(%rbx), %rdi
callq 0xbbae8
testb %al, %al
jne 0xb472c
movq 0x50(%rbx), %rdi
movq 0x38(%rdi), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xb46f5
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x5, 0x10(%rax)
jne 0xb4716
orb $0xe, %bpl
jmp 0xb472c
callq 0xbbae8
movzbl %bpl, %ecx
orb $0xa, %bpl
movzbl %bpl, %ebp
testb %al, %al
cmovnel %ecx, %ebp
movl %ebp, %eax
cmpl $-0x8, %r12d
ja 0xb477d
movl 0x1c(%rbx), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
jne 0xb462c
movq %rbx, %rdi
callq 0xc7a7c
testb %al, %al
je 0xb462c
movq 0x10(%rbx), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0xb4765
movq (%rdi), %rdi
callq 0xc0eba
movl %eax, %ecx
movzbl %bpl, %edx
orb $0xa, %bpl
movzbl %bpl, %eax
testb %cl, %cl
cmovel %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ComputeDependence.cpp
|
clang::computeDependence(clang::CallExpr*, llvm::ArrayRef<clang::Expr*>)
|
Stmt **getTrailingStmts() {
return reinterpret_cast<Stmt **>(reinterpret_cast<char *>(this) +
CallExprBits.OffsetToTrailingObjects);
}
|
movl (%rdi), %r8d
movl %r8d, %r9d
shrl $0x18, %r9d
movq (%rdi,%r9), %rax
movzwl 0x1(%rax), %ecx
shrl $0x5, %ecx
andb $0x1f, %cl
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x11(%rax), %al
andb $0x4, %al
orb %cl, %al
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0xb4874
addq %r9, %rdi
shrl $0xf, %r8d
andl $0x8, %r8d
addq %r8, %rdi
addq $0x8, %rdi
shlq $0x3, %rcx
xorl %r8d, %r8d
movq (%rdi,%r8), %r9
testq %r9, %r9
je 0xb486b
movzwl 0x1(%r9), %r9d
shrl $0x5, %r9d
andb $0x1f, %r9b
orb %al, %r9b
movl %r9d, %eax
addq $0x8, %r8
cmpq %r8, %rcx
jne 0xb484f
testq %rdx, %rdx
je 0xb489a
shlq $0x3, %rdx
xorl %ecx, %ecx
movq (%rsi,%rcx), %rdi
movzwl 0x1(%rdi), %edi
shrl $0x5, %edi
andb $0x1f, %dil
orb %dil, %al
addq $0x8, %rcx
cmpq %rcx, %rdx
jne 0xb487f
retq
|
/clang/AST/Expr.h
|
clang::computeDependence(clang::MemberExpr*)
|
ExprDependence clang::computeDependence(MemberExpr *E) {
auto D = E->getBase()->getDependence();
D |= getDependenceInExpr(E->getMemberNameInfo());
if (auto *NNS = E->getQualifier())
D |= toExprDependence(NNS->getDependence() &
~NestedNameSpecifierDependence::Dependent);
for (const auto &A : E->template_arguments())
D |= toExprDependence(A.getArgument().getDependence());
auto *MemberDecl = E->getMemberDecl();
if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
DeclContext *DC = MemberDecl->getDeclContext();
// dyn_cast_or_null is used to handle objC variables which do not
// have a declaration context.
CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
if (!E->getType()->isDependentType())
D &= ~ExprDependence::Type;
}
// Bitfield with value-dependent width is type-dependent.
if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
D |= ExprDependence::Type;
}
}
return D;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movzwl 0x1(%rax), %r15d
shrl $0x5, %r15d
andb $0x1f, %r15b
movq 0x28(%rcx), %rax
movl 0x28(%rdi), %ecx
movq 0x20(%rdi), %rdx
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl %ecx, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %r14, %rdi
callq 0xc07b0
movl %eax, %ebp
addb %al, %bpl
movq %r14, %rdi
callq 0xc074a
movl %eax, %r14d
orb %bpl, %r14b
testb $0x8, 0x2(%rbx)
jne 0xb48ff
xorl %edi, %edi
jmp 0xb4903
movq 0x30(%rbx), %rdi
orb %r15b, %r14b
testq %rdi, %rdi
je 0xb491e
callq 0x1f630e
movl %eax, %ecx
andb $0x3, %cl
addb %al, %al
andb $0x10, %al
orb %cl, %al
orb %al, %r14b
movq %rbx, %rdi
callq 0xb4b28
movq %rax, %r15
movq %rbx, %rdi
callq 0xb4b66
testl %eax, %eax
je 0xb4972
movl %eax, %r12d
shlq $0x5, %r12
movq %r15, %rdi
callq 0x222ace
movl %eax, %ebp
andb $0x3, %al
orb %r14b, %al
movl %ebp, %ecx
shlb $0x5, %cl
sarb $0x7, %cl
andb $0xc, %cl
addb %bpl, %bpl
andb $0x10, %bpl
orb %al, %bpl
orb %cl, %bpl
addq $0x20, %r15
movl %ebp, %r14d
addq $-0x20, %r12
jne 0xb493c
jmp 0xb4975
movl %r14d, %ebp
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0xb4a45
movl 0x1c(%r12), %eax
andl $0x7f, %eax
addl $-0x31, %eax
cmpl $-0x3, %eax
jb 0xb4a45
movq 0x10(%r12), %rax
movq %rax, %r14
andq $-0x8, %r14
testb $0x4, %al
je 0xb49a9
movq (%r14), %r14
testq %r14, %r14
je 0xb49c9
movzwl 0x8(%r14), %eax
andl $0x7f, %eax
addl $-0x38, %eax
leaq -0x40(%r14), %rcx
xorl %r15d, %r15d
cmpl $0x3, %eax
cmovbq %rcx, %r15
jmp 0xb49cc
xorl %r15d, %r15d
testq %r15, %r15
je 0xb4a0b
leaq 0x40(%r15), %rdi
callq 0xc0eba
testb %al, %al
je 0xb4a0b
movq %r15, %rdi
movq %r14, %rsi
callq 0xb51ca
testb %al, %al
je 0xb4a0b
movq 0x8(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl %bpl, %ecx
andb $0x1b, %bpl
testb $0x4, 0x11(%rax)
movzbl %bpl, %ebp
cmovnel %ecx, %ebp
movl 0x44(%r12), %eax
testb $0x1, %al
je 0xb4a45
shrl $0x2, %eax
andl $0x3, %eax
movq 0x48(%r12), %rcx
addq $0x48, %r12
addq $0x8, %rcx
testl %eax, %eax
cmoveq %r12, %rcx
cmpl $0x3, %eax
cmoveq %r12, %rcx
movq (%rcx), %rax
movzwl 0x1(%rax), %eax
shrl $0x6, %eax
andb $0x4, %al
orb %bpl, %al
movl %eax, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ComputeDependence.cpp
|
clang::OverloadExpr::getTemplateArgs() const
|
bool hasTemplateKWAndArgsInfo() const {
return OverloadExprBits.HasTemplateKWAndArgsInfo;
}
|
testb $0x4, 0x2(%rdi)
je 0xb4bf7
xorl %eax, %eax
cmpb $0x19, (%rdi)
setne %al
movl 0x4(%rdi), %ecx
shll $0x4, %eax
addq %rdi, %rax
cmpl $0x0, 0x40(%rax,%rcx,8)
je 0xb4bf7
movb (%rdi), %cl
cmpb $0x19, %cl
jne 0xb4bdb
movl (%rdi), %eax
movl 0x4(%rdi), %edx
leaq (%rdi,%rdx,8), %rdx
shrl $0xe, %eax
andl $0x10, %eax
addq %rdx, %rax
addq $0x40, %rax
cmpb $0x19, %cl
je 0xb4bf6
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
leaq (%rdi,%rcx,8), %rcx
shrl $0xe, %eax
andl $0x10, %eax
addq %rcx, %rax
addq $0x50, %rax
retq
xorl %eax, %eax
retq
|
/clang/AST/ExprCXX.h
|
clang::CXXRecordDecl::FindVirtualBaseClass(clang::CXXBaseSpecifier const*, clang::CXXBasePath&, clang::CXXRecordDecl const*)
|
bool isVirtual() const { return Virtual; }
|
testb $0x1, 0xc(%rdi)
jne 0xb57bb
xorl %eax, %eax
retq
pushq %rbx
movq %rdx, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0xb57db
callq 0x225b78
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c68
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
cmpq %rbx, %rax
sete %al
popq %rbx
retq
nop
|
/clang/AST/DeclCXX.h
|
bool llvm::DenseMapBase<llvm::DenseMap<clang::CXXRecordDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>>, clang::CXXRecordDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>>::LookupBucketFor<clang::CXXRecordDecl const*>(clang::CXXRecordDecl const* const&, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xb6571
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0xb6538
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0xb6515
jmp 0xb656e
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0xb6552
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0xb6531
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0xb6531
popq %rbx
jmp 0xb657a
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<clang::CXXMethodDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXMethodDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, unsigned int>>, clang::CXXMethodDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXMethodDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, unsigned int>>::moveFromOldBuckets(llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, unsigned int>*, llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, unsigned int>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0xb700d
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
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 $0x10, %rax
xorl %edx, %edx
movdqa 0x26b06a(%rip), %xmm1 # 0x322000
movdqa 0x26b072(%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 0xb6fea
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0xb7000
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0xb6fa6
cmpq %rbx, %r14
je 0xb7058
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0xb704f
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xb6ce6
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
incl 0x8(%r15)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0xb701d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::SmallDenseMap<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases, 8u, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>>, clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>>::moveFromOldBuckets(llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>*, llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rax
andl $0x1, (%rdi)
movl $0x0, 0x4(%rdi)
cmoveq 0x8(%rdi), %rax
movl $0x8, %ecx
cmovel 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xb7bb9
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
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 $0x10, %rax
xorl %edx, %edx
movdqa 0x26a4be(%rip), %xmm1 # 0x322000
movdqa 0x26a4c6(%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 0xb7b96
movq $0x0, -0x10(%rax)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0xb7bac
movq $0x0, (%rax)
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0xb7b52
cmpq %rbx, %r14
je 0xb7bf9
movq %rsp, %r12
movq (%r14), %rax
incq %rax
cmpq $0x2, %rax
jb 0xb7bf0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xb78a6
movq (%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
addl $0x2, (%r15)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0xb7bc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
std::pair<unsigned int, llvm::SmallVector<clang::UniqueVirtualMethod, 4u>> const* llvm::SmallVectorTemplateCommon<std::pair<unsigned int, llvm::SmallVector<clang::UniqueVirtualMethod, 4u>>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<unsigned int, llvm::SmallVector<clang::UniqueVirtualMethod, 4u>>, false>>(llvm::SmallVectorTemplateBase<std::pair<unsigned int, llvm::SmallVector<clang::UniqueVirtualMethod, 4u>>, false>*, std::pair<unsigned int, llvm::SmallVector<clang::UniqueVirtualMethod, 4u>> const&, unsigned long)
|
static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0xb835c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
imulq $0x78, %rcx, %rcx
addq %rax, %rcx
cmpq %rbx, %rax
setbe %sil
cmpq %rbx, %rcx
seta %bpl
andb %sil, %bpl
movq $-0x1, %r15
cmpb $0x1, %bpl
je 0xb83a0
movq %r14, %rdi
movq %rdx, %rsi
callq 0xb745e
testb %bpl, %bpl
je 0xb834e
imulq $0x78, %r15, %rbx
addq (%r14), %rbx
jmp 0xb834e
movq %rbx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x1111111111111111, %r15 # imm = 0xEEEEEEEEEEEEEEEF
imulq %rcx, %r15
jmp 0xb8387
|
/llvm/ADT/SmallVector.h
|
clang::LinkageComputer::getDeclLinkageAndVisibility(clang::NamedDecl const*)
|
LinkageInfo LinkageComputer::getDeclLinkageAndVisibility(const NamedDecl *D) {
NamedDecl::ExplicitVisibilityKind EK = usesTypeVisibility(D)
? NamedDecl::VisibilityForType
: NamedDecl::VisibilityForValue;
LVComputationKind CK(EK);
return getLVForDecl(D, D->getASTContext().getLangOpts().IgnoreXCOFFVisibility
? CK.forLinkageOnly()
: CK);
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1c(%rsi), %eax
andl $0x7f, %eax
leal -0x41(%rax), %ecx
cmpl $-0xa, %ecx
setb %cl
cmpl $0x45, %eax
setne %dl
cmpl $0x11, %eax
setne %bpl
andb %dl, %bpl
andb %cl, %bpl
movq %rsi, %rdi
callq 0xc0b9c
movq 0x830(%rax), %rax
btl $0xa, 0x68(%rax)
movzbl %bpl, %eax
movl $0x7, %edx
cmovael %eax, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb89e6
|
/AST/Decl.cpp
|
useInlineVisibilityHidden(clang::NamedDecl const*)
|
static bool useInlineVisibilityHidden(const NamedDecl *D) {
// FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
const LangOptions &Opts = D->getASTContext().getLangOpts();
if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
return false;
const auto *FD = dyn_cast<FunctionDecl>(D);
if (!FD)
return false;
TemplateSpecializationKind TSK = TSK_Undeclared;
if (FunctionTemplateSpecializationInfo *spec
= FD->getTemplateSpecializationInfo()) {
TSK = spec->getTemplateSpecializationKind();
} else if (MemberSpecializationInfo *MSI =
FD->getMemberSpecializationInfo()) {
TSK = MSI->getTemplateSpecializationKind();
}
const FunctionDecl *Def = nullptr;
// InlineVisibilityHidden only applies to definitions, and
// isInlined() only gives meaningful answers on definitions
// anyway.
return TSK != TSK_ExplicitInstantiationDeclaration &&
TSK != TSK_ExplicitInstantiationDefinition &&
FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0xc0b9c
movq 0x830(%rax), %rax
testb $0x4, 0x1(%rax)
je 0xb96c5
testb $0x2, 0x69(%rax)
jne 0xb96cd
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movl 0x1c(%rbx), %ecx
andl $0x7f, %ecx
addl $-0x25, %ecx
xorl %eax, %eax
movl $0x0, %edi
cmpl $-0x6, %ecx
cmovaeq %rbx, %rdi
jb 0xb96c7
movq 0x98(%rdi), %rax
movl %eax, %edx
andl $0x6, %edx
cmpq $0x4, %rdx
setne %cl
andq $-0x8, %rax
sete %sil
orb %cl, %sil
je 0xb972e
xorl %ecx, %ecx
cmpl $0x2, %edx
cmoveq %rax, %rcx
testq %rcx, %rcx
jne 0xb973b
cmpl $0x4, %edx
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0xb972a
testb $0x4, 0x8(%rax)
jne 0xb9737
xorl %ecx, %ecx
jmp 0xb973b
addq $0x10, %rax
movq %rax, %rcx
jmp 0xb9740
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0xb9754
testb $0x4, (%rcx)
movq $0x0, 0x8(%rsp)
jne 0xb96c5
jmp 0xb975d
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0xbc674
testb %al, %al
je 0xb96c5
movq 0x8(%rsp), %rdi
testb $0x1, 0x52(%rdi)
je 0xb96c5
callq 0x96cce
xorb $0x1, %al
jmp 0xb96c7
|
/AST/Decl.cpp
|
clang::LinkageComputer::getLVForClassMember(clang::NamedDecl const*, clang::LVComputationKind, bool)
|
LinkageInfo
LinkageComputer::getLVForClassMember(const NamedDecl *D,
LVComputationKind computation,
bool IgnoreVarTypeLinkage) {
// Only certain class members have linkage. Note that fields don't
// really have linkage, but it's convenient to say they do for the
// purposes of calculating linkage of pointer-to-data-member
// template arguments.
//
// Templates also don't officially have linkage, but since we ignore
// the C++ standard and look at template arguments when determining
// linkage and visibility of a template specialization, we might hit
// a template template argument that way. If we do, we need to
// consider its linkage.
if (!(isa<CXXMethodDecl>(D) ||
isa<VarDecl>(D) ||
isa<FieldDecl>(D) ||
isa<IndirectFieldDecl>(D) ||
isa<TagDecl>(D) ||
isa<TemplateDecl>(D)))
return LinkageInfo::none();
LinkageInfo LV;
// If we have an explicit visibility attribute, merge that in.
if (!hasExplicitVisibilityAlready(computation)) {
if (std::optional<Visibility> Vis = getExplicitVisibility(D, computation))
LV.mergeVisibility(*Vis, true);
// If we're paying attention to global visibility, apply
// -finline-visibility-hidden if this is an inline method.
//
// Note that we do this before merging information about
// the class visibility.
if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D))
LV.mergeVisibility(HiddenVisibility, /*visibilityExplicit=*/false);
}
// If this class member has an explicit visibility attribute, the only
// thing that can change its visibility is the template arguments, so
// only look for them when processing the class.
LVComputationKind classComputation = computation;
if (LV.isVisibilityExplicit())
classComputation = withExplicitVisibilityAlready(computation);
LinkageInfo classLV =
getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
// The member has the same linkage as the class. If that's not externally
// visible, we don't need to compute anything about the linkage.
// FIXME: If we're only computing linkage, can we bail out here?
if (!isExternallyVisible(classLV.getLinkage()))
return classLV;
// Otherwise, don't merge in classLV yet, because in certain cases
// we need to completely ignore the visibility from it.
// Specifically, if this decl exists and has an explicit attribute.
const NamedDecl *explicitSpecSuppressor = nullptr;
if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
// Only look at the type-as-written. Otherwise, deducing the return type
// of a function could change its linkage.
QualType TypeAsWritten = MD->getType();
if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
TypeAsWritten = TSI->getType();
if (!isExternallyVisible(TypeAsWritten->getLinkage()))
return LinkageInfo::uniqueExternal();
// If this is a method template specialization, use the linkage for
// the template parameters and arguments.
if (FunctionTemplateSpecializationInfo *spec
= MD->getTemplateSpecializationInfo()) {
mergeTemplateLV(LV, MD, spec, computation);
if (spec->isExplicitSpecialization()) {
explicitSpecSuppressor = MD;
} else if (isExplicitMemberSpecialization(spec->getTemplate())) {
explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
}
} else if (isExplicitMemberSpecialization(MD)) {
explicitSpecSuppressor = MD;
}
// OpenMP target declare device functions are not callable from the host so
// they should not be exported from the device image. This applies to all
// functions as the host-callable kernel functions are emitted at codegen.
ASTContext &Context = D->getASTContext();
if (Context.getLangOpts().OpenMP &&
Context.getLangOpts().OpenMPIsTargetDevice &&
((Context.getTargetInfo().getTriple().isAMDGPU() ||
Context.getTargetInfo().getTriple().isNVPTX()) ||
OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
LV.mergeVisibility(HiddenVisibility, /*newExplicit=*/false);
} else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
mergeTemplateLV(LV, spec, computation);
if (spec->isExplicitSpecialization()) {
explicitSpecSuppressor = spec;
} else {
const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
if (isExplicitMemberSpecialization(temp)) {
explicitSpecSuppressor = temp->getTemplatedDecl();
}
}
} else if (isExplicitMemberSpecialization(RD)) {
explicitSpecSuppressor = RD;
}
// Static data members.
} else if (const auto *VD = dyn_cast<VarDecl>(D)) {
if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
mergeTemplateLV(LV, spec, computation);
// Modify the variable's linkage by its type, but ignore the
// type's visibility unless it's a definition.
if (!IgnoreVarTypeLinkage) {
LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
// FIXME: If the type's linkage is not externally visible, we can
// give this static data member UniqueExternalLinkage.
if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
LV.mergeVisibility(typeLV);
LV.mergeExternalVisibility(typeLV);
}
if (isExplicitMemberSpecialization(VD)) {
explicitSpecSuppressor = VD;
}
// Template members.
} else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
bool considerVisibility =
(!LV.isVisibilityExplicit() &&
!classLV.isVisibilityExplicit() &&
!hasExplicitVisibilityAlready(computation));
LinkageInfo tempLV =
getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
if (const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
if (isExplicitMemberSpecialization(redeclTemp)) {
explicitSpecSuppressor = temp->getTemplatedDecl();
}
}
}
// We should never be looking for an attribute directly on a template.
assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
// If this member is an explicit member specialization, and it has
// an explicit attribute, ignore visibility from the parent.
bool considerClassVisibility = true;
if (explicitSpecSuppressor &&
// optimization: hasDVA() is true only with explicit visibility.
LV.isVisibilityExplicit() &&
classLV.getVisibility() != DefaultVisibility &&
hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
considerClassVisibility = false;
}
// Finally, merge in information from the class.
LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
return LV;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x1c(%rsi), %ecx
movl %ecx, %eax
andl $0x7c, %eax
cmpl $0x20, %eax
je 0xb9870
andl $0x7f, %ecx
movb $0x11, %al
addl $-0x1d, %ecx
cmpl $0x2a, %ecx
ja 0xb9d01
movabsq $0x7f07c0e7f01, %rdx # imm = 0x7F07C0E7F01
btq %rcx, %rdx
jae 0xb9d01
movb 0x6(%rsp), %al
andb $-0x40, %al
orb $0x16, %al
movb %al, 0x6(%rsp)
testb $0x2, %bl
jne 0xb98da
movl %ebx, %esi
andl $0x1, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0xba0ef
btq $0x20, %rax
jae 0xb98b9
movzbl 0x6(%rsp), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $0x3, %edx
cmpl %eax, %edx
jl 0xb98b9
shlb $0x3, %al
andb $0x18, %al
andb $-0x39, %cl
orb %al, %cl
orb $0x20, %cl
movb %cl, 0x6(%rsp)
testb $0x20, 0x6(%rsp)
jne 0xb98da
movq %r14, %rdi
callq 0xb96a5
testb %al, %al
je 0xb98da
movb 0x6(%rsp), %al
testb $0x18, %al
je 0xb98da
andb $-0x39, %al
movb %al, 0x6(%rsp)
movl %ebx, %edx
andl $0xffffff00, %edx # imm = 0xFFFFFF00
movzbl 0x6(%rsp), %eax
shrl $0x4, %eax
andl $0x2, %eax
movq 0x10(%r14), %rsi
movq %rsi, %rcx
andq $-0x8, %rcx
testb $0x4, %sil
je 0xb9901
movq (%rcx), %rcx
leaq -0x40(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
movzbl %bl, %ecx
orl %ecx, %edx
orl %eax, %edx
movq %r15, %rdi
callq 0xb89e6
movl %eax, %ebp
andb $0x7, %al
addb $-0x4, %al
cmpb $0x2, %al
ja 0xb99f2
movl 0x1c(%r14), %eax
movl %eax, %ecx
andl $0x7c, %ecx
cmpl $0x20, %ecx
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
je 0xb99f9
andl $0x7f, %eax
leal -0x3b(%rax), %ecx
cmpl $-0x3, %ecx
setb %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
je 0xb9a17
leal -0x2c(%rax), %ecx
cmpl $-0x7, %ecx
setb %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
je 0xb9afa
addl $-0x48, %eax
cmpl $-0x7, %eax
setb %al
testq %r14, %r14
sete %cl
orb %al, %cl
movb $0x1, %r13b
jne 0xb9c2f
testb $0x2, %bl
sete %al
leaq 0x6(%rsp), %r12
movb (%r12), %cl
orb %bpl, %cl
testb $0x20, %cl
sete %r13b
andb %al, %r13b
movq 0x38(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0xb8768
movzbl %al, %esi
movzbl %r13b, %edx
movq %r12, %rdi
callq 0xb8b52
movl 0x1c(%r14), %eax
andl $0x7e, %eax
addl $-0x46, %eax
cmpl $-0x4, %eax
jb 0xb99ea
movq %r14, %rdi
callq 0xd32ac
testb $0x4, (%rax)
jne 0xb9c37
xorl %r12d, %r12d
jmp 0xb9c3b
movl %ebp, %eax
jmp 0xb9d01
movq 0x38(%r14), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xb9a0d
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xb9a80
movq (%rax), %rax
jmp 0xb9a84
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x39, %eax
xorl %r12d, %r12d
cmpl $0x2, %eax
cmovbq %r14, %r12
testq %r12, %r12
je 0xb9be3
leaq 0x6(%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
movl %ebx, %ecx
callq 0xb8be2
movb 0xb4(%r12), %al
andb $0x7, %al
movb $0x1, %r13b
cmpb $0x2, %al
je 0xb9cbe
movq %r12, %rdi
callq 0xd3aca
movq %rax, %r14
movq %rax, %rdi
callq 0xd32ac
testb $0x4, (%rax)
je 0xb9c2f
movq 0x30(%r14), %r12
jmp 0xb9cbe
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x22a66e
addb $-0x4, %al
cmpb $0x3, %al
setb %r13b
jae 0xb9c2f
movb %r13b, 0x7(%rsp)
movq 0x98(%r14), %r13
movl %r13d, %eax
andl $0x6, %eax
cmpq $0x4, %rax
setne %cl
andq $-0x8, %r13
sete %dl
orb %cl, %dl
je 0xb9b98
xorl %ecx, %ecx
cmpl $0x2, %eax
cmoveq %r13, %rcx
testq %rcx, %rcx
jne 0xb9c44
cmpl $0x4, %eax
setne %al
testq %r13, %r13
sete %cl
orb %al, %cl
jne 0xb9af3
testb $0x4, 0x8(%r13)
jne 0xb9c40
xorl %ecx, %ecx
jmp 0xb9c44
movl 0x1c(%r14), %eax
andl $0x7e, %eax
cmpl $0x26, %eax
jne 0xb9b18
leaq 0x6(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0xb8d20
testb %r12b, %r12b
jne 0xb9c0b
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0xb8750
movb 0x6(%rsp), %cl
movl %ecx, %edx
orb %bpl, %dl
testb $0x20, %dl
jne 0xb9b83
movl %eax, %edx
shrb $0x3, %dl
andb $0x3, %dl
movl %eax, %esi
andb $0x20, %sil
movl %ecx, %r8d
shrb $0x3, %r8b
andb $0x3, %r8b
movl %r8d, %edi
xorb %dl, %dil
orb %sil, %dil
setne %dil
cmpb %dl, %r8b
jb 0xb9b83
testb %dil, %dil
je 0xb9b83
shlb $0x3, %dl
andb $-0x39, %cl
orb %dl, %cl
orb %sil, %cl
movb %cl, 0x6(%rsp)
andb $0x7, %al
movb 0x6(%rsp), %cl
movl %ecx, %edx
andb $0x7, %dl
addb $-0x4, %al
cmpb $0x3, %al
jae 0xb9bed
movl %edx, %eax
jmp 0xb9c02
leaq 0x6(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %r13, %rcx
movl %ebx, %r8d
callq 0xb8aaa
movq 0x10(%r13), %rdi
movl %edi, %eax
andl $0x6, %eax
movq %r14, %r12
cmpl $0x2, %eax
je 0xb9c5d
andq $-0x8, %rdi
callq 0xd32ac
testb $0x4, (%rax)
je 0xb9c5a
movq 0x10(%r13), %rax
andq $-0x8, %rax
movq 0x30(%rax), %r12
jmp 0xb9c5d
movq %r14, %rdi
callq 0xc76c4
jmp 0xb9c13
movb $0x1, %al
cmpb $0x4, %dl
je 0xb9c02
cmpb $0x6, %dl
movzbl %dl, %edx
movl $0x3, %eax
cmovnel %edx, %eax
andb $-0x8, %cl
orb %al, %cl
movb %cl, 0x6(%rsp)
movq %r14, %rdi
callq 0xbc33a
movb $0x1, %r13b
testq %rax, %rax
je 0xb9c2f
movl (%rax), %eax
andl $0x6, %eax
xorl %r12d, %r12d
cmpl $0x2, %eax
cmoveq %r14, %r12
jmp 0xb9cbe
xorl %r12d, %r12d
jmp 0xb9cbe
movq 0x30(%r14), %r12
movb $0x1, %r13b
jmp 0xb9cbe
movq 0x30(%r13), %rcx
testq %rcx, %rcx
je 0xb9c5a
movl (%rcx), %eax
andl $0x6, %eax
xorl %r12d, %r12d
cmpl $0x2, %eax
cmoveq %r14, %r12
jmp 0xb9c5d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0xc0b9c
movq 0x830(%rax), %rcx
movq 0x40(%rcx), %rcx
testl %ecx, %ecx
sete %dl
btq $0x23, %rcx
setae %cl
orb %dl, %cl
je 0xb9c88
movb 0x7(%rsp), %r13b
jmp 0xb9cbe
movq 0x4348(%rax), %rax
movl 0xf8(%rax), %eax
cmpq $0x2a, %rax
movb 0x7(%rsp), %r13b
ja 0xb9d10
movabsq $0x60006000000, %rcx # imm = 0x60006000000
btq %rax, %rcx
jae 0xb9d10
movb 0x6(%rsp), %al
testb $0x18, %al
je 0xb9cbe
andb $-0x39, %al
movb %al, 0x6(%rsp)
movb $0x13, %al
testb %r13b, %r13b
je 0xb9d01
movb $0x1, %al
testq %r12, %r12
je 0xb9ceb
movl %ebp, %ecx
andb $0x18, %cl
cmpb $0x10, %cl
je 0xb9ceb
movb 0x6(%rsp), %cl
andb $0x20, %cl
je 0xb9ceb
movq %r12, %rdi
movl %ebx, %esi
callq 0xb9d21
xorb $0x1, %al
movzbl %bpl, %esi
movzbl %al, %edx
leaq 0x6(%rsp), %rbx
movq %rbx, %rdi
callq 0xb8b52
movb (%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x9abca
btq $0x20, %rax
jb 0xb9cb0
jmp 0xb9cbe
|
/AST/Decl.cpp
|
getExplicitVisibilityAux(clang::NamedDecl const*, clang::NamedDecl::ExplicitVisibilityKind, bool)
|
static std::optional<Visibility>
getExplicitVisibilityAux(const NamedDecl *ND,
NamedDecl::ExplicitVisibilityKind kind,
bool IsMostRecent) {
assert(!IsMostRecent || ND == ND->getMostRecentDecl());
// Check the declaration itself first.
if (std::optional<Visibility> V = getVisibilityOf(ND, kind))
return V;
// If this is a member class of a specialization of a class template
// and the corresponding decl has explicit visibility, use that.
if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
if (InstantiatedFrom)
return getVisibilityOf(InstantiatedFrom, kind);
}
// If there wasn't explicit visibility there, and this is a
// specialization of a class template, check for visibility
// on the pattern.
if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
// Walk all the template decl till this point to see if there are
// explicit visibility attributes.
const auto *TD = spec->getSpecializedTemplate()->getTemplatedDecl();
while (TD != nullptr) {
auto Vis = getVisibilityOf(TD, kind);
if (Vis != std::nullopt)
return Vis;
TD = TD->getPreviousDecl();
}
return std::nullopt;
}
// Use the most recent declaration.
if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
const NamedDecl *MostRecent = ND->getMostRecentDecl();
if (MostRecent != ND)
return getExplicitVisibilityAux(MostRecent, kind, true);
}
if (const auto *Var = dyn_cast<VarDecl>(ND)) {
if (Var->isStaticDataMember()) {
VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
if (InstantiatedFrom)
return getVisibilityOf(InstantiatedFrom, kind);
}
if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
kind);
return std::nullopt;
}
// Also handle function template specializations.
if (const auto *fn = dyn_cast<FunctionDecl>(ND)) {
// If the function is a specialization of a template with an
// explicit visibility attribute, use that.
if (FunctionTemplateSpecializationInfo *templateInfo
= fn->getTemplateSpecializationInfo())
return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
kind);
// If the function is a member of a specialization of a class template
// and the corresponding decl has explicit visibility, use that.
FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
if (InstantiatedFrom)
return getVisibilityOf(InstantiatedFrom, kind);
return std::nullopt;
}
// The visibility of a template is stored in the templated decl.
if (const auto *TD = dyn_cast<TemplateDecl>(ND))
return getVisibilityOf(TD->getTemplatedDecl(), kind);
return std::nullopt;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0xbf5e7
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
btq $0x20, %rax
jb 0xba398
movl %ebp, 0x4(%rsp)
movb $0x1, %bpl
testq %r14, %r14
je 0xba167
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x3b, %eax
cmpl $-0x3, %eax
jb 0xba167
movq %r14, %rdi
callq 0xc76a2
testq %rax, %rax
je 0xba167
movq %rax, %rdi
movl %ebx, %esi
callq 0xbf5e7
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
xorl %ebp, %ebp
testb %bpl, %bpl
je 0xba398
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x3b, %eax
cmpl $-0x2, %eax
setb %al
testq %r14, %r14
sete %bpl
orb %al, %bpl
jne 0xba1ed
movq %r14, %rdi
callq 0xd3aca
movq 0x30(%rax), %r12
testq %r12, %r12
je 0xba1da
movq %r12, %rdi
movl %ebx, %esi
callq 0xbf5e7
movq %rax, %r15
btq $0x20, %rax
jb 0xba1df
testb $0x3, 0x60(%r12)
je 0xba1be
xorl %r12d, %r12d
jmp 0xba1ce
leaq 0x60(%r12), %rdi
movq %r12, %rsi
callq 0x79ef0
movq %rax, %r12
testq %r12, %r12
jne 0xba19d
movq %r15, %r13
shrq $0x28, %r13
xorl %r12d, %r12d
jmp 0xba1ed
movq %r15, %r12
shrq $0x20, %r12
movq %r15, %r13
shrq $0x28, %r13
testb %bpl, %bpl
je 0xba398
cmpb $0x0, 0x4(%rsp)
jne 0xba243
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0xba243
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %rbp
cmpq %r14, %rax
je 0xba23a
movq %rbp, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0xba0ef
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
cmpq %r14, %rbp
jne 0xba398
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x2c, %eax
cmpl $-0x7, %eax
setb %al
testq %r14, %r14
sete %bpl
orb %al, %bpl
jne 0xba2e4
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xba2af
movq 0x10(%r14), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xba282
movq (%rax), %rax
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
addl $-0x37, %eax
cmpw $0x3, %ax
ja 0xba2af
movq %r14, %rdi
callq 0xbc33a
testq %rax, %rax
je 0xba2a8
movq (%rax), %rdi
andq $-0x8, %rdi
jmp 0xba2aa
xorl %edi, %edi
testq %rdi, %rdi
jne 0xba2c7
movl 0x1c(%r14), %eax
andl $0x7e, %eax
cmpl $0x26, %eax
jne 0xba2e1
movq %r14, %rdi
callq 0xd3ae8
movq 0x30(%rax), %rdi
movl %ebx, %esi
callq 0xbf5e7
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
jmp 0xba2e4
xorl %r12d, %r12d
testb %bpl, %bpl
je 0xba398
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x25, %eax
cmpl $-0x6, %eax
setb %al
testq %r14, %r14
sete %bpl
orb %al, %bpl
jne 0xba360
movq 0x98(%r14), %rax
movl %eax, %ecx
andl $0x6, %ecx
cmpl $0x4, %ecx
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0xba33c
movq %r14, %rdi
callq 0xbc7c2
testq %rax, %rax
je 0xba3bc
movq %rax, %rdi
jmp 0xba348
movq 0x10(%rax), %rax
andq $-0x8, %rax
movq 0x30(%rax), %rdi
movl %ebx, %esi
callq 0xbf5e7
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
testb %bpl, %bpl
je 0xba398
xorl %r12d, %r12d
testq %r14, %r14
je 0xba398
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x48, %eax
cmpl $-0x7, %eax
jb 0xba398
movq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0xbf5e7
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq %rax, %r13
shrq $0x28, %r13
shlq $0x28, %r13
movzbl %r12b, %ecx
shlq $0x20, %rcx
orq %r13, %rcx
movl %r15d, %eax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xba360
nop
|
/AST/Decl.cpp
|
clang::LinkageComputer::getLVForClosure(clang::DeclContext const*, clang::Decl*, clang::LVComputationKind)
|
LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
Decl *ContextDecl,
LVComputationKind computation) {
// This lambda has its linkage/visibility determined by its owner.
const NamedDecl *Owner;
if (!ContextDecl)
Owner = dyn_cast<NamedDecl>(DC);
else if (isa<ParmVarDecl>(ContextDecl))
Owner =
dyn_cast<NamedDecl>(ContextDecl->getDeclContext()->getRedeclContext());
else if (isa<ImplicitConceptSpecializationDecl>(ContextDecl)) {
// Replace with the concept's owning decl, which is either a namespace or a
// TU, so this needs a dyn_cast.
Owner = dyn_cast<NamedDecl>(ContextDecl->getDeclContext());
} else {
Owner = cast<NamedDecl>(ContextDecl);
}
if (!Owner)
return LinkageInfo::none();
// If the owner has a deduced type, we need to skip querying the linkage and
// visibility of that type, because it might involve this closure type. The
// only effect of this is that we might give a lambda VisibleNoLinkage rather
// than NoLinkage when we don't strictly need to, which is benign.
auto *VD = dyn_cast<VarDecl>(Owner);
LinkageInfo OwnerLV =
VD && VD->getType()->getContainedDeducedType()
? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/true)
: getLVForDecl(Owner, computation);
// A lambda never formally has linkage. But if the owner is externally
// visible, then the lambda is too. We apply the same rules to blocks.
if (!isExternallyVisible(OwnerLV.getLinkage()))
return LinkageInfo::none();
return LinkageInfo(Linkage::VisibleNone, OwnerLV.getVisibility(),
OwnerLV.isVisibilityExplicit());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0xba406
movq %rdx, %r15
movl 0x1c(%rdx), %eax
andl $0x7f, %eax
cmpl $0x50, %eax
je 0xba422
cmpl $0x28, %eax
jne 0xba446
movq 0x10(%r15), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0xba3f8
movq (%rdi), %rdi
callq 0xc1f32
movq %rax, %rsi
movzwl 0x8(%rax), %eax
jmp 0xba40a
movzwl 0x8(%rsi), %eax
andl $0x7f, %eax
addl $-0xf, %eax
cmpl $0x3f, %eax
jae 0xba443
movq %rsi, %rdi
callq 0xc1de2
movq %rax, %r15
jmp 0xba446
movq 0x10(%r15), %rax
movq %rax, %rsi
andq $-0x8, %rsi
testb $0x4, %al
je 0xba434
movq (%rsi), %rsi
movzwl 0x8(%rsi), %eax
andl $0x7f, %eax
addl $-0xf, %eax
cmpl $0x3e, %eax
jbe 0xba415
xorl %r15d, %r15d
movb $0x11, %bpl
testq %r15, %r15
je 0xba4a6
movl 0x1c(%r15), %eax
andl $0x7f, %eax
addl $-0x2c, %eax
cmpl $-0x7, %eax
jb 0xba486
movq 0x30(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c7c
testq %rax, %rax
je 0xba486
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0xb9d50
jmp 0xba493
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xb89e6
movl %eax, %ecx
andb $0x7, %cl
addb $-0x4, %cl
cmpb $0x2, %cl
ja 0xba4a6
andb $0x38, %al
orb $0x4, %al
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Decl.cpp
|
clang::FunctionDecl::getTemplateSpecializationKind() const
|
static inline bool isPresent(const T &t) { return t != T(nullptr); }
|
movq 0x98(%rdi), %rdx
movl %edx, %ecx
andl $0x6, %ecx
cmpq $0x4, %rcx
setne %al
andq $-0x8, %rdx
sete %sil
orb %al, %sil
jne 0xba8a6
movl 0x10(%rdx), %eax
shrl %eax
andl $0x3, %eax
incl %eax
testb %sil, %sil
je 0xba8de
cmpl $0x2, %ecx
setne %r8b
testq %rdx, %rdx
sete %sil
orb %r8b, %sil
jne 0xba8c7
movl (%rdx), %eax
shrl %eax
andl $0x3, %eax
incl %eax
testb %sil, %sil
je 0xba8de
cmpl $0x6, %ecx
jne 0xba8dc
movzwl 0x1e(%rdi), %eax
testl $0x180, %eax # imm = 0x180
je 0xba8df
xorl %eax, %eax
retq
movl $0x2, %eax
retq
nop
|
/llvm/Support/Casting.h
|
clang::NamedDecl::isCXXClassMember() const
|
constexpr intptr_t asInt() const {
intptr_t R = 0;
std::memcpy(&R, Data, sizeof(R));
return R;
}
|
movq 0x10(%rdi), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xbb5e5
movq (%rax), %rax
pushq %rax
movzwl 0x8(%rax), %ecx
andl $0x7f, %ecx
cmpw $0x3b, %cx
jne 0xbb5fb
movq %rax, %rdi
callq 0xc1f32
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
addl $-0x37, %eax
cmpw $0x4, %ax
setb %al
popq %rcx
retq
|
/llvm/ADT/PointerIntPair.h
|
clang::VarDecl::hasDefinition(clang::ASTContext&) const
|
static std::optional<Visibility>
getVisibilityOf(const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind) {
// If we're ultimately computing the visibility of a type, look for
// a 'type_visibility' attribute before looking for 'visibility'.
if (kind == NamedDecl::VisibilityForType) {
if (const auto *A = D->getAttr<TypeVisibilityAttr>()) {
return getVisibilityFromAttr(A);
}
}
// If this declaration has an explicit visibility attribute, use it.
if (const auto *A = D->getAttr<VisibilityAttr>()) {
return getVisibilityFromAttr(A);
}
return std::nullopt;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %r12
testq %r12, %r12
je 0xbbcd6
movq %rsi, %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %r12, %r15
movl %r14d, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbb8f6
movl %eax, %r14d
cmpl %eax, %ebp
cmovgl %ebp, %r14d
cmpl $0x2, %r14d
je 0xbbcd9
testb $0x3, 0x48(%r15)
je 0xbbcb0
movb $0x1, %bpl
testb $0x1, %r13b
je 0xbbcb3
xorl %r15d, %r15d
jmp 0xbbccf
movl %r13d, %ebp
leaq 0x48(%r15), %rdi
movq %r15, %rsi
callq 0x99420
cmpq %r12, %rax
movl $0x0, %r15d
cmovneq %rax, %r15
movl %ebp, %r13d
testq %r15, %r15
jne 0xbbc7e
jmp 0xbbcd9
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Decl.cpp
|
clang::VarDecl::getAnyInitializer(clang::VarDecl const*&) const
|
const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
for (auto *I : redecls()) {
if (auto Expr = I->getInit()) {
D = I;
return Expr;
}
}
return nullptr;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq %rdi, %r12
movq %r12, %rdi
callq 0xbbd6c
testq %rax, %rax
je 0xbbd16
movq %r12, (%rbx)
movq %rax, %r15
testq %rax, %rax
jne 0xbbd59
testb $0x3, 0x48(%r12)
je 0xbbd31
movb $0x1, %bpl
testb $0x1, %r13b
je 0xbbd34
xorl %r12d, %r12d
jmp 0xbbd51
movl %r13d, %ebp
leaq 0x48(%r12), %rdi
movq %r12, %rsi
callq 0x99420
cmpq %r14, %rax
movl $0x0, %r12d
cmovneq %rax, %r12
movl %ebp, %r13d
testq %r12, %r12
jne 0xbbd03
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Decl.cpp
|
bool clang::Decl::hasAttr<clang::AlwaysDestroyAttr>() const
|
bool hasAttrs() const { return HasAttrs; }
|
testb $0x1, 0x1d(%rdi)
jne 0xbc42f
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0xbc45c
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x6f, 0x20(%rsi)
je 0xbc45c
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0xbc448
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
retq
nop
|
/clang/AST/DeclBase.h
|
clang::FunctionDecl::getDescribedFunctionTemplate() const
|
static inline bool isPresent(const T &t) { return t != T(nullptr); }
|
movq 0x98(%rdi), %rcx
testb $0x6, %cl
setne %al
andq $-0x8, %rcx
sete %dl
orb %al, %dl
je 0xbc86b
xorl %eax, %eax
retq
movl 0x1c(%rcx), %edx
andl $0x7f, %edx
xorl %eax, %eax
cmpl $0x44, %edx
cmoveq %rcx, %rax
retq
nop
|
/llvm/Support/Casting.h
|
clang::FunctionDecl::isReservedGlobalPlacementOperator() const
|
bool FunctionDecl::isReservedGlobalPlacementOperator() const {
if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
return false;
if (getDeclName().getCXXOverloadedOperator() != OO_New &&
getDeclName().getCXXOverloadedOperator() != OO_Delete &&
getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
return false;
if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
return false;
const auto *proto = getType()->castAs<FunctionProtoType>();
if (proto->getNumParams() != 2 || proto->isVariadic())
return false;
const ASTContext &Context =
cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
->getASTContext();
// The result type and first argument type are constant across all
// these operators. The second argument must be exactly void*.
return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x7, %ecx
jne 0xbcd0a
movq %rax, %rcx
andq $-0x8, %rcx
movl (%rcx), %edx
cmpl $0x3, %edx
movl $0x3, %ecx
cmovbl %edx, %ecx
orl $0x8, %ecx
cmpl $0x6, %ecx
jne 0xbcdfb
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x6, %rcx
jne 0xbcdfb
andq $-0x8, %rax
cmpl $0x1, (%rax)
jne 0xbcdd1
movq 0x10(%rbx), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0xbcd41
movq (%rdi), %rdi
callq 0xc1f32
testb $0x7f, 0x8(%rax)
jne 0xbcdfb
movq 0x30(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
xorl %r14d, %r14d
cmpb $0x1a, 0x10(%rdi)
cmoveq %rdi, %r14
je 0xbcd70
callq 0x22549c
movq %rax, %r14
movabsq $0x103fffc000000000, %rax # imm = 0x103FFFC000000000
andq 0x10(%r14), %rax
movabsq $0x8000000000, %rcx # imm = 0x8000000000
cmpq %rcx, %rax
jne 0xbcdfb
movq 0x10(%rbx), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0xbcd9f
movq (%rdi), %rdi
callq 0xc1f32
leaq -0x28(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x38(%r14), %rax
movq %rax, %rdx
andq $-0x10, %rdx
andl $0x7, %eax
orq 0x8(%rdx), %rax
movq 0x58(%rcx), %rcx
cmpq 0x4990(%rcx), %rax
sete %al
jmp 0xbcdfd
cmpl $0x6, %ecx
jne 0xbcdfb
cmpl $0x2, (%rax)
je 0xbcd2f
cmpl $0x6, %ecx
jne 0xbcdfb
cmpl $0x3, (%rax)
je 0xbcd2f
cmpl $0x6, %ecx
jne 0xbcdfb
cmpl $0x4, (%rax)
je 0xbcd2f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/Decl.cpp
|
clang::FunctionDecl::getTemplateSpecializationArgsAsWritten() const
|
static inline bool isPresent(const T &t) { return t != T(nullptr); }
|
movq 0x98(%rdi), %rcx
movl %ecx, %edx
andl $0x6, %edx
cmpq $0x4, %rdx
setne %al
andq $-0x8, %rcx
sete %sil
orb %al, %sil
jne 0xbde18
movq 0x20(%rcx), %rax
testb %sil, %sil
je 0xbde34
cmpl $0x6, %edx
setne %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
je 0xbde30
xorl %eax, %eax
retq
movq 0x8(%rcx), %rax
retq
nop
|
/llvm/Support/Casting.h
|
clang::TagDecl::completeDefinition()
|
void TagDecl::completeDefinition() {
assert((!isa<CXXRecordDecl>(this) ||
cast<CXXRecordDecl>(this)->hasDefinition()) &&
"definition completed but not started");
setCompleteDefinition(true);
setBeingDefined(false);
if (ASTMutationListener *L = getASTMutationListener())
L->CompletedTagDefinition(this);
}
|
pushq %rbx
movq %rdi, %rbx
movb 0x4a(%rdi), %al
andb $-0x4, %al
incb %al
movb %al, 0x4a(%rdi)
callq 0xc1278
testq %rax, %rax
je 0xbe676
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmpq *%rcx
popq %rbx
retq
|
/AST/Decl.cpp
|
clang::TypedefDecl::getSourceRange() const
|
SourceRange TypedefDecl::getSourceRange() const {
SourceLocation RangeEnd = getLocation();
if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
if (typeIsPostfix(TInfo->getType()))
RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
}
return SourceRange(getBeginLoc(), RangeEnd);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq %rax, %r15
andq $-0x8, %r15
testb $0x4, %al
je 0xbf1d0
movq (%r15), %r15
movl 0x18(%rbx), %r14d
testq %r15, %r15
je 0xbf209
movq (%r15), %rdi
callq 0xbb6c4
testb %al, %al
je 0xbf209
movq (%r15), %rax
addq $0x8, %r15
movq %rsp, %r14
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %r14, %rdi
callq 0x22d2de
movq %r14, %rdi
callq 0x22d3b0
movl %eax, %r14d
movl 0x38(%rbx), %eax
shlq $0x20, %r14
orq %rax, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Decl.cpp
|
bool llvm::DenseMapBase<llvm::DenseMap<clang::Decl*, clang::Decl*, llvm::DenseMapInfo<clang::Decl*, void>, llvm::detail::DenseMapPair<clang::Decl*, clang::Decl*>>, clang::Decl*, clang::Decl*, llvm::DenseMapInfo<clang::Decl*, void>, llvm::detail::DenseMapPair<clang::Decl*, clang::Decl*>>::LookupBucketFor<clang::Decl const*>(clang::Decl const* const&, llvm::detail::DenseMapPair<clang::Decl*, clang::Decl*> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xbf41f
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0xbf3e6
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0xbf3c3
jmp 0xbf41c
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0xbf400
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0xbf3df
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0xbf3df
popq %rbx
jmp 0xbf428
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
clang::DeclarationNameInfo::getEndLocPrivate() const
|
StoredNameKind getStoredNameKind() const {
return static_cast<StoredNameKind>(Ptr & PtrMask);
}
|
movq (%rdi), %rcx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x7, %eax
jne 0xc0a8f
andq $-0x8, %rcx
movl (%rcx), %ecx
cmpl $0x3, %ecx
movl $0x3, %eax
cmovbl %ecx, %eax
orl $0x8, %eax
movl %eax, %eax
leaq 0x26c364(%rip), %rcx # 0x32cdfc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %eax
retq
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xc0aa1
subq $0x18, %rsp
movq (%rax), %rcx
addq $0x8, %rax
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x22d3b0
addq $0x18, %rsp
retq
movl 0x14(%rdi), %eax
retq
movl 0x10(%rdi), %eax
retq
nop
|
/clang/AST/DeclarationName.h
|
clang::Decl::getDescribedTemplate() const
|
TemplateDecl *Decl::getDescribedTemplate() const {
if (auto *FD = dyn_cast<FunctionDecl>(this))
return FD->getDescribedFunctionTemplate();
if (auto *RD = dyn_cast<CXXRecordDecl>(this))
return RD->getDescribedClassTemplate();
if (auto *VD = dyn_cast<VarDecl>(this))
return VD->getDescribedVarTemplate();
if (auto *AD = dyn_cast<TypeAliasDecl>(this))
return AD->getDescribedAliasTemplate();
return nullptr;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %ebp
andl $0x7f, %ebp
addl $-0x25, %ebp
cmpl $-0x6, %ebp
jb 0xc0d7e
movq %rbx, %rdi
callq 0xbc850
cmpl $-0x7, %ebp
ja 0xc0dcc
movl 0x1c(%rbx), %ebp
andl $0x7f, %ebp
addl $-0x3b, %ebp
cmpl $-0x3, %ebp
jb 0xc0d99
movq %rbx, %rdi
callq 0xc76de
cmpl $-0x4, %ebp
ja 0xc0dcc
movl 0x1c(%rbx), %ebp
andl $0x7f, %ebp
addl $-0x2c, %ebp
cmpl $-0x7, %ebp
jb 0xc0db4
movq %rbx, %rdi
callq 0xb95f2
cmpl $-0x8, %ebp
ja 0xc0dcc
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x3e, %eax
jne 0xc0dca
movq 0x58(%rbx), %rax
jmp 0xc0dcc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/AST/DeclBase.cpp
|
shouldBeHidden(clang::NamedDecl*)
|
static bool shouldBeHidden(NamedDecl *D) {
// Skip unnamed declarations.
if (!D->getDeclName())
return true;
// Skip entities that can't be found by name lookup into a particular
// context.
if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
D->isTemplateParameter())
return true;
// Skip friends and local extern declarations unless they're the first
// declaration of the entity.
if ((D->isLocalExternDecl() || D->getFriendObjectKind()) &&
D != D->getCanonicalDecl())
return true;
// Skip template specializations.
// FIXME: This feels like a hack. Should DeclarationName support
// template-ids, or is there a better way to keep specializations
// from being visible?
if (isa<ClassTemplateSpecializationDecl>(D))
return true;
if (auto *FD = dyn_cast<FunctionDecl>(D))
if (FD->isFunctionTemplateSpecialization())
return true;
// Hide destructors that are invalid. There should always be one destructor,
// but if it is an invalid decl, another one is created. We need to hide the
// invalid one from places that expect exactly one destructor, like the
// serialization code.
if (isa<CXXDestructorDecl>(D) && D->isInvalidDecl())
return true;
return false;
}
|
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpq $0x0, 0x28(%rdi)
je 0xc2608
movq %rdi, %r14
movl 0x1c(%rdi), %eax
testl $0x3fff0000, %eax # imm = 0x3FFF0000
sete %dl
movl %eax, %ecx
andl $0x7f, %ecx
cmpl $0x35, %ecx
setne %sil
testb %sil, %dl
jne 0xc2608
addl $-0x2c, %ecx
cmpl $0x15, %ecx
ja 0xc2612
movl $0x300001, %edx # imm = 0x300001
btl %ecx, %edx
jae 0xc2612
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testl $0x9800000, %eax # imm = 0x9800000
je 0xc2627
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
cmpq %r14, %rax
jne 0xc2608
movl 0x1c(%r14), %eax
andl $0x7f, %eax
leal -0x39(%rax), %ecx
cmpl $0x2, %ecx
jb 0xc2608
addl $-0x25, %eax
cmpl $-0x6, %eax
setb %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xc2655
movq %r14, %rdi
callq 0xbdb6c
testb %al, %al
jne 0xc2608
cmpb $-0x5f, 0x1c(%r14)
sete %bl
jmp 0xc2608
nop
|
/AST/DeclBase.cpp
|
clang::StoredDeclsList::prependDeclNoReplace(clang::NamedDecl*)
|
void prependDeclNoReplace(NamedDecl *D) {
if (isNull()) {
Data.setPointer(D);
return;
}
ASTContext &C = D->getASTContext();
DeclListNode *Node = C.AllocateDeclListNode(D);
Node->Rest = Data.getPointer();
Data.setPointer(Node);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
cmpq $0x7, %rcx
ja 0xc2eaf
andq $-0x5, %r14
andl $0x3, %ecx
orq %r14, %rcx
jmp 0xc2edb
movq %r14, %rdi
callq 0xc1216
movq 0x58(%rax), %rdi
movq %r14, %rsi
callq 0xc3464
movq (%rbx), %rcx
andq $-0x4, %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rcx
andl $0x3, %ecx
orq %rax, %rcx
orq $0x4, %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/clang/AST/DeclContextInternals.h
|
clang::CXXRecordDecl::isTriviallyCopyConstructible() const
|
bool CXXRecordDecl::isTriviallyCopyConstructible() const {
// A trivially copy constructible class is a class that:
// -- has no non-trivial copy constructors,
if (hasNonTrivialCopyConstructor())
return false;
// -- has a trivial destructor.
if (!hasTrivialDestructor())
return false;
return true;
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xc4aca
testb %al, %al
je 0xc4bf3
xorl %eax, %eax
jmp 0xc4c0f
movq 0x68(%rbx), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%rbx), %rax
movb 0x5(%rax), %al
andb $0x10, %al
shrb $0x4, %al
popq %rbx
retq
nop
|
/AST/DeclCXX.cpp
|
clang::ASTUnresolvedSet::addDecl(clang::ASTContext&, clang::NamedDecl*, clang::AccessSpecifier)
|
void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS) {
Decls.push_back(DeclAccessPair::make(D, AS), C);
}
|
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
andq $-0x8, %rax
cmpq %rax, 0x8(%rdi)
jb 0xc6db7
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc8e1c
movl %ebp, %eax
orq %r14, %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
addq $0x8, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/clang/AST/ASTUnresolvedSet.h
|
clang::LValueReferenceType const* clang::Type::getAs<clang::LValueReferenceType>() const
|
const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
"ArrayType cannot be used with getAs!");
// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
return Ty;
// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
return nullptr;
// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
}
|
xorl %eax, %eax
cmpb $0x29, 0x10(%rdi)
cmoveq %rdi, %rax
je 0xc7d69
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x29, 0x10(%rax)
je 0x22549c
xorl %eax, %eax
retq
|
/clang/AST/Type.h
|
clang::CXXMethodDecl::isLambdaStaticInvoker() const
|
bool CXXMethodDecl::isLambdaStaticInvoker() const {
const CXXRecordDecl *P = getParent();
return P->isLambda() && getDeclName().isIdentifier() &&
getName() == getLambdaStaticInvokerName();
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x48, %rdi
callq 0xc1de2
movq 0x10(%rax), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xc7eee
movq (%rax), %rax
leaq -0x40(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x80(%rcx), %rax
testq %rax, %rax
je 0xc7f45
testb $0x10, 0xa(%rax)
je 0xc7f45
movq 0x28(%rbx), %rax
testb $0x7, %al
jne 0xc7f45
testq %rax, %rax
je 0xc7f24
movq 0x10(%rax), %rdi
movl (%rdi), %edx
addq $0x10, %rdi
jmp 0xc7f2d
leaq 0x2c79b9(%rip), %rdi # 0x38f8e4
xorl %edx, %edx
cmpl $0x8, %edx
jne 0xc7f45
leaq 0x266391(%rip), %rsi # 0x32e2ca
callq 0x3c520
testl %eax, %eax
sete %al
jmp 0xc7f47
xorl %eax, %eax
popq %rbx
retq
nop
|
/AST/DeclCXX.cpp
|
clang::CXXConstructorDecl::init_begin() const
|
CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
return CtorInitializers.get(getASTContext().getExternalSource());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %r14
testb $0x1, %r14b
je 0xc7fa2
movq %rbx, %rdi
callq 0xc0b9c
movq 0x46d8(%rax), %rdi
movq (%rdi), %rax
shrq %r14
movq %r14, %rsi
callq *0x30(%rax)
movq %rax, 0xa8(%rbx)
movq 0xa8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/DeclCXX.cpp
|
clang::BindingDecl::getHoldingVar() const
|
Expr *getBinding() const { return Binding; }
|
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xc83aa
pushq %rax
callq 0xd929c
cmpb $0x46, (%rax)
jne 0xc83ad
movq 0x10(%rax), %rax
jmp 0xc83af
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
|
/clang/AST/DeclCXX.h
|
clang::UnnamedGlobalConstantDecl::UnnamedGlobalConstantDecl(clang::ASTContext const&, clang::DeclContext*, clang::QualType, clang::APValue const&)
|
UnnamedGlobalConstantDecl::UnnamedGlobalConstantDecl(const ASTContext &C,
DeclContext *DC,
QualType Ty,
const APValue &Val)
: ValueDecl(Decl::UnnamedGlobalConstant, DC, SourceLocation(),
DeclarationName(), Ty),
Value(Val) {
// Cleanup the embedded APValue if required (note that our destructor is never
// run)
if (Value.needsCleanup())
C.addDestruction(&Value);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movl $0x1a, %esi
xorl %ecx, %ecx
callq 0xb86b2
movq %r13, 0x28(%rbx)
movq %r12, 0x30(%rbx)
movq %r13, 0x38(%rbx)
leaq 0x3f0ac1(%rip), %rax # 0x4b9350
addq $0x10, %rax
movq %rax, (%rbx)
addq $0x40, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x866dc
movq %rbx, %rdi
callq 0x870e6
testb %al, %al
je 0xc88cc
leaq -0x8c92(%rip), %rsi # 0xbfc26
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a068
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/AST/DeclCXX.cpp
|
clang::Redeclarable<clang::NamespaceDecl>::DeclLink::setLatest(clang::NamespaceDecl*)
|
void setLatest(decl_type *D) {
assert(isFirst() && "decl became canonical unexpectedly");
if (Link.is<NotKnownLatest>()) {
NotKnownLatest NKL = Link.get<NotKnownLatest>();
Link = KnownLatest(*reinterpret_cast<const ASTContext *>(
NKL.get<UninitializedLatest>()),
D);
} else {
auto Latest = Link.get<KnownLatest>();
Latest.set(D);
Link = Latest;
}
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testb $0x1, %al
jne 0xc95e1
andq $-0x4, %rax
movq %rax, %rdi
callq 0x78712
jmp 0xc9603
testb $0x4, %al
sete %dl
movq %rax, %rcx
andq $-0x8, %rcx
sete %dil
orb %dl, %dil
je 0xc95ff
andq $-0x5, %rsi
movq %rsi, %rax
jmp 0xc9603
movq %rsi, 0x10(%rcx)
orq $0x1, %rax
movq %rax, (%rbx)
popq %rbx
retq
|
/clang/AST/Redeclarable.h
|
clang::ObjCInterfaceDecl::getSuperClass() const
|
ObjCInterfaceDecl *ObjCInterfaceDecl::getSuperClass() const {
// FIXME: Should make sure no callers ever do this.
if (!hasDefinition())
return nullptr;
if (data().ExternallyCompleted)
LoadExternalDefinition();
if (const ObjCObjectType *superType = getSuperClassType()) {
if (ObjCInterfaceDecl *superDecl = superType->getInterface()) {
if (ObjCInterfaceDecl *superDef = superDecl->getDefinition())
return superDef;
return superDecl;
}
}
return nullptr;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x78(%rdi)
jne 0xc9732
movq 0x60(%rbx), %rsi
leaq 0x58(%rsi), %rdi
callq 0x78662
movq 0x78(%rbx), %rax
cmpq $0x8, %rax
jb 0xc97e3
andq $-0x8, %rax
movb 0x48(%rax), %cl
testb $0x1, %cl
je 0xc976d
andb $-0x2, %cl
movb %cl, 0x48(%rax)
movq %rbx, %rdi
callq 0xc0b9c
movq 0x46d8(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x90(%rax)
movq %rbx, %rdi
callq 0xc9d62
testq %rax, %rax
je 0xc97e3
movq 0x18(%rax), %r15
movq %r15, %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x90ed2
testq %rax, %rax
je 0xc97bd
movq %rax, %r14
movb 0x10(%rax), %bpl
cmpb $0x22, %bpl
jne 0xc97aa
movq %r14, %rdi
callq 0x2268c6
movq %rax, %rbx
movl $0x1, %eax
cmpb $0x22, %bpl
je 0xc97c2
movq 0x18(%r14), %r15
xorl %eax, %eax
jmp 0xc97c2
movl $0x3, %eax
testl %eax, %eax
je 0xc977e
cmpl $0x3, %eax
jne 0xc97cd
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xc97e3
movq %rbx, %rdi
callq 0xc20ee
testq %rax, %rax
cmoveq %rbx, %rax
jmp 0xc97e5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/DeclObjC.cpp
|
clang::ObjCInterfaceDecl::LoadExternalDefinition() const
|
void ObjCInterfaceDecl::LoadExternalDefinition() const {
assert(data().ExternallyCompleted && "Class is not externally completed");
data().ExternallyCompleted = false;
getASTContext().getExternalSource()->CompleteType(
const_cast<ObjCInterfaceDecl *>(this));
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rax
andq $-0x8, %rax
andb $-0x2, 0x48(%rax)
callq 0xc0b9c
movq 0x46d8(%rax), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
|
/AST/DeclObjC.cpp
|
clang::ObjCProtocolDecl::getObjCRuntimeNameAsString() const
|
StringRef
ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
return ObjCRTName->getMetadataName();
return getName();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xcaafc
movq %rax, %rcx
testq %rax, %rax
je 0xcb0e0
movq 0x28(%rcx), %rax
movl 0x24(%rcx), %edx
jmp 0xcb0e0
testq %rcx, %rcx
jne 0xcb10e
movq 0x28(%rbx), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0xcb104
leaq 0x2c47e4(%rip), %rax # 0x38f8e4
xorl %edx, %edx
jmp 0xcb10e
movq 0x10(%rax), %rax
movl (%rax), %edx
addq $0x10, %rax
popq %rbx
retq
|
/AST/DeclObjC.cpp
|
CollectOverriddenMethodsRecurse(clang::ObjCContainerDecl const*, clang::ObjCMethodDecl const*, llvm::SmallVectorImpl<clang::ObjCMethodDecl const*>&, bool)
|
static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
const ObjCMethodDecl *Method,
SmallVectorImpl<const ObjCMethodDecl *> &Methods,
bool MovedToSuper) {
if (!Container)
return;
// In categories look for overridden methods from protocols. A method from
// category is not "overridden" since it is considered as the "same" method
// (same USR) as the one from the interface.
if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
// Check whether we have a matching method at this category but only if we
// are at the super class level.
if (MovedToSuper)
if (ObjCMethodDecl *
Overridden = Container->getMethod(Method->getSelector(),
Method->isInstanceMethod(),
/*AllowHidden=*/true))
if (Method != Overridden) {
// We found an override at this category; there is no need to look
// into its protocols.
Methods.push_back(Overridden);
return;
}
for (const auto *P : Category->protocols())
CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
return;
}
// Check whether we have a matching method at this level.
if (const ObjCMethodDecl *
Overridden = Container->getMethod(Method->getSelector(),
Method->isInstanceMethod(),
/*AllowHidden=*/true))
if (Method != Overridden) {
// We found an override at this level; there is no need to look
// into other protocols or categories.
Methods.push_back(Overridden);
return;
}
if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
for (const auto *P : Protocol->protocols())
CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
}
if (const auto *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
for (const auto *P : Interface->protocols())
CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
for (const auto *Cat : Interface->known_categories())
CollectOverriddenMethodsRecurse(Cat, Method, Methods, MovedToSuper);
if (const ObjCInterfaceDecl *Super = Interface->getSuperClass())
return CollectOverriddenMethodsRecurse(Super, Method, Methods,
/*MovedToSuper=*/true);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %r12, %r12
je 0xcb35f
movl 0x1c(%r12), %eax
andl $0x7f, %eax
movl $0x0, %r13d
movzbl %cl, %r15d
cmpl $0x14, %eax
cmoveq %r12, %r13
movq %r12, (%rsp)
jne 0xcb251
movl %eax, 0xc(%rsp)
testb $0x1, %cl
je 0xcb1f7
movq 0x28(%r14), %rsi
movzbl 0x3a(%r14), %edx
shrl %edx
andl $0x1, %edx
movq %r12, %rdi
movl $0x1, %ecx
callq 0xc962c
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %dl
orb %cl, %dl
je 0xcb237
movl 0x70(%r13), %r12d
testq %r12, %r12
je 0xcb242
movq 0x68(%r13), %rax
movq %rax, 0x10(%rsp)
shlq $0x3, %r12
movl %r15d, %ebp
andl $0x1, %ebp
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movq (%rax,%r13), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xcb180
addq $0x8, %r13
cmpq %r13, %r12
jne 0xcb216
jmp 0xcb242
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc9ed4
cmpl $0x14, 0xc(%rsp)
movq (%rsp), %r12
je 0xcb35f
movq 0x28(%r14), %rsi
movzbl 0x3a(%r14), %edx
shrl %edx
andl $0x1, %edx
movq %r12, %rdi
movl $0x1, %ecx
callq 0xc962c
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %dl
orb %cl, %dl
je 0xcb36e
movl 0x1c(%r12), %eax
andl $0x7f, %eax
cmpl $0x10, %eax
jne 0xcb2cc
movq (%rsp), %r13
movq %r13, %rdi
callq 0x95cea
movq %rax, %r12
movq %r13, %rdi
callq 0x95d1a
cmpq %rax, %r12
je 0xcb2cc
movq %rax, %r13
movl %r15d, %ebp
andl $0x1, %ebp
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xcb180
addq $0x8, %r12
cmpq %r13, %r12
jne 0xcb2b2
movq (%rsp), %rbp
movl 0x1c(%rbp), %eax
andl $0x7f, %eax
cmpl $0x11, %eax
jne 0xcb35f
movq %rbp, %rdi
callq 0x95c34
movq %rax, %r12
movq %rbp, %rdi
callq 0x95c7a
movq %rax, %r13
cmpq %rax, %r12
je 0xcb318
movq (%r12), %rdi
movl %r15d, %ecx
andl $0x1, %ecx
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcb180
addq $0x8, %r12
cmpq %r13, %r12
jne 0xcb2fa
movq %rbp, %rdi
callq 0x7861c
movq %rax, %r12
testq %rax, %rax
je 0xcb349
movl %r15d, %ecx
andl $0x1, %ecx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcb180
movq 0x80(%r12), %r12
testq %r12, %r12
jne 0xcb328
movq %rbp, %rdi
callq 0xc9714
movq %rax, %r12
movb $0x1, %cl
testq %rax, %rax
jne 0xcb197
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc9ed4
nop
|
/AST/DeclObjC.cpp
|
clang::Decl::printGroup(clang::Decl**, unsigned int, llvm::raw_ostream&, clang::PrintingPolicy const&, unsigned int)
|
void Decl::printGroup(Decl** Begin, unsigned NumDecls,
raw_ostream &Out, const PrintingPolicy &Policy,
unsigned Indentation) {
if (NumDecls == 1) {
(*Begin)->print(Out, Policy, Indentation);
return;
}
Decl** End = Begin + NumDecls;
TagDecl* TD = dyn_cast<TagDecl>(*Begin);
if (TD)
++Begin;
PrintingPolicy SubPolicy(Policy);
bool isFirst = true;
for ( ; Begin != End; ++Begin) {
if (isFirst) {
if(TD)
SubPolicy.IncludeTagDefinition = true;
SubPolicy.SuppressSpecifiers = false;
isFirst = false;
} else {
if (!isFirst) Out << ", ";
SubPolicy.IncludeTagDefinition = false;
SubPolicy.SuppressSpecifiers = true;
}
(*Begin)->print(Out, SubPolicy, Indentation);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r14
cmpl $0x1, %esi
jne 0xcc365
movq (%rdi), %r15
movq %r15, %rdi
callq 0xc0b9c
leaq 0x20(%rsp), %rdi
movq %r14, (%rdi)
movups (%rbp), %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movl %ebx, 0x20(%rdi)
movb $0x0, 0x24(%rdi)
movq %r15, %rsi
callq 0xcbf32
jmp 0xcc46d
movl %ebx, 0x14(%rsp)
movl %esi, %edx
shlq $0x3, %rdx
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
addl $-0x3c, %ecx
cmpl $-0x5, %ecx
setb %cl
testq %rax, %rax
sete %al
orb %cl, %al
movb %al, 0x7(%rsp)
xorb $0x1, %al
movzbl %al, %r12d
shll $0x3, %r12d
movq %rdx, 0x18(%rsp)
cmpq %rdx, %r12
je 0xcc46d
movq 0x8(%rbp), %rbx
movq (%rbp), %r15
movb $0x1, %r13b
testb $0x1, %r13b
je 0xcc3e0
movq %r15, %rax
orq $0x400, %rax # imm = 0x400
cmpb $0x0, 0x7(%rsp)
cmovneq %r15, %rax
andq $-0x101, %rax # imm = 0xFEFF
xorl %r13d, %r13d
movq %rax, %r15
movq 0x8(%rsp), %rax
jmp 0xcc424
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xcc407
movl $0x2, %edx
movq %r14, %rdi
leaq 0x258c2b(%rip), %rsi # 0x32502b
callq 0x582a2
jmp 0xcc411
movw $0x202c, (%rax) # imm = 0x202C
addq $0x2, 0x20(%r14)
movq 0x8(%rsp), %rax
andq $-0x501, %r15 # imm = 0xFAFF
orq $0x100, %r15 # imm = 0x100
movq (%rax,%r12), %rbp
movq %rbp, %rdi
callq 0xc0b9c
movq %r14, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x40(%rsp)
movb $0x0, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0xcbf32
addq $0x8, %r12
cmpq %r12, 0x18(%rsp)
jne 0xcc3b5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitLinkageSpecDecl(clang::LinkageSpecDecl*)
|
void DeclPrinter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
const char *l;
if (D->getLanguage() == LinkageSpecLanguageIDs::C)
l = "C";
else {
assert(D->getLanguage() == LinkageSpecLanguageIDs::CXX &&
"unknown language in linkage specification");
l = "C++";
}
Out << "extern \"" << l << "\" ";
if (D->hasBraces()) {
Out << "{\n";
VisitDeclContext(D);
Indent() << "}";
} else
Visit(*D->decls_begin());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x30(%rsi), %ebp
andl $0xe000, %ebp # imm = 0xE000
cmpl $0x2000, %ebp # imm = 0x2000
leaq 0x2857f0(%rip), %rax # 0x3527f2
leaq 0x27c321(%rip), %r15 # 0x34932a
cmoveq %rax, %r15
movq (%rdi), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x7, %rcx
ja 0xcd037
leaq 0x261680(%rip), %rsi # 0x32e6a8
movl $0x8, %edx
callq 0x582a2
movq %rax, %rdi
jmp 0xcd049
movabsq $0x22206e7265747865, %rcx # imm = 0x22206E7265747865
movq %rcx, (%rax)
addq $0x8, 0x20(%rdi)
movzwl %bp, %eax
xorl %ecx, %ecx
cmpl $0x2000, %eax # imm = 0x2000
setne %cl
leaq 0x1(,%rcx,2), %rdx
movq %r15, %rsi
callq 0x577a6
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
subq %rcx, %rdx
cmpq $0x1, %rdx
ja 0xcd08d
leaq 0x261633(%rip), %rsi # 0x32e6b1
movl $0x2, %edx
movq %rax, %rdi
callq 0x582a2
jmp 0xcd097
movw $0x2022, (%rcx) # imm = 0x2022
addq $0x2, 0x20(%rax)
testb $0x1, 0x32(%r14)
jne 0xcd0bf
addq $0x28, %r14
movq %r14, %rdi
callq 0xc25b2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcbf32
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xcd0e6
leaq 0x2816f7(%rip), %rsi # 0x34e7d1
movl $0x2, %edx
callq 0x582a2
jmp 0xcd0f0
movw $0xa7b, (%rax) # imm = 0xA7B
addq $0x2, 0x20(%rdi)
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xcc47c
movq %rbx, %rdi
callq 0xcca46
movq 0x20(%rax), %rcx
cmpq %rcx, 0x18(%rax)
je 0xcd128
movb $0x7d, (%rcx)
incq 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27228a(%rip), %rsi # 0x33f3b9
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x582a2
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitStaticAssertDecl(clang::StaticAssertDecl*)
|
void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) {
Out << "static_assert(";
D->getAssertExpr()->printPretty(Out, nullptr, Policy, Indentation, "\n",
&Context);
if (Expr *E = D->getMessage()) {
Out << ", ";
E->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
}
Out << ")";
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x261553(%rip), %rsi # 0x32e6b4
movl $0xe, %edx
callq 0x577a6
movq 0x28(%r15), %rdi
andq $-0x4, %rdi
movq (%rbx), %rsi
leaq 0x8(%rbx), %r14
movl 0x20(%rbx), %r8d
leaq 0x283dcb(%rip), %r12 # 0x350f50
movq %r12, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x18(%rbx), %r9
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %edx, %edx
movq %r14, %rcx
callq 0x2104a0
movq 0x30(%r15), %r15
testq %r15, %r15
je 0xcd1f6
movq (%rbx), %rdi
leaq 0x257e6e(%rip), %rsi # 0x32502b
movl $0x2, %edx
callq 0x577a6
movq (%rbx), %rsi
movl 0x20(%rbx), %r8d
movq %r12, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
movq 0x18(%rbx), %r9
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2104a0
movq (%rbx), %rdi
leaq 0x258099(%rip), %rsi # 0x325299
movl $0x1, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x577a6
nop
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitObjCCategoryDecl(clang::ObjCCategoryDecl*)
|
void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
Out << "@interface ";
if (const auto *CID = PID->getClassInterface())
Out << *CID;
else
Out << "<<error-type>>";
if (auto TypeParams = PID->getTypeParamList()) {
PrintObjCTypeParams(TypeParams);
}
Out << "(" << *PID << ")\n";
if (PID->ivar_size() > 0) {
Out << "{\n";
Indentation += Policy.Indentation;
for (const auto *I : PID->ivars())
Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
getAsString(Policy) << ' ' << *I << ";\n";
Indentation -= Policy.Indentation;
Out << "}\n";
}
VisitDeclContext(PID, false);
Out << "@end";
// FIXME: implement the rest...
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0xa, %rcx
ja 0xce481
leaq 0x2602e6(%rip), %rsi # 0x32e75b
movl $0xb, %edx
callq 0x582a2
jmp 0xce49a
movabsq $0x61667265746e6940, %rcx # imm = 0x61667265746E6940
movq %rcx, (%rax)
movl $0x20656361, 0x7(%rax) # imm = 0x20656361
addq $0xb, 0x20(%rdi)
movq 0x58(%r14), %rdi
movq (%rbx), %rsi
testq %rdi, %rdi
je 0xce4ad
callq 0xbaa18
jmp 0xce4f7
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rax
subq %rax, %rcx
cmpq $0xd, %rcx
ja 0xce4d7
leaq 0x2602d1(%rip), %rax # 0x32e796
movl $0xe, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x582a2
jmp 0xce4f7
movabsq $0x3e3e657079742d72, %rcx # imm = 0x3E3E657079742D72
movq %rcx, 0x6(%rax)
movabsq $0x2d726f7272653c3c, %rcx # imm = 0x2D726F7272653C3C
movq %rcx, (%rax)
addq $0xe, 0x20(%rsi)
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0xce508
movq %rbx, %rdi
callq 0xd2b24
movq (%rbx), %r15
movq 0x20(%r15), %rax
cmpq %rax, 0x18(%r15)
je 0xce51e
movb $0x28, (%rax)
incq 0x20(%r15)
jmp 0xce535
leaq 0x275652(%rip), %rsi # 0x343b77
movl $0x1, %edx
movq %r15, %rdi
callq 0x582a2
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xbaa18
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xce567
leaq 0x28389b(%rip), %rsi # 0x351df3
movl $0x2, %edx
movq %r15, %rdi
callq 0x582a2
jmp 0xce571
movw $0xa29, (%rax) # imm = 0xA29
addq $0x2, 0x20(%r15)
movq %r14, %rdi
callq 0x8c352
testl %eax, %eax
je 0xce702
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xce5a8
leaq 0x280235(%rip), %rsi # 0x34e7d1
movl $0x2, %edx
callq 0x582a2
jmp 0xce5b2
movw $0xa7b, (%rax) # imm = 0xA7B
addq $0x2, 0x20(%rdi)
movzbl 0x8(%rbx), %eax
addl %eax, 0x20(%rbx)
movq %r14, 0x8(%rsp)
movq %r14, %rdi
callq 0x95db4
testq %rax, %rax
je 0xce6c5
movq %rax, %r15
leaq 0x8(%rbx), %r12
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
callq 0xcca46
movq %rax, %r14
movq %r15, %rdi
callq 0xc0b9c
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0xd2a84
movq %rax, 0x10(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x22ed96
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x582a2
movq %rax, %r14
movq 0x20(%rax), %rax
cmpq 0x18(%r14), %rax
jae 0xce63e
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
movb $0x20, (%rax)
jmp 0xce64e
movq %r14, %rdi
movl $0x20, %esi
callq 0x5822c
movq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xbaa18
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xce680
movl $0x2, %edx
movq %r14, %rdi
leaq 0x256d35(%rip), %rsi # 0x3253ae
callq 0x582a2
jmp 0xce68a
movw $0xa3b, (%rax) # imm = 0xA3B
addq $0x2, 0x20(%r14)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xce6a6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3c080
movq 0x8(%r15), %r15
andq $-0x8, %r15
je 0xce6bc
movl 0x1c(%r15), %eax
andl $0x7f, %eax
cmpl $0x2f, %eax
jne 0xce6a6
testq %r15, %r15
jne 0xce5e0
movzbl 0x8(%rbx), %eax
subl %eax, 0x20(%rbx)
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0xce6f3
leaq 0x25526c(%rip), %rsi # 0x323953
movl $0x2, %edx
callq 0x582a2
jmp 0xce6fd
movw $0xa7d, (%rax) # imm = 0xA7D
addq $0x2, 0x20(%rdi)
movq 0x8(%rsp), %r14
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xcc47c
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x3, %rcx
ja 0xce73a
leaq 0x260020(%rip), %rsi # 0x32e74e
movl $0x4, %edx
callq 0x582a2
jmp 0xce745
movl $0x646e6540, (%rax) # imm = 0x646E6540
addq $0x4, 0x20(%rdi)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitVarDecl(clang::VarDecl*)
|
void DeclPrinter::VisitVarDecl(VarDecl *D) {
prettyPrintPragmas(D);
prettyPrintAttributes(D, AttrPosAsWritten::Left);
if (const auto *Param = dyn_cast<ParmVarDecl>(D);
Param && Param->isExplicitObjectParameter())
Out << "this ";
QualType T = D->getTypeSourceInfo()
? D->getTypeSourceInfo()->getType()
: D->getASTContext().getUnqualifiedObjCPointerType(D->getType());
if (!Policy.SuppressSpecifiers) {
StorageClass SC = D->getStorageClass();
if (SC != SC_None)
Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
switch (D->getTSCSpec()) {
case TSCS_unspecified:
break;
case TSCS___thread:
Out << "__thread ";
break;
case TSCS__Thread_local:
Out << "_Thread_local ";
break;
case TSCS_thread_local:
Out << "thread_local ";
break;
}
if (D->isModulePrivate())
Out << "__module_private__ ";
if (D->isConstexpr()) {
Out << "constexpr ";
T.removeLocalConst();
}
}
if (!Policy.SuppressTagKeyword && Policy.SuppressScope &&
!Policy.SuppressUnwrittenScope)
MaybePrintTagKeywordIfSupressingScopes(Policy, T, Out);
printDeclType(T, (isa<ParmVarDecl>(D) && Policy.CleanUglifiedParameters &&
D->getIdentifier())
? D->getIdentifier()->deuglifiedName()
: D->getName());
prettyPrintAttributes(D, AttrPosAsWritten::Right);
Expr *Init = D->getInit();
if (!Policy.SuppressInitializers && Init) {
bool ImplicitInit = false;
if (D->isCXXForRangeDecl()) {
// FIXME: We should print the range expression instead.
ImplicitInit = true;
} else if (CXXConstructExpr *Construct =
dyn_cast<CXXConstructExpr>(Init->IgnoreImplicit())) {
if (D->getInitStyle() == VarDecl::CallInit &&
!Construct->isListInitialization()) {
ImplicitInit = Construct->getNumArgs() == 0 ||
Construct->getArg(0)->isDefaultArgument();
}
}
if (!ImplicitInit) {
if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init))
Out << "(";
else if (D->getInitStyle() == VarDecl::CInit) {
Out << " = ";
}
PrintingPolicy SubPolicy(Policy);
SubPolicy.SuppressSpecifiers = false;
SubPolicy.IncludeTagDefinition = false;
Init->printPretty(Out, nullptr, SubPolicy, Indentation, "\n", &Context);
if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init))
Out << ")";
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd2cb4
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd28aa
testq %r14, %r14
je 0xd06bc
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
jne 0xd06bc
cmpl $0x0, 0x64(%r14)
je 0xd06bc
movq (%rbx), %rdi
leaq 0x25e23f(%rip), %rsi # 0x32e8f1
movl $0x5, %edx
callq 0x577a6
movq 0x38(%r14), %rax
movq %rax, %rcx
andq $-0x8, %rcx
testb $0x4, %al
je 0xd06cf
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xd06e8
movl %eax, %ecx
andq $-0x8, %rax
testb $0x4, %cl
je 0xd06e3
movq 0x20(%rax), %rax
movq (%rax), %r15
jmp 0xd06ff
movq %r14, %rdi
callq 0xc0b9c
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0xd2a84
movq %rax, %r15
leaq 0x8(%rbx), %r13
testb $0x1, 0x9(%rbx)
jne 0xd07da
movzbl 0x60(%r14), %edi
andl $0x7, %edi
je 0xd073e
movq (%rbx), %r12
callq 0xbb73c
movq %r12, %rdi
movq %rax, %rsi
callq 0x576b8
leaq 0x344962(%rip), %rsi # 0x415093
movl $0x1, %edx
movq %rax, %rdi
callq 0x577a6
movl 0x60(%r14), %eax
shrl $0x3, %eax
andl $0x3, %eax
leaq 0x25dd59(%rip), %rcx # 0x32e4a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
leaq 0x25e195(%rip), %rsi # 0x32e8f7
movl $0x9, %edx
jmp 0xd0789
movq (%rbx), %rdi
leaq 0x25e19d(%rip), %rsi # 0x32e910
movl $0xd, %edx
jmp 0xd0789
movq (%rbx), %rdi
leaq 0x25e17d(%rip), %rsi # 0x32e901
movl $0xe, %edx
callq 0x577a6
movl 0x8(%r14), %eax
andl $0x7, %eax
cmpl $0x4, %eax
jne 0xd07ae
movq (%rbx), %rdi
leaq 0x25e0b5(%rip), %rsi # 0x32e859
movl $0x13, %edx
callq 0x577a6
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xd07da
cmpw $0x0, 0x60(%r14)
jns 0xd07da
movq (%rbx), %rdi
leaq 0x25e0a1(%rip), %rsi # 0x32e86d
movl $0xa, %edx
callq 0x577a6
andq $-0x2, %r15
movl $0x1a00, %eax # imm = 0x1A00
andl (%r13), %eax
cmpl $0x800, %eax # imm = 0x800
jne 0xd07f5
movq (%rbx), %rsi
movq %r15, %rdi
callq 0xd2eb4
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
jne 0xd081e
testb $0x8, 0x5(%r13)
je 0xd081e
movq 0x28(%r14), %rdi
testb $0x7, %dil
setne %al
andq $-0x8, %rdi
sete %cl
orb %al, %cl
je 0xd0849
movq 0x28(%r14), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0xd083d
leaq 0x2bf0ab(%rip), %rax # 0x38f8e4
xorl %ecx, %ecx
jmp 0xd0851
movq 0x10(%rax), %rax
movl (%rax), %ecx
addq $0x10, %rax
jmp 0xd0851
callq 0x2ec6f0
movq %rdx, %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0xccf16
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0xd28aa
movq %r14, %rdi
callq 0xbbd6c
testq %rax, %rax
je 0xd09b1
movq %rax, %r15
movq 0x8(%rbx), %rax
andl $0x8000, %eax # imm = 0x8000
jne 0xd09b1
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xd08b1
movzwl 0x60(%r14), %eax
andl $0x800, %eax # imm = 0x800
jne 0xd09b1
movq %r15, %rdi
callq 0xd929c
movb (%rax), %cl
andb $-0x2, %cl
cmpb $0x70, %cl
jne 0xd0909
movb 0x60(%r14), %cl
andb $0x60, %cl
cmpb $0x20, %cl
jne 0xd0909
testb $0x10, 0x2(%rax)
jne 0xd0909
cmpl $0x0, 0x20(%rax)
je 0xd09b1
movb (%rax), %cl
xorl %edx, %edx
cmpb $0x71, %cl
cmoveq %rax, %rdx
addq $0x30, %rdx
addq $0x28, %rax
cmpb $0x71, %cl
cmoveq %rdx, %rax
movq (%rax), %rdi
callq 0xd9674
testb %al, %al
jne 0xd09b1
movl 0x60(%r14), %eax
shrl $0x5, %eax
andl $0x3, %eax
je 0xd0924
cmpl $0x1, %eax
jne 0xd0949
cmpb $0x14, (%r15)
jne 0xd0935
testb %al, %al
jne 0xd0949
movq (%rbx), %rdi
leaq 0x2b5358(%rip), %rsi # 0x385c86
movl $0x3, %edx
jmp 0xd0944
movq (%rbx), %rdi
leaq 0x273238(%rip), %rsi # 0x343b77
movl $0x1, %edx
callq 0x577a6
movups (%r13), %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
andb $-0x6, 0x1(%rcx)
movq (%rbx), %rsi
movl 0x20(%rbx), %r8d
leaq 0x2805e8(%rip), %rax # 0x350f50
movq %rax, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rbx), %r9
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
xorl %edx, %edx
callq 0x2104a0
movb 0x60(%r14), %al
andb $0x60, %al
cmpb $0x20, %al
jne 0xd09b1
cmpb $0x14, (%r15)
je 0xd09b1
movq (%rbx), %rdi
leaq 0x2548f2(%rip), %rsi # 0x325299
movl $0x1, %edx
callq 0x577a6
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitRecordDecl(clang::RecordDecl*)
|
void DeclPrinter::VisitRecordDecl(RecordDecl *D) {
if (!Policy.SuppressSpecifiers && D->isModulePrivate())
Out << "__module_private__ ";
Out << D->getKindName();
prettyPrintAttributes(D);
if (D->getIdentifier())
Out << ' ' << *D;
if (D->isCompleteDefinition()) {
Out << " {\n";
VisitDeclContext(D);
Indent() << "}";
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, 0x9(%rdi)
jne 0xd0c7e
movl 0x8(%r14), %eax
andl $0x7, %eax
cmpl $0x4, %eax
jne 0xd0c7e
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x12, %rcx
ja 0xd0c68
leaq 0x25dbfd(%rip), %rsi # 0x32e859
movl $0x13, %edx
callq 0x582a2
jmp 0xd0c7e
movups 0x25dbea(%rip), %xmm0 # 0x32e859
movups %xmm0, (%rax)
movl $0x205f5f65, 0xf(%rax) # imm = 0x205F5F65
addq $0x13, 0x20(%rdi)
movq (%rbx), %r15
movzwl 0x48(%r14), %edi
shrl $0xd, %edi
callq 0x227e58
movl %eax, %edi
callq 0x227e5c
movq %r15, %rdi
movq %rax, %rsi
callq 0x577a6
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd28aa
movq 0x28(%r14), %rax
testb $0x7, %al
setne %cl
cmpq $0x8, %rax
setb %al
orb %cl, %al
jne 0xd0cf3
movq (%rbx), %rsi
movq 0x20(%rsi), %rax
cmpq 0x18(%rsi), %rax
jae 0xd0cdb
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rsi)
movb $0x20, (%rax)
jmp 0xd0ceb
movq %rsi, %rdi
movl $0x20, %esi
callq 0x5822c
movq %rax, %rsi
movq %r14, %rdi
callq 0xbaa18
testb $0x1, 0x4a(%r14)
je 0xd0d5c
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x2, %rcx
ja 0xd0d21
leaq 0x27dabb(%rip), %rsi # 0x34e7d0
movl $0x3, %edx
callq 0x582a2
jmp 0xd0d2f
movb $0xa, 0x2(%rax)
movw $0x7b20, (%rax) # imm = 0x7B20
addq $0x3, 0x20(%rdi)
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xcc47c
movq %rbx, %rdi
callq 0xcca46
movq 0x20(%rax), %rcx
cmpq %rcx, 0x18(%rax)
je 0xd0d62
movb $0x7d, (%rcx)
incq 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x26e650(%rip), %rsi # 0x33f3b9
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x582a2
nop
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitTypeAliasDecl(clang::TypeAliasDecl*)
|
void DeclPrinter::VisitTypeAliasDecl(TypeAliasDecl *D) {
Out << "using " << *D;
prettyPrintAttributes(D);
Out << " = " << D->getTypeSourceInfo()->getType().getAsString(Policy);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x252697(%rip), %rsi # 0x323d0c
movl $0x6, %edx
callq 0x577a6
movq %r14, %rdi
movq %rax, %rsi
callq 0xbaa18
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd28aa
movq (%rbx), %rdi
leaq 0x2b45e5(%rip), %rsi # 0x385c86
movl $0x3, %edx
callq 0x577a6
movq %rax, %r15
movq 0x50(%r14), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xd16c1
movq (%rax), %rax
movq (%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x22ed96
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x582a2
movq (%r14), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd1709
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3c080
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::VisitObjCCompatibleAliasDecl(clang::ObjCCompatibleAliasDecl*)
|
void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) {
Out << "@compatibility_alias " << *AID
<< ' ' << *AID->getClassInterface() << ";\n";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x25c9d1(%rip), %rsi # 0x32e9a8
movl $0x15, %edx
callq 0x577a6
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbaa18
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0xd2006
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
movb $0x20, (%rax)
jmp 0xd2016
movq %r14, %rdi
movl $0x20, %esi
callq 0x5822c
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xbaa18
leaq 0x253385(%rip), %rsi # 0x3253ae
movl $0x2, %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x577a6
nop
|
/AST/DeclPrinter.cpp
|
(anonymous namespace)::DeclPrinter::PrintObjCMethodType(clang::ASTContext&, clang::Decl::ObjCDeclQualifier, clang::QualType)
|
void DeclPrinter::PrintObjCMethodType(ASTContext &Ctx,
Decl::ObjCDeclQualifier Quals,
QualType T) {
Out << '(';
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_In)
Out << "in ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Inout)
Out << "inout ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Out)
Out << "out ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Bycopy)
Out << "bycopy ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Byref)
Out << "byref ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Oneway)
Out << "oneway ";
if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_CSNullability) {
if (auto nullability = AttributedType::stripOuterNullability(T))
Out << getNullabilitySpelling(*nullability, true) << ' ';
}
Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy);
Out << ')';
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq (%rdi), %rdi
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0xd272d
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movb $0x28, (%rax)
jmp 0xd2737
movl $0x28, %esi
callq 0x5822c
testb $0x1, %bpl
je 0xd2751
movq (%rbx), %rdi
leaq 0x271677(%rip), %rsi # 0x343dbe
movl $0x3, %edx
callq 0x577a6
testb $0x2, %bpl
je 0xd276b
movq (%rbx), %rdi
leaq 0x25bfc4(%rip), %rsi # 0x32e725
movl $0x6, %edx
callq 0x577a6
testb $0x4, %bpl
je 0xd2785
movq (%rbx), %rdi
leaq 0x25bfac(%rip), %rsi # 0x32e727
movl $0x4, %edx
callq 0x577a6
testb $0x8, %bpl
je 0xd279f
movq (%rbx), %rdi
leaq 0x25bf97(%rip), %rsi # 0x32e72c
movl $0x7, %edx
callq 0x577a6
testb $0x10, %bpl
je 0xd27b9
movq (%rbx), %rdi
leaq 0x25bf85(%rip), %rsi # 0x32e734
movl $0x6, %edx
callq 0x577a6
testb $0x20, %bpl
je 0xd27d3
movq (%rbx), %rdi
leaq 0x25bf72(%rip), %rsi # 0x32e73b
movl $0x7, %edx
callq 0x577a6
testb $0x40, %bpl
je 0xd2828
leaq 0x8(%rsp), %rdi
callq 0x22ab6e
btl $0x8, %eax
jae 0xd2828
movq (%rbx), %r15
movzbl %al, %edi
movl $0x1, %esi
callq 0x2ed31d
movq %r15, %rdi
movq %rax, %rsi
callq 0x577a6
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0xd281b
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x20, (%rcx)
jmp 0xd2828
movq %rax, %rdi
movl $0x20, %esi
callq 0x5822c
movq (%rbx), %r15
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xd2a84
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rbx), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x22ed96
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x582a2
movq (%r14), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xd287a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3c080
movq (%rbx), %rdi
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0xd2894
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movb $0x29, (%rax)
jmp 0xd289e
movl $0x29, %esi
callq 0x5822c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/DeclPrinter.cpp
|
clang::TemplateTypeParmDecl::TemplateTypeParmDecl(clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, bool, bool, std::optional<unsigned int>)
|
TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
SourceLocation IdLoc, IdentifierInfo *Id, bool Typename,
bool HasTypeConstraint,
std::optional<unsigned> NumExpanded)
: TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename),
HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false),
ExpandedParameterPack(NumExpanded),
NumExpanded(NumExpanded.value_or(0)) {}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r14
movl %edx, %r15d
movq %rsi, %rdx
movq %rdi, %rbx
movb 0x40(%rsp), %r13b
movq 0x48(%rsp), %r12
movl $0x40, %esi
callq 0xb86b2
movq %r14, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movl %r15d, 0x38(%rbx)
leaq 0x3e5e91(%rip), %rcx # 0x4b94d8
addq $0x10, %rcx
movq %rcx, (%rbx)
movb 0x3c(%rbx), %cl
andb $-0x10, %cl
addb %r13b, %r13b
movabsq $0x100000000, %rdx # imm = 0x100000000
andq %r12, %rdx
movq %rdx, %rsi
shrq $0x1d, %rsi
orb %bpl, %r13b
orb %sil, %r13b
orb %cl, %r13b
testq %rdx, %rdx
movb %r13b, 0x3c(%rbx)
movl $0x0, %ecx
cmovnel %r12d, %ecx
movl %ecx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/clang/AST/DeclTemplate.h
|
clang::TemplateTemplateParmDecl::Create(clang::ASTContext const&, clang::DeclContext*, clang::SourceLocation, unsigned int, unsigned int, bool, clang::IdentifierInfo*, bool, clang::TemplateParameterList*)
|
TemplateTemplateParmDecl *
TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
SourceLocation L, unsigned D, unsigned P,
bool ParameterPack, IdentifierInfo *Id,
bool Typename, TemplateParameterList *Params) {
return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
Typename, Params);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rsi
movl $0x58, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xc0ba8
movq %rax, %r14
movq %rax, %rdi
movl $0x41, %esi
movq %r13, %rdx
movl %r12d, %ecx
callq 0xb86b2
movq 0x40(%rsp), %rax
movq %rax, 0x28(%r14)
xorl %ecx, %ecx
movq %rcx, 0x30(%r14)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%r14)
andl $0xfffff, %r15d # imm = 0xFFFFF
shll $0x14, %ebp
orl %r15d, %ebp
movl %ebp, 0x40(%r14)
leaq 0x3e59ce(%rip), %rax # 0x4b9460
addq $0x10, %rax
movq %rax, (%r14)
movq %rcx, 0x48(%r14)
movb 0x50(%r14), %al
andb $-0x8, %al
addb %bl, %bl
addb 0x48(%rsp), %bl
orb %al, %bl
movb %bl, 0x50(%r14)
movl $0x0, 0x54(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/DeclTemplate.cpp
|
clang::ConstantExpr::getAPValueResult() const
|
APValue ConstantExpr::getAPValueResult() const {
switch (getResultStorageKind()) {
case ConstantResultStorageKind::APValue:
return APValueResult();
case ConstantResultStorageKind::Int64:
return APValue(
llvm::APSInt(llvm::APInt(ConstantExprBits.BitWidth, Int64Result()),
ConstantExprBits.IsUnsigned));
case ConstantResultStorageKind::None:
if (ConstantExprBits.APValueKind == APValue::Indeterminate)
return APValue::IndeterminateValue();
return APValue();
}
llvm_unreachable("invalid ResultKind");
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
je 0xd4959
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0xd496d
movl %eax, %esi
shrl $0x19, %esi
andl $0xc0000, %eax # imm = 0xC0000
xorl %ecx, %ecx
cmpl $0x80000, %eax # imm = 0x80000
sete %cl
leaq (%rcx,%rcx,8), %rax
movq 0x18(%r14,%rax,8), %rdx
movq %rsp, %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x66024
movb 0x3(%r14), %al
andb $0x1, %al
movl 0x8(%r15), %ecx
leaq 0x10(%rsp), %r14
movl %ecx, 0x8(%r14)
movq (%r15), %rcx
movq %rcx, (%r14)
movl $0x0, 0x8(%r15)
movb %al, 0xc(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc87de
cmpl $0x41, 0x8(%r14)
jb 0xd4942
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd4942
callq 0x3c180
cmpl $0x41, 0x8(%rsp)
jb 0xd4984
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd4984
callq 0x3c180
jmp 0xd4984
andl $0xf00000, %eax # imm = 0xF00000
cmpl $0x100000, %eax # imm = 0x100000
jne 0xd497e
movl $0x1, (%rbx)
jmp 0xd4984
addq $0x18, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x866dc
jmp 0xd4984
movl $0x0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/AST/Expr.cpp
|
clang::SYCLUniqueStableNameExpr::ComputeName[abi:cxx11](clang::ASTContext&, clang::QualType)
|
std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context,
QualType Ty) {
auto MangleCallback = [](ASTContext &Ctx,
const NamedDecl *ND) -> std::optional<unsigned> {
if (const auto *RD = dyn_cast<CXXRecordDecl>(ND))
return RD->getDeviceLambdaManglingNumber();
return std::nullopt;
};
std::unique_ptr<MangleContext> Ctx{ItaniumMangleContext::create(
Context, Context.getDiagnostics(), MangleCallback)};
std::string Buffer;
Buffer.reserve(128);
llvm::raw_string_ostream Out(Buffer);
Ctx->mangleCanonicalTypeName(Ty, Out);
return Out.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8a37c
leaq 0x6860(%rip), %rdx # 0xdb5f4
xorl %r15d, %r15d
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x1ce98e
movq %rax, %r14
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r15, -0x8(%rbp)
movb %r15b, (%rbp)
leaq 0x10(%rsp), %r12
movl $0x80, %esi
movq %r12, %rdi
callq 0x3c5d0
leaq 0x30(%rsp), %r13
movl $0x0, 0x8(%r13)
movb %r15b, 0x28(%r13)
movl $0x1, 0x2c(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movq %r15, 0x20(%r13)
leaq 0x3e2c52(%rip), %rax # 0x4b7a48
addq $0x10, %rax
movq %rax, (%r13)
movq %r12, 0x30(%r13)
movq %r13, %rdi
callq 0x57780
movq (%r14), %rax
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq *0xb8(%rax)
movq 0x30(%r13), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x57bf6
movq %r13, %rdi
callq 0x58c66
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0xd4e5b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3c080
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Expr.cpp
|
clang::ImplicitCastExpr::ImplicitCastExpr(clang::QualType, clang::CastKind, clang::Expr*, unsigned int, clang::FPOptionsOverride, clang::ExprValueKind)
|
ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
unsigned BasePathLength, FPOptionsOverride FPO,
ExprValueKind VK)
: CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength,
FPO.requiresTrailingStorage()) {
setDependence(computeDependence(this));
if (hasStoredFPFeatures())
*getTrailingFPFeatures() = FPO;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %eax
movq %rcx, %r9
movl %edx, %r8d
movq %rsi, %rdx
movq %rdi, %r14
movl 0x20(%rsp), %ecx
xorl %r10d, %r10d
movq %rbx, %rsi
shrq $0x20, %rsi
setne %r10b
movl $0x4e, %esi
pushq %r10
pushq %rax
callq 0xdb730
addq $0x10, %rsp
movq %r14, %rdi
callq 0xb43c0
movzwl 0x1(%r14), %ecx
andb $0x1f, %al
movzbl %al, %eax
shll $0x5, %eax
andl $0xfffffc1f, %ecx # imm = 0xFFFFFC1F
orl %eax, %ecx
movw %cx, 0x1(%r14)
testb $0x4, 0x3(%r14)
je 0xd7bc7
movq %r14, %rdi
callq 0xd7a92
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/clang/AST/Expr.h
|
clang::Expr::IgnoreImplicit()
|
Expr *Expr::IgnoreImplicit() {
return IgnoreExprNodes(this, IgnoreImplicitSingleStep);
}
|
movq %rdi, %rax
movq %rax, %rcx
movb (%rax), %dl
cmpb $0x4e, %dl
jne 0xd92ad
movq 0x10(%rcx), %rax
cmpb $0x4e, %dl
je 0xd92c2
leal -0x3d(%rdx), %esi
movq %rcx, %rax
cmpb $-0x2, %sil
jb 0xd92c2
movq 0x10(%rcx), %rax
cmpq %rcx, %rax
jne 0xd92f2
cmpb $0x30, %dl
jne 0xd92e1
movq 0x10(%rcx), %rsi
movq %rsi, %rax
andq $-0x8, %rax
testb $0x4, %sil
je 0xd92e1
movq 0x28(%rax), %rax
cmpb $0x30, %dl
je 0xd92f2
movq %rcx, %rax
cmpb $0x73, %dl
jne 0xd92f2
movq 0x18(%rcx), %rax
cmpq %rcx, %rax
jne 0xd929f
retq
|
/AST/Expr.cpp
|
clang::Expr::ClassifyImpl(clang::ASTContext&, clang::SourceLocation*) const
|
Cl Expr::ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const {
assert(!TR->isReferenceType() && "Expressions can't have reference type.");
Cl::Kinds kind = ClassifyInternal(Ctx, this);
// C99 6.3.2.1: An lvalue is an expression with an object type or an
// incomplete type other than void.
if (!Ctx.getLangOpts().CPlusPlus) {
// Thus, no functions.
if (TR->isFunctionType() || TR == Ctx.OverloadTy)
kind = Cl::CL_Function;
// No void either, but qualified void is OK because it is "other than void".
// Void "lvalues" are classified as addressable void values, which are void
// expressions whose address can be taken.
else if (TR->isVoidType() && !TR.hasQualifiers())
kind = (kind == Cl::CL_LValue ? Cl::CL_AddressableVoid : Cl::CL_Void);
}
// Enable this assertion for testing.
switch (kind) {
case Cl::CL_LValue:
assert(isLValue());
break;
case Cl::CL_XValue:
assert(isXValue());
break;
case Cl::CL_Function:
case Cl::CL_Void:
case Cl::CL_AddressableVoid:
case Cl::CL_DuplicateVectorComponents:
case Cl::CL_MemberFunction:
case Cl::CL_SubObjCPropertySetting:
case Cl::CL_ClassTemporary:
case Cl::CL_ArrayTemporary:
case Cl::CL_ObjCMessageRValue:
case Cl::CL_PRValue:
assert(isPRValue());
break;
}
Cl::ModifiableType modifiable = Cl::CM_Untested;
if (Loc)
modifiable = IsModifiable(Ctx, this, kind, *Loc);
return Classification(kind, modifiable);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xdc025
movq 0x830(%r15), %r8
movq (%r8), %r13
btl $0xa, %r13d
jb 0xdbe6b
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
andq $-0x10, %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
andq $-0x10, %rdx
movq (%rdx), %rdx
movb 0x10(%rdx), %sil
leal -0x19(%rsi), %edi
movl $0x2, %ebp
cmpb $0x2, %dil
jb 0xdbe6d
cmpq 0x49a8(%r15), %rcx
je 0xdbe6d
cmpb $0xd, %sil
setne %sil
testq %rdx, %rdx
sete %dil
orb %sil, %dil
jne 0xdbe6b
testb $0xf, %cl
jne 0xdbe6b
movl $0xff80000, %esi # imm = 0xFF80000
andl 0x10(%rdx), %esi
cmpl $0xd580000, %esi # imm = 0xD580000
jne 0xdbe6b
testb $0xf, 0x8(%rcx)
movl %eax, %ebp
jne 0xdbe6d
xorl %ebp, %ebp
cmpl $0x1, %eax
adcl $0x3, %ebp
jmp 0xdbe6d
movl %eax, %ebp
testq %r14, %r14
je 0xdbec8
testl %ebp, %ebp
je 0xdbedc
movl $0x20000, %r12d # imm = 0x20000
cmpl $0xb, %ebp
jne 0xdc010
movq %r8, (%rsp)
movq %rbx, %rdi
callq 0xd90f0
movq %rax, %r15
movb (%rax), %al
addb $-0x58, %al
cmpb $-0x9, %al
jb 0xdbed0
movq 0x10(%r15), %rdi
callq 0xd71d0
movzwl 0x1(%rax), %eax
andl $0x3, %eax
cmpw $0x1, %ax
jne 0xdbed0
movq %r15, %rdi
callq 0xd4508
movl %eax, (%r14)
movl $0x40000, %r12d # imm = 0x40000
jmp 0xdc010
xorl %r12d, %r12d
jmp 0xdc010
testl %ebp, %ebp
movq (%rsp), %r8
jne 0xdc010
btl $0xa, %r13d
jae 0xdbf0c
movq 0x8(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x19, %al
movl $0x30000, %r12d # imm = 0x30000
cmpb $0x2, %al
jb 0xdc010
cmpb $0x20, (%rbx)
jne 0xdbf28
testb $0x4, 0x10(%rbx)
je 0xdbf28
cmpq $0x8, 0x18(%rbx)
jae 0xdbf28
movl $0x50000, %r12d # imm = 0x50000
xorl %eax, %eax
jmp 0xdbf30
movl $0x40000, %r12d # imm = 0x40000
movb $0x1, %al
testb %al, %al
je 0xdc010
movq 0x8(%rbx), %rbx
movq %rbx, %rax
andq $-0x10, %rax
movq 0x8(%rax), %r14
andl $0x7, %ebx
orq %r14, %rbx
movl $0x60000, %r12d # imm = 0x60000
testb $0x1, %bl
jne 0xdc010
testb $0x8, %r14b
je 0xdbf96
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
andq 0x28(%r8), %rax
je 0xdbf96
movq %r14, %rax
andq $-0x10, %rax
movabsq $0x1fffffffe00, %rcx # imm = 0x1FFFFFFFE00
andq 0x18(%rax), %rcx
movl $0x80000, %r12d # imm = 0x80000
cmpq $0x600, %rcx # imm = 0x600
je 0xdc010
movq %r14, %r15
andq $-0x10, %r15
movq (%r15), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
addl $-0x2, %eax
movl $0x90000, %r12d # imm = 0x90000
cmpl $0x5, %eax
jb 0xdc010
xorl %esi, %esi
callq 0x2273a8
movl $0xa0000, %r12d # imm = 0xA0000
testb %al, %al
jne 0xdc010
cmpq $0x10, %r14
jae 0xdbfd8
xorl %eax, %eax
jmp 0xdbfe5
movq (%r15), %rcx
xorl %eax, %eax
cmpb $0x2e, 0x10(%rcx)
cmoveq %rbx, %rax
cmpq $0x10, %rax
jae 0xdbfef
xorl %edi, %edi
jmp 0xdbff6
andq $-0x10, %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xdc00a
callq 0x22a226
movl $0x70000, %r12d # imm = 0x70000
testb %al, %al
jne 0xdc010
movl $0x10000, %r12d # imm = 0x10000
movzwl %bp, %eax
orl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprClassification.cpp
|
llvm::maxnum(llvm::APFloat const&, llvm::APFloat const&)
|
LLVM_READONLY
inline APFloat maxnum(const APFloat &A, const APFloat &B) {
if (A.isNaN())
return B;
if (B.isNaN())
return A;
if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative()))
return A.isNegative() ? B : A;
return A < B ? B : A;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
movq 0x8(%rsi), %r13
callq 0x69800
movq 0x10(%r14), %rcx
addq $0x8, %rcx
cmpq %r13, %rax
cmovneq %r12, %rcx
movb 0x14(%rcx), %cl
movl %ecx, %edx
andb $0x7, %dl
cmpb $0x1, %dl
jne 0xde2e6
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r15
movq %r15, %rsi
jmp 0xde359
leaq 0x8(%r15), %rsi
movq 0x10(%r15), %rdi
addq $0x8, %rdi
cmpq 0x8(%r15), %rax
cmovneq %rsi, %rdi
movb 0x14(%rdi), %al
movl %eax, %esi
andb $0x7, %sil
cmpb $0x1, %sil
jne 0xde315
movq %rbx, %rdi
addq $0x8, %rdi
movq %r12, %rsi
jmp 0xde359
cmpb $0x3, %dl
jne 0xde33a
cmpb $0x3, %sil
jne 0xde33a
movl %ecx, %edx
andb $0x8, %dl
shrb $0x3, %dl
andb $0x8, %al
shrb $0x3, %al
cmpb %al, %dl
je 0xde33a
testb $0x8, %cl
cmovneq %r15, %r14
jmp 0xde34b
movq %r14, %rdi
movq %r15, %rsi
callq 0x6fd40
testl %eax, %eax
cmoveq %r15, %r14
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x892a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/APFloat.h
|
(anonymous namespace)::EvalInfo::EvalInfo(clang::ASTContext const&, clang::Expr::EvalStatus&, (anonymous namespace)::EvalInfo::EvaluationMode)
|
EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
: Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
CallStackDepth(0), NextCallIndex(1),
StepsLeft(C.getLangOpts().ConstexprStepLimit),
EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
BottomFrame(*this, SourceLocation(), /*Callee=*/nullptr,
/*This=*/nullptr,
/*CallExpr=*/nullptr, CallRef()),
EvaluatingDecl((const ValueDecl *)nullptr),
EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
HasFoldFailureDiagnostic(false), EvalMode(Mode) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movb $0x0, 0x8(%rdi)
leaq 0x3db17d(%rip), %rax # 0x4b9610
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
xorl %r15d, %r15d
movq %r15, 0x20(%rdi)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x28(%rdi)
movq 0x830(%rsi), %rax
movl 0x84(%rax), %ecx
movl %ecx, 0x30(%rdi)
movb 0x88(%rax), %al
andb $0x1, %al
movb %al, 0x34(%rdi)
addq $0x38, %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe161c
leaq 0x118(%r14), %rax
movq %rax, 0x108(%r14)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, 0x110(%r14)
leaq 0x318(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85f7a
movl %r15d, 0x328(%r14)
leaq 0x358(%r14), %rax
movl %r15d, 0x358(%r14)
movq %r15, 0x360(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x330(%r14)
movups %xmm0, 0x33c(%r14)
movq %rax, 0x368(%r14)
movq %rax, 0x370(%r14)
movups %xmm0, 0x378(%r14)
movq $-0x1, 0x388(%r14)
movl %r15d, 0x390(%r14)
movl %ebx, 0x394(%r14)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/ExprConstant.cpp
|
EvaluateAsInt(clang::Expr const*, clang::Expr::EvalResult&, clang::ASTContext const&, clang::Expr::SideEffectsKind, (anonymous namespace)::EvalInfo&)
|
static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
const ASTContext &Ctx,
Expr::SideEffectsKind AllowSideEffects,
EvalInfo &Info) {
assert(!E->isValueDependent());
if (!E->getType()->isIntegralOrEnumerationType())
return false;
if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
!ExprResult.Val.isInt() ||
hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
return false;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %r12
movq 0x8(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %al
cmpb $0xd, %al
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0xdea22
movl 0x10(%rdi), %ecx
shrl $0x13, %ecx
andl $0x1fc, %ecx # imm = 0x1FC
addl $0xfffffe54, %ecx # imm = 0xFFFFFE54
cmpl $0x14, %ecx
setb %cl
testb %dl, %dl
je 0xdea62
testq %rdi, %rdi
sete %dl
cmpb $0x2d, %al
setne %r13b
orb %dl, %r13b
jne 0xdea4a
callq 0x226c68
cmpq $0x8, 0x80(%rax)
setae %cl
orb 0x4a(%rax), %cl
testb %r13b, %r13b
je 0xdea62
movq 0x8(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xa, 0x10(%rax)
sete %cl
testb $0x1, %cl
je 0xdea8d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xde589
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xdea8f
cmpl $0x2, 0x10(%rbx)
jne 0xdea8f
cmpl $0x1, %ebp
jg 0xdea9e
cmpb $0x0, (%rbx)
je 0xdea9e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
testl %ebp, %ebp
jg 0xdea8f
movb 0x1(%rbx), %al
xorb $0x1, %al
jmp 0xdea8f
nop
|
/AST/ExprConstant.cpp
|
CheckMemoryLeaks((anonymous namespace)::EvalInfo&)
|
bool CheckCallLimit(SourceLocation Loc) {
// Don't perform any constexpr calls (other than the call we're checking)
// when checking a potential constant expression.
if (checkingPotentialConstantExpression() && CallStackDepth > 1)
return false;
if (NextCallIndex == 0) {
// NextCallIndex has wrapped around.
FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
return false;
}
if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
return true;
FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
<< getLangOpts().ConstexprCallDepth;
return false;
}
|
pushq %rbx
cmpq $0x0, 0x378(%rdi)
je 0xdfbd8
movq %rdi, %rbx
movq 0x368(%rdi), %rax
movq 0x70(%rax), %rsi
movl $0x8bd, %edx # imm = 0x8BD
xorl %ecx, %ecx
callq 0x1cdd9c
testq %rax, %rax
je 0xdfbd8
movl 0x378(%rbx), %esi
decl %esi
movq %rax, %rdi
movl $0x3, %edx
popq %rbx
jmp 0x96fba
popq %rbx
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::LValueExprEvaluator::VisitMemberExpr(clang::MemberExpr const*)
|
bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
// Handle static data members.
if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
VisitIgnoredBaseExpression(E->getBase());
return VisitVarDecl(E, VD);
}
// Handle static member functions.
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
if (MD->isStatic()) {
VisitIgnoredBaseExpression(E->getBase());
return Success(MD);
}
}
// Handle non-static data members.
return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
movl 0x1c(%r15), %eax
andl $0x7f, %eax
addl $-0x2c, %eax
cmpl $-0x7, %eax
setb %al
testq %r15, %r15
sete %bpl
orb %al, %bpl
jne 0xe4219
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xf06fe
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf0748
movl %eax, %r12d
testb %bpl, %bpl
je 0xe4481
movq 0x18(%r14), %r15
movb $0x1, %bpl
testq %r15, %r15
je 0xe427f
movl 0x1c(%r15), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
jne 0xe427f
movq %r15, %rdi
callq 0xc7a7c
testb %al, %al
je 0xe427f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xf06fe
leaq 0x68(%rsp), %r12
xorl %ebp, %ebp
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85f7a
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x8(%rbx), %rdi
xorl %ecx, %ecx
callq 0xdf9e0
movb $0x1, %r12b
testb %bpl, %bpl
je 0xe4481
testb $0x4, 0x2(%r14)
movq 0x10(%r14), %rsi
jne 0xe42a3
testb $0x3, 0x1(%rsi)
je 0xe42d7
movq %rbx, %rdi
callq 0xe3880
jmp 0xe42eb
movb 0x10(%rbx), %al
movups (%rbx), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movb %al, 0x10(%rdi)
callq 0x127dd4
movl %eax, %ebp
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
cmpb $0x28, 0x10(%rdi)
je 0xe42ed
callq 0x22549c
jmp 0xe42ed
movups (%rbx), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rdi)
callq 0xf0cc0
movl %eax, %ebp
testb %bpl, %bpl
je 0xe4335
movq 0x18(%r14), %r15
movl 0x1c(%r15), %eax
andl $0x7f, %eax
leal -0x31(%rax), %ecx
cmpl $-0x3, %ecx
setb %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
je 0xe4373
cmpl $0x1d, %eax
setne %al
testq %r15, %r15
sete %cl
orb %al, %cl
je 0xe4394
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6e, %edx
callq 0xe7e98
jmp 0xe447e
cmpb $0x1, 0x10(%rbx)
jne 0xe447e
movq 0x8(%rbx), %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85fac
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xdf9e0
movb $0x1, %r12b
jmp 0xe4481
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
xorl %r12d, %r12d
movq %r14, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xef0c4
testb %al, %al
jne 0xe440b
jmp 0xe4481
movl 0x40(%r15), %ebp
testq %rbp, %rbp
sete %r12b
je 0xe4406
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq 0x38(%r15), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %rdi, 0x18(%rsp)
movq %r14, %rsi
movq %rdx, 0x10(%rsp)
xorl %r8d, %r8d
callq 0xef0c4
testb %al, %al
je 0xe4406
shlq $0x3, %rbp
movl $0x8, %r13d
cmpq %r13, %rbp
sete %r12b
je 0xe4406
movq 0x8(%rsp), %rax
movq (%rax,%r13), %rcx
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
xorl %r8d, %r8d
callq 0xef0c4
addq $0x8, %r13
testb %al, %al
jne 0xe43d7
testb %r12b, %r12b
je 0xe447e
movq 0x30(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x29, %al
movb $0x1, %r12b
cmpb $0x1, %al
ja 0xe4481
leaq 0x20(%rsp), %r8
movl $0x0, (%r8)
movq 0x30(%r15), %rdx
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %r14, %rsi
xorl %r9d, %r9d
callq 0xe3166
movl %eax, %r12d
testb %al, %al
je 0xe446b
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
leaq 0x20(%rsp), %rdx
callq 0xeb40a
cmpl $0x2, 0x20(%rsp)
jb 0xe4481
leaq 0x20(%rsp), %rdi
callq 0x86f80
jmp 0xe4481
xorl %r12d, %r12d
andb $0x1, %r12b
movl %r12d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::LValueExprEvaluator>::VisitConditionalOperator(clang::ConditionalOperator const*)
|
bool VisitConditionalOperator(const ConditionalOperator *E) {
bool IsBcpCall = false;
// If the condition (ignoring parens) is a __builtin_constant_p call,
// the result is a constant expression if it can be folded without
// side-effects. This is an important GNU extension. See GCC PR38377
// for discussion.
if (const CallExpr *CallCE =
dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
IsBcpCall = true;
// Always assume __builtin_constant_p(...) ? ... : ... is a potential
// constant expression; we can't check whether it's potentially foldable.
// FIXME: We should instead treat __builtin_constant_p as non-constant if
// it would return 'false' in this mode.
if (Info.checkingPotentialConstantExpression() && IsBcpCall)
return false;
FoldConstant Fold(Info, IsBcpCall);
if (!HandleConditionalOperator(E)) {
Fold.keepDiagnostics();
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0xd92f8
movb (%rax), %cl
addb $-0x5d, %cl
cmpb $-0x5, %cl
jae 0xe6058
xorl %ebp, %ebp
jmp 0xe6069
movq %rax, %rdi
callq 0xd7320
cmpl $0xd3, %eax
sete %bpl
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0xe6082
testb %al, %al
je 0xe6082
xorl %ebx, %ebx
jmp 0xe6263
movq (%rbx), %rdx
movq %rdx, 0x10(%rsp)
movb %bpl, 0x18(%rsp)
movq 0x18(%rdx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xe60a2
cmpl $0x0, 0x8(%rcx)
je 0xe60a6
xorl %eax, %eax
jmp 0xe60aa
movb (%rax), %al
xorb $0x1, %al
movb %al, 0x19(%rsp)
movl 0x394(%rdx), %eax
movl %eax, 0x1c(%rsp)
testb %bpl, %bpl
je 0xe60c7
movl $0x2, 0x394(%rdx)
movq 0x18(%r14), %rdi
leaq 0xf(%rsp), %rsi
callq 0xefb79
testb %al, %al
je 0xe60f5
movzbl 0xf(%rsp), %eax
xorl $0x1, %eax
movq 0x20(%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0xe3880
movl %eax, %ebx
jmp 0xe6250
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xe6220
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0xe6220
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x384(%r15), %ebp
leaq 0x30(%rsp), %r12
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
movl 0x8(%r12), %eax
testq %r15, %r15
je 0xe618c
movq 0x18(%r15), %rcx
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0xe6214
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x384(%r15), %ebp
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0xb4bfa
movl $0x0, 0x38(%rsp)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
movl 0x38(%rsp), %eax
testq %r15, %r15
je 0xe6200
movq 0x18(%r15), %rcx
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0xe6214
movq %rbx, %rdi
movq %r14, %rsi
movl $0x891, %edx # imm = 0x891
callq 0xe7e98
leaq 0x30(%rsp), %rdi
callq 0xb4396
jmp 0xe624e
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0xe624e
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
xorl %ebx, %ebx
testb %bl, %bl
jne 0xe6259
movb $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xfc570
movl %ebx, %eax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
findCompleteObject((anonymous namespace)::EvalInfo&, clang::Expr const*, clang::AccessKinds, (anonymous namespace)::LValue const&, clang::QualType)
|
static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
AccessKinds AK, const LValue &LVal,
QualType LValType) {
if (LVal.InvalidBase) {
Info.FFDiag(E);
return CompleteObject();
}
if (!LVal.Base) {
Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
return CompleteObject();
}
CallStackFrame *Frame = nullptr;
unsigned Depth = 0;
if (LVal.getLValueCallIndex()) {
std::tie(Frame, Depth) =
Info.getCallFrameAndDepth(LVal.getLValueCallIndex());
if (!Frame) {
Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
<< AK << LVal.Base.is<const ValueDecl*>();
NoteLValueLocation(Info, LVal.Base);
return CompleteObject();
}
}
bool IsAccess = isAnyAccess(AK);
// C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
// is not a constant expression (even if the object is non-volatile). We also
// apply this rule to C++98, in order to conform to the expected 'volatile'
// semantics.
if (isFormalAccess(AK) && LValType.isVolatileQualified()) {
if (Info.getLangOpts().CPlusPlus)
Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
<< AK << LValType;
else
Info.FFDiag(E);
return CompleteObject();
}
// Compute value storage location and type of base object.
APValue *BaseVal = nullptr;
QualType BaseType = getType(LVal.Base);
if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl &&
lifetimeStartedInEvaluation(Info, LVal.Base)) {
// This is the object whose initializer we're evaluating, so its lifetime
// started in the current evaluation.
BaseVal = Info.EvaluatingDeclValue;
} else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {
// Allow reading from a GUID declaration.
if (auto *GD = dyn_cast<MSGuidDecl>(D)) {
if (isModification(AK)) {
// All the remaining cases do not permit modification of the object.
Info.FFDiag(E, diag::note_constexpr_modify_global);
return CompleteObject();
}
APValue &V = GD->getAsAPValue();
if (V.isAbsent()) {
Info.FFDiag(E, diag::note_constexpr_unsupported_layout)
<< GD->getType();
return CompleteObject();
}
return CompleteObject(LVal.Base, &V, GD->getType());
}
// Allow reading the APValue from an UnnamedGlobalConstantDecl.
if (auto *GCD = dyn_cast<UnnamedGlobalConstantDecl>(D)) {
if (isModification(AK)) {
Info.FFDiag(E, diag::note_constexpr_modify_global);
return CompleteObject();
}
return CompleteObject(LVal.Base, const_cast<APValue *>(&GCD->getValue()),
GCD->getType());
}
// Allow reading from template parameter objects.
if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {
if (isModification(AK)) {
Info.FFDiag(E, diag::note_constexpr_modify_global);
return CompleteObject();
}
return CompleteObject(LVal.Base, const_cast<APValue *>(&TPO->getValue()),
TPO->getType());
}
// In C++98, const, non-volatile integers initialized with ICEs are ICEs.
// In C++11, constexpr, non-volatile variables initialized with constant
// expressions are constant expressions too. Inside constexpr functions,
// parameters are constant expressions even if they're non-const.
// In C++1y, objects local to a constant expression (those with a Frame) are
// both readable and writable inside constant expressions.
// In C, such things can also be folded, although they are not ICEs.
const VarDecl *VD = dyn_cast<VarDecl>(D);
if (VD) {
if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
VD = VDef;
}
if (!VD || VD->isInvalidDecl()) {
Info.FFDiag(E);
return CompleteObject();
}
bool IsConstant = BaseType.isConstant(Info.Ctx);
bool ConstexprVar = false;
if (const auto *VD = dyn_cast_if_present<VarDecl>(
Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()))
ConstexprVar = VD->isConstexpr();
// Unless we're looking at a local variable or argument in a constexpr call,
// the variable we're reading must be const.
if (!Frame) {
if (IsAccess && isa<ParmVarDecl>(VD)) {
// Access of a parameter that's not associated with a frame isn't going
// to work out, but we can leave it to evaluateVarDeclInit to provide a
// suitable diagnostic.
} else if (Info.getLangOpts().CPlusPlus14 &&
lifetimeStartedInEvaluation(Info, LVal.Base)) {
// OK, we can read and modify an object if we're in the process of
// evaluating its initializer, because its lifetime began in this
// evaluation.
} else if (isModification(AK)) {
// All the remaining cases do not permit modification of the object.
Info.FFDiag(E, diag::note_constexpr_modify_global);
return CompleteObject();
} else if (VD->isConstexpr()) {
// OK, we can read this variable.
} else if (Info.getLangOpts().C23 && ConstexprVar) {
Info.FFDiag(E);
return CompleteObject();
} else if (BaseType->isIntegralOrEnumerationType()) {
if (!IsConstant) {
if (!IsAccess)
return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
if (Info.getLangOpts().CPlusPlus) {
Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
Info.Note(VD->getLocation(), diag::note_declared_at);
} else {
Info.FFDiag(E);
}
return CompleteObject();
}
} else if (!IsAccess) {
return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
} else if (IsConstant && Info.checkingPotentialConstantExpression() &&
BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {
// This variable might end up being constexpr. Don't diagnose it yet.
} else if (IsConstant) {
// Keep evaluating to see what we can do. In particular, we support
// folding of const floating-point types, in order to make static const
// data members of such types (supported as an extension) more useful.
if (Info.getLangOpts().CPlusPlus) {
Info.CCEDiag(E, Info.getLangOpts().CPlusPlus11
? diag::note_constexpr_ltor_non_constexpr
: diag::note_constexpr_ltor_non_integral, 1)
<< VD << BaseType;
Info.Note(VD->getLocation(), diag::note_declared_at);
} else {
Info.CCEDiag(E);
}
} else {
// Never allow reading a non-const value.
if (Info.getLangOpts().CPlusPlus) {
Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
? diag::note_constexpr_ltor_non_constexpr
: diag::note_constexpr_ltor_non_integral, 1)
<< VD << BaseType;
Info.Note(VD->getLocation(), diag::note_declared_at);
} else {
Info.FFDiag(E);
}
return CompleteObject();
}
}
if (!evaluateVarDeclInit(Info, E, VD, Frame, LVal.getLValueVersion(), BaseVal))
return CompleteObject();
} else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {
std::optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
if (!Alloc) {
Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK;
return CompleteObject();
}
return CompleteObject(LVal.Base, &(*Alloc)->Value,
LVal.Base.getDynamicAllocType());
} else {
const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
if (!Frame) {
if (const MaterializeTemporaryExpr *MTE =
dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {
assert(MTE->getStorageDuration() == SD_Static &&
"should have a frame for a non-global materialized temporary");
// C++20 [expr.const]p4: [DR2126]
// An object or reference is usable in constant expressions if it is
// - a temporary object of non-volatile const-qualified literal type
// whose lifetime is extended to that of a variable that is usable
// in constant expressions
//
// C++20 [expr.const]p5:
// an lvalue-to-rvalue conversion [is not allowed unless it applies to]
// - a non-volatile glvalue that refers to an object that is usable
// in constant expressions, or
// - a non-volatile glvalue of literal type that refers to a
// non-volatile object whose lifetime began within the evaluation
// of E;
//
// C++11 misses the 'began within the evaluation of e' check and
// instead allows all temporaries, including things like:
// int &&r = 1;
// int x = ++r;
// constexpr int k = r;
// Therefore we use the C++14-onwards rules in C++11 too.
//
// Note that temporaries whose lifetimes began while evaluating a
// variable's constructor are not usable while evaluating the
// corresponding destructor, not even if they're of const-qualified
// types.
if (!MTE->isUsableInConstantExpressions(Info.Ctx) &&
!lifetimeStartedInEvaluation(Info, LVal.Base)) {
if (!IsAccess)
return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
return CompleteObject();
}
BaseVal = MTE->getOrCreateValue(false);
assert(BaseVal && "got reference to unevaluated temporary");
} else {
if (!IsAccess)
return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
APValue Val;
LVal.moveInto(Val);
Info.FFDiag(E, diag::note_constexpr_access_unreadable_object)
<< AK
<< Val.getAsString(Info.Ctx,
Info.Ctx.getLValueReferenceType(LValType));
NoteLValueLocation(Info, LVal.Base);
return CompleteObject();
}
} else {
BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion());
assert(BaseVal && "missing value for temporary");
}
}
// In C++14, we can't safely access any mutable state when we might be
// evaluating after an unmodeled side effect. Parameters are modeled as state
// in the caller, but aren't visible once the call returns, so they can be
// modified in a speculatively-evaluated call.
//
// FIXME: Not all local state is mutable. Allow local constant subobjects
// to be read here (but take care with 'mutable' fields).
unsigned VisibleDepth = Depth;
if (llvm::isa_and_nonnull<ParmVarDecl>(
LVal.Base.dyn_cast<const ValueDecl *>()))
++VisibleDepth;
if ((Frame && Info.getLangOpts().CPlusPlus14 &&
Info.EvalStatus.HasSideEffects) ||
(isModification(AK) && VisibleDepth < Info.SpeculativeEvaluationDepth))
return CompleteObject();
return CompleteObject(LVal.getLValueBase(), BaseVal, BaseType);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
testb $0x2, 0x80(%r8)
jne 0xe8012
movq %r9, %r12
movq %r8, %r15
movl %ecx, %r14d
movq %r8, %rdi
callq 0x86120
testb %al, %al
je 0xe8036
movq %rbp, 0x18(%rsp)
movq %r14, 0x28(%rsp)
movq %r15, %rdi
callq 0x86134
testl %eax, %eax
je 0xe80d3
movq %r15, %rdi
callq 0x86134
movl 0x28(%rbx), %r14d
movq 0x20(%rbx), %rbp
movl 0x80(%rbp), %ecx
cmpl %eax, %ecx
jbe 0xe8066
decl %r14d
movq 0x10(%rbp), %rbp
jmp 0xe7fff
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, 0x10(%r13)
jmp 0xe846b
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x877, %edx # imm = 0x877
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe845e
movslq %r14d, %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
jmp 0xe845e
xorl %edx, %edx
cmpl %eax, %ecx
cmovneq %rdx, %rbp
cmovnel %edx, %r14d
testq %rbp, %rbp
jne 0xe80d8
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x8ac, %edx # imm = 0x8AC
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe80bf
movq %rax, %r12
movslq 0x28(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
xorl %esi, %esi
testb $0x3, (%r15)
sete %sil
movq %r12, %rdi
movl $0x2, %edx
callq 0x96fba
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xe8a62
jmp 0xe845e
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x28(%rsp), %rcx
cmpl $0x2, %ecx
setb %al
movl $0x31c, %edx # imm = 0x31C
shrl %cl, %edx
orb %al, %dl
movl %edx, %eax
notb %al
addl $-0xa, %ecx
cmpl $-0x2, %ecx
setae %cl
orb %al, %cl
testb $0x1, %cl
jne 0xe811b
testb $0x4, %r12b
jne 0xe81f3
movq %r12, %rax
andq $-0x10, %rax
testb $0x4, 0x8(%rax)
jne 0xe81f3
movl %edx, 0x24(%rsp)
movq $0x0, 0x38(%rsp)
movups (%r15), %xmm0
leaq 0x60(%rsp), %rdi
movups %xmm0, (%rdi)
callq 0x85fd8
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
callq 0x1ce21c
testb $0x10, 0x1(%rax)
movq %rbx, 0x8(%rsp)
je 0xe818a
leaq 0x318(%rbx), %rsi
movq %r15, %rdi
callq 0x8619d
testb %al, %al
je 0xe818a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xe8bb1
testb %al, %al
je 0xe818a
movq 0x330(%rbx), %rax
movq %rax, 0x38(%rsp)
jmp 0xe83f9
movq %r13, 0x10(%rsp)
movq (%r15), %rbx
movq %rbx, %rax
andq $0x3, %rax
setne %cl
movq %rbx, %r13
andq $-0x4, %r13
sete %dl
orb %cl, %dl
je 0xe821a
cmpl $0x3, %eax
setne %cl
movq %rbx, %rsi
shrq $0x3, %rsi
testl %esi, %esi
sete %dl
orb %cl, %dl
je 0xe82b9
xorl %ecx, %ecx
cmpl $0x1, %eax
cmoveq %r13, %rcx
testq %rbp, %rbp
je 0xe8396
movq %r15, %rdi
movq %rcx, %rbx
callq 0x86140
movq %rbp, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xe9090
jmp 0xe83ef
movq %rbx, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0xe8277
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
jmp 0xe845e
movl 0x1c(%r13), %eax
andl $0x7f, %eax
cmpl $0x1c, %eax
jne 0xe82f4
movq 0x8(%rsp), %rbx
movl $0xe3, %eax
movq 0x28(%rsp), %rcx
btl %ecx, %eax
movq 0x18(%rsp), %r14
jae 0xe838b
movq %r13, %rdi
callq 0xc83b4
cmpl $0x0, (%rax)
je 0xe8529
movups (%r15), %xmm0
movq 0x30(%r13), %rcx
movq 0x10(%rsp), %r13
movups %xmm0, (%r13)
movq %rax, 0x10(%r13)
movq %rcx, 0x18(%r13)
jmp 0xe846b
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x87e, %edx # imm = 0x87E
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe845e
movq %rax, %r14
movslq 0x28(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r14, %rdi
movq %r12, %rsi
movl $0x8, %edx
jmp 0xe805c
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xe9032
testb $0x1, %dl
je 0xe835f
movq %rax, %r12
movq 0x8(%r15), %r14
movq %r15, %rdi
callq 0x8612e
movq 0x10(%rsp), %r13
movq %rbx, (%r13)
movq %r14, 0x8(%r13)
movq %r12, 0x10(%r13)
jmp 0xe8497
testq %r13, %r13
movq 0x8(%rsp), %rbx
je 0xe830a
movl 0x1c(%r13), %eax
andl $0x7f, %eax
cmpl $0x1a, %eax
je 0xe8323
testq %r13, %r13
je 0xe84b9
movl 0x1c(%r13), %eax
andl $0x7f, %eax
cmpl $0x1b, %eax
jne 0xe84b9
movl $0xe3, %eax
movq 0x28(%rsp), %rcx
btl %ecx, %eax
movq 0x18(%rsp), %rsi
jae 0xe849d
movups (%r15), %xmm0
movq 0x30(%r13), %rax
addq $0x40, %r13
movq 0x10(%rsp), %rcx
movups %xmm0, (%rcx)
movq %r13, 0x10(%rcx)
movq %rcx, %r13
movq %rax, 0x18(%rcx)
jmp 0xe846b
movq %r14, %rdi
movq 0x18(%rsp), %rsi
movl $0x874, %edx # imm = 0x874
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
movq 0x10(%rsp), %r13
je 0xe845e
movslq 0x28(%rsp), %rsi
jmp 0xe8054
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xe84a0
xorl %r13d, %r13d
testq %rcx, %rcx
je 0xe83a5
cmpb $0x30, (%rcx)
cmoveq %rcx, %r13
movl 0x24(%rsp), %eax
testq %r13, %r13
je 0xe856b
movq 0x8(%rsp), %rbx
movq 0x10(%rbx), %rsi
movq %r13, %rdi
callq 0x12f118
testb %al, %al
jne 0xe83e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xe8bb1
testb %al, %al
je 0xe8615
movq 0x10(%r13), %rdi
andq $-0x8, %rdi
xorl %esi, %esi
callq 0xc8304
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %r13
movq (%r15), %rax
testb $0x3, %al
setne %cl
andq $-0x4, %rax
sete %dl
xorl %ebx, %ebx
orb %cl, %dl
jne 0xe841c
movl 0x1c(%rax), %eax
andl $0x7f, %eax
xorl %ebx, %ebx
cmpl $0x28, %eax
sete %bl
testq %rbp, %rbp
je 0xe843f
movq 0x8(%rsp), %rdi
callq 0x1ce21c
testb $0x10, 0x1(%rax)
je 0xe843f
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpb $0x0, (%rax)
jne 0xe845e
movl $0x31c, %eax # imm = 0x31C
movq 0x28(%rsp), %rcx
btl %ecx, %eax
jae 0xe8480
addl %r14d, %ebx
movq 0x8(%rsp), %rax
cmpl 0x384(%rax), %ebx
jae 0xe8480
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movq %r13, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movups (%r15), %xmm0
movq 0x38(%rsp), %rax
movups %xmm0, (%r13)
movq %rax, 0x10(%r13)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%r13)
jmp 0xe846b
movq %rbx, %rdi
movl $0x8bf, %edx # imm = 0x8BF
xorl %ecx, %ecx
callq 0x1cdc80
xorps %xmm0, %xmm0
movq 0x10(%rsp), %r13
jmp 0xe8027
movl 0x1c(%r13), %eax
andl $0x7f, %eax
addl $-0x25, %eax
xorl %r12d, %r12d
cmpl $0x7, %eax
cmovbq %r13, %r12
testq %r12, %r12
je 0xe84e5
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0xbbbe0
testq %rax, %rax
cmovneq %rax, %r12
movq 0x10(%rsp), %r13
testq %r12, %r12
je 0xe855e
testb $-0x80, 0x1c(%r12)
jne 0xe855e
movq 0x10(%rbx), %rsi
movq 0x30(%rsp), %rdi
callq 0x224bfc
movq 0x318(%rbx), %rsi
testb $0x3, %sil
setne %cl
andq $-0x4, %rsi
sete %dl
orb %cl, %dl
je 0xe866a
xorl %ecx, %ecx
jmp 0xe867c
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8f1, %edx # imm = 0x8F1
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe8551
movq 0x30(%r13), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x96fba
xorps %xmm0, %xmm0
movq 0x10(%rsp), %r13
jmp 0xe8461
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
jmp 0xe8018
testb $0x1, %al
je 0xe85ff
leaq 0x60(%rsp), %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
callq 0xdf29e
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x87b, %edx # imm = 0x87B
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe87d5
movq %rax, %r13
movslq 0x28(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq 0x10(%rbx), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x8debe
leaq 0x40(%rsp), %r12
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x88bea
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x964fa
jmp 0xe87fe
movq 0x8(%r15), %rax
movq 0x10(%rsp), %r13
movq %rbx, (%r13)
movq %rax, 0x8(%r13)
jmp 0xe8919
testb $0x1, 0x24(%rsp)
je 0xe890b
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x879, %edx # imm = 0x879
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe864e
movslq 0x28(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r13, %rdi
callq 0xd4508
movq %rbx, %rdi
movl %eax, %esi
movl $0x8e8, %edx # imm = 0x8E8
callq 0x1cdde8
jmp 0xe84ac
movl 0x1c(%rsi), %edx
andl $0x7f, %edx
addl $-0x25, %edx
xorl %ecx, %ecx
cmpl $0x7, %edx
cmovbq %rsi, %rcx
movl 0x24(%rsp), %edx
testq %rcx, %rcx
je 0xe869f
movl 0x1c(%rcx), %esi
andl $0x7f, %esi
cmpl $0x28, %esi
sete %sil
cmpw $0x0, 0x60(%rcx)
setns %bl
orb %sil, %bl
jmp 0xe86a1
movb $0x1, %bl
testq %rbp, %rbp
je 0xe86d8
movq %r15, %rdi
callq 0x86140
leaq 0x38(%rsp), %r9
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %rbp, %rcx
movl %eax, %r8d
callq 0xe8ccd
testb %al, %al
jne 0xe83f9
jmp 0xe845e
testb $0x1, %dl
je 0xe86ea
movl 0x1c(%r12), %ecx
andl $0x7f, %ecx
cmpl $0x28, %ecx
je 0xe86a6
movq 0x8(%rsp), %rdi
movb %al, 0x7(%rsp)
callq 0x1ce21c
testb $0x10, 0x1(%rax)
je 0xe8715
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x8(%rsp), %rdi
xorl %ecx, %ecx
callq 0xe8bb1
testb %al, %al
jne 0xe86a6
movl $0xe3, %eax
movq 0x28(%rsp), %rcx
btl %ecx, %eax
jae 0xe8854
movl 0x1c(%r12), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xe8742
cmpw $0x0, 0x60(%r12)
js 0xe86a6
movq 0x8(%rsp), %rdi
callq 0x1ce21c
testb $0x8, (%rax)
sete %al
orb %al, %bl
je 0xe8868
movq 0x30(%rsp), %rbx
andq $-0x10, %rbx
movq (%rbx), %rdi
callq 0xe37fa
testb %al, %al
je 0xe8872
cmpb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %r13
movl 0x24(%rsp), %eax
jne 0xe86a6
testb $0x1, %al
je 0xe890b
movq 0x8(%rsp), %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
je 0xe8936
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x8b1, %edx # imm = 0x8B1
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe89a6
movq %rax, %rdi
movq %r12, %rsi
movl $0xa, %edx
jmp 0xe89a1
movq 0x10(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x8debe
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x88bea
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
movq 0x10(%rsp), %r13
je 0xe881e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3c080
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xe8a62
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
cmpl $0x2, 0x60(%rsp)
jb 0xe846b
leaq 0x60(%rsp), %rdi
callq 0x86f80
jmp 0xe846b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x8bf, %edx # imm = 0x8BF
jmp 0xe801d
movq 0x8(%rsp), %rdi
jmp 0xe8561
testb $0x1, 0x24(%rsp)
je 0xe890b
cmpb $0x0, 0x7(%rsp)
je 0xe8926
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
movq 0x10(%rsp), %r13
movb 0x7(%rsp), %cl
je 0xe88d8
movq (%rbx), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x227976
movb 0x7(%rsp), %cl
testb %al, %al
je 0xe88d8
movq %r12, %rdi
callq 0xc0b9c
movq %r12, %rdi
movq %rax, %rsi
callq 0xbbc5e
movb 0x7(%rsp), %cl
testl %eax, %eax
je 0xe86a6
testb %cl, %cl
je 0xe8926
movq 0x8(%rsp), %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0xe89bf
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdd9c
jmp 0xe8a28
movups (%r15), %xmm0
movq 0x10(%rsp), %r13
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
jmp 0xe8492
movq 0x8(%rsp), %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0xe8951
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
jmp 0xe8551
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1ce21c
btl $0xb, (%rax)
movl $0x8b2, %edx # imm = 0x8B2
sbbl $-0x1, %edx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xe89a6
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x96fba
movq %r15, %rdi
movq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x96fba
movl 0x18(%r12), %esi
movq 0x8(%rsp), %rdi
movl $0x69, %edx
callq 0x1cdde8
jmp 0xe8551
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1ce21c
btl $0xb, (%rax)
movl $0x8b2, %edx # imm = 0x8B2
sbbl $-0x1, %edx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %ecx
callq 0x1cdd9c
testq %rax, %rax
je 0xe8a14
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x96fba
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x96fba
movl 0x18(%r12), %esi
movq 0x8(%rsp), %rdi
movl $0x69, %edx
callq 0x1cdde8
movq 0x10(%rsp), %r13
jmp 0xe86a6
|
/AST/ExprConstant.cpp
|
clang::APValue::LValuePathEntry* llvm::SmallVectorImpl<clang::APValue::LValuePathEntry>::insert<clang::APValue::LValuePathEntry const*, void>(clang::APValue::LValuePathEntry*, clang::APValue::LValuePathEntry const*, clang::APValue::LValuePathEntry const*)
|
iterator insert(iterator I, ItTy From, ItTy To) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t InsertElt = I - this->begin();
if (I == this->end()) { // Important special case for empty vector.
append(From, To);
return this->begin()+InsertElt;
}
assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
// Check that the reserve that follows doesn't invalidate the iterators.
this->assertSafeToAddRange(From, To);
size_t NumToInsert = std::distance(From, To);
// Ensure there is enough space.
reserve(this->size() + NumToInsert);
// Uninvalidate the iterator.
I = this->begin()+InsertElt;
// If there are more elements between the insertion point and the end of the
// range than there are being inserted, we can use a simple approach to
// insertion. Since we already reserved space, we know that this won't
// reallocate the vector.
if (size_t(this->end()-I) >= NumToInsert) {
T *OldEnd = this->end();
append(std::move_iterator<iterator>(this->end() - NumToInsert),
std::move_iterator<iterator>(this->end()));
// Copy the existing elements that get replaced.
std::move_backward(I, OldEnd-NumToInsert, OldEnd);
std::copy(From, To, I);
return I;
}
// Otherwise, we're inserting more elements than exist already, and we're
// not inserting at the end.
// Move over the elements that we're about to overwrite.
T *OldEnd = this->end();
this->set_size(this->size() + NumToInsert);
size_t NumOverwritten = OldEnd-I;
this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
// Replace the overwritten part.
for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
*J = *From;
++J; ++From;
}
// Insert the non-overwritten middle part.
this->uninitialized_copy(From, To, OldEnd);
return I;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r13
movq (%rdi), %rax
movq %rsi, %r12
subq %rax, %r12
movl 0x8(%rdi), %edx
leaq (%rax,%rdx,8), %rax
cmpq %rsi, %rax
je 0xeb6be
movq %rcx, 0x8(%rsp)
movq %rcx, %rbp
subq %rbx, %rbp
movq %rbp, 0x10(%rsp)
sarq $0x3, %rbp
addq %rbp, %rdx
movl 0xc(%r13), %eax
cmpq %rax, %rdx
jbe 0xeb626
leaq 0x10(%r13), %rsi
movl $0x8, %ecx
movq %r13, %rdi
callq 0x56f14
movq (%r13), %rax
leaq (%rax,%r12), %r15
movl 0x8(%r13), %ecx
leaq (,%rcx,8), %rsi
leaq (%rax,%rcx,8), %r8
movq %rsi, %rdx
subq %r12, %rdx
movq %rdx, %r14
sarq $0x3, %r14
cmpq %rbp, %r14
jae 0xeb6d5
addl %ecx, %ebp
movl %ebp, 0x8(%r13)
cmpq %r12, %rsi
je 0xeb684
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rdi
leaq (,%r14,8), %rax
subq %rax, %rdi
movq %rsi, %rbp
movq %r15, %rsi
movq %r8, %r13
callq 0x3c370
movq %rbp, %rsi
movq %r13, %r8
cmpq %r12, %rsi
je 0xeb6a4
xorl %eax, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
addq $-0x8, %rax
cmpq %rcx, %r14
jne 0xeb68d
subq %rax, %rbx
movq 0x8(%rsp), %rdx
cmpq %rdx, %rbx
je 0xeb72b
subq %rbx, %rdx
movq %r8, %rdi
movq %rbx, %rsi
callq 0x3c370
jmp 0xeb72b
movq %r13, %rdi
movq %rbx, %rsi
movq %rcx, %rdx
callq 0xeb73e
addq (%r13), %r12
movq %r12, %r15
jmp 0xeb72b
shlq $0x3, %rbp
movq %r8, %r12
subq %rbp, %r12
movq %r13, %rdi
movq %r12, %rsi
movq %r8, %rdx
movq %r8, %r14
callq 0xeb7a4
subq %r15, %r12
je 0xeb706
subq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3c0c0
cmpq %rbx, 0x8(%rsp)
je 0xeb72b
movq %r15, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c0c0
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/ADT/SmallVector.h
|
checkFloatingPointResult((anonymous namespace)::EvalInfo&, clang::Expr const*, llvm::APFloatBase::opStatus)
|
static bool checkFloatingPointResult(EvalInfo &Info, const Expr *E,
APFloat::opStatus St) {
// In a constant context, assume that any dynamic rounding mode or FP
// exception state matches the default floating-point environment.
if (Info.InConstantContext)
return true;
FPOptions FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
if ((St & APFloat::opInexact) &&
FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
// Inexact result means that it depends on rounding mode. If the requested
// mode is dynamic, the evaluation cannot be made in compile time.
Info.FFDiag(E, diag::note_constexpr_dynamic_rounding);
return false;
}
if ((St != APFloat::opOK) &&
(FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
FPO.getExceptionMode() != LangOptions::FPE_Ignore ||
FPO.getAllowFEnvAccess())) {
Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
return false;
}
if ((St & APFloat::opStatus::opInvalidOp) &&
FPO.getExceptionMode() != LangOptions::FPE_Ignore) {
// There is no usefully definable result.
Info.FFDiag(E);
return false;
}
// FIXME: if:
// - evaluation triggered other FP exception, and
// - exception mode is not "ignore", and
// - the expression being evaluated is not a part of global variable
// initializer,
// the evaluation probably need to be rejected.
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpb $0x0, 0x8(%rdi)
jne 0xebb6a
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq 0x830(%rax), %rsi
movq %r14, %rdi
callq 0xda68e
testb $0x10, %bpl
je 0xebaf5
movl %eax, %ecx
andl $0x38, %ecx
cmpl $0x38, %ecx
jne 0xebaf5
movl %eax, %ecx
movl $0x89f, %edx # imm = 0x89F
andl $0x104, %ecx # imm = 0x104
jne 0xebb5b
testl %ebp, %ebp
je 0xebb38
movl %eax, %ecx
notl %ecx
testb $0x38, %cl
sete %cl
testl $0x104, %eax # imm = 0x104
setne %sil
movl $0x8a1, %edx # imm = 0x8A1
testb %sil, %cl
jne 0xebb5b
movl %eax, %ecx
shrl $0x6, %ecx
andl $0x3, %ecx
movl %eax, %esi
shrl $0x7, %esi
andl $0x2, %esi
cmpl $0x3, %ecx
cmovnel %ecx, %esi
movl %eax, %ecx
andl $0x100, %ecx # imm = 0x100
orl %esi, %ecx
jne 0xebb5b
testb $0x1, %bpl
je 0xebb6a
movl %eax, %ecx
shrl $0x6, %ecx
andl $0x3, %ecx
shrl $0x7, %eax
andl $0x2, %eax
cmpl $0x3, %ecx
cmovnel %ecx, %eax
movl $0x6e, %edx
testl %eax, %eax
je 0xebb6a
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1cdc80
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::LValueExprEvaluator::VisitUnaryPreIncDec(clang::UnaryOperator const*)
|
bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
return Error(UO);
if (!this->Visit(UO->getSubExpr()))
return false;
return handleIncDec(
this->Info, UO, Result, UO->getSubExpr()->getType(),
UO->isIncrementOp(), nullptr);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1ce21c
testb $0x10, 0x1(%rax)
jne 0xebb9d
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0xebbdb
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xe3880
testb %al, %al
je 0xebbeb
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq 0x10(%rbx), %rax
xorl %r8d, %r8d
testl $0x740000, (%rbx) # imm = 0x740000
movq 0x8(%rax), %rcx
sete %r8b
movq %rbx, %rsi
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xea1bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0xe7e98
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::Cleanup::endLifetime((anonymous namespace)::EvalInfo&, bool)
|
bool endLifetime(EvalInfo &Info, bool RunDestructors) {
if (RunDestructors) {
SourceLocation Loc;
if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
Loc = VD->getLocation();
else if (const Expr *E = Base.dyn_cast<const Expr*>())
Loc = E->getExprLoc();
return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T);
}
*Value.getPointer() = APValue();
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testl %edx, %edx
je 0xee238
movq %rsi, %r14
movq 0x8(%rbx), %r15
movq %r15, %rax
andq $0x3, %rax
setne %cl
movq %r15, %rdi
andq $-0x4, %rdi
sete %dl
orb %cl, %dl
je 0xee26f
cmpl $0x1, %eax
setne %al
testq %rdi, %rdi
sete %cl
xorl %esi, %esi
orb %al, %cl
jne 0xee272
callq 0xd4508
movl %eax, %esi
jmp 0xee272
leaq 0x8(%rsp), %r14
movl $0x0, (%r14)
movq (%rbx), %rdi
andq $-0x8, %rdi
movq %r14, %rsi
callq 0x86f28
cmpl $0x2, (%r14)
jb 0xee263
leaq 0x8(%rsp), %rdi
callq 0x86f80
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%rdi), %esi
movq (%rbx), %r8
movq 0x10(%rbx), %rcx
andq $-0x8, %r8
movq 0x18(%rbx), %r9
movq %r14, %rdi
movq %r15, %rdx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xee295
|
/AST/ExprConstant.cpp
|
void llvm::SmallVectorImpl<clang::FieldDecl*>::append<clang::DeclContext::specific_decl_iterator<clang::FieldDecl>, void>(clang::DeclContext::specific_decl_iterator<clang::FieldDecl>, clang::DeclContext::specific_decl_iterator<clang::FieldDecl>)
|
void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
cmpq %rdx, %rsi
je 0xef502
movq %r15, %rax
movq 0x8(%rax), %rax
andq $-0x8, %rax
je 0xef4fa
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
addl $-0x2e, %ecx
cmpl $0x3, %ecx
jae 0xef4e2
incq %r12
cmpq %r14, %rax
jne 0xef4e2
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %eax
addq %r12, %rdx
cmpq %rax, %rdx
jbe 0xef521
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
movl 0x8(%rbx), %eax
cmpq %r14, %r15
je 0xef559
leaq (,%rax,8), %rcx
addq (%rbx), %rcx
movq %r15, (%rcx)
movq 0x8(%r15), %r15
andq $-0x8, %r15
je 0xef550
movl 0x1c(%r15), %edx
andl $0x7f, %edx
addl $-0x2e, %edx
cmpl $0x3, %edx
jae 0xef537
addq $0x8, %rcx
cmpq %r14, %r15
jne 0xef534
addl %eax, %r12d
movl %r12d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase, llvm::DenseMapInfo<(anonymous namespace)::ObjectUnderConstruction, void>, llvm::detail::DenseMapPair<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase>>, (anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase, llvm::DenseMapInfo<(anonymous namespace)::ObjectUnderConstruction, void>, llvm::detail::DenseMapPair<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase>>::operator[]((anonymous namespace)::ObjectUnderConstruction const&)
|
ValueT &operator[](const KeyT &Key) {
return FindAndConstruct(Key).second;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0xe936e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0xef696
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xef2e4
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movl $0x0, 0x20(%rax)
addq $0x20, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase, llvm::DenseMapInfo<(anonymous namespace)::ObjectUnderConstruction, void>, llvm::detail::DenseMapPair<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase>>, (anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase, llvm::DenseMapInfo<(anonymous namespace)::ObjectUnderConstruction, void>, llvm::detail::DenseMapPair<(anonymous namespace)::ObjectUnderConstruction, (anonymous namespace)::ConstructionPhase>>::erase((anonymous namespace)::ObjectUnderConstruction const&)
|
bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
callq 0xe936e
testb %al, %al
je 0xef6e1
movq (%rsp), %r14
callq 0x8620e
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq 0x8(%rbx), %xmm0
paddd 0x2342d4(%rip), %xmm0 # 0x3239b0
movq %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/llvm/ADT/DenseMap.h
|
EvaluateIgnoredValue((anonymous namespace)::EvalInfo&, clang::Expr const*)
|
static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
assert(!E->isValueDependent());
APValue Scratch;
if (!Evaluate(Scratch, Info, E))
// We don't need the value, but we might have skipped a side effect here.
return Info.noteSideEffect();
return true;
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x0, (%rdi)
movq %r14, %rsi
callq 0xe170f
movb $0x1, %bl
testb %al, %al
jne 0xef810
movq 0x18(%r14), %rax
movb $0x1, (%rax)
cmpl $0x3, 0x394(%r14)
je 0xef810
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testb %al, %al
jne 0xef810
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl %eax, %ebx
cmpl $0x2, (%rsp)
jb 0xef81e
movq %rsp, %rdi
callq 0x86f80
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
|
/AST/ExprConstant.cpp
|
EvaluateCond((anonymous namespace)::EvalInfo&, clang::VarDecl const*, clang::Expr const*, bool&)
|
static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
const Expr *Cond, bool &Result) {
if (Cond->isValueDependent())
return false;
FullExpressionRAII Scope(Info);
if (CondDecl && !EvaluateDecl(Info, CondDecl))
return false;
if (!EvaluateAsBooleanCondition(Cond, Result, Info))
return false;
return Scope.destroy();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb $0x1, 0x2(%rdx)
jne 0xefb4a
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x110(%rdi), %ebp
movq 0x20(%rdi), %rax
leaq 0x88(%rax), %rdi
movl 0xa0(%rax), %esi
incl %esi
movl %esi, 0xa0(%rax)
callq 0x75350
testq %r12, %r12
je 0xefb1f
movq %rbx, %rdi
movq %r12, %rsi
callq 0xefa46
testb %al, %al
je 0xefb4f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xefb79
testb %al, %al
je 0xefb4f
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x12e024
movl %eax, %r14d
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0xefb52
xorl %r14d, %r14d
jmp 0xefb6d
xorl %r14d, %r14d
cmpl $-0x1, %ebp
je 0xefb63
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x12e024
movq 0x20(%rbx), %rax
decl 0x90(%rax)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::TemporaryExprEvaluator>::VisitUnaryPostIncDec(clang::UnaryOperator const*)
|
bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
return Error(UO);
LValue LVal;
if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
return false;
APValue RVal;
if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
UO->isIncrementOp(), &RVal))
return false;
return DerivedSuccess(RVal, UO);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1ce21c
testb $0x10, 0x1(%rax)
jne 0xf1faf
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0xf207f
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r12
movaps %xmm0, -0x40(%r12)
xorl %r14d, %r14d
movq %r14, -0x30(%r12)
orb $0x1, -0x28(%r12)
movq %r14, -0x18(%r12)
movq %r12, -0x10(%r12)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%r12)
movq 0x10(%r15), %rsi
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0xe3880
testb %al, %al
je 0xf206b
leaq 0x8(%rsp), %r9
movl $0x0, (%r9)
movq (%rbx), %rdi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
xorl %r8d, %r8d
testl $0x740000, (%r15) # imm = 0x740000
sete %r8b
leaq 0x50(%rsp), %rdx
movq %r15, %rsi
callq 0xea1bc
movl %eax, %r14d
testb %al, %al
je 0xf205a
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0xeb40a
cmpl $0x2, 0x8(%rsp)
jb 0xf206b
leaq 0x8(%rsp), %rdi
callq 0x86f80
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xf2092
callq 0x3c3a0
jmp 0xf2092
movq %rbx, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0xf20a4
xorl %r14d, %r14d
movl %r14d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/AST/ExprConstant.cpp
|
HandleLValueBase((anonymous namespace)::EvalInfo&, clang::Expr const*, (anonymous namespace)::LValue&, clang::CXXRecordDecl const*, clang::CXXBaseSpecifier const*)
|
static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
const CXXRecordDecl *DerivedDecl,
const CXXBaseSpecifier *Base) {
const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
if (!Base->isVirtual())
return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
SubobjectDesignator &D = Obj.Designator;
if (D.Invalid)
return false;
// Extract most-derived object and corresponding type.
DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
return false;
// Find the virtual base class.
if (DerivedDecl->isInvalidDecl()) return false;
const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%r8), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0xf5417
callq 0x225b78
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
movq %rax, %r12
testb $0x1, 0xc(%rbp)
jne 0xf5451
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r12, %r8
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xef19d
testb $0x1, 0x18(%r14)
jne 0xf54c5
movq 0x28(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
movq %rax, %r13
movl 0x18(%r14), %r8d
shrl $0x4, %r8d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0xf54d6
testb %al, %al
je 0xf54c5
testb $-0x80, 0x1c(%r13)
jne 0xf54c5
movq 0x10(%r15), %rdi
movq %r13, %rsi
callq 0x203026
movq %rax, %rdi
movq %r12, %rsi
callq 0x9393a
addq %rax, 0x10(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0xef592
movb $0x1, %al
jmp 0xf54c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
|
RetTy Visit(PTR(Stmt) S, ParamTys... P) {
// If we have a binary expr, dispatch to the subcode of the binop. A smart
// optimizer (e.g. LLVM) will fold this comparison into the switch stmt
// below.
if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
switch (BinOp->getOpcode()) {
case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator);
case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator);
case BO_Mul: DISPATCH(BinMul, BinaryOperator);
case BO_Div: DISPATCH(BinDiv, BinaryOperator);
case BO_Rem: DISPATCH(BinRem, BinaryOperator);
case BO_Add: DISPATCH(BinAdd, BinaryOperator);
case BO_Sub: DISPATCH(BinSub, BinaryOperator);
case BO_Shl: DISPATCH(BinShl, BinaryOperator);
case BO_Shr: DISPATCH(BinShr, BinaryOperator);
case BO_LT: DISPATCH(BinLT, BinaryOperator);
case BO_GT: DISPATCH(BinGT, BinaryOperator);
case BO_LE: DISPATCH(BinLE, BinaryOperator);
case BO_GE: DISPATCH(BinGE, BinaryOperator);
case BO_EQ: DISPATCH(BinEQ, BinaryOperator);
case BO_NE: DISPATCH(BinNE, BinaryOperator);
case BO_Cmp: DISPATCH(BinCmp, BinaryOperator);
case BO_And: DISPATCH(BinAnd, BinaryOperator);
case BO_Xor: DISPATCH(BinXor, BinaryOperator);
case BO_Or : DISPATCH(BinOr, BinaryOperator);
case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator);
case BO_LOr : DISPATCH(BinLOr, BinaryOperator);
case BO_Assign: DISPATCH(BinAssign, BinaryOperator);
case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator);
case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
case BO_Comma: DISPATCH(BinComma, BinaryOperator);
}
} else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
switch (UnOp->getOpcode()) {
case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator);
case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator);
case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator);
case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator);
case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator);
case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator);
case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator);
case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator);
case UO_Not: DISPATCH(UnaryNot, UnaryOperator);
case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator);
case UO_Real: DISPATCH(UnaryReal, UnaryOperator);
case UO_Imag: DISPATCH(UnaryImag, UnaryOperator);
case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator);
}
}
// Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
switch (S->getStmtClass()) {
default: llvm_unreachable("Unknown stmt kind!");
#define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT) \
case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
#include "clang/AST/StmtNodes.inc"
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x23b4e7(%rip), %r15 # 0x330f40
leaq 0x23b518(%rip), %r12 # 0x330f78
leaq 0x23b455(%rip), %r13 # 0x330ebc
movq %rsi, %rbx
movb (%rsi), %al
leal -0x77(%rax), %ecx
cmpb $-0x2, %cl
setb %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
je 0xf5a92
cmpb $0x4, %al
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movb $0x1, %cl
je 0xf5abc
jmp 0xf5ae6
movl (%rbx), %eax
shrl $0x12, %eax
andl $0x3f, %eax
cmpl $0x20, %eax
ja 0xf5ba2
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf7368
xorl %ecx, %ecx
jmp 0xf5ae6
movl (%rbx), %edx
shrl $0x12, %edx
andl $0x1f, %edx
cmpl $0xd, %edx
ja 0xf5ae6
movslq (%r15,%rdx,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %ecx, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xf5bbb
movzbl (%rbx), %eax
addl $-0x3, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x10(%rbx), %rsi
jmp 0xf5a67
movq 0x18(%rbx), %rsi
jmp 0xf5a67
movl 0x10(%rbx), %eax
movl %eax, %ecx
shrl $0xf, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
btl $0x1e, %eax
adcl $0x0, %ecx
movq 0x20(%rbx,%rcx,8), %rsi
jmp 0xf5a67
xorl %esi, %esi
testb $0x40, 0x2(%rbx)
je 0xf5a67
jmp 0xf5afd
movq 0x20(%rbx), %rsi
jmp 0xf5a67
movq %rbx, %rdi
callq 0xb4478
movl %eax, %eax
movq 0x30(%rbx,%rax,8), %rsi
jmp 0xf5a67
movzbl 0x30(%rbx), %eax
xorl $0x1, %eax
movq 0x18(%rbx,%rax,8), %rsi
jmp 0xf5a67
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf7920
jmp 0xf5ab8
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xf5a46
jmp 0xf5ab8
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xf7cca
movb $0x1, %al
jmp 0xf5ab8
movb $0x1, %cl
jmp 0xf5a90
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf8f00
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6590
movq %r14, %rdi
xorl %esi, %esi
callq 0xf7cca
movb $0x1, %al
jmp 0xf5bbb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf7368
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf64ce
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf64fa
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf631c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf72f2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf60b4
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf725a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf748c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf611a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf5d3e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf76d6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6292
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf653a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf6258
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf5f08
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf636e
nop
|
/clang/AST/StmtVisitor.h
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::MemberPointerExprEvaluator>::VisitCallExpr(clang::CallExpr const*)
|
bool VisitCallExpr(const CallExpr *E) {
APValue Result;
if (!handleCallExpr(E, Result, nullptr))
return false;
return DerivedSuccess(Result, E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, %r15
movl $0x0, 0x108(%rsp)
movq %rdi, %rbp
movq (%rdi), %rax
movl 0x110(%rax), %ecx
movl %ecx, 0x3c(%rsp)
movq %rax, 0x70(%rsp)
movq 0x20(%rax), %rax
leaq 0x88(%rax), %rdi
movl 0xa0(%rax), %esi
incl %esi
movl %esi, 0xa0(%rax)
callq 0x75350
movl (%r15), %r12d
movl %r12d, %eax
shrl $0x18, %eax
leaq (%r15,%rax), %r14
movq (%r15,%rax), %rdi
callq 0xd90f0
movq %rax, %r13
movq 0x8(%rax), %rbx
xorl %eax, %eax
leaq 0x220(%rsp), %rcx
movq %rax, -0x30(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rcx)
orb $0x1, -0x28(%rcx)
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
shrl $0xf, %r12d
andl $0x8, %r12d
addq %r12, %r14
addq $0x8, %r14
movl 0x10(%r15), %r12d
andq $-0x10, %rbx
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xf66dc
cmpb $0xd, 0x10(%rax)
jne 0xf66dc
movl $0xff80000, %ecx # imm = 0xFF80000
andl 0x10(%rax), %ecx
cmpl $0xf580000, %ecx # imm = 0xF580000
jne 0xf66dc
movq %r14, 0x68(%rsp)
movb (%r13), %al
cmpb $0x2e, %al
movq %r12, 0x58(%rsp)
jne 0xf6849
movq %rbp, %r14
movq (%rbp), %rdi
movq 0x10(%r13), %rsi
leaq 0x1e0(%rsp), %rbx
movq %rbx, %rdx
callq 0xe1379
testb %al, %al
je 0xf697f
movq 0x18(%r13), %rax
movl 0x1c(%rax), %ecx
andl $0x7c, %ecx
xorl %r8d, %r8d
cmpl $0x20, %ecx
cmoveq %rax, %r8
testq %r8, %r8
je 0xf696f
movb 0x2(%r13), %sil
andb $0x8, %sil
shrb $0x3, %sil
movb $0x1, %r12b
jmp 0xf698b
callq 0x77ce4
testq %rax, %rax
je 0xf67b1
movq 0x20(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x19, %al
cmpb $0x1, %al
ja 0xf67b1
movq %r12, 0x58(%rsp)
movq %r14, 0x68(%rsp)
xorps %xmm0, %xmm0
leaq 0xc0(%rsp), %rcx
movaps %xmm0, -0x40(%rcx)
xorl %eax, %eax
movq %rax, -0x30(%rcx)
orb $0x1, -0x28(%rcx)
movq $0x0, 0x50(%rsp)
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movq %rbp, %r14
movq (%rbp), %rax
leaq 0x150(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x80(%rsp), %rax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r13, %rsi
callq 0x127dd4
testb %al, %al
je 0xf68ce
cmpq $0x0, 0x90(%rsp)
je 0xf6a7b
movq %r14, %rdi
movq %r13, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %r13d, %r13d
movq $0x0, 0x50(%rsp)
jmp 0xf68d1
movq %rbp, %r14
movq %rbp, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %ebp, %ebp
movq 0x210(%rsp), %rdi
leaq 0x220(%rsp), %rax
cmpq %rax, %rdi
je 0xf67e0
callq 0x3c3a0
movl 0x3c(%rsp), %edx
cmpl $-0x1, %edx
je 0xf67f5
movq 0x70(%rsp), %rdi
xorl %esi, %esi
callq 0xfb310
movq 0x70(%rsp), %rax
movq 0x20(%rax), %rax
decl 0x90(%rax)
testb $0x1, %bpl
je 0xf681a
leaq 0x108(%rsp), %rsi
movq %r14, %rdi
callq 0xf7a40
cmpl $0x2, 0x108(%rsp)
jb 0xf6831
leaq 0x108(%rsp), %rdi
callq 0x86f80
andb $0x1, %bpl
movl %ebp, %eax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal -0x77(%rax), %ecx
cmpb $-0x2, %cl
movq %rbp, %r14
jae 0xf6933
cmpb $0x65, %al
jne 0xf696f
movq (%r14), %rdi
callq 0x1ce21c
testb $0x40, 0x1(%rax)
jne 0xf6880
movq (%r14), %rdi
movq %r13, %rsi
movl $0x8e2, %edx # imm = 0x8E2
xorl %ecx, %ecx
callq 0x1cdd9c
movq (%r14), %rdi
movq 0x10(%r13), %rsi
leaq 0x1e0(%rsp), %rdx
callq 0xe1379
testb %al, %al
je 0xf697f
movq (%r14), %r12
movq %r13, %rdi
callq 0x12e644
leaq 0x1e0(%rsp), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rcx
callq 0xf9368
movl %eax, %edx
xorl %r12d, %r12d
xorl %r8d, %r8d
xorl %esi, %esi
xorl %ebx, %ebx
jmp 0xf698b
xorl %r13d, %r13d
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
xorl %r8d, %r8d
xorl %edx, %edx
leaq 0xc0(%rsp), %rbx
movq 0xb0(%rsp), %rdi
cmpq %rbx, %rdi
je 0xf6919
movq %r8, %rbx
movq %rbp, %r12
movq %r13, %rbp
movq %r15, %r13
movq %rdx, %r15
callq 0x3c3a0
movq %r15, %rdx
movq %r13, %r15
movq %rbp, %r13
movq %r12, %rbp
movq %rbx, %r8
testb %bpl, %bpl
je 0xf692c
xorl %esi, %esi
movq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rbx
jmp 0xf69a2
movl %edx, %ebp
jmp 0xf67c6
movq (%r14), %rdi
leaq 0x1e0(%rsp), %rbx
xorl %r12d, %r12d
movq %r13, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xf55ca
testq %rax, %rax
je 0xf6982
movq %rax, %r8
movl 0x1c(%rax), %eax
andl $0x7c, %eax
xorl %esi, %esi
cmpl $0x20, %eax
cmovneq %rsi, %r8
testq %r8, %r8
je 0xf696f
movb $0x1, %r12b
jmp 0xf6989
movq %r14, %rdi
movq %r13, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %r12d, %r12d
xorl %r8d, %r8d
xorl %esi, %esi
xorl %ebx, %ebx
xorl %edx, %edx
xorl %r13d, %r13d
movl $0x0, %ecx
movl %edx, %ebp
testb %r12b, %r12b
cmoveq %r13, %r8
je 0xf67c6
movq %rsi, 0x40(%rsp)
testq %rcx, %rcx
movq %rbx, 0x30(%rsp)
jne 0xf6a19
movq (%r14), %rcx
movq 0x20(%rcx), %rax
movq %r15, 0x50(%rsp)
movq %rdx, %r15
movl 0x80(%rax), %edx
movl 0xa0(%rax), %r13d
incl %r13d
movl %r13d, 0xa0(%rax)
shlq $0x20, %r13
orq %rdx, %r13
xorl %ebp, %ebp
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r13, %rdx
movq %r14, %r12
movq %r8, %r14
xorl %r9d, %r9d
callq 0xf9d99
movq %r15, %rdx
movq 0x50(%rsp), %r15
movq %r14, %r8
movq %r12, %r14
movq 0x30(%rsp), %rbx
movq %r8, %rcx
testb %al, %al
je 0xf67c6
leaq 0x90(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rsi)
testq %rbx, %rbx
movq %rcx, 0x50(%rsp)
je 0xf6a74
testq %r8, %r8
je 0xf6bbe
movl 0x1c(%r8), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
jne 0xf6bbe
movq %rdx, 0x58(%rsp)
movq (%r8), %rax
movq %r8, %r12
movq %r8, %rdi
callq *0x20(%rax)
testb $0xc, 0x52(%rax)
je 0xf6ae7
xorl %eax, %eax
jmp 0xf6af4
movl %edx, %ebp
jmp 0xf6bca
testb $0x1, 0x100(%rsp)
je 0xf6b8b
movq (%r14), %rdi
movq %r13, %rsi
movl $0x8d0, %edx # imm = 0x8D0
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
leaq 0xc0(%rsp), %rbx
je 0xf6fb0
leaq 0x150(%rsp), %rsi
movl $0x8, (%rsi)
movq %r13, 0x8(%rsi)
movq %rax, %rdi
callq 0x223ab0
xorl %r13d, %r13d
movq $0x0, 0x50(%rsp)
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
xorl %r8d, %r8d
xorl %edx, %edx
jmp 0xf68e9
movq %rax, %rdi
callq 0xc7d6a
testl %eax, %eax
sete %al
movq 0x40(%rsp), %rcx
orb %al, %cl
je 0xf6b54
movq %r12, %rdi
callq 0xc7d00
testb %al, %al
je 0xf6bae
movq (%r14), %rdi
movl 0x1c(%r12), %eax
andl $0x7f, %eax
xorl %ecx, %ecx
cmpl $0x21, %eax
sete %cl
leal 0x5(,%rcx,4), %ecx
xorl %ebx, %ebx
movq %r15, %rsi
movq 0x30(%rsp), %rdx
xorl %r8d, %r8d
callq 0xfb993
movl $0x0, %ebp
testb %al, %al
movq %r12, %r8
movq 0x58(%rsp), %rdx
leaq 0x90(%rsp), %rsi
jne 0xf6bbe
jmp 0xf6bc2
movq (%r14), %rdi
leaq 0x80(%rsp), %r8
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xfa647
movq %rax, %r8
testq %rax, %rax
movq 0x58(%rsp), %rdx
leaq 0x90(%rsp), %rsi
jne 0xf6bbe
xorl %ebx, %ebx
xorl %r8d, %r8d
xorl %ebp, %ebp
jmp 0xf6bc2
movq 0x80(%rsp), %rax
testb $0x3, %al
setne %cl
andq $-0x4, %rax
sete %dl
orb %cl, %dl
je 0xf6d99
xorl %edx, %edx
jmp 0xf6dab
movq %r12, %r8
movq 0x58(%rsp), %rdx
leaq 0x90(%rsp), %rsi
movb $0x1, %bl
movl %edx, %ebp
testb %bl, %bl
je 0xf6d7e
movl 0x1c(%r8), %eax
andl $0x7f, %eax
cmpl $0x21, %eax
setne %al
testq %r8, %r8
sete %bl
orb %al, %bl
movq %r13, 0x60(%rsp)
jne 0xf6c70
movq %r14, 0x40(%rsp)
movq (%r14), %r13
movq 0x10(%r13), %rbp
movq %r8, %r14
leaq 0x48(%r8), %rdi
callq 0xc1de2
movq 0x10(%rax), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xf6c15
movq (%rax), %rax
leaq -0x40(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movq %rbp, %rdi
callq 0x8fdbc
movq %r13, %rdi
movq %r15, %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0xf9368
testb %al, %al
je 0xf6c5e
movq 0x70(%rsp), %rdi
movl $0x1, %esi
movl 0x3c(%rsp), %edx
callq 0xfb310
movl %eax, %ebp
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0xf6c60
xorl %ebp, %ebp
movq %r14, %r8
movq 0x40(%rsp), %r14
leaq 0x90(%rsp), %rsi
testb %bl, %bl
je 0xf6d7e
leaq 0x78(%rsp), %rbp
movq $0x0, (%rbp)
movq %r8, %rdi
movq %rbp, %rsi
movq %r8, %rbx
callq 0xbc90e
movq %rax, %r12
movq (%r14), %r13
movq %r15, %rdi
callq 0xd4508
movq (%rbp), %rcx
movq %r13, %rdi
movl %eax, %esi
movq %rbx, %rdx
movq %r12, %r8
callq 0xeee9b
testb %al, %al
je 0xf6d74
movq %r15, %rdi
callq 0xd4508
movq 0x78(%rsp), %rsi
movq 0x50(%rsp), %rcx
movq %rcx, 0x150(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, 0x158(%rsp)
movq (%r14), %rcx
movups 0x150(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x108(%rsp), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl %eax, %edi
movq 0x30(%rsp), %rdx
movq %r15, %rcx
movq 0x68(%rsp), %r8
movq %r12, %r9
callq 0xe1f6b
testb %al, %al
je 0xf6d74
movl 0x88(%rsp), %r8d
testq %r8, %r8
je 0xf6d55
movq (%r14), %rdi
movq 0x80(%rsp), %rcx
leaq 0x108(%rsp), %rdx
movq %r15, %rsi
callq 0xfa98e
testb %al, %al
je 0xf6d74
movq 0x70(%rsp), %rdi
movl $0x1, %esi
movl 0x3c(%rsp), %edx
callq 0xfb310
movl %eax, %ebp
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0xf6d76
xorl %ebp, %ebp
leaq 0x90(%rsp), %rsi
movq 0x80(%rsp), %rdi
cmpq %rsi, %rdi
je 0xf67c6
callq 0x3c3a0
jmp 0xf67c6
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
addl $-0x1f, %ecx
xorl %edx, %edx
cmpl $0x6, %ecx
cmovbq %rax, %rdx
testq %rdx, %rdx
je 0xf6790
movq (%r14), %rax
movq 0x10(%rax), %r13
movq (%rbx), %rdi
movq %rdx, %rbx
callq 0x224ac4
movq %rbx, 0x48(%rsp)
movq 0x30(%rbx), %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x8d594
testb %al, %al
je 0xf6fd1
movq %r14, 0x40(%rsp)
movb (%r15), %r12b
xorl %r13d, %r13d
movl $0x0, %r14d
movl $0x0, %eax
cmpb $0x5a, %r12b
cmoveq %r15, %r14
movq 0x48(%rsp), %r8
jne 0xf6ec6
movzbl 0x4(%r14), %eax
andl $0x3f, %eax
leal -0x12(%rax), %ecx
cmpl $0x8, %ecx
jb 0xf6e3a
xorl %r13d, %r13d
cmpl $0x1d, %eax
ja 0xf724f
movl $0x30008000, %ecx # imm = 0x30008000
btl %eax, %ecx
movl $0x0, %eax
jae 0xf6ec6
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movl 0x80(%rax), %ecx
movl 0xa0(%rax), %ebx
incl %ebx
movl %ebx, 0xa0(%rax)
shlq $0x20, %rbx
orq %rcx, %rbx
movl 0x1c(%r8), %eax
andl $0x7c, %eax
movq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq 0x58(%rsp), %r13
movq %r13, %rsi
cmpl $0x20, %eax
jne 0xf6e9c
movq %r8, %rdi
callq 0xc7d00
movq 0x48(%rsp), %r8
movq %rbp, %rdi
movq %r13, %rsi
testb %al, %al
je 0xf6e9c
leaq -0x1(%r13), %rsi
leaq 0x8(%rbp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq %rbx, %r13
movq %rbx, %rdx
movq %r8, %rbx
movl $0x1, %r9d
callq 0xf9d99
testb %al, %al
je 0xf7004
movq %rbx, %rax
movq %rbx, %r8
movq %rax, 0x50(%rsp)
testq %r8, %r8
je 0xf70bc
movl 0x1c(%r8), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
jne 0xf70bc
movq %r8, %rdi
callq 0xc7d00
testb %al, %al
je 0xf7019
cmpq $0x0, 0x58(%rsp)
je 0xf7194
movq 0x40(%rsp), %rbx
movq (%rbx), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rsi
leaq 0x1e0(%rsp), %rbp
movq %rbp, %rdx
callq 0xe1379
testb %al, %al
je 0xf71ae
movq %r13, 0x60(%rsp)
movq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0xc7a7c
xorl %ecx, %ecx
testb %al, %al
cmovneq %rcx, %rbp
movq %rbp, 0x30(%rsp)
movq (%rbx), %rdi
callq 0x1ce21c
movq %r13, %r8
cmpb $0x5a, %r12b
jne 0xf6f9d
movq (%rax), %rax
andl $0x4000, %eax # imm = 0x4000
je 0xf6f9d
movb 0x4(%r14), %al
andb $0x3f, %al
cmpb $0xf, %al
jne 0xf6f9d
testb $-0x80, 0x52(%r8)
je 0xf6f9d
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rsi
leaq 0x1e0(%rsp), %rdx
callq 0xe64c0
movq 0x48(%rsp), %r8
testb %al, %al
je 0xf7256
decq 0x58(%rsp)
addq $0x8, 0x68(%rsp)
movb $0x1, %bpl
jmp 0xf7214
movq $0x0, 0x50(%rsp)
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
xorl %r8d, %r8d
xorl %edx, %edx
xorl %r13d, %r13d
jmp 0xf68e9
movq %r14, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %r13d, %r13d
movq $0x0, 0x50(%rsp)
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
xorl %edx, %edx
movq 0x48(%rsp), %r8
jmp 0xf68e1
xorl %ebp, %ebp
movq %rbx, 0x50(%rsp)
movq $0x0, 0x30(%rsp)
jmp 0xf7185
cmpb $0x5a, %r12b
jne 0xf7031
movq 0x48(%rsp), %rdi
callq 0xc7a7c
testb %al, %al
jne 0xf6ef4
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xc7ece
movq %rbx, %r8
testb %al, %al
je 0xf70bc
movq %r13, 0x60(%rsp)
movq %r8, %rdi
movq %r8, %rbx
callq 0x9495e
movq %rax, %r13
movq %rax, %rdi
callq 0xc71e8
movq %rax, %r14
movq %r13, %rdi
callq 0xc7180
movb $0x1, %bpl
testb %al, %al
je 0xf7208
movq %rbx, %rdi
callq 0xbc62a
movq %rax, %r12
movq %r14, %rdi
callq 0xbc850
leaq 0x150(%rsp), %rcx
movq $0x0, (%rcx)
movl (%r12), %edx
addq $0x8, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xd346a
movq %rax, %r8
movq $0x0, 0x30(%rsp)
jmp 0xf7214
movq $0x0, 0x30(%rsp)
movq %r8, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r8, %rbx
callq 0xbce06
testb %al, %al
je 0xf7182
movq 0x28(%rbx), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x6, %rcx
movq 0x40(%rsp), %r14
jne 0xf71d6
andq $-0x8, %rax
cmpl $0x1, (%rax)
jne 0xf71c8
xorps %xmm0, %xmm0
leaq 0x190(%rsp), %rbx
movaps %xmm0, -0x40(%rbx)
xorl %eax, %eax
movq %rax, -0x30(%rbx)
orb $0x1, -0x28(%rbx)
movq %rax, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rbx)
movq (%r14), %rdi
leaq 0x150(%rsp), %rdx
movq %r15, %rsi
callq 0xf9ff1
testb %al, %al
je 0xf7225
leaq 0x150(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0xdf29e
movq 0x70(%rsp), %rdi
movl $0x1, %esi
movl 0x3c(%rsp), %edx
callq 0xfb310
movl %eax, %edx
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0xf7227
movb $0x1, %bpl
xorl %edx, %edx
movq %rbx, %r8
movq 0x40(%rsp), %r14
jmp 0xf68e1
movq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0xf7aae
jmp 0xf6fed
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
xorl %edx, %edx
movq 0x48(%rsp), %r8
movq %rbx, %r14
jmp 0xf68e1
cmpl $0x6, %ecx
jne 0xf71d6
cmpl $0x3, (%rax)
je 0xf7101
movq (%r14), %rdi
movq %r15, %rsi
callq 0xfa49f
testb %al, %al
je 0xf6fed
movq 0x70(%rsp), %rdi
movl $0x1, %esi
movl 0x3c(%rsp), %edx
callq 0xfb310
movl %eax, %edx
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0xf723f
movq $0x0, 0x30(%rsp)
movq %r14, %r8
xorl %edx, %edx
movq 0x40(%rsp), %r14
movq 0x60(%rsp), %r13
jmp 0xf68e1
xorl %edx, %edx
movq 0x180(%rsp), %rdi
cmpq %rbx, %rdi
je 0xf723f
movq %rdx, %rbx
callq 0x3c3a0
movq %rbx, %rdx
xorl %ebp, %ebp
movq $0x0, 0x30(%rsp)
jmp 0xf6ffa
xorl %eax, %eax
jmp 0xf6ec6
xorl %ebp, %ebp
jmp 0xf7214
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::MemberPointerExprEvaluator>::VisitBinaryOperator(clang::BinaryOperator const*)
|
bool VisitBinaryOperator(const BinaryOperator *E) {
switch (E->getOpcode()) {
default:
return Error(E);
case BO_Comma:
VisitIgnoredValue(E->getLHS());
return StmtVisitorTy::Visit(E->getRHS());
case BO_PtrMemD:
case BO_PtrMemI: {
LValue Obj;
if (!HandleMemberPointerAccess(Info, E, Obj))
return false;
APValue Result;
if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
return false;
return DerivedSuccess(Result, E);
}
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
shrl $0x12, %eax
andl $0x3f, %eax
cmpl $0x2, %eax
jae 0xf743b
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r12
movaps %xmm0, -0x40(%r12)
xorl %r14d, %r14d
movq %r14, -0x30(%r12)
orb $0x1, -0x28(%r12)
movq %r14, -0x18(%r12)
movq %r12, -0x10(%r12)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%r12)
movq (%rbx), %rdi
leaq 0x50(%rsp), %rdx
movq %r15, %rsi
movl $0x1, %ecx
callq 0xf55ca
testq %rax, %rax
je 0xf7427
leaq 0x8(%rsp), %r8
movl $0x0, (%r8)
movq (%rbx), %rdi
movq 0x8(%r15), %rdx
leaq 0x50(%rsp), %rcx
movq %r15, %rsi
xorl %r9d, %r9d
callq 0xe3166
movl %eax, %r14d
testb %al, %al
je 0xf7416
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a40
cmpl $0x2, 0x8(%rsp)
jb 0xf7427
leaq 0x8(%rsp), %rdi
callq 0x86f80
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xf7479
callq 0x3c3a0
jmp 0xf7479
cmpl $0x20, %eax
jne 0xf7466
movq 0x10(%r15), %rsi
movq (%rbx), %rdi
callq 0xef7c3
movq 0x18(%r15), %rsi
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf5a46
movq %rbx, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0xf7aae
xorl %r14d, %r14d
movl %r14d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/AST/ExprConstant.cpp
|
llvm::SmallVectorImpl<clang::CXXRecordDecl const*>::assignRemote(llvm::SmallVectorImpl<clang::CXXRecordDecl const*>&&)
|
void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xf7e07
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
|
extractSubobject((anonymous namespace)::EvalInfo&, clang::Expr const*, (anonymous namespace)::CompleteObject const&, (anonymous namespace)::SubobjectDesignator const&, clang::APValue&, clang::AccessKinds)
|
static bool extractSubobject(EvalInfo &Info, const Expr *E,
const CompleteObject &Obj,
const SubobjectDesignator &Sub, APValue &Result,
AccessKinds AK = AK_Read) {
assert(AK == AK_Read || AK == AK_ReadObjectRepresentation);
ExtractSubobjectHandler Handler = {Info, E, Result, AK};
return findSubobject(Info, E, Obj, Sub, Handler);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, 0x40(%rsp)
movl (%rcx), %ebp
testb $0x1, %bpl
jne 0xf7ef3
movl %r9d, %ebx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rcx, %rdi
callq 0xe97a0
testb %al, %al
jne 0xf7e90
movl 0x20(%r13), %esi
cmpq $0x1, %rsi
setne %al
testb $0x4, %bpl
sete %cl
orb %al, %cl
jne 0xf7f0b
movq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1ce21c
testb $0x8, 0x1(%rax)
jne 0xf7eba
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
jmp 0xf7ef6
movq %r13, %rdi
callq 0xe97a0
xorb $0x1, %al
movzbl %al, %eax
leal 0x878(,%rax,4), %edx
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf7ef6
movslq %ebx, %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
xorl %r13d, %r13d
movl %r13d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x58(%rsp)
movq %r14, 0x10(%rsp)
movq 0x10(%r12), %r15
movq %r12, 0x50(%rsp)
movq 0x18(%r12), %r12
movq 0x20(%rsp), %rbp
leaq 0x338(%rbp), %rax
movq %rax, 0x68(%rsp)
leal -0x1(%rsi), %eax
movq %rax, 0x60(%rsp)
xorl %r14d, %r14d
movq $0x0, 0x48(%rsp)
xorl %r13d, %r13d
movq %rsi, 0x8(%rsp)
movl (%r15), %eax
cmpl $0x1, %eax
je 0xf7f76
testl %eax, %eax
jne 0xf7f90
cmpl $0x8, 0x40(%rsp)
jne 0xf85e5
cmpq %r14, %rsi
jne 0xf85e5
cmpl $0x1, %eax
jne 0xf7f90
movl 0x40(%rsp), %eax
leal -0x5(%rax), %ecx
cmpl $0x5, %ecx
jb 0xf7f90
movl $0x6, %ecx
btl %eax, %ecx
jae 0xf85e5
testb $0x1, %r12b
jne 0xf7faf
movq %r12, %rax
andq $-0x10, %rax
movq 0x8(%rax), %rax
movl %r12d, %ecx
andl $0x4, %ecx
andl $0x5, %eax
orq %rcx, %rax
je 0xf802e
movq %r12, %rbx
andq $-0x10, %rbx
movq (%rbx), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x2e, 0x10(%rax)
jne 0xf802e
movq 0x50(%rsp), %rax
movups (%rax), %xmm0
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movups %xmm0, 0x78(%rsp)
movq %rax, 0x88(%rsp)
movq %r14, 0x90(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0xe936e
testb %al, %al
je 0xf8029
movq 0x70(%rsp), %rax
cmpl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rsi
je 0xf802e
movq 0x8(%rbx), %rax
andl $0x2, %r12d
andq $-0x6, %rax
orq %rax, %r12
jmp 0xf802e
movq 0x8(%rsp), %rsi
cmpq %r14, %rsi
jne 0xf80c8
testb $0x4, %r12b
jne 0xf804a
movq %r12, %rax
andq $-0x10, %rax
testb $0x4, 0x8(%rax)
je 0xf8071
movslq 0x40(%rsp), %rbx
cmpq $0x2, %rbx
setb %al
movl $0x31c, %edx # imm = 0x31C
movl %ebx, %ecx
shrl %cl, %edx
leal -0xa(%rbx), %ecx
cmpl $-0x3, %ecx
ja 0xf8071
orb %dl, %al
testb $0x1, %al
jne 0xf8766
movq %r12, %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x2e, 0x10(%rax)
jne 0xf80ee
movl 0x40(%rsp), %ebx
movq 0x50(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0xe97d6
movq 0x8(%rsp), %rsi
testb %al, %al
jne 0xf80ee
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0xe9824
movq 0x8(%rsp), %rsi
testb %al, %al
je 0xf80ee
jmp 0xf7ef3
cmpq %r14, 0x60(%rsp)
jne 0xf80ee
movq %r12, %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xe, 0x10(%rax)
je 0xf8037
cmpq %r14, %rsi
movq %r15, 0x18(%rsp)
je 0xf85bf
movq %r12, %r15
andq $-0x10, %r15
movq (%r15), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0x4, %ecx
ja 0xf8148
movq 0x10(%rbp), %rdi
movq %r12, %rsi
callq 0x8b6d6
testq %rax, %rax
movq 0x58(%rsp), %rcx
je 0xf8182
movq %rax, %rbx
movb 0x10(%rax), %al
andb $-0x2, %al
cmpb $0x2, %al
movl $0x0, %eax
cmovneq %rax, %rbx
jmp 0xf8184
cmpb $0xe, %al
movq 0x58(%rsp), %rax
je 0xf8724
movq 0x18(%rax), %rax
movq (%rax,%r14,8), %r13
andq $-0x8, %r13
je 0xf8242
movl 0x1c(%r13), %eax
andl $0x7f, %eax
addl $-0x2e, %eax
cmpl $0x3, %eax
movl $0x0, %eax
cmovaeq %rax, %r13
jmp 0xf8245
xorl %ebx, %ebx
leaq 0x78(%rsp), %rbp
movq 0x18(%rcx), %rax
movq (%rax,%r14,8), %r13
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x8e94c
movl 0x80(%rsp), %r15d
cmpl $0x41, %r15d
jb 0xf81c0
movq %rbp, %rdi
callq 0x71b6c
movl %r15d, %ecx
subl %eax, %ecx
cmpl $0x40, %ecx
jbe 0xf81c0
xorl %ebp, %ebp
jmp 0xf81d3
cmpl $0x41, %r15d
jb 0xf81cb
movq 0x78(%rsp), %rbp
cmpq %r13, (%rbp)
setbe %bpl
cmpl $0x41, %r15d
jb 0xf81e8
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0xf81e8
callq 0x3c180
testb %bpl, %bpl
movq 0x18(%rsp), %r15
je 0xf8224
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x1ce21c
testb $0x8, 0x1(%rax)
jne 0xf837c
xorl %ebx, %ebx
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
jmp 0xf84c9
movq 0x20(%rbx), %r12
movl 0x10(%r15), %eax
cmpq %rax, %r13
movq 0x20(%rsp), %rbp
jae 0xf83b2
movl %r13d, %eax
jmp 0xf83bd
xorl %r13d, %r13d
testq %r13, %r13
je 0xf8346
testb $0x2, 0x44(%r13)
je 0xf8270
movl 0x40(%rsp), %ebx
movq 0x50(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0xe97d6
testb %al, %al
je 0xf83f7
movq (%r15), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c68
movzwl 0x48(%rax), %eax
andl $0xe000, %eax # imm = 0xE000
cmpl $0x4000, %eax # imm = 0x4000
jne 0xf83d3
movq 0x18(%rsp), %r15
movq 0x8(%r15), %rbx
testq %rbx, %rbx
movq 0x8(%rsp), %rsi
je 0xf82e4
testb $-0x80, 0x1d(%rbx)
movq %rbx, %r15
je 0xf82c3
movq %rbx, %rdi
callq 0xb8626
movq 0x8(%rsp), %rsi
movq %rax, %r15
testb $-0x80, 0x1d(%r13)
movq %r13, %rax
je 0xf82da
movq %r13, %rdi
callq 0xb8626
movq 0x8(%rsp), %rsi
cmpq %rax, %r15
movq 0x18(%rsp), %r15
je 0xf8335
cmpq %r14, 0x60(%rsp)
sete %al
movl 0x40(%rsp), %ebp
cmpl $0x8, %ebp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf84de
movl $0x0, 0x78(%rsp)
movq %r15, %rdi
movq %r13, %rsi
leaq 0x78(%rsp), %rbx
movq %rbx, %rdx
callq 0x86e50
cmpl $0x2, 0x78(%rsp)
jb 0xf832b
movq %rbx, %rdi
callq 0x86f80
movq 0x20(%rsp), %rbp
movq 0x8(%rsp), %rsi
movq 0x10(%r15), %r15
movq %r15, 0x18(%rsp)
movb $0x1, %r15b
jmp 0xf8555
callq 0x224c70
movq 0x58(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx,%r14,8), %rbx
andq $-0x8, %rbx
je 0xf8456
movl 0x1c(%rbx), %ecx
andl $0x7f, %ecx
addl $-0x38, %ecx
cmpl $0x3, %ecx
movl $0x0, %ecx
cmovaeq %rcx, %rbx
jmp 0xf8458
xorl %ebx, %ebx
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movl $0x878, %edx # imm = 0x878
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf84c9
movslq 0x40(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
jmp 0xf84c7
cmpl $0x2, 0x40(%rsp)
jae 0xf849c
leaq (%rax,%rax,8), %rax
shlq $0x3, %rax
addq 0x8(%r15), %rax
movb $0x1, %bl
movq %rax, %r15
jmp 0xf84c9
movq %r13, %rdi
callq 0xbe310
movq 0x18(%rsp), %rcx
addl 0x10(%rcx), %eax
leaq (%rax,%rax,8), %rax
shlq $0x3, %rax
addq 0x8(%rcx), %rax
movq %rax, %r15
jmp 0xf855f
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movl $0x876, %edx # imm = 0x876
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf8436
movq %rax, %r15
movslq %ebx, %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x96fba
movl 0x18(%r13), %esi
movq %rbp, %rdi
movl $0x69, %edx
callq 0x1cdde8
xorl %eax, %eax
xorl %r13d, %r13d
movq 0x18(%rsp), %r15
jmp 0xf859e
xorl %ebx, %ebx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe9c7d
movl %eax, %eax
leaq (%rax,%rax,8), %r15
shlq $0x3, %r15
movq 0x18(%rsp), %rax
addq 0x8(%rax), %r15
movq 0x10(%rbp), %rdi
movq %rbx, %rsi
callq 0x8fdbc
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xe9c38
movq %rax, %r12
movb $0x1, %al
xorl %r13d, %r13d
jmp 0xf859e
movq 0x10(%rsp), %rdi
callq 0xd4508
movq %rbp, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xe9ad4
testb %al, %al
je 0xf84c7
movq %r15, %rdi
movl %r13d, %esi
callq 0xe9b3c
jmp 0xf823a
xorl %ebx, %ebx
movq 0x8(%rsp), %rsi
xorl %r13d, %r13d
testb %bl, %bl
jne 0xf85ab
jmp 0xf7ef6
xorl %r15d, %r15d
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x875, %edx # imm = 0x875
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf854b
movslq %ebp, %rsi
xorl %ebp, %ebp
testq %rbx, %rbx
sete %bpl
movq %rax, %r15
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x96fba
movq %r15, %rdi
movq %rbp, %rsi
movl $0x2, %edx
callq 0x96fba
movq %r15, %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x96fba
xorl %r15d, %r15d
movq 0x20(%rsp), %rbp
movq 0x8(%rsp), %rsi
testb %r15b, %r15b
je 0xf85b3
movq 0x18(%rsp), %r15
movq 0x30(%r13), %rbx
movl 0x44(%r13), %edx
andl $0x2, %edx
shrl %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe9c38
movq %rax, %r12
movb $0x1, %al
testb $0x4, %bl
jne 0xf8599
andq $-0x10, %rbx
testb $0x4, 0x8(%rbx)
movq 0x48(%rsp), %rcx
cmovneq %r13, %rcx
movq %rcx, 0x48(%rsp)
jmp 0xf859e
movq %r13, 0x48(%rsp)
movq 0x8(%rsp), %rsi
testb %al, %al
je 0xf7ef3
incq %r14
jmp 0xf7f51
xorl %eax, %eax
xorl %r13d, %r13d
movq 0x18(%rsp), %r15
jmp 0xf85a3
movq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x86dda
movl 0x40(%rsp), %ebx
cmpl $0x1, %ebx
jne 0xf8667
xorl %eax, %eax
movq 0x10(%rsp), %rsi
jmp 0xf86ed
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
testb %al, %al
jne 0xf7ef3
xorl %r13d, %r13d
movq %rbp, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movl $0x87a, %edx # imm = 0x87A
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf7ef6
movq %rax, %rbx
movslq 0x40(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
xorl %esi, %esi
cmpl $0x1, (%r15)
sete %sil
movq %rbx, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r14, %rdi
callq 0x20ebb6
leaq 0x78(%rsp), %rsi
movq %rax, (%rsi)
movb $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe7ed8
jmp 0xf7ef3
movq 0x28(%rsp), %r15
movq 0x30(%rsp), %rdi
callq 0xd4508
movq 0x38(%rsp), %r8
leaq 0x98(%rsp), %rcx
movq %rcx, -0x20(%rcx)
movq %rcx, -0x18(%rcx)
movq $0x8, -0x10(%rcx)
movl $0x0, -0x8(%rcx)
leaq 0x78(%rsp), %r14
movl $0x1, %edi
movq %r15, %rsi
movl %eax, %edx
movq %r12, %rcx
xorl %r9d, %r9d
pushq %r14
pushq $0x0
callq 0xf89a7
addq $0x10, %rsp
movl %eax, %ebp
movq 0x8(%r14), %rdi
cmpq (%r14), %rdi
je 0xf86cc
callq 0x3c3a0
testb %bpl, %bpl
movq 0x10(%rsp), %rsi
je 0xf7ef3
movl $0x31c, %eax # imm = 0x31C
movl %ebx, %ecx
shrl %cl, %eax
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %r15
testq %r13, %r13
je 0xf87cd
testb $0x1, %al
je 0xf87cd
testb $0x1, 0x44(%r13)
je 0xf87cd
movq %rbp, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq 0xe9a02
testb %al, %al
je 0xf7ef3
jmp 0xf87cd
movq 0x18(%rax), %rax
movq (%rax,%r14,8), %rbx
cmpq $0x2, %rbx
jae 0xf8792
cmpb $0xe, 0x10(%rdi)
je 0xf873d
callq 0x22549c
movq 0x18(%rsp), %rcx
cmpl $0x5, (%rcx)
jne 0xf87b0
xorl %eax, %eax
testq %rbx, %rbx
setne %al
shll $0x4, %eax
leaq (%rcx,%rax), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0xf88cc
jmp 0xf87cd
movq %rbp, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
je 0xf87a0
movq 0x48(%rsp), %r15
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0xf87ff
movl 0x18(%r15), %r14d
movl $0x2, %r12d
jmp 0xf885a
movq %rbp, %rdi
callq 0x1ce21c
testb $0x8, 0x1(%rax)
jne 0xf87d5
xorl %r13d, %r13d
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
jmp 0xf7eac
xorl %eax, %eax
testq %rbx, %rbx
setne %al
shll $0x5, %eax
leaq (%rcx,%rax), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0xf894a
movb $0x1, %r13b
jmp 0xf7ef6
xorl %r13d, %r13d
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movl $0x878, %edx # imm = 0x878
xorl %ecx, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf7ef6
movslq 0x40(%rsp), %rsi
jmp 0xf7ee6
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movq %rcx, %rdi
andq $-0x4, %rdi
xorl %r14d, %r14d
andq $0x3, %rcx
movl $0x0, %r15d
cmoveq %rdi, %r15
testq %r15, %r15
je 0xf8830
movl 0x18(%r15), %r14d
movl $0x1, %r12d
jmp 0xf885a
cmpl $0x1, %ecx
setne %dl
testq %rdi, %rdi
sete %cl
orb %dl, %cl
movl $0x0, %r15d
movl $0x0, %r12d
jne 0xf885a
callq 0xd4508
movl %eax, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbp, %rdi
movq %r13, %rsi
movl $0x87d, %edx # imm = 0x87D
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xf88a7
movq %rax, %r13
movq %rax, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x96fba
movq %r13, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x96fba
movq %r13, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x96fba
movq %rbp, %rdi
movl %r14d, %esi
movl $0x8fb, %edx # imm = 0x8FB
callq 0x1cdde8
testq %rax, %rax
je 0xf7ef3
movq %rax, %rdi
movq %r12, %rsi
jmp 0xf7ee9
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExtractSubobjectHandler::found(llvm::APSInt&, clang::QualType)
|
bool found(APSInt &Value, QualType SubobjType) {
Result = APValue(Value);
return true;
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rsp)
cmpl $0x40, %eax
ja 0xf88ee
movq (%r14), %rax
movq %rax, (%rsp)
jmp 0xf88f9
movq %rsp, %rdi
movq %r14, %rsi
callq 0x70bce
movb 0xc(%r14), %al
movq %rsp, %rsi
movb %al, 0xc(%rsi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xc87de
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x86f28
cmpl $0x2, (%r14)
jb 0xf892c
leaq 0x10(%rsp), %rdi
callq 0x86f80
cmpl $0x41, 0x8(%rsp)
jb 0xf8941
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xf8941
callq 0x3c180
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::MemberPtr::castBack(clang::CXXRecordDecl const*)
|
bool castBack(const CXXRecordDecl *Class) {
assert(!Path.empty());
const CXXRecordDecl *Expected;
if (Path.size() >= 2)
Expected = Path[Path.size() - 2];
else
Expected = getContainingRecord();
if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
// C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
// if B does not contain the original member and is not a base or
// derived class of the class containing the original member, the result
// of the cast is undefined.
// C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
// (D::*). We consider that to be a language defect.
return false;
}
Path.pop_back();
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpq $0x2, %rax
jb 0xf931d
movq 0x8(%rbx), %rcx
movq -0x10(%rcx,%rax,8), %rdi
jmp 0xf9342
movq (%rbx), %rax
andq $-0x8, %rax
movq 0x10(%rax), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xf9337
movq (%rax), %rax
leaq -0x40(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
cmpq %rax, %r15
jne 0xf935c
decl 0x10(%rbx)
cmpq %rax, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
|
/AST/ExprConstant.cpp
|
HandleVirtualDispatch((anonymous namespace)::EvalInfo&, clang::Expr const*, (anonymous namespace)::LValue&, clang::CXXMethodDecl const*, llvm::SmallVectorImpl<clang::QualType>&)
|
static const CXXMethodDecl *HandleVirtualDispatch(
EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found,
llvm::SmallVectorImpl<QualType> &CovariantAdjustmentPath) {
std::optional<DynamicType> DynType = ComputeDynamicType(
Info, E, This,
isa<CXXDestructorDecl>(Found) ? AK_Destroy : AK_MemberCall);
if (!DynType)
return nullptr;
// Find the final overrider. It must be declared in one of the classes on the
// path from the dynamic type to the static type.
// FIXME: If we ever allow literal types to have virtual base classes, that
// won't be true.
const CXXMethodDecl *Callee = Found;
unsigned PathLength = DynType->PathLength;
for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) {
const CXXRecordDecl *Class = getBaseClassType(This.Designator, PathLength);
const CXXMethodDecl *Overrider =
Found->getCorrespondingMethodDeclaredInClass(Class, false);
if (Overrider) {
Callee = Overrider;
break;
}
}
// C++2a [class.abstract]p6:
// the effect of making a virtual call to a pure virtual function [...] is
// undefined
if (Callee->isPureVirtual()) {
Info.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << Callee;
Info.Note(Callee->getLocation(), diag::note_declared_at);
return nullptr;
}
// If necessary, walk the rest of the path to determine the sequence of
// covariant adjustment steps to apply.
if (!Info.Ctx.hasSameUnqualifiedType(Callee->getReturnType(),
Found->getReturnType())) {
CovariantAdjustmentPath.push_back(Callee->getReturnType());
for (unsigned CovariantPathLength = PathLength + 1;
CovariantPathLength != This.Designator.Entries.size();
++CovariantPathLength) {
const CXXRecordDecl *NextClass =
getBaseClassType(This.Designator, CovariantPathLength);
const CXXMethodDecl *Next =
Found->getCorrespondingMethodDeclaredInClass(NextClass, false);
if (Next && !Info.Ctx.hasSameUnqualifiedType(
Next->getReturnType(), CovariantAdjustmentPath.back()))
CovariantAdjustmentPath.push_back(Next->getReturnType());
}
if (!Info.Ctx.hasSameUnqualifiedType(Found->getReturnType(),
CovariantAdjustmentPath.back()))
CovariantAdjustmentPath.push_back(Found->getReturnType());
}
// Perform 'this' adjustment.
if (!CastToDerivedClass(Info, E, This, Callee->getParent(), PathLength))
return nullptr;
return Callee;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, (%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbp
movl 0x1c(%rcx), %eax
andl $0x7f, %eax
xorl %ecx, %ecx
cmpl $0x21, %eax
sete %cl
leal 0x5(,%rcx,4), %r8d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xfb81f
cmpb $0x1, 0x10(%rbx)
jne 0xfa97d
movl 0x28(%rsp), %r13d
leaq 0x18(%r12), %rbx
movq %r12, 0x8(%rsp)
cmpl %r13d, 0x38(%r12)
jae 0xfa6b6
movq %r14, %r12
jmp 0xfa6e8
movq %r14, %r12
movq %rbx, %rdi
movl %r13d, %esi
callq 0xfb954
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xc7abc
testq %rax, %rax
cmovneq %rax, %r12
jne 0xfa6e8
incl %r13d
movq 0x8(%rsp), %rax
cmpl %r13d, 0x38(%rax)
jae 0xfa6b9
testb $0x8, 0x52(%r12)
jne 0xfa941
movq %r15, 0x10(%rsp)
movq 0x30(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa71b
callq 0x22549c
movq 0x18(%rax), %r15
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa740
callq 0x22549c
movq 0x18(%rax), %rax
andq $-0x10, %r15
movq 0x8(%r15), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
andq $-0x10, %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
cmpq (%rax), %rcx
movq 0x10(%rsp), %r15
je 0xfa8fa
movq %rbp, 0x18(%rsp)
movq 0x30(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa794
callq 0x22549c
movq 0x18(%rax), %rsi
movq (%rsp), %rdi
callq 0x89fa6
leal 0x1(%r13), %ebp
movq 0x8(%rsp), %rax
cmpl %ebp, 0x38(%rax)
je 0xfa86e
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfb954
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xc7abc
testq %rax, %rax
je 0xfa85e
movq %rax, %r15
movq 0x30(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
movl $0x0, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa7fa
callq 0x22549c
movq 0x18(%rax), %rax
movq (%rsp), %rdx
movq (%rdx), %rcx
movl 0x8(%rdx), %edx
movq -0x8(%rcx,%rdx,8), %rcx
andq $-0x10, %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
andq $-0x10, %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
cmpq (%rcx), %rax
je 0xfa85e
movq 0x30(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
movl $0x0, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa851
callq 0x22549c
movq 0x18(%rax), %rsi
movq (%rsp), %rdi
callq 0x89fa6
incl %ebp
movq 0x8(%rsp), %rax
cmpl 0x38(%rax), %ebp
jne 0xfa7b3
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
movq 0x18(%rsp), %rbp
jae 0xfa894
callq 0x22549c
movq 0x18(%rax), %rax
movq (%rsp), %rdx
movq (%rdx), %rcx
movl 0x8(%rdx), %edx
movq -0x8(%rcx,%rdx,8), %rcx
andq $-0x10, %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
andq $-0x10, %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
cmpq (%rcx), %rax
movq 0x10(%rsp), %r15
je 0xfa8fa
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x1b, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0xfa8ed
callq 0x22549c
movq 0x18(%rax), %rsi
movq (%rsp), %rdi
callq 0x89fa6
leaq 0x48(%r12), %rdi
callq 0xc1de2
movq 0x10(%rax), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0xfa917
movq (%rax), %rax
leaq -0x40(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rbp, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movl %r13d, %r8d
callq 0xf54d6
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %r12, %rax
jmp 0xfa97f
movq %rbp, %rdi
movq %r15, %rsi
movl $0x8e3, %edx # imm = 0x8E3
movl $0x1, %ecx
callq 0x1cdc80
testq %rax, %rax
je 0xfa96b
movq %rax, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x96fba
movl 0x18(%r12), %esi
movq %rbp, %rdi
movl $0x69, %edx
callq 0x1cdde8
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
HandleCovariantReturnAdjustment((anonymous namespace)::EvalInfo&, clang::Expr const*, clang::APValue&, llvm::ArrayRef<clang::QualType>)
|
static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E,
APValue &Result,
ArrayRef<QualType> Path) {
assert(Result.isLValue() &&
"unexpected kind of APValue for covariant return");
if (Result.isNullPointer())
return true;
LValue LVal;
LVal.setFrom(Info.Ctx, Result);
const CXXRecordDecl *OldClass = Path[0]->getPointeeCXXRecordDecl();
for (unsigned I = 1; I != Path.size(); ++I) {
const CXXRecordDecl *NewClass = Path[I]->getPointeeCXXRecordDecl();
assert(OldClass && NewClass && "unexpected kind of covariant return");
if (OldClass != NewClass &&
!CastToBaseClass(Info, E, LVal, OldClass, NewClass))
return false;
OldClass = NewClass;
}
LVal.moveInto(Result);
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
movq %rdx, %rdi
callq 0x86d66
movb $0x1, %cl
testb %al, %al
jne 0xfabcf
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rcx
movaps %xmm0, -0x40(%rcx)
xorl %eax, %eax
movq %rax, -0x30(%rcx)
orb $0x1, -0x28(%rcx)
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movq 0x10(%r14), %rsi
leaq 0x40(%rsp), %rdi
movq %rbx, 0x20(%rsp)
movq %rbx, %rdx
callq 0xeb40a
movq (%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224b90
movq %rax, %r13
cmpq $0x1, %r15
sete %al
movb %al, 0xf(%rsp)
je 0xfaba5
movq %r14, 0x10(%rsp)
movl $0x1, %r14d
movl $0x1, %eax
movq %r15, 0x30(%rsp)
movq %r12, 0x28(%rsp)
movq (%r12,%rax,8), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224b90
movq %rax, %rbx
cmpq %rax, %r13
je 0xfab84
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x781e6
movq %r13, 0x38(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xb4d06
movq 0xd8(%rsp), %rax
movl 0x18(%rax), %r13d
testq %r13, %r13
sete %r15b
je 0xfab0b
movq 0x10(%rax), %r12
movq (%r12), %r8
movq 0x8(%r12), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xf53e1
testb %al, %al
je 0xfab0b
leaq (,%r13,2), %rax
addq %r13, %rax
leaq -0x18(,%rax,8), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
sete %r15b
je 0xfab0b
movq 0x18(%r12,%rbp), %r8
movq 0x20(%r12,%rbp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xf53e1
addq $0x18, %rbp
testb %al, %al
jne 0xfaadc
movq 0x1c0(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0xfab25
callq 0x3c3a0
movq 0x180(%rsp), %rdi
cmpq 0x178(%rsp), %rdi
movq 0x28(%rsp), %r12
movq 0x38(%rsp), %r13
je 0xfab46
callq 0x3c3a0
testb $0x1, 0xf0(%rsp)
jne 0xfab6d
movq 0xf8(%rsp), %rdi
movl 0x100(%rsp), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x56dc8
leaq 0xd8(%rsp), %rdi
callq 0x78520
testb %r15b, %r15b
movq 0x30(%rsp), %r15
je 0xfab8b
movb $0x1, %al
movq %rbx, %r13
jmp 0xfab8d
xorl %eax, %eax
testb %al, %al
je 0xfabb4
incl %r14d
movq %r14, %rax
cmpq %r15, %r14
sete 0xf(%rsp)
jne 0xfaa45
leaq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdf29e
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0xfabcb
callq 0x3c3a0
movb 0xf(%rsp), %cl
andb $0x1, %cl
movl %ecx, %eax
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
CheckDeleteKind((anonymous namespace)::EvalInfo&, clang::Expr const*, (anonymous namespace)::LValue const&, (anonymous namespace)::DynAlloc::Kind)
|
static std::optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
const LValue &Pointer,
DynAlloc::Kind DeallocKind) {
auto PointerAsString = [&] {
return Pointer.toString(Info.Ctx, Info.Ctx.VoidPtrTy);
};
DynamicAllocLValue DA = Pointer.Base.dyn_cast<DynamicAllocLValue>();
if (!DA) {
Info.FFDiag(E, diag::note_constexpr_delete_not_heap_alloc)
<< PointerAsString();
if (Pointer.Base)
NoteLValueLocation(Info, Pointer.Base);
return std::nullopt;
}
std::optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
if (!Alloc) {
Info.FFDiag(E, diag::note_constexpr_double_delete);
return std::nullopt;
}
if (DeallocKind != (*Alloc)->getKind()) {
QualType AllocType = Pointer.Base.getDynamicAllocType();
Info.FFDiag(E, diag::note_constexpr_new_delete_mismatch)
<< DeallocKind << (*Alloc)->getKind() << AllocType;
NoteLValueLocation(Info, Pointer.Base);
return std::nullopt;
}
bool Subobject = false;
if (DeallocKind == DynAlloc::New) {
Subobject = Pointer.Designator.MostDerivedPathLength != 0 ||
Pointer.Designator.isOnePastTheEnd();
} else {
Subobject = Pointer.Designator.Entries.size() != 1 ||
Pointer.Designator.Entries[0].getAsArrayIndex() != 0;
}
if (Subobject) {
Info.FFDiag(E, diag::note_constexpr_delete_subobject)
<< PointerAsString() << Pointer.Designator.isOnePastTheEnd();
return std::nullopt;
}
return Alloc;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r13d
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq (%rdx), %rsi
movl %esi, %eax
notl %eax
testb $0x3, %al
sete %al
shrq $0x3, %rsi
testl %esi, %esi
setne %cl
testb %cl, %al
jne 0xfb535
movq %r12, %rsi
movl $0x895, %edx # imm = 0x895
xorl %ecx, %ecx
callq 0x1cdc80
movq %rax, %r14
movq 0x10(%r15), %rdx
movq 0x4990(%rdx), %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xfb7c6
testq %r14, %r14
je 0xfb4f8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x964fa
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb513
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3c080
movq %rbx, %rdi
callq 0x86120
testb %al, %al
je 0xfb52e
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0xe8a62
xorl %ebp, %ebp
jmp 0xfb6ac
callq 0xe9032
movq %rax, %r14
testb $0x1, %dl
je 0xfb582
movl %edx, %ebp
movq 0x48(%r14), %rcx
movl $0x2, %eax
cmpb $0x69, (%rcx)
jne 0xfb55a
movl (%rcx), %eax
shrl $0x13, %eax
andl $0x1, %eax
cmpl %r13d, %eax
jne 0xfb59b
testl %r13d, %r13d
je 0xfb61c
cmpl $0x1, 0x38(%rbx)
jne 0xfb62f
movq 0x30(%rbx), %rax
cmpq $0x0, (%rax)
setne %al
jmp 0xfb62b
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movl $0x89a, %edx # imm = 0x89A
xorl %ecx, %ecx
callq 0x1cdc80
jmp 0xfb6ac
movq %rbx, %rdi
callq 0x8612e
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
movl $0x8c2, %edx # imm = 0x8C2
xorl %ecx, %ecx
callq 0x1cdc80
movq %rax, %r12
testq %rax, %rax
je 0xfb5d0
movslq %r13d, %rsi
movq %r12, %rdi
movl $0x2, %edx
callq 0x96fba
movq 0x48(%r14), %rax
movl $0x2, %esi
cmpb $0x69, (%rax)
jne 0xfb5e6
movl (%rax), %esi
shrl $0x13, %esi
andl $0x1, %esi
testq %r12, %r12
je 0xfb608
movq %r12, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r12, %rdi
movq %rbp, %rsi
movl $0x8, %edx
callq 0x96fba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0xe8a62
jmp 0xfb6aa
cmpl $0xf, 0x18(%rbx)
ja 0xfb62f
leaq 0x18(%rbx), %rdi
callq 0xe97a0
testb %al, %al
je 0xfb6ac
movq %r15, %rdi
movq %r12, %rsi
movl $0x896, %edx # imm = 0x896
xorl %ecx, %ecx
callq 0x1cdc80
movq %rax, %r12
movq 0x10(%r15), %rdx
movq 0x4990(%rdx), %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xfb7c6
testq %r12, %r12
je 0xfb68f
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x964fa
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xe97a0
movzbl %al, %esi
movq %r12, %rdi
movl $0x2, %edx
callq 0x96fba
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb6aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3c080
xorl %ebp, %ebp
movq %r14, %rax
movl %ebp, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::LValueExprEvaluator::VisitCastExpr(clang::CastExpr const*)
|
bool VisitCastExpr(const CastExpr *E) {
switch (E->getCastKind()) {
default:
return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
case CK_LValueBitCast:
this->CCEDiag(E, diag::note_constexpr_invalid_cast)
<< 2 << Info.Ctx.getLangOpts().CPlusPlus;
if (!Visit(E->getSubExpr()))
return false;
Result.Designator.setInvalid();
return true;
case CK_BaseToDerived:
if (!Visit(E->getSubExpr()))
return false;
return HandleBaseToDerivedCast(Info, E, Result);
case CK_Dynamic:
if (!Visit(E->getSubExpr()))
return false;
return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
shrl $0x12, %eax
andl $0x7f, %eax
cmpl $0x2, %eax
je 0xfc659
cmpl $0x6, %eax
je 0xfc628
cmpl $0x9, %eax
jne 0xfc6d3
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
testb %al, %al
je 0xfc805
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfca7d
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
testb %al, %al
je 0xfc805
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfc91c
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x8a6, %edx # imm = 0x8A6
xorl %ecx, %ecx
callq 0x1cdd9c
testq %rax, %rax
je 0xfc6a8
movq %rax, %r15
movl $0x2, %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq 0x830(%rax), %rax
movl (%rax), %esi
shrl $0xa, %esi
andl $0x1, %esi
movq %r15, %rdi
movl $0x3, %edx
callq 0x96fba
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
testb %al, %al
je 0xfc805
movq 0x8(%rbx), %rax
orl $0x1, 0x18(%rax)
movl $0x0, 0x38(%rax)
movb $0x1, %r15b
jmp 0xfc808
leal -0x7(%rax), %ecx
cmpl $0x2, %ecx
jae 0xfc714
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xe3880
testb %al, %al
je 0xfc805
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %r14, %rsi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf26b1
cmpl $0x12, %eax
jg 0xfc731
cmpl $0x3, %eax
je 0xfc796
cmpl $0x4, %eax
je 0xfc81a
cmpl $0x5, %eax
je 0xfc77c
jmp 0xfc7f5
cmpl $0x13, %eax
je 0xfc77c
cmpl $0x3f, %eax
je 0xfc744
cmpl $0x3a, %eax
jne 0xfc7f5
movq %rsp, %rdi
movl $0x0, (%rdi)
movq (%rbx), %rsi
movq 0x10(%r14), %rdx
callq 0xe170f
movl %eax, %r15d
testb %al, %al
je 0xfc905
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0xeb40a
jmp 0xfc905
movq 0x10(%r14), %rsi
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe3880
xorl %r15d, %r15d
movl %r15d, (%rsp)
leaq 0x90(%rsp), %rdi
movl %r15d, (%rdi)
movq (%rbx), %rsi
movq 0x10(%r14), %rdx
callq 0xe170f
testb %al, %al
je 0xfc8ee
movq (%rbx), %rdi
movq %rsp, %rsi
leaq 0x90(%rsp), %rdx
movq %r14, %rcx
callq 0xf2783
testb %al, %al
je 0xfc8eb
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0xeb40a
movb $0x1, %r15b
jmp 0xfc8ee
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6e, %edx
callq 0xe7e98
xorl %r15d, %r15d
movl %r15d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, -0x40(%r12)
xorl %r15d, %r15d
movq %r15, -0x30(%r12)
orb $0x1, -0x28(%r12)
movq %r15, -0x18(%r12)
movq %r12, -0x10(%r12)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%r12)
movq 0x10(%r14), %rsi
movq (%rbx), %rax
leaq 0x90(%rsp), %rdi
movq %rax, (%rdi)
movq %rsp, %rax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0xe3880
testb %al, %al
je 0xfc8d3
leaq 0x90(%rsp), %r8
movl $0x0, (%r8)
movq (%rbx), %rdi
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq %rsp, %rcx
movq %r14, %rsi
xorl %r9d, %r9d
callq 0xe3166
movl %eax, %r15d
testb %al, %al
je 0xfc8bc
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
leaq 0x90(%rsp), %rdx
callq 0xeb40a
cmpl $0x2, 0x90(%rsp)
jb 0xfc8d3
leaq 0x90(%rsp), %rdi
callq 0x86f80
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0xfc808
callq 0x3c3a0
jmp 0xfc808
xorl %r15d, %r15d
cmpl $0x2, 0x90(%rsp)
jb 0xfc905
leaq 0x90(%rsp), %rdi
callq 0x86f80
cmpl $0x2, (%rsp)
jb 0xfc808
movq %rsp, %rdi
callq 0x86f80
jmp 0xfc808
|
/AST/ExprConstant.cpp
|
clang::APValue& llvm::SmallVectorImpl<clang::APValue>::emplace_back<llvm::APSInt&>(llvm::APSInt&)
|
reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0xffa49
leaq (%rax,%rax,8), %r15
shlq $0x3, %r15
addq (%rbx), %r15
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsp)
cmpl $0x40, %eax
ja 0xff9f2
movq (%r14), %rax
movq %rax, (%rsp)
jmp 0xff9fd
movq %rsp, %rdi
movq %r14, %rsi
callq 0x70bce
movb 0xc(%r14), %al
movq %rsp, %r14
movb %al, 0xc(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0xc87de
cmpl $0x41, 0x8(%r14)
jb 0xffa28
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xffa28
callq 0x3c180
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax,8), %rax
addq $-0x48, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1000c0
|
/llvm/ADT/SmallVector.h
|
HandleFloatToIntCast((anonymous namespace)::EvalInfo&, clang::Expr const*, clang::QualType, llvm::APFloat const&, clang::QualType, llvm::APSInt&)
|
static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
QualType SrcType, const APFloat &Value,
QualType DestType, APSInt &Result) {
unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
// Determine whether we are converting to unsigned or signed.
bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
Result = APSInt(DestWidth, !DestSigned);
bool ignored;
if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
& APFloat::opInvalidOp)
return HandleOverflow(Info, E, Value, DestType);
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %rcx, %rsi
callq 0x91cba
movl %eax, %ebp
movq %r14, %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x227082
movl %eax, %r12d
xorb $0x1, %r12b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x66024
movb %r12b, 0xc(%r15)
cmpl $0x41, 0x8(%r13)
jb 0x1003da
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1003da
callq 0x3c180
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%r13)
movl $0x0, 0x10(%rsp)
movb 0x14(%rsp), %al
movb %al, 0xc(%r13)
leaq 0x7(%rsp), %rcx
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7071c
movl %eax, %ecx
movb $0x1, %al
testb $0x1, %cl
je 0x10045d
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl $0x8d3, %edx # imm = 0x8D3
xorl %ecx, %ecx
callq 0x1cdd9c
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
callq 0x10046c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x100454
movq %r14, %rsi
movl $0x8, %edx
callq 0x96fba
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.