name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 declaration was the only
// declaration of its entity, and is used for space optimization.
if (FirstDeclID.isInvalid()) {
FirstDeclID = ThisDeclID;
IsKeyDecl = true;
IsFirstLocalDecl = true;
} else if (unsigned N = Record.readInt()) {
// This declaration was the first local declaration, but may have imported
// other declarations.
IsKeyDecl = N == 1;
IsFirstLocalDecl = true;
// We have some declarations that must be before us in our redeclaration
// chain. Read them now, and remember that we ought to merge with one of
// them.
// FIXME: Provide a known merge target to the second and subsequent such
// declaration.
for (unsigned I = 0; I != N - 1; ++I)
MergeWith = readDecl();
RedeclOffset = ReadLocalOffset();
} else {
// This declaration was not the first local declaration. Read the first
// local declaration now, to trigger the import of other redeclarations.
(void)readDecl();
}
auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
if (FirstDecl != D) {
// We delay loading of the redeclaration chain to avoid deeply nested calls.
// We temporarily set the first (canonical) declaration as the previous one
// which is the one that matters and mark the real previous DeclID to be
// loaded & attached later on.
D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
D->First = FirstDecl->getCanonicalDecl();
}
auto *DAsT = static_cast<T *>(D);
// Note that we need to load local redeclarations of this decl and build a
// decl chain for them. This must happen *after* we perform the preloading
// above; this ensures that the redeclaration chain is built in the correct
// order.
if (IsFirstLocalDecl)
Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);
} | 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
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movl (%rax,%rcx,8), %r13d
testl %r13d, %r13d
je 0x6f2612
movq %rbx, 0x10(%rsp)
leal -0x1(%r13), %ebx
xorl %r12d, %r12d
subl $0x1, %ebx
jb 0x6f25dc
movq %r14, %rdi
callq 0x6efb22
movq %rax, %r12
jmp 0x6f25ca
cmpl $0x1, %r13d
sete 0x7(%rsp)
movq %r14, %rdi
callq 0x6f7acc
movq %rax, 0x8(%rsp)
movq %rbp, %r13
movq 0x10(%rsp), %rbx
jmp 0x6f260d
movq $0x0, 0x8(%rsp)
movb $0x1, 0x7(%rsp)
xorl %r12d, %r12d
movb $0x1, %bpl
jmp 0x6f2630
movb %sil, 0x7(%rsp)
movq %r14, %rdi
callq 0x6efb22
movq $0x0, 0x8(%rsp)
movq %rbp, %r13
xorl %ebp, %ebp
xorl %r12d, %r12d
movq (%r14), %rdi
movq %r13, %rsi
callq 0x6c6a26
leaq 0x58(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
cmpq %r15, %rcx
je 0x6f2662
movq %rax, %rcx
andq $-0x4, %rcx
movq %rcx, (%r15)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
movq %rax, 0x8(%r15)
testb %bpl, %bpl
je 0x6f2684
leaq -0x58(%r15), %rsi
testq %r15, %r15
cmoveq %r15, %rsi
movl $0x29a8, %edi # imm = 0x29A8
addq (%r14), %rdi
movq 0x8(%rsp), %rdx
callq 0x707f54
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movb 0x7(%rsp), %al
movb %al, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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.readTemplateParameterList();
if (Record.readInt()) // HasFriendDecl
D->Friend = readDeclAs<NamedDecl>();
else
D->Friend = readTypeSourceInfo();
D->FriendLoc = readSourceLocation();
} | 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 $0x850, %edi # imm = 0x850
addq 0x88(%rax), %rdi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, 0x28(%rbx)
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
cmpq %r12, %r15
je 0x6f645b
callq 0x6ce106
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x6f6440
movl 0x18(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rdi)
movq 0x20(%rdi), %rcx
cmpq $0x0, (%rcx,%rax,8)
je 0x6f647d
movq %r14, %rdi
callq 0x6f1168
andq $-0x5, %rax
jmp 0x6f6489
movq %r14, %rdi
callq 0x6efad4
orq $0x4, %rax
movq %rax, 0x30(%rbx)
movq %r14, %rdi
callq 0x6ef7c0
movl %eax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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.readDecl();
assert(MD && "couldn't read decl from update record");
Reader.PendingAddedClassMembers.push_back({RD, MD});
break;
}
case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
// It will be added to the template's lazy specialization set.
PendingLazySpecializationIDs.push_back(readDeclID());
break;
case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
auto *Anon = readDeclAs<NamespaceDecl>();
// Each module has its own anonymous namespace, which is disjoint from
// any other module's anonymous namespaces, so don't attach the anonymous
// namespace at all.
if (!Record.isModule()) {
if (auto *TU = dyn_cast<TranslationUnitDecl>(D))
TU->setAnonymousNamespace(Anon);
else
cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
}
break;
}
case UPD_CXX_ADDED_VAR_DEFINITION: {
auto *VD = cast<VarDecl>(D);
VD->NonParmVarDeclBits.IsInline = Record.readInt();
VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
ReadVarDeclInit(VD);
break;
}
case UPD_CXX_POINT_OF_INSTANTIATION: {
SourceLocation POI = Record.readSourceLocation();
if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D)) {
VTSD->setPointOfInstantiation(POI);
} else if (auto *VD = dyn_cast<VarDecl>(D)) {
MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo();
assert(MSInfo && "No member specialization information");
MSInfo->setPointOfInstantiation(POI);
} else {
auto *FD = cast<FunctionDecl>(D);
if (auto *FTSInfo = FD->TemplateOrSpecialization
.dyn_cast<FunctionTemplateSpecializationInfo *>())
FTSInfo->setPointOfInstantiation(POI);
else
FD->TemplateOrSpecialization.get<MemberSpecializationInfo *>()
->setPointOfInstantiation(POI);
}
break;
}
case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: {
auto *Param = cast<ParmVarDecl>(D);
// We have to read the default argument regardless of whether we use it
// so that hypothetical further update records aren't messed up.
// TODO: Add a function to skip over the next expr record.
auto *DefaultArg = Record.readExpr();
// Only apply the update if the parameter still has an uninstantiated
// default argument.
if (Param->hasUninstantiatedDefaultArg())
Param->setDefaultArg(DefaultArg);
break;
}
case UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER: {
auto *FD = cast<FieldDecl>(D);
auto *DefaultInit = Record.readExpr();
// Only apply the update if the field still has an uninstantiated
// default member initializer.
if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {
if (DefaultInit)
FD->setInClassInitializer(DefaultInit);
else
// Instantiation failed. We can get here if we serialized an AST for
// an invalid program.
FD->removeInClassInitializer();
}
break;
}
case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
auto *FD = cast<FunctionDecl>(D);
if (Reader.PendingBodies[FD]) {
// FIXME: Maybe check for ODR violations.
// It's safe to stop now because this update record is always last.
return;
}
if (Record.readInt()) {
// Maintain AST consistency: any later redeclarations of this function
// are inline if this one is. (We might have merged another declaration
// into this one.)
forAllLaterRedecls(FD, [](FunctionDecl *FD) {
FD->setImplicitlyInline();
});
}
FD->setInnerLocStart(readSourceLocation());
ReadFunctionDefinition(FD);
assert(Record.getIdx() == Record.size() && "lazy body must be last");
break;
}
case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
auto *RD = cast<CXXRecordDecl>(D);
auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
bool HadRealDefinition =
OldDD && (OldDD->Definition != RD ||
!Reader.PendingFakeDefinitionData.count(OldDD));
RD->setParamDestroyedInCallee(Record.readInt());
RD->setArgPassingRestrictions(
static_cast<RecordArgPassingKind>(Record.readInt()));
ReadCXXRecordDefinition(RD, /*Update*/true);
// Visible update is handled separately.
uint64_t LexicalOffset = ReadLocalOffset();
if (!HadRealDefinition && LexicalOffset) {
Record.readLexicalDeclContextStorage(LexicalOffset, RD);
Reader.PendingFakeDefinitionData.erase(OldDD);
}
auto TSK = (TemplateSpecializationKind)Record.readInt();
SourceLocation POI = readSourceLocation();
if (MemberSpecializationInfo *MSInfo =
RD->getMemberSpecializationInfo()) {
MSInfo->setTemplateSpecializationKind(TSK);
MSInfo->setPointOfInstantiation(POI);
} else {
auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
Spec->setTemplateSpecializationKind(TSK);
Spec->setPointOfInstantiation(POI);
if (Record.readInt()) {
auto *PartialSpec =
readDeclAs<ClassTemplatePartialSpecializationDecl>();
SmallVector<TemplateArgument, 8> TemplArgs;
Record.readTemplateArgumentList(TemplArgs);
auto *TemplArgList = TemplateArgumentList::CreateCopy(
Reader.getContext(), TemplArgs);
// FIXME: If we already have a partial specialization set,
// check that it matches.
if (!Spec->getSpecializedTemplateOrPartial()
.is<ClassTemplatePartialSpecializationDecl *>())
Spec->setInstantiationOf(PartialSpec, TemplArgList);
}
}
RD->setTagKind(static_cast<TagTypeKind>(Record.readInt()));
RD->setLocation(readSourceLocation());
RD->setLocStart(readSourceLocation());
RD->setBraceRange(readSourceRange());
if (Record.readInt()) {
AttrVec Attrs;
Record.readAttributes(Attrs);
// If the declaration already has attributes, we assume that some other
// AST file already loaded them.
if (!D->hasAttrs())
D->setAttrsImpl(Attrs, Reader.getContext());
}
break;
}
case UPD_CXX_RESOLVED_DTOR_DELETE: {
// Set the 'operator delete' directly to avoid emitting another update
// record.
auto *Del = readDeclAs<FunctionDecl>();
auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
auto *ThisArg = Record.readExpr();
// FIXME: Check consistency if we have an old and new operator delete.
if (!First->OperatorDelete) {
First->OperatorDelete = Del;
First->OperatorDeleteThisArg = ThisArg;
}
break;
}
case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
SmallVector<QualType, 8> ExceptionStorage;
auto ESI = Record.readExceptionSpecInfo(ExceptionStorage);
// Update this declaration's exception specification, if needed.
auto *FD = cast<FunctionDecl>(D);
auto *FPT = FD->getType()->castAs<FunctionProtoType>();
// FIXME: If the exception specification is already present, check that it
// matches.
if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
FD->setType(Reader.getContext().getFunctionType(
FPT->getReturnType(), FPT->getParamTypes(),
FPT->getExtProtoInfo().withExceptionSpec(ESI)));
// When we get to the end of deserializing, see if there are other decls
// that we need to propagate this exception specification onto.
Reader.PendingExceptionSpecUpdates.insert(
std::make_pair(FD->getCanonicalDecl(), FD));
}
break;
}
case UPD_CXX_DEDUCED_RETURN_TYPE: {
auto *FD = cast<FunctionDecl>(D);
QualType DeducedResultType = Record.readType();
Reader.PendingDeducedTypeUpdates.insert(
{FD->getCanonicalDecl(), DeducedResultType});
break;
}
case UPD_DECL_MARKED_USED:
// Maintain AST consistency: any later redeclarations are used too.
D->markUsed(Reader.getContext());
break;
case UPD_MANGLING_NUMBER:
Reader.getContext().setManglingNumber(cast<NamedDecl>(D),
Record.readInt());
break;
case UPD_STATIC_LOCAL_NUMBER:
Reader.getContext().setStaticLocalNumber(cast<VarDecl>(D),
Record.readInt());
break;
case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),
readSourceRange()));
break;
case UPD_DECL_MARKED_OPENMP_ALLOCATE: {
auto AllocatorKind =
static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt());
Expr *Allocator = Record.readExpr();
Expr *Alignment = Record.readExpr();
SourceRange SR = readSourceRange();
D->addAttr(OMPAllocateDeclAttr::CreateImplicit(
Reader.getContext(), AllocatorKind, Allocator, Alignment, SR));
break;
}
case UPD_DECL_EXPORTED: {
unsigned SubmoduleID = readSubmoduleID();
auto *Exported = cast<NamedDecl>(D);
Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
Reader.getContext().mergeDefinitionIntoModule(Exported, Owner);
Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);
break;
}
case UPD_DECL_MARKED_OPENMP_DECLARETARGET: {
auto MapType = Record.readEnum<OMPDeclareTargetDeclAttr::MapTypeTy>();
auto DevType = Record.readEnum<OMPDeclareTargetDeclAttr::DevTypeTy>();
Expr *IndirectE = Record.readExpr();
bool Indirect = Record.readBool();
unsigned Level = Record.readInt();
D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(
Reader.getContext(), MapType, DevType, IndirectE, Indirect, Level,
readSourceRange()));
break;
}
case UPD_ADDED_ATTR_TO_RECORD:
AttrVec Attrs;
Record.readAttributes(Attrs);
assert(Attrs.size() == 1);
D->addAttr(Attrs[0]);
break;
}
}
} | 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 0x8(%r15), %rsi
movl 0x18(%rsi), %eax
cmpl %eax, 0x28(%rsi)
jbe 0x706d8a
leal 0x1(%rax), %edx
movl %edx, 0x18(%rsi)
movq 0x20(%rsi), %rcx
movl (%rcx,%rax,8), %edi
cmpq $0x13, %rdi
ja 0x706466
movslq (%rbp,%rdi,4), %rdi
addq %rbp, %rdi
movl %edx, %edx
jmpq *%rdi
movq %rsi, %rdi
callq 0x6dd0da
movq (%r15), %rdi
movl $0x2ca0, %ecx # imm = 0x2CA0
addq %rcx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x707230
jmp 0x706466
addl $0x2, %eax
movl %eax, 0x18(%rsi)
movl (%rcx,%rdx,8), %ebx
movq %rsi, %rdi
callq 0x6c8fdc
movq %rax, %r12
movq 0x8(%r15), %rdi
callq 0x6c8fdc
movq %rax, %r13
movq %r15, %rdi
callq 0x6efeee
movq (%r15), %rcx
movq 0x88(%rcx), %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
leaq 0x40(%rsp), %r13
movq %rax, %r8
callq 0xdf35e4
jmp 0x7067c3
movq (%r15), %rdi
movq 0x88(%rdi), %rdi
addl $0x2, %eax
movl %eax, 0x18(%rsi)
movl (%rcx,%rdx,8), %edx
movq %r14, %rsi
callq 0xdb8540
jmp 0x706466
movq %rsi, %rdi
callq 0x6c9c32
movq %rax, %rbx
movq (%r15), %r12
movl $0xd28, %eax # imm = 0xD28
addq %rax, %r12
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, 0x40(%rsp)
movq %rbx, 0x48(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x6cf55e
jmp 0x706466
leal 0x2(%rax), %edx
movl %edx, 0x18(%rsi)
movl 0x8(%rcx,%rax,8), %eax
andl $0x1, %eax
shll $0xd, %eax
movl 0x60(%r14), %ecx
movl $0xffffdfff, %edx # imm = 0xFFFFDFFF
andl %edx, %ecx
orl %eax, %ecx
movw %cx, 0x60(%r14)
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movl (%rax,%rcx,8), %eax
andl $0x1, %eax
shll $0xe, %eax
movl 0x60(%r14), %ecx
movl $0xffffbfff, %edx # imm = 0xFFFFBFFF
andl %edx, %ecx
orl %eax, %ecx
movw %cx, 0x60(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ef244
jmp 0x706466
movq (%r15), %rax
movq 0x88(%rax), %rsi
movq %r14, %rdi
callq 0xe1cda6
jmp 0x706466
movq %r15, %rdi
callq 0x6f10e4
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, %r12
movq 0x8(%r15), %rdi
callq 0x6c8fdc
cmpq $0x0, 0xa8(%r12)
jne 0x706466
movq %rbx, 0xa8(%r12)
movq %rax, 0xb0(%r12)
jmp 0x706466
movq %r15, %rdi
callq 0x707268
movq 0x8(%r15), %rcx
movq 0x10(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpl $0x5, %ecx
ja 0x706637
pushq $0x23
popq %rdx
btl %ecx, %edx
jb 0x706466
testq %r14, %r14
je 0x706d6a
movl 0x1c(%r14), %ecx
andl $0x7f, %ecx
jne 0x706d6a
movq %r14, %rdi
movq %rax, %rsi
callq 0xe16250
jmp 0x706466
movq (%r15), %rax
movq 0x88(%rax), %rbx
movq %r15, %rdi
callq 0x6efeee
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdf4702
jmp 0x7067c3
movq (%r15), %rdi
movl $0xf08, %eax # imm = 0xF08
addq %rax, %rdi
movq %r14, 0x40(%rsp)
movq %r13, %rsi
callq 0x6eee8c
cmpq $0x0, (%rax)
jne 0x706d8a
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
cmpq $0x0, (%rax,%rcx,8)
je 0x706a73
orb $0x1, 0x52(%r14)
movq 0x28(%rsp), %rdi
callq 0x6d10a2
movq %rax, %r12
xorl %ebx, %ebx
testb $0x1, %bl
jne 0x706a52
testq %rax, %rax
je 0x706a52
cmpq %r14, %rax
sete %bl
addq $0x68, %rax
movq %rax, %rdi
callq 0x63634e
jmp 0x7066d1
movq %rsi, %rdi
callq 0x6c8fdc
movl 0x60(%r14), %ecx
movl $0x600, %edx # imm = 0x600
andl %edx, %ecx
cmpl $0x400, %ecx # imm = 0x400
jne 0x706466
movq %r14, %rdi
movq %rax, %rsi
callq 0xe128dc
jmp 0x706466
movq %r15, %rdi
callq 0x6ef5e4
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x6b5384
jmp 0x706466
leal 0x2(%rax), %edi
movl (%rcx,%rdx,8), %edx
movl %edx, 0x18(%rsp)
addl $0x3, %eax
movl %eax, 0x18(%rsi)
movl (%rcx,%rdi,8), %eax
movl %eax, 0x10(%rsp)
movq %rsi, %rdi
callq 0x6c8fdc
movq %rax, 0x38(%rsp)
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movq 0x20(%rax), %rsi
movq %rbp, %rbx
xorl %ebp, %ebp
cmpq $0x0, (%rsi,%rcx,8)
setne %bpl
addl $0x2, %ecx
movl %ecx, 0x18(%rax)
movl (%rsi,%rdx,8), %r12d
movq (%r15), %rax
movq 0x88(%rax), %r13
movq %r15, %rdi
callq 0x6efeee
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x40(%rsp), %r13
movl 0x18(%rsp), %esi
movl 0x10(%rsp), %edx
movq 0x38(%rsp), %rcx
movl %ebp, %r8d
movq %rbx, %rbp
movl %r12d, %r9d
callq 0xdf409a
movq %r14, %rdi
movq %rax, %rsi
callq 0xe1d7d6
jmp 0x706466
testq %r14, %r14
sete %bl
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6c9526
movl %eax, %r12d
movl 0x1c(%r14), %eax
movl %eax, %ecx
andl $0x7e, %ecx
cmpl $0x26, %ecx
setne %cl
orb %bl, %cl
je 0x706a8f
testq %r14, %r14
je 0x706ace
andl $0x7f, %eax
addl $-0x2c, %eax
cmpl $-0x7, %eax
jb 0x706ace
movq %r14, %rdi
callq 0xe122de
jmp 0x706aef
movq (%r15), %rdi
movq 0x88(%rdi), %rdi
addl $0x2, %eax
movl %eax, 0x18(%rsi)
movl (%rcx,%rdx,8), %edx
movq %r14, %rsi
callq 0xdb83e8
jmp 0x706466
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq 0x80(%rax), %r12
testq %r12, %r12
je 0x706a9b
cmpq %r14, 0x58(%r12)
je 0x706af8
xorl %ebx, %ebx
jmp 0x706b10
movq %r15, %rdi
callq 0x6ef72e
movq %r14, 0x40(%rsp)
testl %eax, %eax
je 0x706a9f
movq (%r15), %rdi
movl %eax, %esi
callq 0x6b8b7e
movq %rax, %rdx
movq 0x40(%rsp), %rsi
jmp 0x706aa4
leaq 0x150(%rsp), %rax
movq %rax, 0x140(%rsp)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x148(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x140(%rsp), %rdx
callq 0x6e4bfa
movq 0x30(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4eedc6
movq 0x10(%rax), %rcx
movq %rcx, %rdx
shrq $0x36, %rdx
andl $0xf, %edx
addl $-0x9, %edx
cmpl $0x1, %edx
ja 0x7069ba
movq (%r15), %rdx
movq 0x88(%rdx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x18(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rax, %r13
addq $0x30, %r13
shrq $0x26, %rcx
movq %rbp, %rbx
movzwl %cx, %ebp
leaq 0x190(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x6d0f4c
pushq $0xf
popq %rcx
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
rep movsq (%rsi), %es:(%rdi)
movups 0x110(%rsp), %xmm0
movups 0x120(%rsp), %xmm1
movups 0x130(%rsp), %xmm2
leaq 0x50(%rsp), %rax
movups %xmm2, 0x28(%rax)
movups %xmm1, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
leaq 0x40(%rsp), %r13
movq %rbp, %rcx
movq %rbx, %rbp
movq %r13, %r8
callq 0x6e4ddc
movq %rax, 0x30(%r14)
movq (%r15), %rbx
movl $0xc90, %eax # imm = 0xC90
addq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, 0x40(%rsp)
movq %r14, 0x48(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x70489e
leaq 0x140(%rsp), %rdi
callq 0x6e4ff2
jmp 0x706466
movq %rsi, %rdi
callq 0x6c8fdc
movq %rax, %rbx
movl 0x44(%r14), %eax
shrl $0x2, %eax
andl $0x3, %eax
je 0x706466
cmpl $0x3, %eax
je 0x706466
movq %r14, %rdi
callq 0x707272
testb %al, %al
jne 0x706466
movq %r14, %rdi
testq %rbx, %rbx
je 0x706d80
movq %rbx, %rsi
callq 0xe14d14
jmp 0x706466
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x48(%rsp)
movq %rsi, %rdi
movq %r13, %rsi
callq 0x6ef6f0
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xe1d7d6
jmp 0x706d5d
testb $0x1, %bl
je 0x706a73
cmpq %r14, %r12
je 0x706a73
orb $0x1, 0x52(%r12)
addq $0x68, %r12
movq %r12, %rdi
callq 0x63634e
movq %rax, %r12
jmp 0x706a57
movq %r15, %rdi
callq 0x6ef7c0
movl %eax, 0x40(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6eed5e
jmp 0x706466
movl %r12d, 0x88(%r14)
jmp 0x706466
movb $0x1, %bl
jmp 0x706b10
movq %r14, %rsi
xorl %edx, %edx
movq (%r15), %rax
movq 0x88(%rax), %rdi
pushq $0x1
popq %rcx
callq 0xd95aaa
movq (%r15), %rdi
movl $0xfa0, %eax # imm = 0xFA0
addq %rax, %rdi
movq %r13, %rsi
callq 0x6c27a0
jmp 0x706466
movq 0x98(%r14), %rax
movl %eax, %ecx
andl $0x6, %ecx
cmpl $0x4, %ecx
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0x706d77
movl %r12d, 0x8(%rax)
jmp 0x706466
movq (%r15), %rdi
movl $0xc78, %eax # imm = 0xC78
addq %rax, %rdi
movq %r12, %rsi
callq 0x7072ba
testl %eax, %eax
setne %bl
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
xorl %edx, %edx
cmpq $0x0, (%rax,%rcx,8)
setne %dl
shlq $0x22, %rdx
movq 0x48(%r14), %rax
movabsq $-0x400000001, %rcx # imm = 0xFFFFFFFBFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
movq %rax, 0x48(%r14)
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movq (%rax,%rcx,8), %rax
andl $0x3, %eax
shlq $0x23, %rax
movq 0x48(%r14), %rcx
movabsq $-0x1800000001, %rdx # imm = 0xFFFFFFE7FFFFFFFF
andq %rdx, %rcx
orq %rax, %rcx
movq %rcx, 0x48(%r14)
movq %r15, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6f5bca
movq %r15, %rdi
callq 0x6f7acc
testq %rax, %rax
sete %cl
xorb $0x1, %bl
orb %cl, %bl
jne 0x706bcc
movq 0x8(%r15), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x7072c6
movq (%r15), %rdi
movl $0xc78, %eax # imm = 0xC78
addq %rax, %rdi
movq %r12, 0x40(%rsp)
movq %r13, %rsi
callq 0x7072e4
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movq (%rax,%rcx,8), %r12
movq %r15, %rdi
callq 0x6ef7c0
movl %eax, %ebx
movq %r14, %rdi
callq 0xe22fb2
testq %rax, %rax
je 0x706c1e
movq (%rax), %rcx
andq $-0x7, %rcx
movabsq $0x1fffffffe, %rsi # imm = 0x1FFFFFFFE
leaq (%rsi,%r12,2), %rdx
andq %rsi, %rdx
orq %rcx, %rdx
movq %rdx, (%rax)
movl %ebx, 0x8(%rax)
jmp 0x706cb7
movq %r14, %rdi
movl %r12d, %esi
callq 0xe23078
movl %ebx, 0xb0(%r14)
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
cmpq $0x0, (%rax,%rcx,8)
je 0x706cb7
movq %r15, %rdi
callq 0x6f7026
movq %rax, %r12
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x6ce208
movq (%r15), %rax
movq 0x88(%rax), %rdi
movq 0x40(%rsp), %rsi
movl 0x48(%rsp), %edx
callq 0xe34644
movq %rax, %rbx
movq %r14, %rdi
callq 0x4dc972
testb $0x4, %al
jne 0x706caf
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x70731e
movq %r13, %rdi
callq 0x6ddcc0
movq 0x8(%r15), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movl (%rax,%rcx,8), %eax
movzwl 0x48(%r14), %ecx
shll $0xd, %eax
andl $0x1fff, %ecx # imm = 0x1FFF
orl %eax, %ecx
movw %cx, 0x48(%r14)
movq %r15, %rdi
callq 0x6ef7c0
movl %eax, 0x18(%r14)
movq %r15, %rdi
callq 0x6ef7c0
movl %eax, 0x38(%r14)
movq %r15, %rdi
callq 0x6efeee
movq %rax, 0x70(%r14)
movq 0x8(%r15), %rdi
movl 0x18(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rdi)
movq 0x20(%rdi), %rcx
cmpq $0x0, (%rcx,%rax,8)
je 0x706466
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x48(%rsp)
movq %r13, %rsi
callq 0x6ef6f0
testb $0x1, 0x1d(%r14)
jne 0x706d5d
movq (%r15), %rax
movq 0x88(%rax), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0xe1d780
movq %r13, %rdi
callq 0x68f664
jmp 0x706466
movq 0x58(%r14), %rcx
movq %rax, 0x68(%rcx)
jmp 0x706466
movl %r12d, 0x28(%rax)
jmp 0x706466
callq 0x70729e
jmp 0x706466
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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::RecordDecl*, 2u>>>, clang::RecordDecl*, llvm::SmallVector<clang::RecordDecl*, 2u>, llvm::DenseMapInfo<clang::RecordDecl*, void>, llvm::detail::DenseMapPair<clang::RecordDecl*, llvm::SmallVector<clang::RecordDecl*, 2u>>>::InsertIntoBucketImpl<clang::RecordDecl*>(clang::RecordDecl* const&, clang::RecordDecl* const&, llvm::detail::DenseMapPair<clang::RecordDecl*, llvm::SmallVector<clang::RecordDecl*, 2u>>*) | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
} | pushq %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 0x4(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x7091ec
addl $0x2, (%rbx)
movq (%rsp), %rax
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x7091e2
decl 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x709204
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7090c0
jmp 0x7091cf
| /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::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>>::LookupBucketFor<clang::CXXRecordDecl const*>(clang::CXXRecordDecl const* const&, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int> const*&) const | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 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 $0x1, %al
cmpq %rbx, %rsi
je 0x70acac
cmpq $-0x1000, %rbx # imm = 0xF000
je 0x70aca3
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
jmp 0x70ac64
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x70acad
testq %r9, %r9
cmovneq %r9, %r11
xorl %eax, %eax
popq %rbx
movq %r11, (%rdx)
retq
nop
| /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::DenseMapBase<llvm::DenseMap<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*>>, 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*>>::try_emplace<clang::NamedDecl*>(std::pair<clang::DeclContext*, clang::IdentifierInfo*>&&, clang::NamedDecl*&&) | 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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket =
InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
} | 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, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x70c85c
movb $0x1, %cl
movl 0x10(%r14), %edx
imulq $0x18, %rdx, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /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*, unsigned int>>, clang::Decl*, unsigned int, llvm::DenseMapInfo<clang::Decl*, void>, llvm::detail::DenseMapPair<clang::Decl*, unsigned int>>::try_emplace<unsigned int>(clang::Decl*&&, unsigned int&&) | 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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket =
InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
} | 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, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x70d638
movq %rax, %r15
movq %rax, (%rsp)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x6dafcc
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movb %bpl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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>()),
D);
} else {
auto Latest = Link.get<KnownLatest>();
Latest.set(D);
Link = Latest;
}
} | 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 %rax, (%rbx)
popq %rbx
retq
| /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));
E->setOperatorLoc(readSourceLocation());
E->setCanOverflow(CurrentUnpackingBits->getNextBit());
if (hasFP_Features)
E->setStoredFPFeatures(
FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
} | 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)
leal 0x1(%r15), %ecx
movl %ebp, %eax
shrl %cl, %eax
leal 0x6(%r15), %ecx
movl %ecx, 0x14(%r14)
andl $0x1f, %eax
shll $0x12, %eax
movl $0xff83ffff, %ecx # imm = 0xFF83FFFF
andl (%rbx), %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movq %r14, %rdi
callq 0x70e574
movl %eax, 0x4(%rbx)
movl 0x10(%r14), %eax
movl 0x14(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x14(%r14)
xorl %edx, %edx
btl %ecx, %eax
setb %dl
movl $0xff7fffff, %eax # imm = 0xFF7FFFFF
andl (%rbx), %eax
shll $0x17, %edx
orl %edx, %eax
btl %r15d, %ebp
movl %eax, (%rbx)
jae 0x710360
movq (%r14), %rax
movl 0x18(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rax)
movq 0x20(%rax), %rax
movq (%rax,%rcx,8), %rax
rolq $0x20, %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 %edx
movl %edx, 0x31b8(%rax)
movq %rcx, 0x18(%rsi)
callq 0x70e574
movl %eax, 0x8(%rbx)
popq %rbx
retq
| /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 0x31b8(%rcx), %edx
movq -0x8(%rax,%rdx,8), %rax
decl %edx
movl %edx, 0x31b8(%rcx)
andq $-0x5, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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
callq 0x73aa70
addl %r12d, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 && "Not given an operator delete");
if (!Chain) return;
Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) {
DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, 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 $-0x80, 0x1d(%rax)
je 0x72fbe6
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x73ec30
leaq 0x3150(%rbx), %rdi
movq %r14, %rsi
callq 0x7335f8
movl 0x3160(%rbx), %ecx
imulq $0x28, %rcx, %rcx
addq 0x3150(%rbx), %rcx
cmpq %rcx, %rax
je 0x72fc41
movq 0x8(%rax), %r15
movl 0x10(%rax), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
cmpq %r13, %r12
je 0x72fc41
movq (%r15,%r13), %rsi
movq %rbx, %rdi
callq 0x6c1bca
movq %r14, %rdi
movq %rax, %rsi
callq 0x73ec30
addq $0x8, %r13
jmp 0x72fc1f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /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())
return;
DeclsToEmitEvenIfUnreferenced.push_back(D);
} | 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.
while (NNS) {
nestedNames.push_back(NNS);
NNS = NNS->getPrefix();
}
asImpl().writeUInt32(nestedNames.size());
while (!nestedNames.empty()) {
NNS = nestedNames.pop_back_val();
NestedNameSpecifier::SpecifierKind kind = NNS->getKind();
asImpl().writeNestedNameSpecifierKind(kind);
switch (kind) {
case NestedNameSpecifier::Identifier:
asImpl().writeIdentifier(NNS->getAsIdentifier());
continue;
case NestedNameSpecifier::Namespace:
asImpl().writeNamespaceDeclRef(NNS->getAsNamespace());
continue;
case NestedNameSpecifier::NamespaceAlias:
asImpl().writeNamespaceAliasDeclRef(NNS->getAsNamespaceAlias());
continue;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
asImpl().writeQualType(QualType(NNS->getAsType(), 0));
continue;
case NestedNameSpecifier::Global:
// Don't need to write an associated value.
continue;
case NestedNameSpecifier::Super:
asImpl().writeDeclRef(NNS->getAsRecordDecl());
continue;
}
llvm_unreachable("bad nested name specifier kind");
}
} | 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(%r14), %r14
andq $-0x8, %r14
jmp 0x73309a
movl 0x10(%rsp), %esi
movq %rbx, %rdi
callq 0x730224
leaq 0xabafe9(%rip), %r15 # 0x11ee0b0
movl 0x10(%rsp), %eax
testq %rax, %rax
je 0x733169
movq 0x8(%rsp), %rcx
movq -0x8(%rcx,%rax,8), %r14
decl %eax
movl %eax, 0x10(%rsp)
movq %r14, %rdi
callq 0xf40b02
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x730224
movl %ebp, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%r14), %rsi
shlq $0x3d, %rsi
sarq $0x3f, %rsi
andq 0x10(%r14), %rsi
andq $-0x10, %rsi
movq %rbx, %rdi
callq 0x72e6c0
jmp 0x7330c7
movq %r14, %rdi
callq 0xf40b6e
jmp 0x73314a
testb $0x6, 0x8(%r14)
jne 0x73315a
movq 0x10(%r14), %rsi
jmp 0x73315c
movq %r14, %rdi
callq 0xf40b4c
jmp 0x73314a
movq %r14, %rdi
callq 0xf40b90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x718e7e
jmp 0x7330c7
xorl %esi, %esi
movq %rbx, %rdi
callq 0x729cfa
jmp 0x7330c7
leaq 0x8(%rsp), %rdi
callq 0x7331ee
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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::DeclIDInFileInfo>>>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %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 0x73e814
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x464066
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x73bd20
nop
| /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::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | 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 thing if there is any local declaration of
// the template, to avoid emitting an update record.
if (!Template->isFromASTFile())
return;
// We only need to associate the first local declaration of the
// specialization. The other declarations will get pulled in by it.
if (Writer.getFirstLocalDecl(Specialization) != Specialization)
return;
Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate(
UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization));
} | 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, %rsi
callq 0x72d5b0
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x72d66a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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::DenseMapPair<clang::FileEntryRef, unsigned int>>, clang::FileEntryRef, unsigned int, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, unsigned int>>::try_emplace<unsigned int const&>(clang::FileEntryRef const&, unsigned int const&) | 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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
} | 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, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x75399a
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x4, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /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(Priority),
Availability(Availability), ParentName(ParentName),
BriefComment(BriefComment) {
assert(NumChunks <= 0xffff);
assert(NumAnnotations <= 0xffff);
Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
for (unsigned I = 0; I != NumChunks; ++I)
StoredChunks[I] = Chunks[I];
const char **StoredAnnotations =
reinterpret_cast<const char **>(StoredChunks + NumChunks);
for (unsigned I = 0; I != NumAnnotations; ++I)
StoredAnnotations[I] = Annotations[I];
} | 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
orq %r11, %r8
movq %r8, (%rdi)
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x8(%rdi)
movq %r10, 0x18(%rdi)
addq $0x20, %rdi
shlq $0x4, %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x7579e6
movups (%rsi,%rcx), %xmm0
movups %xmm0, (%rdi,%rcx)
addq $0x10, %rcx
jmp 0x7579d3
addq %rdx, %rdi
movl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x7579ff
movq (%r9,%rcx,8), %rdx
movq %rdx, (%rdi,%rcx,8)
incq %rcx
jmp 0x7579ed
popq %rbx
popq %r14
retq
nop
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x77eb5f
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x77ec62
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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)
jmp 0x7a1d36
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0xdbb4e2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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 = &Stack->back();
bool StartsWithPragma = Back->first != NoVisibility;
if (StartsWithPragma && IsNamespaceEnd) {
Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
// For better error recovery, eat all pushes inside the namespace.
do {
Stack->pop_back();
Back = &Stack->back();
StartsWithPragma = Back->first != NoVisibility;
} while (StartsWithPragma);
} else if (!StartsWithPragma && !IsNamespaceEnd) {
Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
Diag(Back->second, diag::note_surrounding_namespace_starts_here);
return;
}
Stack->pop_back();
// To simplify the implementation, never keep around an empty stack.
if (Stack->empty())
FreeVisContext();
} | 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(%rbx), %r14
movl -0x4(%r15), %edx
leaq 0x120(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x117a, %ecx # imm = 0x117A
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
callq 0x78b0f8
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x1742, %ecx # imm = 0x1742
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
callq 0x78b0f8
movq 0x8(%r12), %rax
leaq -0x8(%rax), %r15
cmpl $-0x1, -0x10(%rax)
movq %r15, %rax
jne 0x7a3c79
jmp 0x7a3cae
addq $0x8, %rbx
leaq 0x180(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl $0x1179, %ecx # imm = 0x1179
jmp 0x7a3cff
cmpl $-0x1, %eax
setne %al
orb %sil, %al
je 0x7a3cc7
addq $-0x8, %r15
movq %r15, 0x8(%r12)
cmpq %r15, (%r12)
jne 0x7a3d0f
movq %rbx, %rdi
callq 0x7a3a4e
jmp 0x7a3d0f
addq $0x8, %rbx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl $0x1179, %ecx # imm = 0x1179
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r14, %rdi
callq 0x78b0f8
movl -0x4(%r15), %edx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1743, %ecx # imm = 0x1743
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r14, %rdi
callq 0x78b0f8
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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::AlignPackIncludeState const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %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];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
} | 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, (%rbx)
movq %rbx, %rdi
callq 0x7a5790
movq (%rbx), %rax
xorl %edx, %edx
jmp 0x7a575b
decl 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7a5768
movq %rax, (%r12)
incl 0xc(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x466df2
movl %eax, %eax
shlq $0x3, %rax
addq (%rbx), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x7a5790
movq (%rbx), %rax
movb $0x1, %dl
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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::SourceRange>>>::LookupBucketFor<int>(int const&, llvm::detail::DenseMapPair<int, std::pair<int, clang::SourceRange>> const*&) const | 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), %ebx
movb $0x1, %al
cmpl %ebx, %esi
je 0x7a59ee
cmpl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
je 0x7a59e5
testq %r9, %r9
cmovneq %r9, %r11
negl %ebx
cmovoq %r11, %r9
addl %r10d, %edi
incl %r10d
jmp 0x7a59aa
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x7a59ef
testq %r9, %r9
cmovneq %r9, %r11
xorl %eax, %eax
popq %rbx
movq %r11, (%rdx)
retq
nop
| /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 *Rec = dyn_cast<RecordDecl>(D))
handlePreserveAIRecord(Rec);
}
} | 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 %rax, %rsi
callq 0xe1d7d6
movl 0x1c(%r14), %eax
andl $0x7f, %eax
addl $-0x3b, %eax
cmpl $-0x4, %eax
jb 0x7a6ab5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a6a54
movq 0x8(%r14), %r14
andq $-0x8, %r14
jmp 0x7a6a6b
popq %rbx
popq %r14
popq %r15
retq
nop
| /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.Current == Right.Current;
} | 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 %rbx, %r14
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /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()))
return;
QualType TheOffendingSrcType, TheOffendingDestType;
Qualifiers CastAwayQualifiers;
if (CastsAwayConstness(Self, SrcType, DestType, true, false,
&TheOffendingSrcType, &TheOffendingDestType,
&CastAwayQualifiers) !=
CastAwayConstnessKind::CACK_Similar)
return;
// FIXME: 'restrict' is not properly handled here.
int qualifiers = -1;
if (CastAwayQualifiers.hasConst() && CastAwayQualifiers.hasVolatile()) {
qualifiers = 0;
} else if (CastAwayQualifiers.hasConst()) {
qualifiers = 1;
} else if (CastAwayQualifiers.hasVolatile()) {
qualifiers = 2;
}
// This is a variant of int **x; const int **y = (const int **)x;
if (qualifiers == -1)
Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual2)
<< SrcType << DestType;
else
Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual)
<< TheOffendingSrcType << TheOffendingDestType << qualifiers;
} | 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(%rax), %cl
andb $-0x9, %cl
movq %rdx, %rax
andq $-0x10, %rax
cmpb $0x20, %cl
jne 0x7ad41d
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %cl
andb $-0x9, %cl
cmpb $0x20, %cl
je 0x7ad435
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x29, 0x10(%rax)
jne 0x7ad535
leaq 0x20(%rsp), %r9
andq $0x0, (%r9)
leaq 0x18(%rsp), %rax
andq $0x0, (%rax)
leaq 0x10(%rsp), %r10
andq $0x0, (%r10)
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
pushq %r10
pushq %rax
callq 0x7af269
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x7ad535
movq 0x10(%rsp), %rax
testb $0x1, %al
jne 0x7ad4bf
testb $0x4, %al
jne 0x7ad4cd
addq $0x8, %rbx
movq (%r14), %rdi
andq $-0x2, %rdi
callq 0xf67aee
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1847, %ecx # imm = 0x1847
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x787c63
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x787c63
jmp 0x7ad52d
testb $0x4, %al
jne 0x7ad4d7
movl $0x1, 0xc(%rsp)
jmp 0x7ad4dc
movl $0x2, 0xc(%rsp)
jmp 0x7ad4dc
andl $0x0, 0xc(%rsp)
addq $0x8, %rbx
movq (%r14), %rdi
andq $-0x2, %rdi
callq 0xf67aee
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1846, %ecx # imm = 0x1846
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x787c63
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x787c63
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x7a3ec7
movq %r14, %rdi
callq 0x78b0f8
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| /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 RPLoc) {
assert(LPLoc.isValid() && "List-initialization shouldn't get here.");
CastOperation Op(*this, Type, CastExpr);
Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
Op.OpRange = SourceRange(Op.DestRange.getBegin(), RPLoc);
Op.CheckCXXCStyleCast(/*FunctionalCast=*/true, /*ListInit=*/false);
if (Op.SrcExpr.isInvalid())
return ExprError();
auto *SubExpr = Op.SrcExpr.get();
if (auto *BindExpr = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
SubExpr = BindExpr->getSubExpr();
if (auto *ConstructExpr = dyn_cast<CXXConstructExpr>(SubExpr))
ConstructExpr->setParenOrBraceRange(SourceRange(LPLoc, RPLoc));
// -Wcast-qual
DiagnoseCastQual(Op.Self, Op.SrcExpr, Op.DestType);
return Op.complete(CXXFunctionalCastExpr::Create(
Context, Op.ResultType, Op.ValueKind, CastTypeInfo, Op.Kind,
Op.SrcExpr.get(), &Op.BasePath, CurFPFeatureOverrides(), LPLoc, RPLoc));
} | 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, 0x8(%rdi)
callq 0x7ace2c
movq %rax, 0x6c(%r13)
movq %rbp, %rbx
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
movq %rax, 0x64(%r13)
pushq $0x1
popq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x7ace52
movq 0x8(%r13), %rax
cmpq $0x1, %rax
jne 0x7ad5bb
pushq $0x1
popq %rbx
jmp 0x7ad666
andq $-0x2, %rax
movb (%rax), %cl
cmpb $0x73, %cl
jne 0x7ad5cc
movq 0x18(%rax), %rax
movb (%rax), %cl
movq %rbp, 0x18(%rsp)
leaq 0x38(%rsp), %rsi
andb $-0x2, %cl
cmpb $0x70, %cl
jne 0x7ad5e8
movl %r14d, %ecx
orq %rcx, %rbx
movq %rbx, 0x18(%rax)
leaq 0x60(%rsp), %r13
movq -0x30(%r13), %rdi
movq -0x20(%r13), %rdx
callq 0x7ad3ae
movq 0x100(%r12), %rax
movq %rax, 0x8(%rsp)
movq -0x28(%r13), %rbp
movq -0x18(%r13), %rbx
movq %r14, 0x10(%rsp)
movl -0x10(%r13), %r14d
movl -0xc(%r13), %eax
movl %eax, 0x4(%rsp)
andq $-0x2, %rbp
movq %r12, %rdi
callq 0x72d44e
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl 0x4(%rsp), %r8d
movq %rbp, %r9
pushq 0x18(%rsp)
pushq 0x18(%rsp)
pushq %rax
pushq %r13
callq 0xe9468e
addq $0x20, %rsp
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x7aaeb6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x664926
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 0x10(%rax), %al
addb $-0x19, %al
cmpb $0x2, %al
pushq $0x2
popq %rax
sbbl $0x0, %eax
popq %rcx
retq
| /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 = dyn_cast<UnaryOperator>(Arg))
switch (UnaryExpr->getOpcode()) {
case UnaryOperator::Opcode::UO_AddrOf:
return CheckFreeArgumentsAddressof(*this, CalleeName, UnaryExpr);
case UnaryOperator::Opcode::UO_Plus:
return CheckFreeArgumentsPlus(*this, CalleeName, UnaryExpr);
default:
break;
}
if (const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
if (Lvalue->getType()->isArrayType())
return CheckFreeArgumentsStackArray(*this, CalleeName, Lvalue);
if (const auto *Label = dyn_cast<AddrLabelExpr>(Arg)) {
Diag(Label->getBeginLoc(), diag::warn_free_nonheap_object)
<< CalleeName << 0 /*object: */ << Label->getLabel()->getIdentifier();
return;
}
if (isa<BlockExpr>(Arg)) {
Diag(Arg->getBeginLoc(), diag::warn_free_nonheap_object)
<< CalleeName << 1 /*object: block*/;
return;
}
}
// Maybe the cast was important, check after the other cases.
if (const auto *Cast = dyn_cast<CastExpr>(E->getArg(0)))
return CheckFreeArgumentsCast(*this, CalleeName, Cast);
} | 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 0x8(%rax,%rcx), %r14
movq %r14, %rdi
callq 0xe50100
movq %rax, %r15
movzbl (%rax), %eax
cmpl $0x7e, %eax
je 0x7bdbeb
cmpl $0x46, %eax
je 0x7bd982
cmpl $0x74, %eax
je 0x7bdb9d
cmpl $0x4, %eax
jne 0x7bda2a
movl (%r15), %eax
shrl $0x12, %eax
andl $0x1f, %eax
cmpl $0x6, %eax
je 0x7bdc79
cmpl $0x4, %eax
jne 0x7bda2a
movq 0x10(%r15), %rax
movzbl (%rax), %ecx
cmpl $0x2e, %ecx
je 0x7bdcf0
cmpl $0x46, %ecx
jne 0x7bdc5f
movq 0x10(%rax), %rcx
movl 0x1c(%rcx), %eax
andl $0x7f, %eax
addl $-0x1f, %eax
cmpl $0x11, %eax
ja 0x7bdc5f
movq 0x30(%rcx), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x29, %al
cmpb $0x2, %al
jb 0x7bdc5f
jmp 0x7bdcf4
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x7bda2a
movq 0x10(%r15), %rax
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
addl $-0x25, %ecx
xorl %edx, %edx
cmpl $0x7, %ecx
cmovbq %rax, %rdx
movq %rdx, 0x88(%rsp)
testq %rdx, %rdx
je 0x7bdc5f
addq $0x8, %rbx
movq %r15, %rdi
callq 0xe4b35c
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1957, %ecx # imm = 0x1957
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x78fcdb
leaq 0x50(%rsp), %rsi
andl $0x0, (%rsi)
movq %rax, %rdi
callq 0x75c9d2
leaq 0x88(%rsp), %rsi
movq %rax, %rdi
callq 0x78a8b0
jmp 0x7bdc57
movb (%r14), %al
addb $-0x58, %al
cmpb $-0xa, %al
jb 0x7bdc5f
leaq 0x110(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
movq $0x80, -0x8(%rax)
leaq 0x50(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x463d3a
movl (%r14), %eax
shrl $0x12, %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0x7bdcd1
cmpl $0x1, %eax
jne 0x7bda9e
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x7adb28
testb %al, %al
je 0x7bdb81
movl (%r14), %eax
shrl $0x12, %eax
andl $0x7f, %eax
cmpl $0x15, %eax
ja 0x7bdb81
movl $0x201002, %ecx # imm = 0x201002
btl %eax, %ecx
jae 0x7bdb81
leaq 0x50(%rsp), %r15
pushq $0x27
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x45931a
movq %rbx, %rdi
callq 0x6438c6
leaq 0x88(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x9eee53(%rip), %rax # 0x11ac938
movq %rax, 0x40(%rsp)
movq $0x1, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf83dea
movq %r15, %rdi
movl %ebp, %esi
callq 0x45931a
addq $0x8, %rbx
movq %r14, %rdi
callq 0xf67aee
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1957, %ecx # imm = 0x1957
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x78fcdb
leaq 0x3c(%rsp), %rsi
andl $0x0, (%rsi)
movq %rax, %rdi
callq 0x75c9d2
movq 0x30(%r15), %rcx
movups (%rcx), %xmm0
leaq 0xe8(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rax, %rdi
callq 0x787ea2
movq %r14, %rdi
callq 0x78b0f8
leaq 0x50(%rsp), %rdi
callq 0x4801c6
leaq 0xf8(%rsp), %rdi
callq 0x4521fe
jmp 0x7bdc5f
addq $0x8, %rbx
movq %r15, %rdi
callq 0xf67aee
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1957, %ecx # imm = 0x1957
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x78fcdb
leaq 0x88(%rsp), %rsi
movl $0x1, (%rsi)
movq %rax, %rdi
callq 0x75c9d2
jmp 0x7bdc57
addq $0x8, %rbx
movl 0x10(%r15), %edx
leaq 0xf8(%rsp), %r14
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1957, %ecx # imm = 0x1957
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x78fcdb
leaq 0x50(%rsp), %rsi
andl $0x0, (%rsi)
movq %rax, %rdi
callq 0x75c9d2
movq 0x18(%r15), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, %rdx
andq $-0x8, %rdx
testb $0x7, %cl
cmoveq %rdx, %r12
leaq 0x88(%rsp), %rsi
movq %r12, (%rsi)
movq %rax, %rdi
callq 0x7c071a
movq %r14, %rdi
callq 0x78b0f8
leaq 0x18(%rsp), %rdi
callq 0x436d30
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %rdi
callq 0xe500b8
movq %rax, %rdi
callq 0xe4ffc8
cmpb $0x33, (%rax)
jne 0x7bdc5f
addq $0x8, %rbx
movl 0x10(%rax), %edx
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1957, %ecx # imm = 0x1957
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x78fcdb
leaq 0x88(%rsp), %rsi
movl $0x2, (%rsi)
jmp 0x7bdbe1
movq 0x10(%r14), %rdi
callq 0xe4d66e
movq %rax, %rdi
callq 0xe4ffc8
cmpb $0x34, (%rax)
je 0x7bdab5
jmp 0x7bdb81
movq 0x18(%rax), %rcx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7d2a5e
jmp 0x7bdc5f
nop
| /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() && !Literal->isUTF8())) {
return ExprError(
Diag(Arg->getBeginLoc(), diag::err_os_log_format_not_string_constant)
<< Arg->getSourceRange());
}
ExprResult Result(Literal);
QualType ResultTy = Context.getPointerType(Context.CharTy.withConst());
InitializedEntity Entity =
InitializedEntity::InitializeParameter(Context, ResultTy, false);
Result = PerformCopyInitialization(Entity, SourceLocation(), Result);
return Result;
} | 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
movq 0x47f8(%rdi), %rsi
orq $0x1, %rsi
callq 0xd9978a
movq 0x100(%rbx), %rdi
leaq 0x10(%rsp), %r15
andl $0x0, 0x18(%r15)
movl $0x1, (%r15)
movq %rax, %rsi
callq 0xd9daf0
movq %rax, 0x10(%r15)
andq $0x0, 0x8(%r15)
andq $0x0, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xa3d2e0
jmp 0x7c0335
addq $0x8, %rbx
movq %r15, %rdi
callq 0xf67aee
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x111c, %ecx # imm = 0x111C
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
callq 0xf67396
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x75caca
movq %r14, %rdi
callq 0x78b0f8
pushq $0x1
popq %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x7c2e78
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x7d7308
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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 (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
(!isObjCMethod && isNonNullType(lhsType))) &&
CheckNonNullExpr(*this, RetValExp))
Diag(ReturnLoc, diag::warn_null_ret)
<< (isObjCMethod ? 1 : 0) << RetValExp->getSourceRange();
// C++11 [basic.stc.dynamic.allocation]p4:
// If an allocation function declared with a non-throwing
// exception-specification fails to allocate storage, it shall return
// a null pointer. Any other allocation function that fails to allocate
// storage shall indicate failure only by throwing an exception [...]
if (FD) {
OverloadedOperatorKind Op = FD->getOverloadedOperator();
if (Op == OO_New || Op == OO_Array_New) {
const FunctionProtoType *Proto
= FD->getType()->castAs<FunctionProtoType>();
if (!Proto->isNothrow(/*ResultIfDependent*/true) &&
CheckNonNullExpr(*this, RetValExp))
Diag(ReturnLoc, diag::warn_operator_new_returns_null)
<< FD << getLangOpts().CPlusPlus11;
}
}
if (RetValExp && RetValExp->getType()->isWebAssemblyTableType()) {
Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
}
// PPC MMA non-pointer types are not allowed as return type. Checking the type
// here prevent the user from using a PPC MMA type as trailing return type.
if (Context.getTargetInfo().getTriple().isPPC64())
PPC().CheckPPCMMAType(RetValExp->getType(), ReturnLoc);
} | 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
callq 0x7c34b7
testb %al, %al
je 0x7c337c
movq %r15, %rdi
movq %r14, %rsi
callq 0x7c34d2
testb %al, %al
je 0x7c337c
leaq 0x8(%r15), %rsi
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl %ebx, %edx
movl $0x1a20, %ecx # imm = 0x1A20
xorl %r8d, %r8d
callq 0x7a6d9e
movzbl %bpl, %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
callq 0x75c9d2
movq %rax, %rbp
movq %r14, %rdi
callq 0xf67396
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbp, %rdi
callq 0x75caca
movq %r13, %rdi
callq 0x78b0f8
testq %r12, %r12
je 0x7c3419
movq %r12, %rdi
callq 0xe1367a
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x7c3419
movq 0x30(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4eedc6
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x7c359e
testb %al, %al
jne 0x7c3419
movq %r15, %rdi
movq %r14, %rsi
callq 0x7c34d2
testb %al, %al
je 0x7c3419
leaq 0x8(%r15), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl %ebx, %edx
movl $0x1a5f, %ecx # imm = 0x1A5F
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0xb0(%rsp), %rsi
movq %r12, %rdi
callq 0x78a831
movq 0xf0(%r15), %rcx
movl (%rcx), %ecx
shrl $0xb, %ecx
andl $0x1, %ecx
leaq 0x8(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0x77c488
movq %r12, %rdi
callq 0x78b0f8
testq %r14, %r14
je 0x7c3468
movq 0x8(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa66fc
testb %al, %al
je 0x7c3468
leaq 0x8(%r15), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl %ebx, %edx
movl $0x13d7, %ecx # imm = 0x13D7
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movq %r12, %rdi
callq 0x75c9d2
movq %r12, %rdi
callq 0x78b0f8
movq 0x100(%r15), %rax
movq 0x4348(%rax), %rax
movl 0xf8(%rax), %eax
addl $-0x17, %eax
cmpl $0x1, %eax
ja 0x7c3496
movq 0x2f8(%r15), %rdi
movq 0x8(%r14), %rsi
movl %ebx, %edx
callq 0xb219c2
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, IgnoreImplicitAsWrittenSingleStep,
IgnoreElidableImplicitConstructorSingleStep)))
return true;
// If the expression has non-null type, it doesn't evaluate to null.
if (auto nullability = Expr->IgnoreImplicit()->getType()->getNullability()) {
if (*nullability == NullabilityKind::NonNull)
return false;
}
// As a special case, transparent unions initialized with zero are
// considered null for the purposes of the nonnull attribute.
if (const RecordType *UT = Expr->getType()->getAsUnionType();
UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
if (const auto *CLE = dyn_cast<CompoundLiteralExpr>(Expr))
if (const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
Expr = ILE->getInit(0);
}
bool Result;
return (!Expr->isValueDependent() &&
Expr->EvaluateAsBooleanCondition(Result, S.Context) &&
!Result);
} | 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), %rdi
callq 0xfaa7fe
andl $0x1ff, %eax # imm = 0x1FF
cmpw $0x100, %ax # imm = 0x100
je 0x7c3590
movq 0x8(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa3766
testq %rax, %rax
je 0x7c3563
movq %rax, %rdi
callq 0xfa5a44
movq %rax, %rdi
callq 0x7d2c42
testb %al, %al
je 0x7c3563
cmpb $0x4b, (%rbx)
jne 0x7c3563
movq 0x20(%rbx), %rax
cmpb $0x35, (%rax)
jne 0x7c3563
movq 0x10(%rax), %rax
movq (%rax), %rbx
testb $0x1, 0x2(%rbx)
jne 0x7c3590
movq 0x100(%r14), %rdx
leaq 0xf(%rsp), %rsi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xe5652c
testb %al, %al
je 0x7c3592
movb 0xf(%rsp), %bpl
xorb $0x1, %bpl
jmp 0x7c3592
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /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->isInstantiationDependent())
CheckUnsequencedOperations(E);
if (!IsConstexpr && !E->isValueDependent())
CheckForIntOverflow(E);
DiagnoseMisalignedMembers();
} | 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
movq %r14, %rsi
callq 0x7c8a9c
testb %bpl, %bpl
jne 0x7c8c25
testb $0x1, 0x2(%r14)
jne 0x7c8c25
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c87f4
movq %rbx, %rdi
callq 0x7c8c40
movb %r15b, 0x978(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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());
if (PRE && !PRE->isImplicitProperty()) {
const ObjCPropertyDecl *PD = PRE->getExplicitProperty();
if (PD)
LHSType = PD->getType();
}
if (LHSType.isNull())
LHSType = LHS->getType();
Qualifiers::ObjCLifetime LT = LHSType.getObjCLifetime();
if (LT == Qualifiers::OCL_Weak) {
if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))
getCurFunction()->markSafeWeakUse(LHS);
}
if (checkUnsafeAssigns(Loc, LHSType, RHS))
return;
// FIXME. Check for other life times.
if (LT != Qualifiers::OCL_None)
return;
if (PRE) {
if (PRE->isImplicitProperty())
return;
const ObjCPropertyDecl *PD = PRE->getExplicitProperty();
if (!PD)
return;
unsigned Attributes = PD->getPropertyAttributes();
if (Attributes & ObjCPropertyAttribute::kind_assign) {
// when 'assign' attribute was not explicitly specified
// by user, ignore it and rely on property type itself
// for lifetime info.
unsigned AsWrittenAttr = PD->getPropertyAttributesAsWritten();
if (!(AsWrittenAttr & ObjCPropertyAttribute::kind_assign) &&
LHSType->isObjCRetainableType())
return;
while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
if (cast->getCastKind() == CK_ARCConsumeObject) {
Diag(Loc, diag::warn_arc_retained_property_assign)
<< RHS->getSourceRange();
return;
}
RHS = cast->getSubExpr();
}
} else if (Attributes & ObjCPropertyAttribute::kind_weak) {
if (checkUnsafeAssignObject(*this, Loc, Qualifiers::OCL_Weak, RHS, true))
return;
}
}
} | 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 $-0x8, %rax
je 0x7ca58f
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0xf, %rax
ja 0x7ca598
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x79a6c0
movl %eax, %r12d
cmpl $0x3, %eax
jne 0x7ca5d6
movq 0x110(%r14), %rdi
movl $0x17bb, %esi # imm = 0x17BB
movl %ebp, %edx
callq 0x4fbfd8
testb %al, %al
jne 0x7ca5d6
movl 0x28(%r14), %eax
movq 0x20(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdi
movq %r15, %rsi
callq 0xcbbcd2
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x7ca3da
testq %r13, %r13
je 0x7ca6b4
testl %r12d, %r12d
jne 0x7ca6b4
testb %al, %al
jne 0x7ca6b4
movq 0x10(%r13), %rax
testb $0x4, %al
jne 0x7ca6b4
andq $-0x8, %rax
je 0x7ca6b4
movl 0x48(%rax), %eax
testb $0x4, %al
jne 0x7ca63f
btl $0x9, %eax
jae 0x7ca6b4
pushq $0x3
popq %rdx
pushq $0x1
popq %r8
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x7ca420
jmp 0x7ca6b4
btl $0x12, %eax
jb 0x7ca65a
movq 0x8(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfaab8a
testb %al, %al
jne 0x7ca6b4
movl $0x1fc0000, %eax # imm = 0x1FC0000
cmpb $0x4e, (%rbx)
jne 0x7ca6b4
movl (%rbx), %ecx
andl %eax, %ecx
cmpl $0xdc0000, %ecx # imm = 0xDC0000
je 0x7ca676
movq 0x10(%rbx), %rbx
jmp 0x7ca65f
addq $0x8, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x17be, %ecx # imm = 0x17BE
xorl %r8d, %r8d
callq 0x7a6d9e
movq %rbx, %rdi
callq 0xf67396
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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
movl %ecx, 0x8(%rdi)
retq
| /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().dyn_cast<const ValueDecl *>();
if (!BaseDecl)
return {nullptr, CharUnits()};
return {BaseDecl, Result.Val.getLValueOffset()};
} | 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, 0x10(%rsp)
jne 0x7cd547
movq %rbx, %rdi
callq 0xd8dd84
movq %rax, %r12
testb $0x3, %r12b
setne %al
andq $-0x4, %r12
sete %cl
xorl %r15d, %r15d
orb %al, %cl
movl $0x0, %r14d
jne 0x7cd547
movq %rbx, %rdi
callq 0xd8f56a
movq (%rax), %r14
movq %r12, %r15
movq %rbx, %rdi
callq 0x6dce06
movq %r15, %rax
movq %r14, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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;
}
llvm_unreachable("Invalid language synch scope value");
} | 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.Current == Right.Current;
} | 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 %rbx, %r14
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /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_args),
Loc, /*isStringLoc*/true, getSpecifierRange(startSpec, specifierLen));
} | 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
callq 0x7d07f6
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %dl, %r9d
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %rax, %r8
callq 0x7d06a8
movq %r12, %rdi
callq 0x4a59f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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(start, end - start));
} | 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
subl %r12d, %r15d
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x7d07f6
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %dl, %r9d
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %rax, %r8
callq 0x7d06a8
movq %rbx, %rdi
callq 0x4a59f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 (%rcx,%r14,4), %edx
orl %eax, %edx
movl %edx, (%rcx,%r14,4)
popq %rbx
popq %r14
popq %rbp
retq
| /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::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>>::LookupBucketFor<std::pair<clang::IdentifierInfo const*, unsigned long>>(std::pair<clang::IdentifierInfo const*, unsigned long> const&, llvm::detail::DenseMapPair<std::pair<clang::IdentifierInfo const*, unsigned long>, clang::Sema::TypeTagData> const*&) const | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %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
leaq (%r15,%rcx), %r9
movq (%r15,%rcx), %r11
movq 0x8(%r15,%rcx), %r10
cmpq %r11, %rsi
jne 0x7d6b6a
movb $0x1, %cl
cmpq %r10, %rdi
je 0x7d6b9b
cmpq $-0x1000, %r11 # imm = 0xF000
jne 0x7d6b79
cmpq $-0x1, %r10
je 0x7d6bab
xorq $-0x2000, %r11 # imm = 0xE000
xorq $-0x2, %r10
orq %r11, %r10
orq %rdx, %r10
cmoveq %r9, %rdx
addl %r8d, %eax
incl %r8d
jmp 0x7d6b48
xorl %r9d, %r9d
xorl %ecx, %ecx
movq %r9, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rdx, %rdx
cmovneq %rdx, %r9
jmp 0x7d6b99
| /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::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | 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), %rdi
callq 0x7b2a7a
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x20(%r13), %rax
movq (%rax), %r12
movl (%r12), %eax
movl %eax, %ecx
shrl $0x18, %ecx
addq %r12, %rcx
shrl $0xf, %eax
andl $0x8, %eax
addq %rcx, %rax
movq 0x8(%rax,%rbp,8), %rdi
callq 0xf67aee
movl %eax, 0x4(%rsp)
leaq 0x8(%rbx), %rsi
movq (%r13), %rax
movl (%rax), %edx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x7a6c72
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x75d23c
movq %rax, %rbp
leal (%r14,%r15), %esi
incl %esi
movq %rax, %rdi
callq 0x534868
movq %rbp, %rdi
movl 0x8(%rsp), %esi
callq 0x534868
movq %rbp, %rdi
movl 0xc(%rsp), %esi
callq 0x534868
movq %rbx, %rdi
movl 0x4(%rsp), %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x90c66c
movq %r13, %rdi
callq 0x4a59f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 $0x28, 0x10(%rax)
jne 0x7d7e3e
movzwl %r8w, %eax
addl $-0x1c, %eax
cmpl $0x30, %eax
ja 0x7d7e83
leaq 0xa3c76d(%rip), %rcx # 0x1214590
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x100(%r12), %rdi
callq 0xd9ab06
movq %rax, %r15
jmp 0x7d7e86
movzwl %r8w, %eax
addl $-0x1c, %eax
cmpl $0x30, %eax
ja 0x7d7e83
leaq 0xa3c67b(%rip), %rcx # 0x12144cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x7af5c8
xorl %ecx, %ecx
testb %al, %al
cmoveq %rcx, %r15
jmp 0x7d7e86
callq 0x7af5c8
testb %al, %al
je 0x7d7e83
movq 0x100(%r12), %rax
movq 0x4840(%rax), %r15
jmp 0x7d7e86
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x100(%r12), %rax
movq 0x47f0(%rax), %r15
jmp 0x7d7e86
nop
| /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 0x28(%r14), %rax
jne 0x7d878a
movq 0x28(%r15), %rcx
movq %rcx, %rdx
andq $-0x8, %rdx
xorl %esi, %esi
testb $0x7, %cl
cmovneq %rsi, %rdx
movq %rax, %rcx
andq $-0x8, %rcx
testb $0x7, %al
cmovneq %rsi, %rcx
cmpq %rcx, %rdx
je 0x7d878a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd903fe
testq %rax, %rax
jne 0x7d878c
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xd903fe
testq %rax, %rax
jne 0x7d878c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
nop
| /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 from the first declaration of
// the template.
Template = cast<TemplateDecl>(Template->getCanonicalDecl());
TemplateParameterList *Params = Template->getTemplateParameters();
TemplateParameterList::iterator PEnd = Params->end();
if (MaxParameters)
PEnd = Params->begin() + MaxParameters;
for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd;
++P) {
bool HasDefaultArg = false;
std::string PlaceholderStr;
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
if (TTP->wasDeclaredWithTypename())
PlaceholderStr = "typename";
else if (const auto *TC = TTP->getTypeConstraint()) {
llvm::raw_string_ostream OS(PlaceholderStr);
TC->print(OS, Policy);
} else
PlaceholderStr = "class";
if (TTP->getIdentifier()) {
PlaceholderStr += ' ';
PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
}
HasDefaultArg = TTP->hasDefaultArgument();
} else if (NonTypeTemplateParmDecl *NTTP =
dyn_cast<NonTypeTemplateParmDecl>(*P)) {
if (NTTP->getIdentifier())
PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName());
NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
HasDefaultArg = NTTP->hasDefaultArgument();
} else {
assert(isa<TemplateTemplateParmDecl>(*P));
TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
// Since putting the template argument list into the placeholder would
// be very, very long, we just use an abbreviation.
PlaceholderStr = "template<...> class";
if (TTP->getIdentifier()) {
PlaceholderStr += ' ';
PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
}
HasDefaultArg = TTP->hasDefaultArgument();
}
if (HasDefaultArg && !InDefaultArg) {
// When we see an optional default argument, put that argument and
// the remaining default arguments into a new, optional string.
CodeCompletionBuilder Opt(Result.getAllocator(),
Result.getCodeCompletionTUInfo());
if (!FirstParameter)
Opt.AddChunk(CodeCompletionString::CK_Comma);
AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
P - Params->begin(), true);
Result.AddOptionalChunk(Opt.TakeString());
break;
}
InDefaultArg = false;
if (FirstParameter)
FirstParameter = false;
else
Result.AddChunk(CodeCompletionString::CK_Comma);
// Add the placeholder string.
Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(PlaceholderStr));
}
} | 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 # imm = 0x1FFFFFFF
movq %rax, 0x30(%rsp)
andl 0xc(%rax), %ecx
testl %ebx, %ebx
movl %ebx, 0x24(%rsp)
cmovnel %ebx, %ecx
movl %r12d, %r15d
shlq $0x3, %r15
shlq $0x3, %rcx
movq %rcx, 0x38(%rsp)
movb $0x1, %al
movl %eax, 0x10(%rsp)
leaq 0x50(%rsp), %r13
leaq 0x70(%rsp), %r12
cmpq %r15, 0x38(%rsp)
je 0x7d9cc4
leaq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
andq $0x0, 0x58(%rsp)
movb $0x0, 0x60(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax,%r15), %rbp
movl 0x1c(%rbp), %eax
andl $0x7f, %eax
cmpl $0x40, %eax
setne %cl
testq %rbp, %rbp
sete %dl
orb %cl, %dl
je 0x7d9a82
testq %rbp, %rbp
sete %cl
cmpl $0x2c, %eax
setne %al
orb %cl, %al
je 0x7d9aa0
movq %r13, %rdi
leaq 0xa3c16e(%rip), %rsi # 0x1215beb
jmp 0x7d9b17
movb 0x3c(%rbp), %al
movl %eax, %ecx
notb %cl
movl %eax, %edx
shrb %dl
orb %cl, %dl
testb $0x1, %dl
jne 0x7d9b05
movq %r13, %rdi
leaq 0xa3c208(%rip), %rsi # 0x1215ca6
jmp 0x7d9b17
movq 0x28(%rbp), %rdi
testb $0x7, %dil
setne %al
andq $-0x8, %rdi
sete %cl
orb %al, %cl
jne 0x7d9aea
callq 0x106d87c
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x17(%rsp), %rdx
callq 0x454ae0
movq %r13, %rdi
movq %r12, %rsi
callq 0x436ae0
movq %r12, %rdi
callq 0x436d30
movq 0x30(%rbp), %rax
movq %rax, 0x70(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
callq 0xfaeb92
jmp 0x7d9b61
testb $0x4, %al
jne 0x7d9c98
movq %r13, %rdi
leaq 0xa3c0e2(%rip), %rsi # 0x1215bf9
callq 0x436030
movq 0x28(%rbp), %rax
testb $0x7, %al
setne %cl
cmpq $0x8, %rax
setb %al
orb %cl, %al
jne 0x7d9b61
movq %r13, %rdi
pushq $0x20
popq %rsi
callq 0x436040
movq 0x28(%rbp), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x7, %al
movl $0x0, %eax
cmovneq %rax, %rdi
callq 0x106d87c
movq %r13, %rdi
movq %rax, %rsi
callq 0x4362c0
cmpq $0x8, 0x48(%rbp)
setb %al
orb 0xc(%rsp), %al
testb $0x1, %al
je 0x7d9b89
testb $0x1, 0x10(%rsp)
je 0x7d9c41
movl $0x0, 0x10(%rsp)
jmp 0x7d9c53
movups (%r14), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x80(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0xb0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0xa8(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0xf0(%rsp)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0xf8(%rsp)
testb $0x1, 0x10(%rsp)
jne 0x7d9c01
movq %r12, %rdi
pushq $0xf
popq %rsi
leaq 0xaa8acb(%rip), %rdx # 0x12826c7
callq 0x75802e
movq %r15, %r8
shrq $0x3, %r8
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %r12, %rdx
movl 0x24(%rsp), %ecx
pushq $0x1
popq %r9
callq 0x7d99b8
movq %r12, %rdi
callq 0x757eb0
movq %r14, %rdi
movq %rax, %rsi
callq 0x757fae
movq %r12, %rdi
callq 0x4f1b80
xorl %ebx, %ebx
jmp 0x7d9c82
movq %r14, %rdi
pushq $0xf
popq %rsi
leaq 0xaa8a79(%rip), %rdx # 0x12826c7
callq 0x75802e
movq (%r14), %rdi
movw $0x104, 0x90(%rsp) # imm = 0x104
movq %r13, 0x70(%rsp)
movq %r12, %rsi
callq 0x757b7e
movq %r14, %rdi
movq %rax, %rsi
callq 0x757fbe
movb $0x1, %bl
movl $0x0, 0xc(%rsp)
movq %r13, %rdi
callq 0x436d30
addq $0x8, %r15
testb %bl, %bl
jne 0x7d9a23
jmp 0x7d9cc4
leaq 0x50(%rbp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x45b7c2
movq %rbx, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
callq 0x7f6856
movq %r12, %rdi
callq 0x4801c6
jmp 0x7d9b1c
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 == "nil" || MacroName == "NULL" || MacroName == "Nil") {
Priority = CCP_Constant;
if (PreferredTypeIsPointer)
Priority = Priority / CCF_SimilarTypeMatch;
}
// Treat "YES", "NO", "true", and "false" as constants.
else if (MacroName == "YES" || MacroName == "NO" || MacroName == "true" ||
MacroName == "false")
Priority = CCP_Constant;
// Treat "bool" as a type.
else if (MacroName == "bool")
Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0);
return Priority;
} | 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
callq 0x450e2d
testb %al, %al
jne 0x7db3b5
leaq 0xa3a613(%rip), %rdx # 0x12159b6
pushq $0x3
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
testb %al, %al
je 0x7db3ce
testb %bpl, %bpl
pushq $0x20
popq %rax
pushq $0x41
popq %rbp
cmovnel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa38dcd(%rip), %rdx # 0x12141a2
pushq $0x3
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
pushq $0x41
popq %rbp
testb %al, %al
jne 0x7db3c1
leaq 0xa616ca(%rip), %rdx # 0x123cabb
pushq $0x2
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
testb %al, %al
jne 0x7db3c1
leaq 0xc475da(%rip), %rdx # 0x14229e4
pushq $0x4
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
testb %al, %al
jne 0x7db3c1
leaq 0xa3a8f6(%rip), %rdx # 0x1215d19
pushq $0x5
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
testb %al, %al
jne 0x7db3c1
leaq 0xab094a(%rip), %rdx # 0x128bd86
pushq $0x4
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e2d
testb %al, %al
je 0x7db45e
movl (%rbx), %ebp
shrl $0x11, %ebp
andl $0x1, %ebp
orl $0x32, %ebp
jmp 0x7db3c1
pushq $0x46
popq %rbp
jmp 0x7db3c1
| /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:
return CXCursor_FunctionDecl;
case Decl::ObjCCategory:
return CXCursor_ObjCCategoryDecl;
case Decl::ObjCCategoryImpl:
return CXCursor_ObjCCategoryImplDecl;
case Decl::ObjCImplementation:
return CXCursor_ObjCImplementationDecl;
case Decl::ObjCInterface:
return CXCursor_ObjCInterfaceDecl;
case Decl::ObjCIvar:
return CXCursor_ObjCIvarDecl;
case Decl::ObjCMethod:
return cast<ObjCMethodDecl>(D)->isInstanceMethod()
? CXCursor_ObjCInstanceMethodDecl
: CXCursor_ObjCClassMethodDecl;
case Decl::CXXMethod:
return CXCursor_CXXMethod;
case Decl::CXXConstructor:
return CXCursor_Constructor;
case Decl::CXXDestructor:
return CXCursor_Destructor;
case Decl::CXXConversion:
return CXCursor_ConversionFunction;
case Decl::ObjCProperty:
return CXCursor_ObjCPropertyDecl;
case Decl::ObjCProtocol:
return CXCursor_ObjCProtocolDecl;
case Decl::ParmVar:
return CXCursor_ParmDecl;
case Decl::Typedef:
return CXCursor_TypedefDecl;
case Decl::TypeAlias:
return CXCursor_TypeAliasDecl;
case Decl::TypeAliasTemplate:
return CXCursor_TypeAliasTemplateDecl;
case Decl::Var:
return CXCursor_VarDecl;
case Decl::Namespace:
return CXCursor_Namespace;
case Decl::NamespaceAlias:
return CXCursor_NamespaceAlias;
case Decl::TemplateTypeParm:
return CXCursor_TemplateTypeParameter;
case Decl::NonTypeTemplateParm:
return CXCursor_NonTypeTemplateParameter;
case Decl::TemplateTemplateParm:
return CXCursor_TemplateTemplateParameter;
case Decl::FunctionTemplate:
return CXCursor_FunctionTemplate;
case Decl::ClassTemplate:
return CXCursor_ClassTemplate;
case Decl::AccessSpec:
return CXCursor_CXXAccessSpecifier;
case Decl::ClassTemplatePartialSpecialization:
return CXCursor_ClassTemplatePartialSpecialization;
case Decl::UsingDirective:
return CXCursor_UsingDirective;
case Decl::StaticAssert:
return CXCursor_StaticAssert;
case Decl::Friend:
return CXCursor_FriendDecl;
case Decl::TranslationUnit:
return CXCursor_TranslationUnit;
case Decl::Using:
case Decl::UnresolvedUsingValue:
case Decl::UnresolvedUsingTypename:
return CXCursor_UsingDeclaration;
case Decl::UsingEnum:
return CXCursor_EnumDecl;
case Decl::ObjCPropertyImpl:
switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
case ObjCPropertyImplDecl::Dynamic:
return CXCursor_ObjCDynamicDecl;
case ObjCPropertyImplDecl::Synthesize:
return CXCursor_ObjCSynthesizeDecl;
}
llvm_unreachable("Unexpected Kind!");
case Decl::Import:
return CXCursor_ModuleImportDecl;
case Decl::ObjCTypeParam:
return CXCursor_TemplateTypeParameter;
case Decl::Concept:
return CXCursor_ConceptDecl;
case Decl::LinkageSpec:
return CXCursor_LinkageSpec;
default:
if (const auto *TD = dyn_cast<TagDecl>(D)) {
switch (TD->getTagKind()) {
case TagTypeKind::Interface: // fall through
case TagTypeKind::Struct:
return CXCursor_StructDecl;
case TagTypeKind::Class:
return CXCursor_ClassDecl;
case TagTypeKind::Union:
return CXCursor_UnionDecl;
case TagTypeKind::Enum:
return CXCursor_EnumDecl;
}
}
}
return CXCursor_UnexposedDecl;
} | 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
jmp 0x7db568
pushq $0xe
jmp 0x7db568
pushq $0x1f
jmp 0x7db568
pushq $0x1a
jmp 0x7db568
pushq $0xa
jmp 0x7db568
pushq $0x22
jmp 0x7db568
pushq $0x16
jmp 0x7db568
pushq $0x6
jmp 0x7db568
pushq $0x1d
jmp 0x7db568
pushq $0x1c
jmp 0x7db568
pushq $0x18
jmp 0x7db568
movl $0x258, %eax # imm = 0x258
retq
movl $0x25a, %eax # imm = 0x25A
retq
pushq $0xd
jmp 0x7db568
pushq $0x14
jmp 0x7db568
pushq $0xf
jmp 0x7db568
movl $0x15e, %eax # imm = 0x15E
retq
pushq $0x17
jmp 0x7db568
pushq $0xb
jmp 0x7db568
movl $0x25b, %eax # imm = 0x25B
retq
pushq $0x7
jmp 0x7db568
pushq $0x8
jmp 0x7db568
pushq $0xc
jmp 0x7db568
xorl %eax, %eax
cmpq $0x1, 0x38(%rdi)
adcl $0x25, %eax
retq
movb 0x3a(%rdi), %cl
andb $0x2, %cl
xorl %eax, %eax
cmpb $0x1, %cl
adcl $0x10, %eax
retq
pushq $0x24
jmp 0x7db568
movl $0x25c, %eax # imm = 0x25C
retq
pushq $0x19
jmp 0x7db568
pushq $0x15
jmp 0x7db568
movl $0x259, %eax # imm = 0x259
retq
pushq $0x9
jmp 0x7db568
pushq $0x27
jmp 0x7db568
pushq $0x20
jmp 0x7db568
pushq $0x1e
popq %rax
retq
addl $-0x3c, %ecx
cmpl $-0x5, %ecx
jb 0x7db58c
movzwl 0x48(%rdi), %ecx
cmpq $0x9fff, %rcx # imm = 0x9FFF
ja 0x7db58c
shrl $0xd, %ecx
leaq 0xa3ac73(%rip), %rax # 0x12161fc
movl (%rax,%rcx,4), %eax
retq
nop
| /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::CCC_ClassStructUnion;
case SemaCodeCompletion::PCC_ObjCInterface:
return CodeCompletionContext::CCC_ObjCInterface;
case SemaCodeCompletion::PCC_ObjCImplementation:
return CodeCompletionContext::CCC_ObjCImplementation;
case SemaCodeCompletion::PCC_ObjCInstanceVariableList:
return CodeCompletionContext::CCC_ObjCIvarList;
case SemaCodeCompletion::PCC_Template:
case SemaCodeCompletion::PCC_MemberTemplate:
if (S.CurContext->isFileContext())
return CodeCompletionContext::CCC_TopLevel;
if (S.CurContext->isRecord())
return CodeCompletionContext::CCC_ClassStructUnion;
return CodeCompletionContext::CCC_Other;
case SemaCodeCompletion::PCC_RecoveryInFunction:
return CodeCompletionContext::CCC_Recovery;
case SemaCodeCompletion::PCC_ForInit:
if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
S.getLangOpts().ObjC)
return CodeCompletionContext::CCC_ParenthesizedExpression;
else
return CodeCompletionContext::CCC_Expression;
case SemaCodeCompletion::PCC_Expression:
return CodeCompletionContext::CCC_Expression;
case SemaCodeCompletion::PCC_Condition:
return CodeCompletionContext(CodeCompletionContext::CCC_Expression,
S.getASTContext().BoolTy);
case SemaCodeCompletion::PCC_Statement:
return CodeCompletionContext::CCC_Statement;
case SemaCodeCompletion::PCC_Type:
return CodeCompletionContext::CCC_Type;
case SemaCodeCompletion::PCC_ParenthesizedExpression:
return CodeCompletionContext::CCC_ParenthesizedExpression;
case SemaCodeCompletion::PCC_LocalDeclarationSpecifiers:
return CodeCompletionContext::CCC_Type;
case SemaCodeCompletion::PCC_TopLevelOrExpression:
return CodeCompletionContext::CCC_TopLevelOrExpression;
}
llvm_unreachable("Invalid ParserCompletionContext!");
} | 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(%rsi), %rax
movq 0x47f0(%rax), %rdx
pushq $0x8
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7e0e64
jmp 0x7dbf6d
pushq $0x24
jmp 0x7dbf64
pushq $0x5
jmp 0x7dbf64
pushq $0x26
jmp 0x7dbf64
pushq $0x3
jmp 0x7dbf64
pushq $0x4
jmp 0x7dbf64
movq 0xf0(%rsi), %rax
testl $0x20401, (%rax) # imm = 0x20401
je 0x7dbf4e
pushq $0x1d
jmp 0x7dbf64
pushq $0x8
jmp 0x7dbf64
pushq $0x7
jmp 0x7dbf64
movzwl %ax, %eax
addl $-0x37, %eax
cmpw $0x3, %ax
ja 0x7dbf72
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x7db958
movq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x7dbf68
nop
| /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 && !Qualifier && Enumerators.Seen.empty()) {
// If there are no prior enumerators in C++, check whether we have to
// qualify the names of the enumerators that we suggest, because they
// may not be visible in this scope.
Qualifier = getRequiredQualification(Context, CurContext, Enum);
}
Results.EnterNewScope();
for (auto *E : Enum->enumerators()) {
if (Enumerators.Seen.count(E))
continue;
CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
Results.AddResult(R, CurContext, nullptr, false);
}
Results.ExitScope();
} | 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
jne 0x7e107c
movl 0x14(%rbx), %eax
cmpl 0x18(%rbx), %eax
jne 0x7e1073
leaq 0x40(%r14), %rdx
testq %r14, %r14
cmoveq %r14, %rdx
movq %rsi, %rdi
movq 0x20(%rsp), %rsi
callq 0x7f747c
movq %rax, 0x10(%rsp)
jmp 0x7e107c
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7dba8a
movq %r14, %rdi
callq 0x4defa6
movq %rax, %r14
movq %rdx, %r13
leaq 0x28(%rsp), %rbp
movq %rax, (%rbp)
cmpq %r13, %r14
je 0x7e114d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7f8584
testl %eax, %eax
jne 0x7e113b
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, (%rsp)
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
pushq $0x7
popq %rdx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
pushq $0x1
popq %r9
callq 0x7e507c
movq %r15, %rdi
callq 0x4f12d6
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x4f1f84
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq 0x20(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7e50ce
leaq 0x70(%rsp), %rdi
callq 0x4f12d6
leaq 0xd0(%rsp), %rdi
callq 0x4f12d6
movq %rbp, %rdi
callq 0x4df0aa
movq 0x28(%rsp), %r14
jmp 0x7e109d
movq 0x18(%rsp), %rdi
callq 0x7dbac6
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 IsBaseExprStatement = false,
bool IsClassProperty = false, bool InOriginalClass = true) {
typedef CodeCompletionResult Result;
// Retrieve the definition.
Container = getContainerDef(Container);
// Add properties in this container.
const auto AddProperty = [&](const ObjCPropertyDecl *P) {
if (!AddedProperties.insert(P->getIdentifier()).second)
return;
// FIXME: Provide block invocation completion for non-statement
// expressions.
if (!P->getType().getTypePtr()->isBlockPointerType() ||
!IsBaseExprStatement) {
Result R = Result(P, Results.getBasePriority(P), nullptr);
if (!InOriginalClass)
setInBaseClass(R);
Results.MaybeAddResult(R, CurContext);
return;
}
// Block setter and invocation completion is provided only when we are able
// to find the FunctionProtoTypeLoc with parameter names for the block.
FunctionTypeLoc BlockLoc;
FunctionProtoTypeLoc BlockProtoLoc;
findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
BlockProtoLoc);
if (!BlockLoc) {
Result R = Result(P, Results.getBasePriority(P), nullptr);
if (!InOriginalClass)
setInBaseClass(R);
Results.MaybeAddResult(R, CurContext);
return;
}
// The default completion result for block properties should be the block
// invocation completion when the base expression is a statement.
CodeCompletionBuilder Builder(Results.getAllocator(),
Results.getCodeCompletionTUInfo());
AddObjCBlockCall(Container->getASTContext(),
getCompletionPrintingPolicy(Results.getSema()), Builder, P,
BlockLoc, BlockProtoLoc);
Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P));
if (!InOriginalClass)
setInBaseClass(R);
Results.MaybeAddResult(R, CurContext);
// Provide additional block setter completion iff the base expression is a
// statement and the block property is mutable.
if (!P->isReadOnly()) {
CodeCompletionBuilder Builder(Results.getAllocator(),
Results.getCodeCompletionTUInfo());
AddResultTypeChunk(Container->getASTContext(),
getCompletionPrintingPolicy(Results.getSema()), P,
CCContext.getBaseType(), Builder);
Builder.AddTypedTextChunk(
Results.getAllocator().CopyString(P->getName()));
Builder.AddChunk(CodeCompletionString::CK_Equal);
std::string PlaceholderStr = formatBlockPlaceholder(
getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
BlockProtoLoc, /*SuppressBlockName=*/true);
// Add the placeholder string.
Builder.AddPlaceholderChunk(
Builder.getAllocator().CopyString(PlaceholderStr));
// When completing blocks properties that return void the default
// property completion result should show up before the setter,
// otherwise the setter completion should show up before the default
// property completion, as we normally want to use the result of the
// call.
Result R =
Result(Builder.TakeString(), P,
Results.getBasePriority(P) +
(BlockLoc.getTypePtr()->getReturnType()->isVoidType()
? CCD_BlockPropertySetter
: -CCD_BlockPropertySetter));
if (!InOriginalClass)
setInBaseClass(R);
Results.MaybeAddResult(R, CurContext);
}
};
if (IsClassProperty) {
for (const auto *P : Container->class_properties())
AddProperty(P);
} else {
for (const auto *P : Container->instance_properties())
AddProperty(P);
}
// Add nullary methods or implicit class properties
if (AllowNullaryMethods) {
ASTContext &Context = Container->getASTContext();
PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
// Adds a method result
const auto AddMethod = [&](const ObjCMethodDecl *M) {
const IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
if (!Name)
return;
if (!AddedProperties.insert(Name).second)
return;
CodeCompletionBuilder Builder(Results.getAllocator(),
Results.getCodeCompletionTUInfo());
AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
Builder.AddTypedTextChunk(
Results.getAllocator().CopyString(Name->getName()));
Result R = Result(Builder.TakeString(), M,
CCP_MemberDeclaration + CCD_MethodAsProperty);
if (!InOriginalClass)
setInBaseClass(R);
Results.MaybeAddResult(R, CurContext);
};
if (IsClassProperty) {
for (const auto *M : Container->methods()) {
// Gather the class method that can be used as implicit property
// getters. Methods with arguments or methods that return void aren't
// added to the results as they can't be used as a getter.
if (!M->getSelector().isUnarySelector() ||
M->getReturnType()->isVoidType() || M->isInstanceMethod())
continue;
AddMethod(M);
}
} else {
for (auto *M : Container->methods()) {
if (M->getSelector().isUnarySelector())
AddMethod(M);
}
}
}
// Add properties in referenced protocols.
if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
for (auto *P : Protocol->protocols())
AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
CurContext, AddedProperties, Results,
IsBaseExprStatement, IsClassProperty,
/*InOriginalClass*/ false);
} else if (ObjCInterfaceDecl *IFace =
dyn_cast<ObjCInterfaceDecl>(Container)) {
if (AllowCategories) {
// Look through categories.
for (auto *Cat : IFace->known_categories())
AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
CurContext, AddedProperties, Results,
IsBaseExprStatement, IsClassProperty,
InOriginalClass);
}
// Look through protocols.
for (auto *I : IFace->all_referenced_protocols())
AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
CurContext, AddedProperties, Results,
IsBaseExprStatement, IsClassProperty,
/*InOriginalClass*/ false);
// Look in the superclass.
if (IFace->getSuperClass())
AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
AllowNullaryMethods, CurContext, AddedProperties,
Results, IsBaseExprStatement, IsClassProperty,
/*InOriginalClass*/ false);
} else if (const auto *Category =
dyn_cast<ObjCCategoryDecl>(Container)) {
// Look through protocols.
for (auto *P : Category->protocols())
AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
CurContext, AddedProperties, Results,
IsBaseExprStatement, IsClassProperty,
/*InOriginalClass*/ false);
}
} | 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
movb %al, (%rbp)
movq %rsi, %rdi
callq 0x7efff8
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movq %r12, 0x10(%rsp)
movq %r12, 0x70(%rsp)
movq %rbx, 0x78(%rsp)
movq %r15, 0x80(%rsp)
movq %rbp, 0x88(%rsp)
movq %r14, 0x90(%rsp)
movq %rcx, 0x98(%rsp)
movq %r13, %r14
movq %r13, 0xa0(%rsp)
movq %rax, %rdi
cmpb $0x0, 0x100(%rsp)
je 0x7e2b39
callq 0x7f8900
movq %rax, %rsi
movq %rdx, %r15
leaq 0x38(%rsp), %r12
movq %rax, (%r12)
leaq 0x70(%rsp), %r13
cmpq %r15, %rsi
je 0x7e2b6e
movq %r13, %rdi
callq 0x7f8926
movq %r12, %rdi
callq 0x7f9000
movq 0x38(%rsp), %rsi
jmp 0x7e2b1d
callq 0x7f13f0
movq %rax, %rsi
movq %rdx, %r15
leaq 0x38(%rsp), %r12
movq %rax, (%r12)
leaq 0x70(%rsp), %r13
cmpq %r15, %rsi
je 0x7e2b6e
movq %r13, %rdi
callq 0x7f8926
movq %r12, %rdi
callq 0x7f42fa
movq 0x38(%rsp), %rsi
jmp 0x7e2b52
cmpb $0x0, 0x8(%rsp)
je 0x7e2c76
movq 0x30(%rsp), %rdi
callq 0xe1952c
movq %rax, %r15
movq 0xf0(%rsp), %rbx
movq 0xb8(%rbx), %rdi
callq 0x7daf17
leaq 0xa8(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq %r15, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %r14, 0x58(%rsp)
movq %rbp, 0x60(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x30(%rsp), %rdi
callq 0x6d9e9c
movq %rax, %r13
movq %rdx, %r12
leaq 0x28(%rsp), %r15
cmpb $0x0, 0x100(%rsp)
je 0x7e2c43
movq %r13, (%r15)
leaq 0x38(%rsp), %rbp
cmpq %r12, %r13
je 0x7e2c76
movl 0x28(%r13), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7e2c34
movq 0x50(%r13), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x79b9a8
testb %al, %al
jne 0x7e2c34
testb $0x2, 0x3a(%r13)
jne 0x7e2c34
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7f901c
movq %r15, %rdi
callq 0x6d9ec2
movq 0x28(%rsp), %r13
jmp 0x7e2bfd
movq %r13, (%r15)
leaq 0x38(%rsp), %rbp
cmpq %r12, %r13
je 0x7e2c76
movl 0x28(%r13), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7e2c67
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7f901c
movq %r15, %rdi
callq 0x6d9ec2
movq 0x28(%rsp), %r13
jmp 0x7e2c4b
movq 0x30(%rsp), %rdi
movl 0x1c(%rdi), %eax
andl $0x7f, %eax
cmpl $0x10, %eax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
je 0x7e2d27
testq %rdi, %rdi
sete %cl
cmpl $0x11, %eax
setne %dl
orb %cl, %dl
je 0x7e2d82
testq %rdi, %rdi
sete %cl
cmpl $0x14, %eax
setne %al
orb %cl, %al
jne 0x7e2e98
movq 0x68(%rdi), %rax
movq %rax, 0x20(%rsp)
movl 0x70(%rdi), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
movzbl 0x100(%rsp), %ebx
movzbl 0xc(%rsp), %ebp
movzbl 0x8(%rsp), %r15d
cmpq %r13, %r12
je 0x7e2e98
movq 0x20(%rsp), %rax
movq (%rax,%r13), %rsi
movq 0x18(%rsp), %r8
movzbl 0x6(%rsp), %eax
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %ecx
movq 0x10(%rsp), %r9
pushq $0x0
pushq %rbx
pushq %rax
pushq 0x108(%rsp)
callq 0x7e2a61
addq $0x20, %rsp
addq $0x8, %r13
jmp 0x7e2ce4
callq 0x4d26d4
movq %rax, %r15
movq %rdx, %r12
movzbl 0x100(%rsp), %ebx
movzbl 0xc(%rsp), %ebp
movzbl 0x8(%rsp), %r13d
cmpq %r12, %r15
je 0x7e2e98
movq (%r15), %rsi
movq 0x18(%rsp), %r8
movzbl 0x6(%rsp), %eax
movq %r14, %rdi
movl %ebp, %edx
movl %r13d, %ecx
movq 0x10(%rsp), %r9
pushq $0x0
pushq %rbx
pushq %rax
pushq 0x108(%rsp)
callq 0x7e2a61
addq $0x20, %rsp
addq $0x8, %r15
jmp 0x7e2d45
movq %rdi, 0x20(%rsp)
cmpb $0x0, 0xc(%rsp)
je 0x7e2df1
movq 0x20(%rsp), %rdi
callq 0x707a5a
movq %rax, %r15
movq %rdx, %r13
movzbl 0x100(%rsp), %ebx
movzbl 0x8(%rsp), %ebp
pushq $0x1
popq %r12
cmpq %r13, %r15
je 0x7e2df1
movq 0x18(%rsp), %r8
movzbl 0x6(%rsp), %eax
movzbl 0x7(%rsp), %r10d
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq 0x10(%rsp), %r9
pushq %r10
pushq %rbx
pushq %rax
pushq 0x108(%rsp)
callq 0x7e2a61
addq $0x20, %rsp
movq 0x80(%r15), %r15
jmp 0x7e2daf
movq 0x20(%rsp), %rdi
callq 0x7f9196
movq %rax, %r13
movq %rdx, %r12
movzbl 0x100(%rsp), %ebx
movzbl 0xc(%rsp), %r15d
movzbl 0x8(%rsp), %ebp
cmpq %r12, %r13
je 0x7e2e4e
movq (%r13), %rsi
movq 0x18(%rsp), %r8
movzbl 0x6(%rsp), %eax
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movq 0x10(%rsp), %r9
pushq $0x0
pushq %rbx
pushq %rax
pushq 0x108(%rsp)
callq 0x7e2a61
addq $0x20, %rsp
addq $0x8, %r13
jmp 0x7e2e14
movq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xe27d6a
testq %rax, %rax
je 0x7e2e98
movq %r12, %rdi
callq 0xe27d6a
movq 0x18(%rsp), %r8
movzbl 0x6(%rsp), %r10d
movq %r14, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl %ebp, %ecx
movq 0x10(%rsp), %r9
pushq $0x0
pushq %rbx
pushq %r10
pushq 0x108(%rsp)
callq 0x7e2a61
addq $0x20, %rsp
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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>())
: Declaration(Declaration), Priority(Priority), Kind(RK_Declaration),
FixIts(std::move(FixIts)), Hidden(false), InBaseClass(false),
QualifierIsInformative(QualifierIsInformative),
StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
DeclaringEntity(false), FunctionCanBeCall(true), Qualifier(Qualifier) {
// FIXME: Add assert to check FixIts range requirements.
computeCursorKindAndAvailability(Accessible);
} | 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, %r8b
orb $0x40, %r8b
movb %r8b, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movups %xmm0, 0x50(%rdi)
movl %r9d, %esi
jmp 0x758cb2
| /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 = getCompletionPrintingPolicy(S);
Builder.AddResultTypeChunk(
GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator));
Builder.AddTypedTextChunk("this");
Results.AddResult(CodeCompletionResult(Builder.TakeString()));
} | 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 %xmm0, -0x30(%rcx)
movups %xmm0, -0x20(%rcx)
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
leaq 0x108(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x200000000, %rcx # imm = 0x200000000
movq %rcx, -0x8(%rax)
movq %r15, %rdi
callq 0x7daf17
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
movq %r12, %rdx
callq 0x7f0550
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x757ff6
leaq 0xa3b0ce(%rip), %rsi # 0x12252d0
movq %r14, %rdi
callq 0x757f24
movq %r14, %rdi
callq 0x757eb0
leaq 0x40(%rsp), %r15
andq $0x0, -0x28(%r15)
movq %rax, -0x20(%r15)
movaps 0xa2a699(%rip), %xmm0 # 0x12148c0
movups %xmm0, -0x18(%r15)
andl $0x0, -0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movb $0x40, 0x18(%r15)
movups %xmm0, 0x20(%r15)
andq $0x0, 0x30(%r15)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7f7190
movq %r15, %rdi
callq 0x4f12d6
movq %r14, %rdi
callq 0x4f1b80
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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.
CDecl = CurMethod->getClassInterface();
if (!CDecl)
return;
// Find the superclass of this class.
CDecl = CDecl->getSuperClass();
if (!CDecl)
return;
if (CurMethod->isInstanceMethod()) {
// We are inside an instance method, which means that the message
// send [super ...] is actually calling an instance method on the
// current object.
return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
AtArgumentExpression, CDecl);
}
// Fall through to send to the superclass in CDecl.
} else {
// "super" may be the name of a type or variable. Figure out which
// it is.
const IdentifierInfo *Super = SemaRef.getSuperIdentifier();
NamedDecl *ND =
SemaRef.LookupSingleName(S, Super, SuperLoc, Sema::LookupOrdinaryName);
if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
// "super" names an interface. Use it.
} else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
if (const ObjCObjectType *Iface =
getASTContext().getTypeDeclType(TD)->getAs<ObjCObjectType>())
CDecl = Iface->getInterface();
} else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
// "super" names an unresolved type; we can't be more specific.
} else {
// Assume that "super" names some kind of value and parse that way.
CXXScopeSpec SS;
SourceLocation TemplateKWLoc;
UnqualifiedId id;
id.setIdentifier(Super, SuperLoc);
ExprResult SuperExpr =
SemaRef.ActOnIdExpression(S, SS, TemplateKWLoc, id,
/*HasTrailingLParen=*/false,
/*IsAddressOfOperand=*/false);
return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
SelIdents, AtArgumentExpression);
}
// Fall through
}
ParsedType Receiver;
if (CDecl)
Receiver = ParsedType::make(getASTContext().getObjCInterfaceType(CDecl));
return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
AtArgumentExpression,
/*IsSuper=*/true);
} | 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 0x7edf06
movq %rax, %rdi
callq 0xe27d6a
testq %rax, %rax
je 0x7edf06
movq %rax, %rbx
testb $0x2, 0x3a(%r14)
je 0x7eddf8
movq %rbx, (%rsp)
movzbl %bpl, %r9d
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x7e1216
jmp 0x7edf06
movq (%r12), %rdi
callq 0x78d152
movq %rax, %r14
movq (%r12), %rdi
movq %r15, %rsi
movq %rax, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xa59312
testq %rax, %rax
je 0x7ede89
movq %rax, %rbx
movl 0x1c(%rax), %eax
andl $0x7f, %eax
cmpl $0x11, %eax
jne 0x7ede38
movq %r12, %rdi
callq 0x7a6c24
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xdae280
movq %rax, %r14
movl $0x1, (%rsp)
movzbl %bpl, %r9d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x7edf44
jmp 0x7edf06
leal -0x37(%rax), %ecx
cmpl $0x9, %ecx
ja 0x7ede7f
movq %r12, %rdi
callq 0x7a6c24
xorl %r14d, %r14d
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x7344c0
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4eda7e
testq %rax, %rax
je 0x7ede10
movq %rax, %rdi
callq 0x7edf18
movq %rax, %rbx
testq %rax, %rax
jne 0x7eddf8
jmp 0x7ede84
cmpl $0x3c, %eax
jne 0x7ede89
xorl %r14d, %r14d
jmp 0x7ede10
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x68(%rsp), %r8
andl $0x0, (%r8)
movq %r14, 0x8(%r8)
movl %r13d, 0x1c(%r8)
movl %r13d, 0x18(%r8)
movq (%r12), %rdi
andq $0x0, 0x18(%rsp)
andl $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x90c960
andq $-0x2, %rax
andq $0x0, (%rsp)
movzbl %bpl, %r9d
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x7e1216
leaq 0x38(%rsp), %rdi
callq 0x4f0656
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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::PointerLikeTypeTraits<clang::ObjCMethodDecl*>>>, llvm::DenseMapInfo<clang::Selector, void>, llvm::detail::DenseMapPair<clang::Selector, llvm::PointerIntPair<clang::ObjCMethodDecl*, 1u, bool, llvm::PointerLikeTypeTraits<clang::ObjCMethodDecl*>, llvm::PointerIntPairInfo<clang::ObjCMethodDecl*, 1u, llvm::PointerLikeTypeTraits<clang::ObjCMethodDecl*>>>>>&, bool) | static void FindImplementableMethods(ASTContext &Context,
ObjCContainerDecl *Container,
std::optional<bool> WantInstanceMethods,
QualType ReturnType,
KnownMethodsMap &KnownMethods,
bool InOriginalClass = true) {
if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
// Make sure we have a definition; that's what we'll walk.
if (!IFace->hasDefinition())
return;
IFace = IFace->getDefinition();
Container = IFace;
const ObjCList<ObjCProtocolDecl> &Protocols =
IFace->getReferencedProtocols();
for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
E = Protocols.end();
I != E; ++I)
FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
KnownMethods, InOriginalClass);
// Add methods from any class extensions and categories.
for (auto *Cat : IFace->visible_categories()) {
FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
KnownMethods, false);
}
// Visit the superclass.
if (IFace->getSuperClass())
FindImplementableMethods(Context, IFace->getSuperClass(),
WantInstanceMethods, ReturnType, KnownMethods,
false);
}
if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
// Recurse into protocols.
const ObjCList<ObjCProtocolDecl> &Protocols =
Category->getReferencedProtocols();
for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
E = Protocols.end();
I != E; ++I)
FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
KnownMethods, InOriginalClass);
// If this category is the original class, jump to the interface.
if (InOriginalClass && Category->getClassInterface())
FindImplementableMethods(Context, Category->getClassInterface(),
WantInstanceMethods, ReturnType, KnownMethods,
false);
}
if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
// Make sure we have a definition; that's what we'll walk.
if (!Protocol->hasDefinition())
return;
Protocol = Protocol->getDefinition();
Container = Protocol;
// Recurse into protocols.
const ObjCList<ObjCProtocolDecl> &Protocols =
Protocol->getReferencedProtocols();
for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
E = Protocols.end();
I != E; ++I)
FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
KnownMethods, false);
}
// Add methods in this container. This operation occurs last because
// we want the methods from this container to override any methods
// we've previously seen with the same selector.
for (auto *M : Container->methods()) {
if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
if (!ReturnType.isNull() &&
!Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
continue;
KnownMethods[M->getSelector()] =
KnownMethodsMap::mapped_type(M, InOriginalClass);
}
}
} | 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
callq 0x4d28e0
testb %al, %al
je 0x7f1274
movl %r12d, 0x4(%rsp)
movq %r15, %rdi
callq 0x67b87e
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x80907c
movq (%rax), %r15
movl 0x8(%rax), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7f1086
movq (%r15,%r13), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x10(%rsp), %r8
callq 0x7f0fef
addq $0x8, %r13
jmp 0x7f1065
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7efb3c
movq %rax, %rdi
movq %rdx, %r13
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
cmpq %r13, %rdi
je 0x7f10c6
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x7f0fef
movq %r12, %rdi
callq 0x7efb46
movq 0x18(%rsp), %rdi
jmp 0x7f10a2
movq %r15, %rdi
callq 0xe27d6a
testq %rax, %rax
je 0x7f10ee
movq %r15, %rdi
callq 0xe27d6a
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x7f0fef
movl 0x4(%rsp), %r12d
testq %r15, %r15
je 0x7f1166
movl 0x1c(%r15), %eax
andl $0x7f, %eax
cmpl $0x14, %eax
jne 0x7f1166
movl %r12d, 0x4(%rsp)
movq %r15, %rax
movq 0x68(%r15), %r15
movq %rax, 0x8(%rsp)
movl 0x70(%rax), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7f1141
movq (%r15,%r13), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x10(%rsp), %r8
callq 0x7f0fef
addq $0x8, %r13
jmp 0x7f1120
cmpb $0x0, 0x4(%rsp)
movq 0x8(%rsp), %r15
je 0x7f1166
movq 0x58(%r15), %rdi
testq %rdi, %rdi
je 0x7f1166
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x7f0fef
testq %r15, %r15
je 0x7f11cf
movl 0x1c(%r15), %eax
andl $0x7f, %eax
cmpl $0x10, %eax
jne 0x7f11cf
movq %r15, %rdi
callq 0x4d273e
testb %al, %al
je 0x7f1274
movq %r15, %rdi
callq 0x67d42a
movq %rax, 0x8(%rsp)
movq 0x68(%rax), %rax
andq $-0x8, %rax
movq 0x8(%rax), %r15
movl 0x10(%rax), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7f11ca
movq (%r15,%r13), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x7f0fef
addq $0x8, %r13
jmp 0x7f11ab
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6d9e9c
movq %rdx, %r12
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq %r14, %rcx
andq $-0x10, %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
shll $0x2, %ecx
movq %rcx, 0x10(%rsp)
cmpq %r12, %rax
je 0x7f1274
btl $0x8, %ebp
jae 0x7f1214
movb 0x3a(%rax), %cl
shrb %cl
andb $0x1, %cl
cmpb %bpl, %cl
jne 0x7f1265
cmpq $0x10, %r14
jb 0x7f123f
movq 0x50(%rax), %rcx
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
andq $-0x10, %rdx
movq (%rdx), %rdx
andq $-0x10, %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
cmpq (%rcx), %rdx
jne 0x7f1265
movq %rax, %r15
andq $-0x5, %r15
orq 0x10(%rsp), %r15
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
callq 0x8090a2
movq %r15, 0x8(%rax)
movq %r13, %rdi
callq 0x6d9ec2
movq 0x18(%rsp), %rax
jmp 0x7f11fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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::Stmt*>>>>*) | 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 we need are the default actions. FIXME: use a helper function.
for (Stmt *SubStmt : S->children()) {
TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt);
}
if (!Queue && getDerived().shouldTraversePostOrder())
TRY_TO(WalkUpFromInitListExpr(S));
}
return true;
} | 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(%r12)
movq %rax, (%r12)
cmpq %r13, %rax
jne 0x80806e
cmpq $0x0, 0x10(%rsp)
je 0x808099
movq %r12, %rdi
callq 0x4cf280
movq (%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x7fb470
testb %al, %al
je 0x808097
movq %r12, %rdi
callq 0x4cf28e
movq 0x8(%rsp), %rax
jmp 0x808061
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /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 0x808170
movq 0x10(%rbx), %rax
movl (%rax), %ecx
movl 0x10(%rax), %r15d
movl %ecx, %edx
shrl $0x18, %edx
addq %rax, %rdx
shrl $0xf, %ecx
andl $0x8, %ecx
leaq (%rcx,%rdx), %r12
addq $0x8, %r12
shlq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x808164
movq (%r12,%r13), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x6e4df2
addq $0x8, %r13
jmp 0x808115
cmpq %rsi, 0x20(%rbx)
jne 0x80813f
movq 0x28(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x802e30
leaq 0x10(%rsp), %rdi
callq 0x80328a
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rax
cmpq 0x20(%rbx), %rax
jne 0x80813f
jmp 0x808136
| /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 %al, %al
jne 0x80940f
movq %r15, %rdi
callq 0xe27d6a
movq %rax, %r15
jmp 0x8093d0
testq %r15, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /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(Normalized.getRHS());
if (Normalized.getCompoundKind() == NormalizedConstraint::CCK_Disjunction) {
LDNF.reserve(LDNF.size() + RDNF.size());
while (!RDNF.empty())
LDNF.push_back(RDNF.pop_back_val());
return LDNF;
}
// Conjunction
NormalForm Res;
Res.reserve(LDNF.size() * RDNF.size());
for (auto &LConjunction : LDNF) {
for (auto &RConjunction : RDNF) {
NormalForm::value_type Combined;
Combined.reserve(LConjunction.size() + RConjunction.size());
std::copy(LConjunction.begin(), LConjunction.end(),
std::back_inserter(Combined));
std::copy(RConjunction.begin(), RConjunction.end(),
std::back_inserter(Combined));
Res.emplace_back(Combined);
}
}
return Res;
} | 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
andq $-0x8, %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x80cecf
testb $0x4, (%r14)
jne 0x80d054
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x8(%rbx)
movl 0xc0(%rsp), %eax
movl 0x30(%rsp), %esi
imulq %rax, %rsi
movq %rbx, %r13
movq %rbx, %rdi
callq 0x80cde2
movq 0xb8(%rsp), %r15
movl 0xc0(%rsp), %eax
shlq $0x5, %rax
addq %r15, %rax
movq %rax, (%rsp)
movabsq $0x200000000, %rbp # imm = 0x200000000
leaq 0x8(%rsp), %r14
cmpq (%rsp), %r15
je 0x80d0b3
movq 0x28(%rsp), %r12
movl 0x30(%rsp), %ebx
shlq $0x5, %rbx
testq %rbx, %rbx
je 0x80d00d
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movl 0x8(%r15), %eax
movl 0x8(%r12), %esi
addq %rax, %rsi
movq %r14, %rdi
callq 0x80ce68
movq (%r15), %rdi
movl 0x8(%r15), %eax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x8116e0
movq (%r12), %rdi
movl 0x8(%r12), %eax
leaq (%rdi,%rax,8), %rsi
movq %r14, %rdx
callq 0x8116e0
movq %r13, %rdi
movq %r14, %rsi
callq 0x80ce76
movq %r14, %rdi
callq 0x8110bc
addq $0x20, %r12
addq $-0x20, %rbx
jmp 0x80cfa0
addq $0x20, %r15
jmp 0x80cf89
orq $0x4, %rsi
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
leaq 0xb8(%rsp), %r14
pushq $0x1
popq %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x80cdaa
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x80cdc8
movq %r14, %rdi
callq 0x8110bc
jmp 0x80d0cd
leaq 0xb8(%rsp), %r14
movl 0x8(%r14), %eax
leaq 0x28(%rsp), %r15
movl 0x8(%r15), %esi
addq %rax, %rsi
movq %r14, %rdi
callq 0x80cde2
leaq 0x8(%rsp), %r12
cmpl $0x0, 0x30(%rsp)
je 0x80d0a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x80ce14
movq %r14, %rdi
movq %r12, %rsi
callq 0x80cdf0
movq %r12, %rdi
callq 0x8110bc
jmp 0x80d079
leaq 0xb8(%rsp), %rsi
movq %rbx, %r13
movq %rbx, %rdi
callq 0x80ce48
leaq 0x28(%rsp), %rdi
callq 0x80ceb0
leaq 0xb8(%rsp), %rdi
callq 0x80ceb0
movq %r13, %rbx
movq %rbx, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 NormalExprEvaluator =
[this] (const AtomicConstraint &A, const AtomicConstraint &B) {
return A.subsumes(Context, B);
};
const Expr *AmbiguousAtomic1 = nullptr, *AmbiguousAtomic2 = nullptr;
auto IdenticalExprEvaluator =
[&] (const AtomicConstraint &A, const AtomicConstraint &B) {
if (!A.hasMatchingParameterMapping(Context, B))
return false;
const Expr *EA = A.ConstraintExpr, *EB = B.ConstraintExpr;
if (EA == EB)
return true;
// Not the same source level expression - are the expressions
// identical?
llvm::FoldingSetNodeID IDA, IDB;
EA->Profile(IDA, Context, /*Canonical=*/true);
EB->Profile(IDB, Context, /*Canonical=*/true);
if (IDA != IDB)
return false;
AmbiguousAtomic1 = EA;
AmbiguousAtomic2 = EB;
return true;
};
{
// The subsumption checks might cause diagnostics
SFINAETrap Trap(*this);
auto *Normalized1 = getNormalizedAssociatedConstraints(D1, AC1);
if (!Normalized1)
return false;
const NormalForm DNF1 = makeDNF(*Normalized1);
const NormalForm CNF1 = makeCNF(*Normalized1);
auto *Normalized2 = getNormalizedAssociatedConstraints(D2, AC2);
if (!Normalized2)
return false;
const NormalForm DNF2 = makeDNF(*Normalized2);
const NormalForm CNF2 = makeCNF(*Normalized2);
bool Is1AtLeastAs2Normally =
clang::subsumes(DNF1, CNF2, NormalExprEvaluator);
bool Is2AtLeastAs1Normally =
clang::subsumes(DNF2, CNF1, NormalExprEvaluator);
bool Is1AtLeastAs2 = clang::subsumes(DNF1, CNF2, IdenticalExprEvaluator);
bool Is2AtLeastAs1 = clang::subsumes(DNF2, CNF1, IdenticalExprEvaluator);
if (Is1AtLeastAs2 == Is1AtLeastAs2Normally &&
Is2AtLeastAs1 == Is2AtLeastAs1Normally)
// Same result - no ambiguity was caused by identical atomic expressions.
return false;
}
// A different result! Some ambiguous atomic constraint(s) caused a difference
assert(AmbiguousAtomic1 && AmbiguousAtomic2);
Diag(AmbiguousAtomic1->getBeginLoc(), diag::note_ambiguous_atomic_constraints)
<< AmbiguousAtomic1->getSourceRange();
Diag(AmbiguousAtomic2->getBeginLoc(),
diag::note_ambiguous_atomic_constraints_similar_expression)
<< AmbiguousAtomic2->getSourceRange();
return true;
} | 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 %r15, %r15
je 0x80d849
movq %rbp, 0x10(%rsp)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
movq %rsp, %rcx
andq $0x0, (%rcx)
movq %rbx, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %edx, %edx
callq 0x636b5e
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x80c15a
testq %rax, %rax
je 0x80d878
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
movq %rax, %rsi
callq 0x80cecf
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x80cb8f
leaq 0x2c0(%rsp), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rcx
callq 0x80c15a
testq %rax, %rax
je 0x80d85f
movq %rax, %r12
leaq 0x1f8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x80cecf
leaq 0x168(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x80cb8f
leaq 0xd8(%rsp), %rdi
leaq 0x18(%rsp), %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x80d923
movl %eax, %r14d
leaq 0x48(%rsp), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x80d923
movl %eax, %r13d
leaq 0x20(%rsp), %r12
leaq 0xd8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x80dadf
movl %eax, %r15d
movq %rbp, %rdi
leaq 0x48(%rsp), %rsi
movq %r12, %rdx
callq 0x80dadf
movl %eax, %ebp
xorb %r14b, %r15b
xorb %r13b, %bpl
orb %r15b, %bpl
leaq 0x168(%rsp), %rdi
callq 0x80ceb0
leaq 0x1f8(%rsp), %rdi
callq 0x80ceb0
jmp 0x80d861
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
leaq 0x48(%rsp), %rdi
callq 0x80ceb0
leaq 0xd8(%rsp), %rdi
callq 0x80ceb0
leaq 0x38(%rsp), %rdi
callq 0x636bb8
testb %bpl, %bpl
je 0x80d84b
addq $0x8, %rbx
movq 0x8(%rsp), %rdi
callq 0xf67aee
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x14fa, %ecx # imm = 0x14FA
xorl %r8d, %r8d
callq 0x7a6d9e
movq 0x8(%rsp), %rdi
callq 0xf67396
leaq 0x48(%rsp), %r14
movq %rax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
movq (%rsp), %rdi
callq 0xf67aee
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x14fb, %ecx # imm = 0x14FB
xorl %r8d, %r8d
callq 0x7a6d9e
movq (%rsp), %rdi
callq 0xf67396
movq %rax, (%r14)
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
jmp 0x80d84b
| /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 (substituteParameterMappings(S, N.getLHS(), Concept, MLTAL,
ArgsAsWritten))
return true;
return substituteParameterMappings(S, N.getRHS(), Concept, MLTAL,
ArgsAsWritten);
}
if (N.isFoldExpanded()) {
Sema::ArgumentPackSubstitutionIndexRAII _(S, -1);
return substituteParameterMappings(
S, N.getFoldExpandedConstraint()->Constraint, Concept, MLTAL,
ArgsAsWritten);
}
TemplateParameterList *TemplateParams = Concept->getTemplateParameters();
AtomicConstraint &Atomic = *N.getAtomicConstraint();
TemplateArgumentListInfo SubstArgs;
if (!Atomic.ParameterMapping) {
llvm::SmallBitVector OccurringIndices(TemplateParams->size());
S.MarkUsedTemplateParameters(Atomic.ConstraintExpr, /*OnlyDeduced=*/false,
/*Depth=*/0, OccurringIndices);
TemplateArgumentLoc *TempArgs =
new (S.Context) TemplateArgumentLoc[OccurringIndices.count()];
for (unsigned I = 0, J = 0, C = TemplateParams->size(); I != C; ++I)
if (OccurringIndices[I])
new (&(TempArgs)[J++])
TemplateArgumentLoc(S.getIdentityTemplateArgumentLoc(
TemplateParams->begin()[I],
// Here we assume we do not support things like
// template<typename A, typename B>
// concept C = ...;
//
// template<typename... Ts> requires C<Ts...>
// struct S { };
// The above currently yields a diagnostic.
// We still might have default arguments for concept parameters.
ArgsAsWritten->NumTemplateArgs > I
? ArgsAsWritten->arguments()[I].getLocation()
: SourceLocation()));
Atomic.ParameterMapping.emplace(TempArgs, OccurringIndices.count());
}
SourceLocation InstLocBegin =
ArgsAsWritten->arguments().empty()
? ArgsAsWritten->getLAngleLoc()
: ArgsAsWritten->arguments().front().getSourceRange().getBegin();
SourceLocation InstLocEnd =
ArgsAsWritten->arguments().empty()
? ArgsAsWritten->getRAngleLoc()
: ArgsAsWritten->arguments().front().getSourceRange().getEnd();
Sema::InstantiatingTemplate Inst(
S, InstLocBegin,
Sema::InstantiatingTemplate::ParameterMappingSubstitution{}, Concept,
{InstLocBegin, InstLocEnd});
if (Inst.isInvalid())
return true;
if (S.SubstTemplateArguments(*Atomic.ParameterMapping, MLTAL, SubstArgs))
return true;
TemplateArgumentLoc *TempArgs =
new (S.Context) TemplateArgumentLoc[SubstArgs.size()];
std::copy(SubstArgs.arguments().begin(), SubstArgs.arguments().end(),
TempArgs);
Atomic.ParameterMapping.emplace(TempArgs, SubstArgs.size());
return false;
} | 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 %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x80fc8c
testb %al, %al
jne 0x80fe91
movq (%rbp), %rbp
andq $-0x8, %rbp
addq $0x8, %rbp
jmp 0x80fcac
cmpl $0x1, %eax
jne 0x80fd29
movl 0x3218(%r12), %ebx
orl $-0x1, 0x3218(%r12)
movq (%rbp), %rsi
andq $-0x4, %rsi
addq $0x8, %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x80fc8c
movl %ebx, 0x3218(%r12)
jmp 0x80ffd1
movq 0x38(%r15), %rbp
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
andq $0x0, 0x100(%rax)
andq $-0x4, %rbx
cmpb $0x0, 0x18(%rbx)
jne 0x80fecd
movq %r15, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movl $0x1fffffff, %esi # imm = 0x1FFFFFFF
andl 0xc(%rbp), %esi
leaq 0x18(%rsp), %r14
movq $0x0, 0x10(%rsp)
movq %r14, %rdi
xorl %edx, %edx
callq 0x689296
movq (%rbx), %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0xbb20cc
movq %r14, %rdi
callq 0x80ffe4
movq %rax, %r15
shrq $0x3b, %rax
movq %r15, %r14
shlq $0x5, %r14
negq %rax
movl $0x0, %esi
sbbq %rsi, %rsi
orq %r14, %rsi
movl $0x850, %edi # imm = 0x850
movq %r12, 0x8(%rsp)
addq 0x100(%r12), %rdi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, (%rsp)
testq %r15, %r15
je 0x80fdfa
movq (%rsp), %rax
addq %rax, %r14
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
andq $0x0, 0x18(%rax)
addq $0x20, %rax
cmpq %r14, %rax
jne 0x80fde4
movq %rbp, 0x48(%rsp)
movl 0xc(%rbp), %r12d
andl $0x1fffffff, %r12d # imm = 0x1FFFFFFF
leaq 0x10(%r13), %rbp
leaq 0x20(%rsp), %r15
xorl %r14d, %r14d
movq %r12, 0x40(%rsp)
cmpq %r14, %r12
je 0x80fe99
leaq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movl %r14d, 0x28(%rsp)
movq %r15, %rdi
callq 0x6892f4
testb %al, %al
je 0x80fe88
movq %r15, %r12
movq 0x48(%rsp), %rax
movq 0x10(%rax,%r14,8), %r15
movl 0x8(%r13), %eax
xorl %ecx, %ecx
cmpq %rax, %r14
jae 0x80fe5d
movq %rbp, %rdi
callq 0x81006a
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %eax, %edi
incl %eax
movq %rax, 0x10(%rsp)
shlq $0x5, %rdi
addq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xba8a2e
movq %r12, %r15
movq 0x40(%rsp), %r12
incq %r14
addq $0x20, %rbp
jmp 0x80fe1b
movb $0x1, %bpl
jmp 0x80ffcf
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x80ffe4
movq (%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
movq %r15, %rdi
callq 0x689302
movq 0x8(%rsp), %r12
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %r15
cmpl $0x0, 0x8(%r13)
je 0x80feec
movq %r15, %rbp
addq $0x10, %r13
movq %r13, %rdi
callq 0xf8d630
movq %rax, %rdx
shrq $0x20, %rax
jmp 0x80fef7
movq %r15, %rbp
movl (%r13), %edx
movl 0x4(%r13), %eax
shlq $0x20, %rax
movl %edx, %r8d
orq %rax, %r8
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rcx
callq 0xc09fa4
movb $0x1, %bpl
cmpb $0x0, 0x8(%r15)
jne 0x80ffbb
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x50(%rsp), %r8
movq %r12, %rdi
movq %r14, %rcx
callq 0xc10740
testb %al, %al
jne 0x80ffbb
movq %r12, %rax
movl 0x58(%rsp), %r12d
movq %r12, %r15
shlq $0x5, %r15
movl $0x850, %edi # imm = 0x850
addq 0x100(%rax), %rdi
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x467060
movq %rax, %r14
testq %r12, %r12
je 0x80ff8b
movq %r14, %rax
addq %r15, %rax
movq %r14, %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
andq $0x0, 0x18(%rcx)
addq $0x20, %rcx
cmpq %rax, %rcx
jne 0x80ff75
movl 0x58(%rsp), %edx
testq %rdx, %rdx
je 0x80ffab
movq 0x50(%rsp), %rsi
shlq $0x5, %rdx
movq %r14, %rdi
callq 0x436140
movl 0x58(%rsp), %eax
jmp 0x80ffad
xorl %eax, %eax
movq %r14, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdi
callq 0xc0a0de
leaq 0x50(%rsp), %rdi
callq 0x6d9e52
movl %ebp, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %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 0x811044
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x464066
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x791242
nop
| /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();
unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);
if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
SubStmt.get() == E->getSubStmt()) {
// Calling this an 'error' is unintuitive, but it does the right thing.
SemaRef.ActOnStmtExprError();
return SemaRef.MaybeBindToTemporary(E);
}
return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
E->getRParenLoc(), NewDepth);
} | 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
movq (%r14), %rdi
andq $-0x2, %rax
cmpl $-0x1, 0x3218(%rdi)
jne 0x811f28
cmpq %rax, 0x10(%rbx)
je 0x811f3d
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %ecx
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9308f6
callq 0x92fe88
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9c58aa
| /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(SubExpr.get(), E->getLParen(),
E->getRParen());
} | 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 0x10(%rbx), %edx
movl 0x14(%rbx), %ecx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8219f2
nop
| /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;
if (!E->expandsToEmptyPack() && E->getExpressions().empty()) {
Expr *Pattern = E->getPackIdExpression();
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(E->getPackIdExpression(),
Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
// Determine whether the set of unexpanded parameter packs can and should
// be expanded.
bool ShouldExpand = true;
bool RetainExpansion = false;
std::optional<unsigned> OrigNumExpansions;
std::optional<unsigned> NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(
E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded,
ShouldExpand, RetainExpansion, NumExpansions))
return true;
if (!ShouldExpand) {
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
ExprResult Pack = getDerived().TransformExpr(Pattern);
if (Pack.isInvalid())
return ExprError();
return getDerived().RebuildPackIndexingExpr(
E->getEllipsisLoc(), E->getRSquareLoc(), Pack.get(), IndexExpr.get(),
std::nullopt);
}
for (unsigned I = 0; I != *NumExpansions; ++I) {
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
ExprResult Out = getDerived().TransformExpr(Pattern);
if (Out.isInvalid())
return true;
if (Out.get()->containsUnexpandedParameterPack()) {
Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
OrigNumExpansions);
if (Out.isInvalid())
return true;
}
ExpandedExprs.push_back(Out.get());
}
// If we're supposed to retain a pack expansion, do so by temporarily
// forgetting the partially-substituted parameter pack.
if (RetainExpansion) {
ForgetPartiallySubstitutedPackRAII Forget(getDerived());
ExprResult Out = getDerived().TransformExpr(Pattern);
if (Out.isInvalid())
return true;
Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
OrigNumExpansions);
if (Out.isInvalid())
return true;
ExpandedExprs.push_back(Out.get());
}
} else if (!E->expandsToEmptyPack()) {
if (getDerived().TransformExprs(E->getExpressions().data(),
E->getExpressions().size(), false,
ExpandedExprs))
return ExprError();
}
return getDerived().RebuildPackIndexingExpr(
E->getEllipsisLoc(), E->getRSquareLoc(), E->getPackIdExpression(),
IndexExpr.get(), ExpandedExprs,
/*EmptyPack=*/ExpandedExprs.size() == 0);
} | 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 $0x500000000, %rcx # imm = 0x500000000
movq %rcx, -0x8(%rax)
movl 0x28(%rbx), %edx
testl %edx, %edx
js 0x812d05
je 0x812d09
leaq 0x30(%rbx), %rsi
leaq 0x50(%rsp), %r8
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x82692a
testb %al, %al
je 0x812d59
pushq $0x1
popq %rbx
jmp 0x812de4
xorl %ecx, %ecx
jmp 0x812d62
movq 0x18(%rbx), %r12
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x200000000, %rcx # imm = 0x200000000
movq %rcx, -0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0xc6bade
movq (%r15), %r13
movl 0x3218(%r13), %ebp
orl $-0x1, 0x3218(%r13)
movq %r15, %rdi
movq %r12, %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x812d9f
pushq $0x1
popq %rbx
jmp 0x812dd3
movq 0x50(%rsp), %rax
movl 0x58(%rsp), %ecx
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %r8d
movq 0x18(%rbx), %rsi
andq $-0x2, %r14
movl %ecx, %edi
xorl %r9d, %r9d
testl %ecx, %ecx
sete %r9b
movq %rax, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq (%r15), %rdi
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rcx
callq 0xc6c8de
movq %rax, %rbx
jmp 0x812de4
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %r8d
andq $-0x2, %rax
andq $-0x2, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r15), %rdi
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, %rsi
movq %r14, %rcx
xorl %r9d, %r9d
callq 0xc6c8de
movq %rax, %rbx
movl %ebp, 0x3218(%r13)
leaq 0x20(%rsp), %rdi
callq 0x80ef16
leaq 0x50(%rsp), %rdi
callq 0x633cd8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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) {
ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
if (OrigElement.isPackExpansion()) {
// This key/value element is a pack expansion.
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
// Determine whether the set of unexpanded parameter packs can
// and should be expanded.
bool Expand = true;
bool RetainExpansion = false;
std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
std::optional<unsigned> NumExpansions = OrigNumExpansions;
SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
OrigElement.Value->getEndLoc());
if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
PatternRange, Unexpanded, Expand,
RetainExpansion, NumExpansions))
return ExprError();
if (!Expand) {
// The transform has determined that we should perform a simple
// transformation on the pack expansion, producing another pack
// expansion.
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
if (Key.isInvalid())
return ExprError();
if (Key.get() != OrigElement.Key)
ArgChanged = true;
ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
if (Value.isInvalid())
return ExprError();
if (Value.get() != OrigElement.Value)
ArgChanged = true;
ObjCDictionaryElement Expansion = {
Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
};
Elements.push_back(Expansion);
continue;
}
// Record right away that the argument was changed. This needs
// to happen even if the array expands to nothing.
ArgChanged = true;
// The transform has determined that we should perform an elementwise
// expansion of the pattern. Do so.
for (unsigned I = 0; I != *NumExpansions; ++I) {
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
if (Key.isInvalid())
return ExprError();
ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
if (Value.isInvalid())
return ExprError();
ObjCDictionaryElement Element = {
Key.get(), Value.get(), SourceLocation(), NumExpansions
};
// If any unexpanded parameter packs remain, we still have a
// pack expansion.
// FIXME: Can this really happen?
if (Key.get()->containsUnexpandedParameterPack() ||
Value.get()->containsUnexpandedParameterPack())
Element.EllipsisLoc = OrigElement.EllipsisLoc;
Elements.push_back(Element);
}
// FIXME: Retain a pack expansion if RetainExpansion is true.
// We've finished with this pack expansion.
continue;
}
// Transform and check key.
ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
if (Key.isInvalid())
return ExprError();
if (Key.get() != OrigElement.Key)
ArgChanged = true;
// Transform and check value.
ExprResult Value
= getDerived().TransformExpr(OrigElement.Value);
if (Value.isInvalid())
return ExprError();
if (Value.get() != OrigElement.Value)
ArgChanged = true;
ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(),
std::nullopt};
Elements.push_back(Element);
}
if (!getDerived().AlwaysRebuild() && !ArgChanged)
return SemaRef.MaybeBindToTemporary(E);
return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
Elements);
} | 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 0x10(%rsi), %eax
movl %eax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
movl $0x0, 0x4(%rsp)
cmpl %ebp, 0x10(%rsp)
je 0x813cbe
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x74cd44
cmpl $0x0, 0x28(%rsp)
je 0x813c2c
movl %ebp, 0x14(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xc6bade
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xc6bade
movq 0x18(%rsp), %rsi
movq 0x2c(%rsp), %rbx
movq (%r14), %r13
movl 0x3218(%r13), %r15d
orl $-0x1, 0x3218(%r13)
movq %r14, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x813ca8
movq %rax, %r12
movq %r14, %rbp
movq 0x18(%rsp), %r14
movq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x813ca8
andq $-0x2, %r12
xorq %r12, %r14
andq $-0x2, %rax
movq 0x20(%rsp), %rcx
xorq %rax, %rcx
orq %r14, %rcx
setne %cl
movl 0x4(%rsp), %edx
orb %cl, %dl
movl %edx, 0x4(%rsp)
movq %r12, 0x68(%rsp)
movq %rax, 0x70(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x78(%rsp)
movq %rbx, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x68000c
movl %r15d, 0x3218(%r13)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x80ef16
movq %rbp, %r14
movl 0x14(%rsp), %ebp
jmp 0x813ca1
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x813cb9
movq %rax, %r12
movq 0x18(%rsp), %rbx
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x813cb9
andq $-0x2, %r12
xorq %r12, %rbx
andq $-0x2, %rax
movq 0x20(%rsp), %rcx
xorq %rax, %rcx
orq %rbx, %rcx
setne %cl
movl 0x4(%rsp), %edx
orb %cl, %dl
movl %edx, 0x4(%rsp)
movq %r12, 0x38(%rsp)
movq %rax, 0x40(%rsp)
andl $0x0, 0x48(%rsp)
movb $0x0, 0x50(%rsp)
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
callq 0x68000c
incl %ebp
jmp 0x813b16
movl %r15d, 0x3218(%r13)
leaq 0x38(%rsp), %rdi
callq 0x80ef16
pushq $0x1
popq %rbx
jmp 0x813d06
movq (%r14), %rdi
cmpl $-0x1, 0x3218(%rdi)
setne %al
orb 0x4(%rsp), %al
testb $0x1, %al
je 0x813cf9
movq 0x8(%rsp), %rax
movq 0x14(%rax), %rsi
movq 0x88(%rsp), %rdx
movl 0x90(%rsp), %ecx
movq 0x2d8(%rdi), %rdi
callq 0xa148fa
jmp 0x813d03
movq 0x8(%rsp), %rsi
callq 0x9c58aa
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x68064c
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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().TransformTemplateArguments(Old->getTemplateArgs(),
Old->NumTemplateArgs, TransArgs))
return ExprError();
return getDerived().RebuildConceptSpecializationExpr(
E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
&TransArgs);
} | 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)
movq %rcx, 0x100(%rax)
movl 0x8(%rsi), %edx
addq $0x10, %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rcx
callq 0x821450
testb %al, %al
je 0x8167b1
pushq $0x1
popq %rbx
jmp 0x816825
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
movl %ecx, 0xc(%rsp)
movq 0x28(%rax), %rcx
leaq 0x10(%rsp), %r15
movq %rcx, 0x10(%r15)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%r15)
movq 0x30(%rax), %r12
movq 0x38(%rax), %r13
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbp
movaps %xmm0, 0x20(%rbp)
movaps %xmm0, 0x10(%rbp)
movaps %xmm0, (%rbp)
movq %rbp, %rdi
callq 0x75a106
movq (%rbx), %rdi
movq %r14, (%rsp)
movq %rbp, %rsi
movl 0xc(%rsp), %edx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xb5a7f6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4f0656
leaq 0x60(%rsp), %rdi
callq 0x6d9e52
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ExprError();
if (!getDerived().AlwaysRebuild() &&
Type == E->getTypeInfoAsWritten() &&
SubExpr.get() == E->getSubExpr())
return E;
return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
Type,
E->getRParenLoc(),
SubExpr.get());
} | 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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rdi
cmpl $-0x1, 0x3218(%rdi)
jne 0x816b9a
cmpq 0x18(%rbx), %r14
jne 0x816b9a
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rcx, 0x10(%rbx)
je 0x816bba
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %ecx
andq $-0x2, %rax
movq %r14, %rdx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7ab612
movq %rbx, %r12
jmp 0x816b6c
nop
| /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().AllowSkippingCXXConstructExpr() &&
((E->getNumArgs() == 1 ||
(E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
(!getDerived().DropCallArgument(E->getArg(0))) &&
!E->isListInitialization()))
return getDerived().TransformInitializer(E->getArg(0),
/*DirectInit*/ false);
TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
return ExprError();
CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
return ExprError();
bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
{
EnterExpressionEvaluationContext Context(
getSema(), EnterExpressionEvaluationContext::InitList,
E->isListInitialization());
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
&ArgumentChanged))
return ExprError();
}
if (!getDerived().AlwaysRebuild() &&
T == E->getType() &&
Constructor == E->getConstructor() &&
!ArgumentChanged) {
// Mark the constructor as referenced.
// FIXME: Instantiation-specific
SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
return E;
}
return getDerived().RebuildCXXConstructExpr(
T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
E->hadMultipleCandidates(), E->isListInitialization(),
E->isStdInitListInitialization(), E->requiresZeroInitialization(),
E->getConstructionKind(), E->getParenOrBraceRange());
} | 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
cmoveq %rcx, %rdx
movq 0x8(%rdx), %rdi
callq 0xe50468
testb %al, %al
je 0x8189ff
movb (%r14), %al
xorl %ecx, %ecx
cmpb $0x71, %al
cmoveq %r14, %rcx
addq $0x30, %rcx
leaq 0x28(%r14), %r15
cmpb $0x71, %al
cmovneq %r15, %rcx
movq (%rcx), %rdi
callq 0xe50468
testb %al, %al
jne 0x8189ff
movl (%r14), %eax
btl $0x14, %eax
jb 0x8189ff
xorl %ecx, %ecx
cmpb $0x71, %al
cmovneq %rcx, %r14
addq $0x30, %r14
cmpb $0x71, %al
cmoveq %r14, %r15
movq (%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8266b8
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x81dc2a
pushq $0x1
popq %r13
cmpq $0x10, %rax
jb 0x818c3a
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x81d820
testq %rax, %rax
je 0x818c3a
movq %rax, 0x40(%rsp)
leaq 0x3b(%rsp), %r13
movb $0x0, (%r13)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movq (%rbx), %rsi
movl (%r14), %ecx
shrl $0x14, %ecx
andl $0x1, %ecx
leaq 0x58(%rsp), %r15
xorl %ebp, %ebp
movq %r15, %rdi
xorl %edx, %edx
callq 0x67825a
movb (%r14), %al
cmpb $0x71, %al
cmoveq %r14, %rbp
addq $0x30, %rbp
leaq 0x28(%r14), %rsi
cmpb $0x71, %al
cmoveq %rbp, %rsi
movl 0x20(%r14), %edx
pushq $0x1
popq %rcx
leaq 0xa8(%rsp), %r8
movq %rbx, %rdi
movq %r13, %r9
callq 0x82692a
movl %eax, %ebp
movq %r15, %rdi
callq 0x629670
testb %bpl, %bpl
je 0x818ac0
pushq $0x1
popq %r13
jmp 0x818c2d
movq (%rbx), %r13
cmpl $-0x1, 0x3218(%r13)
movq 0x40(%rsp), %r15
jne 0x818ae9
cmpq 0x8(%r14), %r12
jne 0x818ae9
cmpq 0x10(%r14), %r15
jne 0x818ae9
cmpb $0x0, 0x3b(%rsp)
je 0x818c4f
movq %r14, %rdi
callq 0xe93bce
movl %eax, 0x3c(%rsp)
movl (%r14), %ebp
movq 0xa8(%rsp), %r9
movl 0xb0(%rsp), %r8d
movq 0x18(%r14), %r14
testb $0x20, 0x57(%r15)
movq %r15, %rsi
je 0x818b3b
movq %r15, %rdi
movq %r9, %r13
movq %r14, %r15
movq %r8, %r14
callq 0x743602
movq %r14, %r8
movq %r15, %r14
movq 0x40(%rsp), %r15
movq %r13, %r9
movq %rdx, %rsi
movq (%rbx), %r13
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rdx
movq %r9, %rcx
movl 0x3c(%rsp), %r13d
movl %r13d, %r9d
callq 0x8bf622
testb %al, %al
je 0x818b88
pushq $0x1
popq %r13
jmp 0x818c23
movd %ebp, %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movl %ebp, %eax
pand 0x9fd895(%rip), %xmm0 # 0x1216430
shrl $0x17, %eax
andl $0x7, %eax
pxor %xmm1, %xmm1
pcmpgtd %xmm1, %xmm0
movmskps %xmm0, %edx
movl %edx, %ecx
shrb $0x3, %cl
movl %edx, %esi
andb $0x4, %sil
shrb $0x2, %sil
movl %edx, %r8d
andb $0x2, %r8b
shrb %r8b
shrl $0x12, %ebp
andl $0x1, %ebp
movq (%rbx), %rdi
movq 0x58(%rsp), %r9
movq %r9, 0x48(%rsp)
movl 0x60(%rsp), %r9d
movq %r9, 0x50(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, 0x30(%rsp)
movl %eax, 0x28(%rsp)
andl $0x1, %edx
movl %edx, 0x20(%rsp)
movzbl %r8b, %eax
movl %eax, 0x18(%rsp)
movzbl %sil, %eax
movl %eax, 0x10(%rsp)
movzbl %cl, %r9d
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x8bf1e0
movq %rax, %r13
leaq 0x58(%rsp), %rdi
callq 0x633cd8
leaq 0xa8(%rsp), %rdi
callq 0x633cd8
movq %r13, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xe93bce
pushq $0x1
popq %rcx
movq %r13, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x9346a0
movq %r14, %r13
jmp 0x818c2d
| /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->TheDecl->setBlockMissingReturnType(
oldBlock->blockMissingReturnType());
SmallVector<ParmVarDecl*, 4> params;
SmallVector<QualType, 4> paramTypes;
const FunctionProtoType *exprFunctionType = E->getFunctionType();
// Parameter substitution.
Sema::ExtParameterInfoBuilder extParamInfos;
if (getDerived().TransformFunctionTypeParams(
E->getCaretLocation(), oldBlock->parameters(), nullptr,
exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
extParamInfos)) {
getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
return ExprError();
}
QualType exprResultType =
getDerived().TransformType(exprFunctionType->getReturnType());
auto epi = exprFunctionType->getExtProtoInfo();
epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
QualType functionType =
getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
blockScope->FunctionType = functionType;
// Set the parameters on the block decl.
if (!params.empty())
blockScope->TheDecl->setParams(params);
if (!oldBlock->blockMissingReturnType()) {
blockScope->HasImplicitReturnType = false;
blockScope->ReturnType = exprResultType;
}
// Transform the body
StmtResult body = getDerived().TransformStmt(E->getBody());
if (body.isInvalid()) {
getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
return ExprError();
}
#ifndef NDEBUG
// In builds with assertions, make sure that we captured everything we
// captured before.
if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
for (const auto &I : oldBlock->captures()) {
VarDecl *oldCapture = I.getVariable();
// Ignore parameter packs.
if (oldCapture->isParameterPack())
continue;
VarDecl *newCapture =
cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
oldCapture));
assert(blockScope->CaptureMap.count(newCapture));
}
// The this pointer may not be captured by the instantiated block, even when
// it's captured by the original block, if the expression causing the
// capture is in the discarded branch of a constexpr if statement.
assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&
"this pointer isn't captured in the old block");
}
#endif
return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
/*Scope=*/nullptr);
} | 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, %r15
movq 0x5d8(%rax), %rax
movzwl 0x30(%rbp), %ecx
andl $0x2000, %ecx # imm = 0x2000
movl $0xffffdfff, %edx # imm = 0xFFFFDFFF
andl 0x30(%rax), %edx
orl %ecx, %edx
movw %dx, 0x30(%rax)
movq 0x5d8(%r15), %rax
movzwl 0x30(%rax), %ecx
movl $0xffff8000, %edx # imm = 0xFFFF8000
andl 0x30(%rbp), %edx
andl $0x7fff, %ecx # imm = 0x7FFF
orl %edx, %ecx
movw %cx, 0x30(%rax)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movq %rbx, %rdi
callq 0xe4f67a
leaq 0x88(%rsp), %rcx
movq %rcx, -0x18(%rcx)
andq $0x0, -0x10(%rcx)
movq %rax, %r13
movq $0x10, -0x8(%rcx)
movb $0x0, 0x10(%rcx)
movq %rbx, %rdi
callq 0xe4f696
movq 0x48(%rbp), %r12
movq %rbp, 0x8(%rsp)
movl 0x50(%rbp), %ebp
movq %r13, %rdi
callq 0x6db1f4
leaq 0x70(%rsp), %r10
leaq 0x40(%rsp), %r11
leaq 0x10(%rsp), %r9
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
movq %rax, %r8
pushq %r10
pushq %r11
callq 0x81fe52
popq %rcx
popq %rdx
testb %al, %al
je 0x818f6d
movq (%r14), %r14
movq %rbx, %rdi
callq 0xe4f696
jmp 0x81901d
movq 0x18(%r13), %rsi
movq %r14, %rdi
callq 0x81dc2a
movq %rax, %r12
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x6d0f4c
movl 0x18(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x8200fc
movq %rax, 0x48(%rbp)
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %r8
callq 0x820182
movq %rax, 0x5e8(%r15)
movl 0x48(%rsp), %edx
testq %rdx, %rdx
je 0x818fd9
movq 0x5d8(%r15), %rdi
movq 0x40(%rsp), %rsi
callq 0xe160ea
movq 0x8(%rsp), %rax
cmpw $0x0, 0x30(%rax)
js 0x818ff4
movb $0x0, 0x5c8(%r15)
movq %r12, 0x5d0(%r15)
movq %rbx, %rdi
callq 0xe4f6a8
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x821bc2
movq %rax, %r15
movq (%r14), %r14
movq %rbx, %rdi
callq 0xe4f696
cmpq $0x1, %r15
jne 0x81902e
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x931b4a
pushq $0x1
popq %rbx
jmp 0x819044
andq $-0x2, %r15
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x931b90
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x6e4fde
leaq 0x10(%rsp), %rdi
callq 0x6e4ff2
leaq 0x40(%rsp), %rdi
callq 0x6767e4
movq %rbx, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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_or_null<TemplateTypeParmDecl>(
TransformDecl(TL.getNameLoc(), OldTTPDecl));
QualType Result = getSema().Context.getTemplateTypeParmType(
T->getDepth() + TemplateDepth, T->getIndex(), T->isParameterPack(),
NewTTPDecl);
TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
} | 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, %r13
movq (%r12), %rax
movq 0x100(%rax), %rbp
movq %r15, %rdi
callq 0x4edaae
movl %eax, %ebx
addl 0x20(%r12), %ebx
movq %r15, %rdi
callq 0x4edace
movl %eax, %r12d
movq %r15, %rdi
callq 0x733452
movzbl %al, %ecx
movq %rbp, %rdi
movl %ebx, %esi
movl %r12d, %edx
movq %r13, %r8
callq 0xdabfca
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x7a8a96
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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(Pattern.getSourceExpression(),
EllipsisLoc, NumExpansions);
if (Result.isInvalid())
return TemplateArgumentLoc();
return TemplateArgumentLoc(Result.get(), Result.get());
}
case TemplateArgument::Template:
return TemplateArgumentLoc(
SemaRef.Context,
TemplateArgument(Pattern.getArgument().getAsTemplate(),
NumExpansions),
Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
EllipsisLoc);
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Declaration:
case TemplateArgument::StructuralValue:
case TemplateArgument::Pack:
case TemplateArgument::TemplateExpansion:
case TemplateArgument::NullPtr:
llvm_unreachable("Pack expansion pattern has no parameter packs");
case TemplateArgument::Type:
if (TypeSourceInfo *Expansion
= getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
EllipsisLoc,
NumExpansions))
return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
Expansion);
break;
}
return TemplateArgumentLoc();
} | 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), %rdi
movq 0x18(%r14), %rsi
andq $-0x4, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0xc6bdd4
cmpq $0x1, %rax
je 0x81e949
movq %rax, %rcx
andq $-0x2, %rcx
movl $0x8, (%rbx)
movq %rcx, 0x8(%rbx)
andq $-0x4, %rax
incq %rax
movq %rax, 0x18(%rbx)
jmp 0x81e956
movq (%rsi), %rax
movq 0x100(%rax), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x81ebe4
movq %rax, 0x8(%rsp)
leal 0x1(%r15), %r13d
xorl %r12d, %r12d
btq $0x20, %r15
cmovael %r12d, %r13d
movq %r14, %rdi
callq 0x4c5dfc
movq %rdx, %rcx
movl $0x7ffffffe, %edx # imm = 0x7FFFFFFE
andl (%r14), %edx
cmpl $0x6, %edx
jne 0x81e8e0
movq 0x18(%r14), %rdx
andq $-0x4, %rdx
movl 0x10(%rdx), %r12d
movl $0x7, (%rbx)
movl %r13d, 0x4(%rbx)
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movl %r12d, %r8d
movl %ebp, %r9d
callq 0xf8da54
jmp 0x81e956
movq (%rsi), %rdi
movq 0x18(%r14), %rsi
andq $-0x4, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0xc6bc84
testq %rax, %rax
je 0x81e949
movq %rax, %r14
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8c79e
andq $-0x4, %r14
orq $0x2, %r14
movq %r14, 0x18(%rbx)
jmp 0x81e956
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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,
QualType ObjectType,
NamedDecl *FirstQualifierInScope,
bool AllowInjectedClassName) {
UnqualifiedId TemplateName;
TemplateName.setIdentifier(&Name, NameLoc);
Sema::TemplateTy Template;
getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc,
TemplateName, ParsedType::make(ObjectType),
/*EnteringContext=*/false, Template,
AllowInjectedClassName);
return Template.get();
} | 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(%rsp)
xorl %esi, %esi
movl %eax, %ecx
movq %r10, %r8
callq 0xb5aecc
movq (%rbx), %rdi
callq 0x4c5afa
addq $0x40, %rsp
popq %rbx
retq
nop
| /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 StmtError();
if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
Handler.get() == S->getHandler())
return S;
return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
TryBlock.get(), Handler.get());
} | 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
cmpq $0x1, %rax
jne 0x822762
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rdi
andq $-0x2, %r14
cmpl $-0x1, 0x3218(%rdi)
jne 0x822785
cmpq %r14, 0x10(%rbx)
jne 0x822785
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rcx, 0x18(%rbx)
je 0x8227a6
movzbl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
andq $-0x2, %rax
movq %r14, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb3265e
movq %rbx, %r12
jmp 0x822753
nop
| /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().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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;
for (unsigned I = 0; I < NumParams; ++I) {
if (I != ContextParamPos) {
Params.push_back(
std::make_pair(
CD->getParam(I)->getName(),
getDerived().TransformType(CD->getParam(I)->getType())));
} else {
Params.push_back(std::make_pair(StringRef(), QualType()));
}
}
getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
S->getCapturedRegionKind(), Params);
StmtResult Body;
{
Sema::CompoundScopeRAII CompoundScope(getSema());
Body = getDerived().TransformStmt(S->getCapturedStmt());
}
if (Body.isInvalid()) {
getSema().ActOnCapturedRegionError();
return StmtError();
}
return getSema().ActOnCapturedRegionEnd(Body.get());
} | 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 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
xorl %r13d, %r13d
leaq 0x58(%rsp), %r14
leaq 0x20(%rsp), %r12
movq %rbx, 0x40(%rsp)
movq 0x48(%rsp), %r15
cmpq %r13, %rbx
je 0x825a01
cmpq %r13, 0x50(%rsp)
jne 0x8259b4
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
jmp 0x8259f1
movq 0x58(%r15,%r13,8), %rdi
callq 0x4ee522
movq %rax, %rbp
movq %r14, %rbx
movq %rdx, %r14
movq 0x58(%r15,%r13,8), %rax
movq 0x30(%rax), %rsi
movq 0x18(%rsp), %rdi
callq 0x81dc2a
movq %rbp, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, %r14
movq 0x40(%rsp), %rbx
movq %rax, 0x30(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x82b8ee
incq %r13
jmp 0x825998
movq 0x18(%rsp), %rbx
movq (%rbx), %r15
movq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xf6a256
movq 0x58(%rsp), %r8
movl 0x60(%rsp), %r9d
andl $0x0, (%rsp)
movq %r15, %rdi
movl 0x14(%rsp), %esi
xorl %edx, %edx
movl %eax, %ecx
callq 0xb32d76
movq (%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xb28fbc
movl 0x8(%r14), %eax
movq 0x20(%r14,%rax,8), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
movq %rax, %r14
movq %r15, %rdi
callq 0xb28fec
movq (%rbx), %rdi
cmpq $0x1, %r14
jne 0x825a72
callq 0xb32fd0
pushq $0x1
popq %rbx
jmp 0x825a81
andq $-0x2, %r14
movq %r14, %rsi
callq 0xb330c8
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x82b9b0
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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().getLangOpts().CPlusPlus23);
// P2718R0 - Lifetime extension in range-based for loops.
if (getSema().getLangOpts().CPlusPlus23) {
auto &LastRecord = getSema().ExprEvalContexts.back();
LastRecord.InLifetimeExtendingContext = true;
}
StmtResult Init =
S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
if (Init.isInvalid())
return StmtError();
StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
if (Range.isInvalid())
return StmtError();
// Before c++23, ForRangeLifetimeExtendTemps should be empty.
assert(getSema().getLangOpts().CPlusPlus23 ||
getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty());
auto ForRangeLifetimeExtendTemps =
getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps;
StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
if (Begin.isInvalid())
return StmtError();
StmtResult End = getDerived().TransformStmt(S->getEndStmt());
if (End.isInvalid())
return StmtError();
ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
return StmtError();
if (Cond.get())
Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
if (Cond.isInvalid())
return StmtError();
if (Cond.get())
Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
return StmtError();
if (Inc.get())
Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
if (LoopVar.isInvalid())
return StmtError();
StmtResult NewStmt = S;
if (getDerived().AlwaysRebuild() ||
Init.get() != S->getInit() ||
Range.get() != S->getRangeStmt() ||
Begin.get() != S->getBeginStmt() ||
End.get() != S->getEndStmt() ||
Cond.get() != S->getCond() ||
Inc.get() != S->getInc() ||
LoopVar.get() != S->getLoopVarStmt()) {
NewStmt = getDerived().RebuildCXXForRangeStmt(
S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
// Might not have attached any initializer to the loop variable.
getSema().ActOnInitializerError(
cast<DeclStmt>(LoopVar.get())->getSingleDecl());
return StmtError();
}
}
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
return StmtError();
// Body has changed but we didn't rebuild the for-range statement. Rebuild
// it now so we have a new statement to attach the body to.
if (Body.get() != S->getBody() && NewStmt.get() == S) {
NewStmt = getDerived().RebuildCXXForRangeStmt(
S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
if (NewStmt.isInvalid())
return StmtError();
}
if (NewStmt.get() == S)
return S;
return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
} | 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
pushq $0x6
popq %rsi
pushq $0x3
popq %rcx
xorl %edx, %edx
callq 0x92fd8c
movq (%rbx), %rax
movq 0xf0(%rax), %rcx
testb $-0x80, 0x1(%rcx)
je 0x825c18
movq 0x1208(%rax), %rcx
movl 0x1210(%rax), %eax
imulq $0x290, %rax, %rax # imm = 0x290
movb $0x1, -0x27(%rcx,%rax)
movq 0x10(%r14), %rsi
pushq $0x1
popq %r15
testq %rsi, %rsi
je 0x825c3d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
movq %rax, %r12
cmpq $0x1, %rax
jne 0x825c40
jmp 0x825f8c
xorl %r12d, %r12d
movq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
cmpq $0x1, %rax
je 0x825f8c
movq %rax, %r13
movq (%rbx), %rax
movq 0x1208(%rax), %rcx
movl 0x1210(%rax), %eax
imulq $0x290, %rax, %rax # imm = 0x290
leaq (%rcx,%rax), %rsi
addq $-0x80, %rsi
leaq 0x98(%rsp), %rdi
callq 0x82b9c4
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
pushq $0x1
popq %r15
cmpq $0x1, %rax
je 0x825f7f
movq %rax, %rbp
movq 0x28(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
cmpq $0x1, %rax
je 0x825f7f
movq %rax, 0x58(%rsp)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x825f7f
andq $-0x2, %rax
je 0x825d16
movq (%rbx), %rdi
movl 0x54(%r14), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x938c56
cmpq $0x1, %rax
je 0x825f7f
andq $-0x2, %rax
je 0x825d16
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c5d36
andq $-0x2, %rax
movq %rax, 0x48(%rsp)
jmp 0x825d1f
movq $0x0, 0x48(%rsp)
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x825f7f
andq $-0x2, %rax
je 0x825d51
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c5d36
andq $-0x2, %rax
movq %rax, 0x50(%rsp)
jmp 0x825d5a
movq $0x0, 0x50(%rsp)
movq 0x40(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
cmpq $0x1, %rax
je 0x825f7f
movq %rax, %rdi
movq (%rbx), %rax
andq $-0x2, %r12
cmpl $-0x1, 0x3218(%rax)
movq 0x58(%rsp), %rcx
movq %rdi, 0x60(%rsp)
jne 0x825de3
cmpq %r12, 0x10(%r14)
jne 0x825de3
movq %r13, %rax
andq $-0x2, %rax
cmpq %rax, 0x18(%r14)
jne 0x825de3
movq %rbp, %rax
andq $-0x2, %rax
cmpq %rax, 0x20(%r14)
jne 0x825de3
movq %rcx, %rax
andq $-0x2, %rax
cmpq %rax, 0x28(%r14)
jne 0x825de3
movq 0x48(%rsp), %rax
cmpq %rax, 0x30(%r14)
jne 0x825de3
movq 0x50(%rsp), %rax
cmpq %rax, 0x38(%r14)
jne 0x825de3
movq %rdi, %rax
andq $-0x2, %rax
cmpq %rax, 0x40(%r14)
je 0x825fae
movl 0x8(%r14), %esi
movl 0x50(%r14), %edx
movl 0x54(%r14), %r8d
movq %r13, %r9
andq $-0x2, %r9
movq %rbp, %rax
andq $-0x2, %rax
andq $-0x2, %rcx
movq %rdi, %r11
andq $-0x2, %r11
movl 0x58(%r14), %edi
movq 0x98(%rsp), %r10
movq %r10, 0x78(%rsp)
movl 0xa0(%rsp), %r10d
movq %r10, 0x80(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movl %edi, 0x28(%rsp)
movq %r11, 0x40(%rsp)
movq %r11, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rcx
callq 0x82b9e4
cmpq $0x1, %rax
jne 0x825e92
movq 0x40(%rsp), %rax
cmpq %rax, 0x40(%r14)
je 0x825e8f
movq (%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x859dfa
pushq $0x1
popq %r15
jmp 0x825f7f
pushq $0x1
popq %rax
movq %rax, 0x40(%rsp)
movq 0x48(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x821bc2
cmpq $0x1, %rax
je 0x825f7f
andq $-0x2, %rax
movq 0x40(%rsp), %rsi
andq $-0x2, %rsi
cmpq %r14, %rsi
jne 0x825f67
cmpq %rax, 0x48(%r14)
je 0x825f67
movq %rax, 0x40(%rsp)
movl 0x8(%r14), %esi
movl 0x50(%r14), %edx
movl 0x54(%r14), %r8d
andq $-0x2, %r13
andq $-0x2, %rbp
movq 0x58(%rsp), %rdi
andq $-0x2, %rdi
movq 0x60(%rsp), %r9
andq $-0x2, %r9
movl 0x58(%r14), %eax
movq 0x98(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movl 0xa0(%rsp), %ecx
movq %rcx, 0x70(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movl %eax, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rbp, (%rsp)
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r9
callq 0x82b9e4
cmpq $0x1, %rax
je 0x825f7f
movq %rax, %rsi
andq $-0x2, %rsi
movq 0x40(%rsp), %rax
cmpq %r14, %rsi
je 0x825f7c
movq (%rbx), %rdi
movq %rax, %rdx
callq 0xb2f018
movq %rax, %r15
jmp 0x825f7f
movq %r14, %r15
leaq 0x98(%rsp), %rdi
callq 0x69fba0
leaq 0x88(%rsp), %rdi
callq 0x629670
movq %r15, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
jmp 0x825e92
| /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::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
if (EVar.isInvalid())
return nullptr;
Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPAllocateClause(
Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
C->getEndLoc());
} | 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, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movl 0x10(%r14), %esi
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x6338e8
movl 0x10(%r14), %ebp
shlq $0x3, %rbp
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x828957
movq 0x28(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x82898a
andq $-0x2, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %r15
jmp 0x82892a
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
movl 0xc(%r14), %r9d
movl 0x20(%r14), %eax
movl (%r14), %r8d
movl 0x4(%r14), %r10d
movq (%rbx), %rsi
movq 0x2f0(%rsi), %rdi
movq (%rsp), %rsi
pushq %r10
pushq %rax
callq 0xaaac1e
popq %rcx
popq %rdx
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x633cd8
movq %r12, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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(),
C->getLParenLoc(), C->getEndLoc());
} | 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
movl 0x4(%r14), %r8d
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa166a
nop
| /Sema/TreeTransform.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.