name string | code string | asm string | file string |
|---|---|---|---|
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->moveFromOldBu... | 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 %ea... | /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 %... | /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->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
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 c... | 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 ... | /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
... | /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::... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %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... | /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<cla... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x99d25
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x9... | /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... | /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->getTemplateAr... | 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 0xb451... | /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 ... | /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 (cons... | 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)
mov... | /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 %r... | /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... | /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:... | 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 ... | /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::Dens... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %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... | /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::IsVirtBaseAndNumberNonVir... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
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 = 0xFFFFFFF... | /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::UniqueVirtu... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 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, %r... | /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(E... | 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 %... | /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... | 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, %rd... | /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 t... | 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 $0x7f07c... | /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... | 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 0x... | /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 (!ContextD... | 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)... | /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
sh... | /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... | 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,... | /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 ... | /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 $0x... | /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(... | 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, %r... | /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->CompletedTagDe... | 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, ... | /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 con... | 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 ... | /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 0... | /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();... | 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, %... | /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())
retur... | 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 $0x... | /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),... | /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 ... | 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
r... | /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... | 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), %ra... | /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::UnnamedGlobalCo... | 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, (%r... | /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>())... | 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, (%... | /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 *supe... | 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 %... | /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, %... | /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)
... | 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)
t... | /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<TagD... | 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 %... | /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 <<... | 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 ... | /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"... | 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... | /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 ... | 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 $0x6166726... | /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()->getT... | 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)... | /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";
VisitDeclCont... | 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... | /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), %rs... | /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)
jm... | /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... | 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,... | /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(Type... | 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... | /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 *Par... | 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
... | /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()),
Const... | 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 = 0... | /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))
ret... | 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), %... | /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(t... | 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 0... | /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,... | /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.get... | 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(%... | /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... | /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().EnableNewConstIn... | 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)
m... | /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())
... | 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
se... | /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) {
// NextCa... | 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... | 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 0xf... | /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 d... | 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 (%... | /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.... | 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... | /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;
}
... | 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 $0... | /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;
... | 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
mov... | /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... | 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(%r... | /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();
... | 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
... | /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, %... | /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>>, (an... | 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, (%ra... | /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>>, (an... | 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... | /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
jn... | /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, Resu... | 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... | /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->getSu... | 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, ... | /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 HandleLValue... | 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 (%... | /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()) {
... | 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 0xf5a9... | /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 ... | /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 (!HandleMemberPointerAcc... | 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(... | /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... | /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);
Extra... | 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
c... | /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 %r... | /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... | 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 -0x... | /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... | 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, %r... | /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.isNullPoi... | 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,... | /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);... | 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... | /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()))
... | 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), %r... | /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 %r... | /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 si... | 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, ... | /AST/ExprConstant.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.