name string | code string | asm string | file string |
|---|---|---|---|
clang::ASTDeclReader::RedeclarableResult clang::ASTDeclReader::VisitRedeclarable<clang::ObjCProtocolDecl>(clang::Redeclarable<clang::ObjCProtocolDecl>*) | ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
GlobalDeclID FirstDeclID = readDeclID();
Decl *MergeWith = nullptr;
bool IsKeyDecl = ThisDeclID == FirstDeclID;
bool IsFirstLocalDecl = false;
uint64_t RedeclOffset = 0;
// invalid FirstDeclID indicates that this de... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6ef5e4
movq 0x20(%r14), %r13
cmpq %rax, %r13
sete %sil
testq %rax, %rax
je 0x6f25fc
movq %rax, %rbp
movq 0x8(%r14), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
m... | /Serialization/ASTReaderDecl.cpp |
clang::ASTDeclReader::VisitFriendTemplateDecl(clang::FriendTemplateDecl*) | void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
VisitDecl(D);
unsigned NumParams = Record.readInt();
D->NumParams = NumParams;
D->Params = new (Reader.getContext()) TemplateParameterList *[NumParams];
for (unsigned i = 0; i != NumParams; ++i)
D->Params[i] = Record.readTemplateParamete... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6ef31a
movq 0x8(%r14), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movq (%rax,%rcx,8), %rax
movl %eax, 0x24(%rbx)
movl %eax, %r15d
leaq (,%r15,8), %rsi
movq (%r14), %rax
movl $0... | /Serialization/ASTReaderDecl.cpp |
clang::ASTDeclReader::UpdateDecl(clang::Decl*, llvm::SmallVectorImpl<clang::GlobalDeclID>&) | void ASTDeclReader::UpdateDecl(
Decl *D,
llvm::SmallVectorImpl<GlobalDeclID> &PendingLazySpecializationIDs) {
while (Record.getIdx() < Record.size()) {
switch ((DeclUpdateKind)Record.readInt()) {
case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
auto *RD = cast<CXXRecordDecl>(D);
Decl *MD = Record.rea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x40(%rsi), %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsi), %rax
movq %rax, 0x28(%rsp)
leaq 0xae66c7(%rip), %rbp # 0x11ecb28
leaq 0x40(%rsp), %r13
movq 0... | /Serialization/ASTReaderDecl.cpp |
llvm::detail::DenseMapPair<clang::RecordDecl*, llvm::SmallVector<clang::RecordDecl*, 2u>>* llvm::DenseMapBase<llvm::SmallDenseMap<clang::RecordDecl*, llvm::SmallVector<clang::RecordDecl*, 2u>, 2u, llvm::DenseMapInfo<clang::RecordDecl*, void>, llvm::detail::DenseMapPair<clang::RecordDecl*, llvm::SmallVector<clang::Recor... | 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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl (%rdi), %ecx
movl %ecx, %eax
shrl %eax
testb $0x1, %cl
jne 0x7091ae
movl 0x10(%rbx), %esi
jmp 0x7091b1
pushq $0x2
popq %rsi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x7091ea
notl %eax
addl %esi, %eax
subl... | /llvm/ADT/DenseMap.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 0x70ac9c
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<std::pair<clang::DeclContext*, clang::IdentifierInfo*>, clang::NamedDecl*, llvm::DenseMapInfo<std::pair<clang::DeclContext*, clang::IdentifierInfo*>, void>, llvm::detail::DenseMapPair<std::pair<clang::DeclContext*, clang::IdentifierInfo*>, clang::NamedDecl*>, false>, bool> llvm::DenseMa... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x70c83c
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x70c802
xorl %ecx, %ecx
jmp 0x70c815
movq %r14,... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<clang::Decl*, unsigned int, llvm::DenseMapInfo<clang::Decl*, void>, llvm::detail::DenseMapPair<clang::Decl*, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<clang::Decl*, unsigned int, 4u, llvm::DenseMapInfo<clang::Decl*, void>, llvm::detail::DenseMapPair<clang::Decl... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x708000
movq (%r15), %r15
testb %al, %al
je 0x70d5f7
xorl %ebp, %ebp
jmp 0x70d612
movq %r14, %rdi
movq %r15,... | /llvm/ADT/DenseMap.h |
clang::Redeclarable<clang::VarDecl>::DeclLink::setLatest(clang::VarDecl*) | 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 0x70d84b
andq $-0x4, %rax
movq %rax, %rdi
callq 0x4c16c6
jmp 0x70d86d
testb $0x4, %al
sete %dl
movq %rax, %rcx
andq $-0x8, %rcx
sete %dil
orb %dl, %dil
je 0x70d869
andq $-0x5, %rsi
movq %rsi, %rax
jmp 0x70d86d
movq %rsi, 0x10(%rcx)
orq $0x1, %rax
movq %ra... | /clang/AST/Redeclarable.h |
clang::ASTStmtReader::VisitUnaryOperator(clang::UnaryOperator*) | void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
VisitExpr(E);
bool hasFP_Features = CurrentUnpackingBits->getNextBit();
assert(hasFP_Features == E->hasStoredFPFeatures());
E->setSubExpr(Record.readSubExpr());
E->setOpcode(
(UnaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/5))... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x70f7c8
movl 0x10(%r14), %ebp
movl 0x14(%r14), %r15d
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x31b0(%rax), %rcx
movl 0x31b8(%rax), %edx
movq -0x8(%rcx,%rdx,8), %rcx
decl %edx
movl %edx, 0x31b8(%rax)
movq %rcx, 0x10(%rbx)
l... | /Serialization/ASTReaderStmt.cpp |
clang::ASTStmtReader::VisitObjCAtSynchronizedStmt(clang::ObjCAtSynchronizedStmt*) | void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
VisitStmt(S); // FIXME: no test coverage.
S->setSynchExpr(Record.readSubStmt());
S->setSynchBody(Record.readSubStmt());
S->setAtSynchronizedLoc(readSourceLocation());
} | pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq 0x31b0(%rax), %rcx
movl 0x31b8(%rax), %edx
movq -0x8(%rcx,%rdx,8), %rcx
decl %edx
movl %edx, 0x31b8(%rax)
movq %rcx, 0x10(%rsi)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq 0x31b0(%rax), %rcx
movl 0x31b8(%rax), %edx
movq -0x8(%rcx,%rdx,8), %rcx
decl ... | /Serialization/ASTReaderStmt.cpp |
clang::ASTStmtReader::VisitMaterializeTemporaryExpr(clang::MaterializeTemporaryExpr*) | void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
VisitExpr(E);
bool HasMaterialzedDecl = Record.readInt();
if (HasMaterialzedDecl)
E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
else
E->State = Record.readSubExpr();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x70f7c8
movq (%r14), %rdi
movl 0x18(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rdi)
movq 0x20(%rdi), %rcx
cmpq $0x0, (%rcx,%rax,8)
je 0x714c21
callq 0x6dd0da
orq $0x4, %rax
jmp 0x714c43
movq 0x8(%rdi), %rcx
movq 0x31b0(%rcx), %rax
movl 0x31b... | /Serialization/ASTReaderStmt.cpp |
void llvm::SmallVectorImpl<clang::NamedDecl*>::append<clang::DeclListNode::iterator, void>(clang::DeclListNode::iterator, clang::DeclListNode::iterator) | 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, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x73aa49
movq %rax, %r12
movl 0x8(%r15), %esi
addq %rax, %rsi
movq %r15, %rdi
callq 0x6ce1fa
movl 0x8(%r15), %edx
shlq $0x3, %rdx
addq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi... | /llvm/ADT/SmallVector.h |
clang::ASTWriter::ResolvedOperatorDelete(clang::CXXDestructorDecl const*, clang::FunctionDecl const*, clang::Expr*) | void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD,
const FunctionDecl *Delete,
Expr *ThisArg) {
if (Chain && Chain->isProcessingUpdateRecords()) return;
assert(!WritingAST && "Already writing the AST!");
assert(Delete &... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, 0x8(%rsp)
movq 0x38(%rdi), %rbx
testq %rbx, %rbx
je 0x72fc41
cmpb $0x0, 0x22da(%rbx)
jne 0x72fc41
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movq %rax, %r14
testb ... | /Serialization/ASTWriter.cpp |
non-virtual thunk to clang::ASTWriter::AddedCXXTemplateSpecialization(clang::FunctionTemplateDecl const*, clang::FunctionDecl const*) | void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
const FunctionDecl *D) {
assert(!WritingAST && "Already writing the AST!");
if (!TD->getFirstDecl()->isFromASTFile())
return;
if (Chain && Chain->isProcessingUpdateRecords())
retu... | addq $-0x8, %rdi
jmp 0x7301a0
nop
| /Serialization/ASTWriter.cpp |
clang::serialization::DataStreamBasicWriter<clang::ASTRecordWriter>::writeNestedNameSpecifier(clang::NestedNameSpecifier*) | void writeNestedNameSpecifier(NestedNameSpecifier *NNS) {
// Nested name specifiers usually aren't too long. I think that 8 would
// typically accommodate the vast majority.
SmallVector<NestedNameSpecifier *, 8> nestedNames;
// Push each of the NNS's onto a stack for serialization in reverse order.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
leaq 0x8(%rsp), %r15
testq %r14, %r14
je 0x7330b4
movq %r15, %rdi
movq %r14, %rsi
callq 0x733186
movq 0x8(%r... | /clang/AST/AbstractBasicWriter.h |
llvm::DenseMap<clang::FileID, std::unique_ptr<clang::ASTWriter::DeclIDInFileInfo, std::default_delete<clang::ASTWriter::DeclIDInFileInfo>>, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, std::unique_ptr<clang::ASTWriter::DeclIDInFileInfo, std::default_delete<clang::ASTWriter::DeclIDI... | 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), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x73bcee
testq %r14, %r14
je 0x73e806
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq... | /llvm/ADT/DenseMap.h |
clang::Decl const* const* llvm::SmallVectorTemplateCommon<clang::Decl const*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::Decl const*, true>>(llvm::SmallVectorTemplateBase<clang::Decl const*, true>*, clang::Decl const* 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::Take... | pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %rdx, %rsi
cmpq %rax, %rsi
ja 0x73eb99
movq %rbx, %rax
popq %rbx
retq
callq 0x73eb50
jmp 0x73eb94
| /llvm/ADT/SmallVector.h |
clang::ASTDeclWriter::RegisterTemplateSpecialization(clang::Decl const*, clang::Decl const*) | void RegisterTemplateSpecialization(const Decl *Template,
const Decl *Specialization) {
Template = Template->getCanonicalDecl();
// If the canonical template is local, we'll write out this specialization
// when we emit it.
// FIXME: We can do the same th... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movq %rax, (%rsp)
testb $-0x80, 0x1d(%rax)
je 0x7409a1
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x744b32
cmpq %rbx, %rax
jne 0x7409a1
movl $0x4c8, %edi # imm = 0x4C8
addq (%r14), %rdi
movq %rsp... | /Serialization/ASTWriterDecl.cpp |
std::pair<llvm::DenseMapIterator<clang::FileEntryRef, unsigned int, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<clang::FileEntryRef, unsigned int, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x753812
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x753960
xorl %ecx, %ecx
jmp 0x753973
movq %r14,... | /llvm/ADT/DenseMap.h |
clang::CodeCompletionString::CodeCompletionString(clang::CodeCompletionString::Chunk const*, unsigned int, unsigned int, CXAvailabilityKind, char const**, unsigned int, llvm::StringRef, char const*) | CodeCompletionString::CodeCompletionString(
const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
CXAvailabilityKind Availability, const char **Annotations,
unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
: NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Pri... | pushq %r14
pushq %rbx
movl 0x18(%rsp), %eax
movq 0x30(%rsp), %r10
movl %edx, %edx
movabsq $-0x4000000000000, %r11 # imm = 0xFFFC000000000000
andq (%rdi), %r11
movl %eax, %ebx
shll $0x10, %ebx
movzwl %dx, %r14d
movzwl %cx, %ecx
shlq $0x20, %rcx
orq %r14, %rcx
andl $0x3, %r8d
shlq $0x30, %r8
orq %rcx, %r8
orq %rbx, %r8
o... | /Sema/CodeCompleteConsumer.cpp |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::HotAttr const*>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::HotAttr const* const&) | const SemaDiagnosticBuilder &
operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
if (Diag.ImmediateDiag)
*Diag.ImmediateDiag << Value;
else if (Diag.PartialDiagId)
Diag.getDeviceDeferredDiags()[Diag.Fn][*Diag.PartialDiagId].second
<< Value;
return Diag;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x77eb3b
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x77ec74
jmp 0x77eb8a
cmpb $0x1, 0x5c(%rbx)
jne 0x77eb8a
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x77eb5d
movq... | /clang/Sema/SemaBase.h |
llvm::SmallVectorTemplateBase<clang::Sema::ExpressionEvaluationContextRecord, false>::takeAllocationForGrow(clang::Sema::ExpressionEvaluationContextRecord*, unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
T *NewElts, size_t NewCapacity) {
// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->isSmall())
free(this->begin());
this->set_allocation_range(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x791b63
callq 0x436840
movq %r15, (%r14)
movl %ebx, 0xc(%r14)
popq %rbx
popq %r14
popq %r15
retq
| /llvm/ADT/SmallVector.h |
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot& llvm::SmallVectorImpl<clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot>::emplace_back<clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot>(clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot&&) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x7a4d84
movq (%rdi), %rcx
shlq $0x5, %rax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
movl 0x8(%rdi), %eax
incl %eax
movl %eax, 0x8(%rdi)
movq (%rdi), %rcx
shlq $0x5, %rax
addq %rcx, %rax
addq $-0x20, %rax
retq
| /llvm/ADT/SmallVector.h |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::ASTContext::SectionInfo>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::ASTContext::SectionInfo const&) | const SemaDiagnosticBuilder &
operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
if (Diag.ImmediateDiag)
*Diag.ImmediateDiag << Value;
else if (Diag.PartialDiagId)
Diag.getDeviceDeferredDiags()[Diag.Fn][*Diag.PartialDiagId].second
<< Value;
return Diag;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x7a1d12
leaq 0x20(%rbx), %rdi
jmp 0x7a1d59
cmpb $0x1, 0x5c(%rbx)
jne 0x7a1d61
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x7a1d34
movq (%rdi), %rax
callq *0x20(%rax)... | /clang/Sema/SemaBase.h |
clang::Sema::PopPragmaVisibility(bool, clang::SourceLocation) | void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
if (!VisContext) {
Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
return;
}
// Pop visibility from stack
VisStack *Stack = static_cast<VisStack*>(VisContext);
const std::pair<unsigned, SourceLocation> *Back = &Stac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movl %edx, %ebp
movq %rdi, %rbx
movq 0x7c8(%rdi), %r12
testq %r12, %r12
je 0x7a3c88
movq 0x8(%r12), %r15
movl -0x8(%r15), %eax
cmpl $-0x1, %eax
sete %cl
movl %esi, %edx
xorb $0x1, %dl
orb %cl, %dl
jne 0x7a3ca3
leaq 0x8(%rb... | /Sema/SemaAttr.cpp |
clang::Sema::AlignPackIncludeState const* llvm::SmallVectorTemplateCommon<clang::Sema::AlignPackIncludeState, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::Sema::AlignPackIncludeState, true>>(llvm::SmallVectorTemplateBase<clang::Sema::AlignPackIncludeState, true>*, clang::Sema::AlignPackI... | 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 %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %rdx, %rsi
cmpq %rax, %rsi
ja 0x7a47af
movq %rbx, %rax
popq %rbx
retq
callq 0x7a47b6
jmp 0x7a47aa
| /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot, true>::push_back(clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot const&) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdx
callq 0x7a4b32
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
shlq $0x5, %rdx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
incl 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/SmallVector.h |
std::pair<llvm::StringMapIterator<std::tuple<llvm::StringRef, clang::SourceLocation>>, bool> llvm::StringMap<std::tuple<llvm::StringRef, clang::SourceLocation>, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x466bea
movl %eax, %ebp
movq (%rbx), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %r12
movq (%r12), %rax
cmpq $-0x8, %rax
je 0x7a571b
testq %rax, %rax
je 0x7a571e
leaq 0x8(%rsp), %rbx
movq %r12, (%... | /llvm/ADT/StringMap.h |
llvm::SmallDenseMap<int, std::pair<int, clang::SourceRange>, 2u, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::pair<int, clang::SourceRange>>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x3, %esi
jb 0x7a57d2
andl $-0x2, %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x7a57dc
movq %rax, 0x8(%rbx)
movl %edx, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x7a57f2
nop
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<int, std::pair<int, clang::SourceRange>, 2u, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::pair<int, clang::SourceRange>>>, int, std::pair<int, clang::SourceRange>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::pair<int, clang::Sour... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x2, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x7a59de
pushq %rbx
movl (%rsi), %esi
imull $0x25, %esi, %edi
decl %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
andl %r8d, %edi
movq %rdi, %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %r11
movl (%rcx,%rax), %eb... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<clang::Sema::PragmaAttributeEntry, false>::moveElementsForGrow(clang::Sema::PragmaAttributeEntry*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
imulq $0x38, %rax, %rsi
addq %rdi, %rsi
callq 0x7a5da8
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
imulq $0x38, %rax, %rsi
addq %rdi, %rsi
popq %rbx
jmp 0x79134a
| /llvm/ADT/SmallVector.h |
clang::SemaBPF::handlePreserveAIRecord(clang::RecordDecl*) | void SemaBPF::handlePreserveAIRecord(RecordDecl *RD) {
// Add preserve_access_index attribute to all fields and inner records.
for (auto *D : RD->decls()) {
if (D->hasAttr<BPFPreserveAccessIndexAttr>())
continue;
D->addAttr(BPFPreserveAccessIndexAttr::CreateImplicit(getASTContext()));
if (auto *R... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rsi), %rdi
callq 0x4d1a72
movq %rax, %r14
movq %rdx, %r15
cmpq %r15, %r14
je 0x7a6abf
movq %r14, %rdi
callq 0x7a6ac6
testb %al, %al
jne 0x7a6ab5
movq %rbx, %rdi
callq 0x7a6c24
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xde4610
movq %r14, %rdi
movq ... | /Sema/SemaBPF.cpp |
clang::operator==(clang::specific_attr_iterator<clang::BPFPreserveAccessIndexAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::BPFPreserveAccessIndexAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Curr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
jae 0x7a6bdd
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7a6c02
movq (%r14), %r14
jmp 0x7a6bf3
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a6c02
movq (%rbx), %rbx
cmpq %r... | /clang/AST/AttrIterator.h |
DiagnoseCastQual(clang::Sema&, clang::ActionResult<clang::Expr*, true> const&, clang::QualType) | static void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr,
QualType DestType) {
if (SrcExpr.isInvalid())
return;
QualType SrcType = SrcExpr.get()->getType();
if (!((SrcType->isAnyPointerType() && DestType->isAnyPointerType()) ||
DestType->isLValueReferenceType())... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x30(%rsp)
movq (%rsi), %rax
cmpq $0x1, %rax
je 0x7ad535
movq %rsi, %r14
movq %rdi, %rbx
andq $-0x2, %rax
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rsi, %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%r... | /Sema/SemaCast.cpp |
clang::Sema::BuildCXXFunctionalCastExpr(clang::TypeSourceInfo*, clang::QualType, clang::SourceLocation, clang::Expr*, clang::SourceLocation) | ExprResult Sema::BuildCXXFunctionalCastExpr(TypeSourceInfo *CastTypeInfo,
QualType Type,
SourceLocation LPLoc,
Expr *CastExpr,
SourceLocation RP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %ebp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r8, %rcx
callq 0x7aadba
movq (%r15), %rax
leaq 0x8(%r15), %rcx
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx... | /Sema/SemaCast.cpp |
clang::Expr::getValueKindForType(clang::QualType) | static ExprValueKind getValueKindForType(QualType T) {
if (const ReferenceType *RT = T->getAs<ReferenceType>())
return (isa<LValueReferenceType>(RT)
? VK_LValue
: (RT->getPointeeType()->isFunctionType()
? VK_LValue : VK_XValue));
return VK_PRValue;
} | pushq %rax
andq $-0x10, %rdi
movq (%rdi), %rdi
callq 0x4ed764
testq %rax, %rax
je 0x7ad6a3
cmpb $0x29, 0x10(%rax)
jne 0x7ad6a7
pushq $0x1
popq %rax
jmp 0x7ad6ce
xorl %eax, %eax
jmp 0x7ad6ce
movq %rax, %rdi
callq 0x4c5cee
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0... | /clang/AST/Expr.h |
clang::Sema::CheckFreeArguments(clang::CallExpr const*) | void Sema::CheckFreeArguments(const CallExpr *E) {
const std::string CalleeName =
cast<FunctionDecl>(E->getCalleeDecl())->getQualifiedNameAsString();
{ // Prefer something that doesn't involve a cast to make things simpler.
const Expr *Arg = E->getArg(0)->IgnoreParenCasts();
if (const auto *UnaryExpr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7c32c8
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xe108a4
movl (%r14), %eax
movl %eax, %ecx
shrl $0x18, %ecx
addq %r14, %rcx
shrl $0xf, %eax
andl $0x8, %eax
movq 0x... | /Sema/SemaChecking.cpp |
clang::Sema::CheckOSLogFormatStringArg(clang::Expr*) | ExprResult Sema::CheckOSLogFormatStringArg(Expr *Arg) {
Arg = Arg->IgnoreParenCasts();
auto *Literal = dyn_cast<StringLiteral>(Arg);
if (!Literal) {
if (auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
Literal = ObjcLiteral->getString();
}
}
if (!Literal || (!Literal->isOrdinary() && !Li... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe50100
movq %rax, %r15
movzbl (%rax), %eax
movq %r15, %r14
cmpl $0xa, %eax
je 0x7c0288
cmpl $0x1d, %eax
jne 0x7c02ec
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x7c02ec
testb $0x14, 0x2(%r14)
jne 0x7c02ec
movq 0x100(%rbx), %rdi
mov... | /Sema/SemaChecking.cpp |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<AbsoluteValueKind>(clang::SemaBase::SemaDiagnosticBuilder const&, AbsoluteValueKind const&) | const SemaDiagnosticBuilder &
operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
if (Diag.ImmediateDiag)
*Diag.ImmediateDiag << Value;
else if (Diag.PartialDiagId)
Diag.getDeviceDeferredDiags()[Diag.Fn][*Diag.PartialDiagId].second
<< Value;
return Diag;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x7c2e54
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x7d7318
jmp 0x7c2ea3
cmpb $0x1, 0x5c(%rbx)
jne 0x7c2ea3
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x7c2e76
movq... | /clang/Sema/SemaBase.h |
clang::Sema::CheckReturnValExpr(clang::Expr*, clang::QualType, clang::SourceLocation, bool, llvm::SmallVector<clang::Attr*, 4u> const*, clang::FunctionDecl const*) | void
Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
SourceLocation ReturnLoc,
bool isObjCMethod,
const AttrVec *Attrs,
const FunctionDecl *FD) {
// Check if the return value is null but should not be.
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq 0xb0(%rsp), %r12
testq %r9, %r9
je 0x7c330b
movq %r9, %rdi
callq 0x7c34a5
testb %al, %al
jne 0x7c331c
testb %bpl, %bpl
jne 0x7c337c
movq %r13, %rdi
call... | /Sema/SemaChecking.cpp |
CheckNonNullExpr(clang::Sema&, clang::Expr const*) | static bool CheckNonNullExpr(Sema &S, const Expr *Expr) {
// Treat (smart) pointers constructed from nullptr as null, whether we can
// const-evaluate them or not.
// This must happen first: the smart pointer expr might have _Nonnull type!
if (isa<CXXNullPtrLiteralExpr>(
IgnoreExprNodes(Expr, IgnoreIm... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf6c6(%rip), %rsi # 0x7d2bad
leaq 0xf6cd(%rip), %rdx # 0x7d2bbb
movq %rbx, %rdi
callq 0x7d2c5a
movb $0x1, %bpl
cmpb $0x67, (%rax)
je 0x7c3592
movq %rbx, %rdi
callq 0xe500ac
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax... | /Sema/SemaChecking.cpp |
clang::Sema::CheckCompletedExpr(clang::Expr*, clang::SourceLocation, bool) | void Sema::CheckCompletedExpr(Expr *E, SourceLocation CheckLoc,
bool IsConstexpr) {
llvm::SaveAndRestore ConstantContext(isConstantEvaluatedOverride,
IsConstexpr || isa<ConstantExpr>(E));
CheckImplicitConversions(E, CheckLoc);
if (!E->isInstanti... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %al
testl %ecx, %ecx
jne 0x7c8be4
cmpb $0x3c, (%r14)
sete %al
movb 0x978(%rbx), %r15b
movb %al, 0x978(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c6e76
testb $0x40, 0x1(%r14)
jne 0x7c8c0e
movq %rbx, %rdi... | /Sema/SemaChecking.cpp |
clang::Sema::checkUnsafeExprAssigns(clang::SourceLocation, clang::Expr*, clang::Expr*) | void Sema::checkUnsafeExprAssigns(SourceLocation Loc,
Expr *LHS, Expr *RHS) {
QualType LHSType;
// PropertyRef on LHS type need be directly obtained from
// its declaration as it has a PseudoType.
ObjCPropertyRefExpr *PRE
= dyn_cast<ObjCPropertyRefExpr>(LHS->IgnoreParens());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0xe4ffc8
xorl %r13d, %r13d
cmpb $0x20, (%rax)
cmoveq %rax, %r13
testq %r13, %r13
je 0x7ca58f
movq 0x10(%r13), %rax
testb $0x4, %al
jne 0x7ca58f
andq $-... | /Sema/SemaChecking.cpp |
clang::Sema::MisalignedMember& llvm::SmallVectorImpl<clang::Sema::MisalignedMember>::emplace_back<clang::Expr*&, clang::RecordDecl*&, clang::ValueDecl*&, clang::CharUnits&>(clang::Expr*&, clang::RecordDecl*&, clang::ValueDecl*&, clang::CharUnits&) | size_t size() const { return Size; } | movl 0x8(%rdi), %r9d
cmpl 0xc(%rdi), %r9d
jae 0x7d7870
movq (%rdi), %r10
movq %r9, %r11
shlq $0x5, %r11
leaq (%r10,%r11), %rax
movq (%rsi), %rsi
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%r8), %r8
movq %rsi, (%r10,%r11)
movq %rdx, 0x8(%r10,%r11)
movq %rcx, 0x10(%r10,%r11)
movq %r8, 0x18(%r10,%r11)
leal 0x1(%r9), %ecx
m... | /llvm/ADT/SmallVector.h |
findConstantBaseAndOffset(clang::Sema&, clang::Expr*) | static std::pair<const ValueDecl *, CharUnits>
findConstantBaseAndOffset(Sema &S, Expr *E) {
// Must evaluate as a pointer.
Expr::EvalResult Result;
if (!E->EvaluateAsRValue(Result, S.Context) || !Result.Val.isLValue())
return {nullptr, CharUnits()};
const auto *BaseDecl =
Result.Val.getLValueBase().... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rax
leaq 0x10(%rsp), %rbx
andw $0x0, -0x10(%rbx)
andq $0x0, -0x8(%rbx)
andl $0x0, (%rbx)
movq 0x100(%rdi), %rdx
movq %rsp, %rsi
xorl %r14d, %r14d
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xe5623c
xorl %r15d, %r15d
testb %al, %al
je 0x7cd547
cmpl $0x7... | /Sema/SemaChecking.cpp |
clang::AtomicScopeOpenCLModel::map(unsigned int) const | SyncScope map(unsigned S) const override {
switch (static_cast<ID>(S)) {
case WorkGroup:
return SyncScope::OpenCLWorkGroup;
case Device:
return SyncScope::OpenCLDevice;
case AllSVMDevices:
return SyncScope::OpenCLAllSVMDevices;
case SubGroup:
return SyncScope::OpenCLSubGroup;... | leal 0x9(%rsi), %eax
retq
| /clang/Basic/SyncScope.h |
clang::operator==(clang::specific_attr_iterator<clang::NSConsumedAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::NSConsumedAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Curr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
jae 0x7cd89d
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7cd8c2
movq (%r14), %r14
jmp 0x7cd8b3
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cd8c2
movq (%rbx), %rbx
cmpq %r... | /clang/AST/AttrIterator.h |
(anonymous namespace)::CheckFormatHandler::getLocationOfByte(char const*) | SourceLocation CheckFormatHandler::getLocationOfByte(const char *x) {
return FExpr->getLocationOfByte(x - Beg, S.getSourceManager(),
S.getLangOpts(), S.Context.getTargetInfo());
} | pushq %rax
movq 0x8(%rdi), %rax
subl 0x30(%rdi), %esi
movq 0x10(%rdi), %r9
movq 0x118(%rax), %rdx
movq 0xf0(%rax), %rcx
movq 0x100(%rax), %rax
movq 0x4348(%rax), %r8
movq (%r9), %rdi
addl 0x8(%r9), %esi
andq $0x0, (%rsp)
xorl %r9d, %r9d
callq 0xe4cfd6
popq %rcx
retq
| /Sema/SemaChecking.cpp |
(anonymous namespace)::CheckFormatHandler::HandlePositionalNonpositionalArgs(clang::SourceLocation, char const*, unsigned int) | void
CheckFormatHandler::HandlePositionalNonpositionalArgs(SourceLocation Loc,
const char *startSpec,
unsigned specifierLen) {
EmitFormatDiagnostic(
S.PDiag(diag::warn_format_mix_positional_nonpositional_ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x8(%rdi), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl $0x1944, %edx # imm = 0x1944
callq 0x7a6c72
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
ca... | /Sema/SemaChecking.cpp |
(anonymous namespace)::CheckScanfHandler::HandleIncompleteScanList(char const*, char const*) | void CheckScanfHandler::HandleIncompleteScanList(const char *start,
const char *end) {
EmitFormatDiagnostic(S.PDiag(diag::warn_scanf_scanlist_incomplete),
getLocationOfByte(end), /*IsStringLocation*/true,
getSpecifierRange(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x1aca, %edx # imm = 0x1ACA
callq 0x7a6c72
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d066a
movl %eax, %ebp
sub... | /Sema/SemaChecking.cpp |
(anonymous namespace)::SequenceChecker::SequenceTree::representative(unsigned int) | unsigned representative(unsigned K) {
if (Values[K].Merged)
// Perform path compression as we go.
return Values[K].Parent = representative(Values[K].Parent);
return K;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movl %esi, %r14d
movq (%rdi), %rcx
movl (%rcx,%r14,4), %esi
testl %esi, %esi
jns 0x7d5447
movq %rdi, %rbx
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
andl %ebp, %esi
callq 0x7d5410
movq (%rbx), %rcx
andl %ebp, %eax
movl $0x80000000, %edx # imm = 0x80000000
andl... | /Sema/SemaChecking.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<clang::IdentifierInfo const*, unsigned long>, clang::Sema::TypeTagData, llvm::DenseMapInfo<std::pair<clang::IdentifierInfo const*, unsigned long>, void>, llvm::detail::DenseMapPair<std::pair<clang::IdentifierInfo const*, unsigned long>, clang::Sema::TypeTagData>>, std::p... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x7d6b96
movq %rsi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0x7d6bb4
decl %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rdi
pushq $0x1
popq %r8
xorl %edx, %edx
andl %ebp, %eax
movq %rax, %rcx
shlq $0x5, %rcx
... | /llvm/ADT/DenseMap.h |
clang::Expr const* const* llvm::SmallVectorTemplateCommon<clang::Expr const*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::Expr const*, true>>(llvm::SmallVectorTemplateBase<clang::Expr const*, true>*, clang::Expr const* 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::Take... | pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %rdx, %rsi
cmpq %rax, %rsi
ja 0x7d6c91
movq %rbx, %rax
popq %rbx
retq
callq 0x7d6c98
jmp 0x7d6c8c
| /llvm/ADT/SmallVector.h |
void llvm::function_ref<void (unsigned int, unsigned int, unsigned int)>::callback_fn<clang::Sema::checkFortifiedBuiltinMemoryFunction(clang::FunctionDecl*, clang::CallExpr*)::$_5>(long, unsigned int, unsigned int, unsigned int) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %esi, %r15d
movq %rdi, %r13
movq (%rdi), %rax
movq 0x18(%rdi), %rbx
movl $0x1951, (%rax) # imm = 0x1951
movq 0x8(%rdi), %rax
movl (%rax), %r14d
leal (%r14,%r15), %ebp
movq 0x10(%rdi)... | /llvm/ADT/STLFunctionalExtras.h |
llvm::DenseMap<std::pair<clang::IdentifierInfo const*, unsigned long>, clang::Sema::TypeTagData, llvm::DenseMapInfo<std::pair<clang::IdentifierInfo const*, unsigned long>, void>, llvm::detail::DenseMapPair<std::pair<clang::IdentifierInfo const*, unsigned long>, clang::Sema::TypeTagData>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
testl %esi, %esi
je 0x7d7655
movl %ebp, %edi
shlq $0x5, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0x7d7657
xorl %eax, %eax
testl %ebp, %ebp
setne %cl
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<clang::Sema::MisalignedMember, true>::push_back(clang::Sema::MisalignedMember const&) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdx
callq 0x7d78e2
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
shlq $0x5, %rdx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
incl 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/SmallVector.h |
clang::PreferredTypeBuilder::enterBinary(clang::Sema&, clang::SourceLocation, clang::Expr*, clang::tok::TokenKind) | void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS,
tok::TokenKind Op) {
if (!Enabled)
return;
ComputeType = nullptr;
Type = getPreferredTypeOfBinaryRHS(S, LHS, Op);
ExpectedLoc = Tok;
} | cmpb $0x1, (%rdi)
jne 0x7d7e99
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
andq $0x0, 0x10(%rdi)
testq %rcx, %rcx
je 0x7d7e83
movq %rsi, %r12
movq 0x8(%rcx), %r15
movq %r15, %rax
andq $-0x10, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb ... | /Sema/SemaCodeComplete.cpp |
clang::getPatternCompletionComment(clang::ASTContext const&, clang::NamedDecl const*) | static inline bool isPresent(const T &t) { return t != T(nullptr); } | testq %rsi, %rsi
je 0x7d8792
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl 0x1c(%rsi), %eax
andl $0x7f, %eax
cmpl $0xf, %eax
jne 0x7d878a
testb $0x8, 0x3a(%r14)
je 0x7d878a
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xe29e52
testq %rax, %rax
je 0x7d878a
movq %rax, %r15
movq 0x50(%rax), %rax
cmpq... | /llvm/Support/Casting.h |
AddTemplateParameterChunks(clang::ASTContext&, clang::PrintingPolicy const&, clang::TemplateDecl const*, clang::CodeCompletionBuilder&, unsigned int, unsigned int, bool) | static void AddTemplateParameterChunks(
ASTContext &Context, const PrintingPolicy &Policy,
const TemplateDecl *Template, CodeCompletionBuilder &Result,
unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) {
bool FirstParameter = true;
// Prefer to take the template parameter names... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r9d, 0xc(%rsp)
movl %r8d, %r12d
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, 0x18(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movq %rax, 0x28(%rsp)
movq 0x38(%rax), %rax
movl $0x1fffffff, %ecx ... | /Sema/SemaCodeComplete.cpp |
clang::getMacroUsagePriority(llvm::StringRef, clang::LangOptions const&, bool) | unsigned clang::getMacroUsagePriority(StringRef MacroName,
const LangOptions &LangOpts,
bool PreferredTypeIsPointer) {
unsigned Priority = CCP_Macro;
// Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
if (MacroName ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa3a8ec(%rip), %rdx # 0x1215c63
pushq $0x3
popq %rcx
callq 0x450e2d
testb %al, %al
jne 0x7db3b5
leaq 0xa3a8df(%rip), %rdx # 0x1215c69
pushq $0x4
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
ca... | /Sema/SemaCodeComplete.cpp |
clang::getCursorKindForDecl(clang::Decl const*) | CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
if (!D)
return CXCursor_UnexposedDecl;
switch (D->getKind()) {
case Decl::Enum:
return CXCursor_EnumDecl;
case Decl::EnumConstant:
return CXCursor_EnumConstantDecl;
case Decl::Field:
return CXCursor_FieldDecl;
case Decl::Function:
... | pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x7db58c
movl 0x1c(%rdi), %ecx
andl $0x7f, %ecx
cmpl $0x55, %ecx
ja 0x7db56a
leaq 0xa392b8(%rip), %rdx # 0x1214740
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
pushq $0x23
jmp 0x7db568
movl %ecx, %eax
retq
pushq $0x1b
jmp 0x7db568
pushq $0x5
jmp 0x7db568
pushq $0x21
... | /Sema/SemaCodeComplete.cpp |
mapCodeCompletionContext(clang::Sema&, clang::SemaCodeCompletion::ParserCompletionContext) | static CodeCompletionContext
mapCodeCompletionContext(Sema &S,
SemaCodeCompletion::ParserCompletionContext PCC) {
switch (PCC) {
case SemaCodeCompletion::PCC_Namespace:
return CodeCompletionContext::CCC_TopLevel;
case SemaCodeCompletion::PCC_Class:
return CodeCompletionContext::C... | pushq %rbx
movq %rdi, %rbx
movl %edx, %eax
leaq 0xa38ae1(%rip), %rcx # 0x12149c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x230(%rsi), %rax
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0x7dbeff
testl %eax, %eax
jne 0x7dbf56
pushq $0x2
jmp 0x7dbf64
pushq $0x12
jmp 0x7dbf64
movq 0x100(... | /Sema/SemaCodeComplete.cpp |
AddEnumerators((anonymous namespace)::ResultBuilder&, clang::ASTContext&, clang::EnumDecl*, clang::DeclContext*, (anonymous namespace)::CoveredEnumerators const&) | static void AddEnumerators(ResultBuilder &Results, ASTContext &Context,
EnumDecl *Enum, DeclContext *CurContext,
const CoveredEnumerators &Enumerators) {
NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier;
if (Context.getLangOpts().CPlusPlus && !Qua... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, %rbx
movq %rcx, 0x20(%rsp)
movq %rdx, %r14
movq %rdi, 0x18(%rsp)
movq 0x60(%r8), %rdx
movq 0x830(%rsi), %rax
testb $0x4, 0x1(%rax)
sete %al
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
setne %cl
orb %al, %cl... | /Sema/SemaCodeComplete.cpp |
AddObjCProperties(clang::CodeCompletionContext const&, clang::ObjCContainerDecl*, bool, bool, clang::DeclContext*, llvm::SmallPtrSet<clang::IdentifierInfo const*, 16u>&, (anonymous namespace)::ResultBuilder&, bool, bool, bool) | static void
AddObjCProperties(const CodeCompletionContext &CCContext,
ObjCContainerDecl *Container, bool AllowCategories,
bool AllowNullaryMethods, DeclContext *CurContext,
AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
bool IsBaseExp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r12
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, %r13
movq 0xf0(%rsp), %r15
movb 0x108(%rsp), %al
movb 0xf8(%rsp), %cl
leaq 0x18(%rsp), %r14
movq %r8, (%r14)
leaq 0x6(%rsp), %rbx
movb %cl, (%rbx)
leaq 0x7(%rsp), %rbp
m... | /Sema/SemaCodeComplete.cpp |
clang::CodeCompletionResult::CodeCompletionResult(clang::NamedDecl const*, unsigned int, clang::NestedNameSpecifier*, bool, bool, std::vector<clang::FixItHint, std::allocator<clang::FixItHint>>) | CodeCompletionResult(const NamedDecl *Declaration, unsigned Priority,
NestedNameSpecifier *Qualifier = nullptr,
bool QualifierIsInformative = false,
bool Accessible = true,
std::vector<FixItHint> FixIts = std::vector<FixItHint>(... | movq 0x8(%rsp), %rax
movq %rsi, (%rdi)
movl %edx, 0x10(%rdi)
andq $0x0, 0x14(%rdi)
andl $0x0, 0x20(%rdi)
movups (%rax), %xmm0
movups %xmm0, 0x28(%rdi)
movq 0x10(%rax), %rdx
movq %rdx, 0x38(%rdi)
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movb 0x40(%rdi), %al
andb $-0x80, %al
shlb $0x2, %r8b
orb %al, ... | /clang/Sema/CodeCompleteConsumer.h |
addThisCompletion(clang::Sema&, (anonymous namespace)::ResultBuilder&) | static void addThisCompletion(Sema &S, ResultBuilder &Results) {
QualType ThisTy = S.getCurrentThisType();
if (ThisTy.isNull())
return;
CodeCompletionAllocator &Allocator = Results.getAllocator();
CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
PrintingPolicy Policy = getComp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r15
callq 0x9b6bdc
cmpq $0x10, %rax
jb 0x7ea269
movq %rax, %r14
movq 0xc0(%rbx), %r12
movq 0xc8(%rbx), %rax
leaq 0xb8(%rsp), %rcx
movq %r12, -0x40(%rcx)
movq %rax, -0x38(%rcx)
xorps %xmm0, %xmm0
movups %xm... | /Sema/SemaCodeComplete.cpp |
clang::SemaCodeCompletion::CodeCompleteObjCSuperMessage(clang::Scope*, clang::SourceLocation, llvm::ArrayRef<clang::IdentifierInfo const*>, bool) | void SemaCodeCompletion::CodeCompleteObjCSuperMessage(
Scope *S, SourceLocation SuperLoc,
ArrayRef<const IdentifierInfo *> SelIdents, bool AtArgumentExpression) {
ObjCInterfaceDecl *CDecl = nullptr;
if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) {
// Figure out which interface we're in.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebp
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x78a9d6
testq %rax, %rax
je 0x7eddbd
movq %rax, %r14
movq %rax, %rdi
callq 0xe29bd6
testq %rax, %rax
je ... | /Sema/SemaCodeComplete.cpp |
FindImplementableMethods(clang::ASTContext&, clang::ObjCContainerDecl*, std::optional<bool>, clang::QualType, llvm::DenseMap<clang::Selector, llvm::PointerIntPair<clang::ObjCMethodDecl*, 1u, bool, llvm::PointerLikeTypeTraits<clang::ObjCMethodDecl*>, llvm::PointerIntPairInfo<clang::ObjCMethodDecl*, 1u, llvm::PointerLike... | static void FindImplementableMethods(ASTContext &Context,
ObjCContainerDecl *Container,
std::optional<bool> WantInstanceMethods,
QualType ReturnType,
KnownMethodsMap &Known... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movzbl %r12b, %eax
movq %rax, 0x10(%rsp)
testq %rdi, %rdi
je 0x7f10f3
movl 0x1c(%r15), %eax
andl $0x7f, %eax
cmpl $0x11, %eax
jne 0x7f10f3
movq %r15, %rdi
c... | /Sema/SemaCodeComplete.cpp |
clang::RecursiveASTVisitor<(anonymous namespace)::ConceptInfo::ValidVisitor>::TraverseSynOrSemInitListExpr(clang::InitListExpr*, llvm::SmallVectorImpl<llvm::PointerIntPair<clang::Stmt*, 1u, bool, llvm::PointerLikeTypeTraits<clang::Stmt*>, llvm::PointerIntPairInfo<clang::Stmt*, 1u, llvm::PointerLikeTypeTraits<clang::Stm... | bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
InitListExpr *S, DataRecursionQueue *Queue) {
if (S) {
// Skip this if we traverse postorder. We will visit it later
// in PostVisitStmt.
if (!getDerived().shouldTraversePostOrder())
TRY_TO(WalkUpFromInitListExpr(S));
// All w... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movb $0x1, %bl
testq %rsi, %rsi
je 0x808099
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %r13
xorl %ecx, %ecx
cmpq %r13, %rax
cmoveq %rcx, %r13
cmoveq %rcx, %rax
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r12
movups %xmm0, 0x8(%r... | /clang/AST/RecursiveASTVisitor.h |
(anonymous namespace)::ConceptInfo::ValidVisitor::addValue(clang::Expr*, clang::DeclarationName, (anonymous namespace)::ConceptInfo::Member::AccessOperator) | bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; } | testb $0x7, %dl
je 0x8080b0
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movb $0x0, 0x28(%rsp)
andq $0x0, 0x38(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x30(%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x808130
cmpq %rsi, 0x18(%rbx)
jne 0x808130
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq... | /clang/AST/DeclarationName.h |
InheritsFromClassNamed(clang::ObjCInterfaceDecl*, llvm::StringRef) | static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) {
if (!Class)
return false;
if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
return true;
return InheritsFromClassNamed(Class->getSuperClass(), Name);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0x80940f
movq 0x28(%r15), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
jne 0x809402
movq 0x10(%rax), %rdi
movl (%rdi), %esi
addq $0x10, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x450e2d
testb ... | /Sema/SemaCodeComplete.cpp |
clang::makeDNF(clang::NormalizedConstraint const&) | NormalForm clang::makeDNF(const NormalizedConstraint &Normalized) {
if (Normalized.isAtomic())
return {{Normalized.getAtomicConstraint()}};
else if (Normalized.isFoldExpanded())
return {{Normalized.getFoldExpandedConstraint()}};
NormalForm LDNF = makeDNF(Normalized.getLHS());
NormalForm RDNF = makeDNF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl %esi, %eax
andl $0x3, %eax
andq $-0x8, %rsi
cmpq $0x1, %rax
je 0x80d016
testq %rax, %rax
je 0x80d01a
leaq 0xb8(%rsp), %rdi
callq 0x80cecf
movq (%r14), %rsi
... | /Sema/SemaConcept.cpp |
clang::Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>, clang::NamedDecl*, llvm::ArrayRef<clang::Expr const*>) | bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {
if (isSFINAEContext())
// No need to work here because our notes would be discarded.
return false;
if (AC1.empty() || AC2.empty())
return false;
auto N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc0b1b2
testq %r12, %r12
sete %al
orb %dl, %al
testb $0x1, %al
jne 0x80d849
leaq 0x2c0(%rsp), %rax
movq 0x8(%rax), %r15
testq... | /Sema/SemaConcept.cpp |
substituteParameterMappings(clang::Sema&, clang::NormalizedConstraint&, clang::ConceptDecl*, clang::MultiLevelTemplateArgumentList const&, clang::ASTTemplateArgumentListInfo const*) | static bool
substituteParameterMappings(Sema &S, NormalizedConstraint &N,
ConceptDecl *Concept,
const MultiLevelTemplateArgumentList &MLTAL,
const ASTTemplateArgumentListInfo *ArgsAsWritten) {
if (N.isCompound()) {
if (substitute... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movq (%rbp), %rbx
movl %ebx, %eax
andl $0x3, %eax
cmpq $0x2, %rax
jne 0x80fce9
andq $-0x8, %rbx
movq %r12, %rdi
movq %rbx, %rsi
movq... | /Sema/SemaConcept.cpp |
llvm::DenseMap<clang::NamedDecl*, clang::NormalizedConstraint*, llvm::DenseMapInfo<clang::NamedDecl*, void>, llvm::detail::DenseMapPair<clang::NamedDecl*, clang::NormalizedConstraint*>>::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), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x791210
testq %r14, %r14
je 0x811036
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq... | /llvm/ADT/DenseMap.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformStmtExpr(clang::StmtExpr*) | ExprResult
TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
SemaRef.ActOnStartStmtExpr();
StmtResult SubStmt
= getDerived().TransformCompoundStmt(E->getSubStmt(), true);
if (SubStmt.isInvalid()) {
SemaRef.ActOnStmtExprError();
return ExprError();
}
unsigned OldDepth = E->getTemplateDepth(... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x92fd5a
movq 0x10(%rbx), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x821a04
cmpq $0x1, %rax
jne 0x811f0e
movq (%r14), %rdi
callq 0x92fe88
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rbx), %r8d
mov... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformParenExpr(clang::ParenExpr*) | ExprResult
TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
return ExprError();
if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
return E;
return getDerived().RebuildParenExpr(Sub... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x812c59
pushq $0x1
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rcx
andq $-0x2, %rax
cmpl $-0x1, 0x3218(%rcx)
jne 0x812c6f
cmpq %rax, 0x18(%rbx)
je 0x812c4e
movl... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformPackIndexingExpr(clang::PackIndexingExpr*) | ExprResult
TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
if (!E->isValueDependent())
return E;
// Transform the index
ExprResult IndexExpr = getDerived().TransformExpr(E->getIndexExpr());
if (IndexExpr.isInvalid())
return ExprError();
SmallVector<Expr *, 5> ExpandedExprs;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
testb $0x1, 0x2(%rsi)
je 0x812dee
movq %rdi, %r15
movq 0x20(%rbx), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x812cc0
pushq $0x1
popq %rbx
jmp 0x812dee
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformObjCDictionaryLiteral(clang::ObjCDictionaryLiteral*) | ExprResult
TreeTransform<Derived>::TransformObjCDictionaryLiteral(
ObjCDictionaryLiteral *E) {
// Transform each of the elements.
SmallVector<ObjCDictionaryElement, 8> Elements;
bool ArgChanged = false;
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %r14
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq %rsi, 0x8(%rsp)
andl 0x... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformConceptSpecializationExpr(clang::ConceptSpecializationExpr*) | ExprResult
TreeTransform<Derived>::TransformConceptSpecializationExpr(
ConceptSpecializationExpr *E) {
const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
if (getDerived().Trans... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x40(%rax), %rsi
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rcx
movabsq $0x800000000, %rdx # imm = 0x800000000
movq %rdx, -0x8(%rax... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformCStyleCastExpr(clang::CStyleCastExpr*) | ExprResult
TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
return ExprError();
ExprResult SubExpr
= getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
return Exp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rsi
callq 0x819796
pushq $0x1
popq %r12
testq %rax, %rax
je 0x816b6c
movq %rax, %r14
movq %rbx, %rdi
callq 0xe4df72
movq %r15, %rdi
movq %rax, %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x816b7b
movq %r12, %rax
addq $0... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformCXXConstructExpr(clang::CXXConstructExpr*) | ExprResult
TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
// CXXConstructExprs other than for list-initialization and
// CXXTemporaryObjectExpr are always implicit, so when we have
// a 1-argument construction we just transform that argument.
if (getDerived().AllowSkippingCXXConstructE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rsi), %eax
testl %eax, %eax
je 0x8189ff
cmpl $0x1, %eax
je 0x8189a1
movb (%r14), %al
xorl %ecx, %ecx
cmpb $0x71, %al
cmoveq %r14, %rcx
addq $0x30, %rcx
leaq 0x28(%r14), %rdx
cmpb $0x71, %al
cmov... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformBlockExpr(clang::BlockExpr*) | ExprResult
TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
BlockDecl *oldBlock = E->getBlockDecl();
SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
BlockScopeInfo *blockScope = SemaRef.getCurBlock();
blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
blockScope->TheDec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rbp
movq (%rdi), %r15
movq %rsi, %rdi
callq 0xe4f696
movq %r15, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x931656
movq (%r14), %rdi
callq 0x78c7d0
movq %rax, %... | /Sema/TreeTransform.h |
(anonymous namespace)::AdjustConstraintDepth::TransformTemplateTypeParmType(clang::TypeLocBuilder&, clang::TemplateTypeParmTypeLoc, bool) | QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
TemplateTypeParmTypeLoc TL, bool) {
const TemplateTypeParmType *T = TL.getTypePtr();
TemplateTypeParmDecl *NewTTPDecl = nullptr;
if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
NewTTPDecl = cast_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x20(%rdx), %rsi
cmpq %rdx, 0x8(%rdx)
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x81d4ec
xorl %r13d, %r13d
jmp 0x81d4f7
movq %r12, %rdi
callq 0x81d820
movq %rax, %... | /Sema/SemaConcept.cpp |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::RebuildPackExpansion(clang::TemplateArgumentLoc, clang::SourceLocation, std::optional<unsigned int>) | TemplateArgumentLoc
RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc,
std::optional<unsigned> NumExpansions) {
switch (Pattern.getArgument().getKind()) {
case TemplateArgument::Expression: {
ExprResult Result
= getSema().CheckPackExpansion(Patte... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl (%r14), %eax
cmpl $0x1, %eax
je 0x81e90f
cmpl $0x6, %eax
je 0x81e890
cmpl $0x8, %eax
jne 0x81e949
movq (%rsi), %rd... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::RebuildTemplateName(clang::CXXScopeSpec&, clang::SourceLocation, clang::IdentifierInfo const&, clang::SourceLocation, clang::QualType, clang::NamedDecl*, bool) | TemplateName
TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
SourceLocation TemplateKWLoc,
const IdentifierInfo &Name,
SourceLocation NameLoc,
... | pushq %rbx
subq $0x40, %rsp
movl %edx, %eax
movq %rsi, %rdx
movb 0x50(%rsp), %sil
leaq 0x20(%rsp), %r10
andl $0x0, (%r10)
movq %rcx, 0x8(%r10)
movl %r8d, 0x1c(%r10)
movl %r8d, 0x18(%r10)
leaq 0x18(%rsp), %rbx
andq $0x0, (%rbx)
movq (%rdi), %rdi
movzbl %sil, %ecx
andl $0x0, (%rsp)
movl %ecx, 0x10(%rsp)
movq %rbx, 0x8(%r... | /Sema/TreeTransform.h |
clang::Sema::ExtParameterInfoBuilder::set(unsigned int, clang::FunctionType::ExtParameterInfo) | void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
assert(Infos.size() <= index);
Infos.resize(index);
Infos.push_back(info);
if (!HasInteresting)
HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
} | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %esi
callq 0x82045e
movq %r14, %rdi
movl %ebx, %esi
callq 0x6e4e66
cmpb $0x0, 0x28(%r14)
jne 0x82041c
testb %bl, %bl
setne 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /clang/Sema/Sema.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformSEHTryStmt(clang::SEHTryStmt*) | StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
return StmtError();
StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
if (Handler.isInvalid())
return StmtE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rsi
callq 0x825920
pushq $0x1
popq %r12
cmpq $0x1, %rax
je 0x822753
movq %rax, %r14
movq 0x18(%rbx), %rsi
cmpb $-0x79, (%rsi)
jne 0x822745
movq %r15, %rdi
callq 0x8227b0
jmp 0x82274d
movq %r15, %rdi
callq 0x8227f0
c... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPTaskDirective(clang::OMPTaskDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_task, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().Ope... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x54
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPParallelForDirective(clang::OMPParallelForDirective*) | StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
OMPParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x31
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPMaskedTaskLoopSimdDirective(clang::OMPMaskedTaskLoopSimdDirective*) | StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
OMPMaskedTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExe... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x27
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPGenericLoopDirective(clang::OMPGenericLoopDirective*) | StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
OMPGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_loop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDeri... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x68
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPDistributeParallelForDirective(clang::OMPDistributeParallelForDirective*) | StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
OMPDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().Transf... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x14
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPFlushDirective(clang::OMPFlushDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_flush, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x22
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPDepobjDirective(clang::OMPDepobjDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_depobj, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x10
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPCancelDirective(clang::OMPCancelDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_cancel, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x8
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x827f70
movq %rax, ... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformCapturedStmt(clang::CapturedStmt*) | StmtResult
TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
SourceLocation Loc = S->getBeginLoc();
CapturedDecl *CD = S->getCapturedDecl();
unsigned NumParams = CD->getNumParams();
unsigned ContextParamPos = CD->getContextParamPosition();
SmallVector<Sema::CapturedParamNameType, 4> Params;
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
movq %rsi, %rdi
callq 0x78fb44
movl %eax, 0x14(%rsp)
movq %rbx, 0x38(%rsp)
movq %rbx, %rdi
callq 0xf6a232
movl 0x48(%rax), %ebx
movq %rax, 0x48(%rsp)
movl 0x4c(%rax), %eax
movq %rax, 0x50(%rsp)
leaq ... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformCXXForRangeStmt(clang::CXXForRangeStmt*) | StmtResult
TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
EnterExpressionEvaluationContext ForRangeInitContext(
getSema(), Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
/*LambdaContextDecl=*/nullptr,
Sema::ExpressionEvaluationContextRecord::EK_Other,
getSema(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0xf0(%rdi), %rax
movq (%rax), %rax
andl $0x8000, %eax # imm = 0x8000
movl %eax, %ecx
shrl $0xf, %ecx
movq %rdi, 0x88(%rsp)
movb %cl, 0x90(%rsp)
testq %rax, %rax
je 0x825c18... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPAllocateClause(clang::OMPAllocateClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
Expr *Allocator = C->getAllocator();
if (Allocator) {
ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
if (AllocatorRes.isInvalid())
return nullptr;
Allocator = AllocatorRes.get();
}
llvm::Sm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x8288e2
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
jne 0x8288ec
xorl %r12d, %r12d
jmp 0x828994
movq $0x0, (%rsp)
jmp 0x8288f4
andq $-0x2, %rax
movq %rax, (%rs... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPDetachClause(clang::OMPDetachClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) {
ExprResult E;
if (Expr *Evt = C->getEventHandler()) {
E = getDerived().TransformExpr(Evt);
if (E.isInvalid())
return nullptr;
}
return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x828e3c
movq %rbx, %rdi
callq 0x80d386
movq %rax, %rsi
cmpq $0x1, %rax
jne 0x828e3e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %esi, %esi
andq $-0x2, %rsi
movl 0xc(%r14), %ecx
movl (%r14), %edx... | /Sema/TreeTransform.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.