name string | code string | asm string | file string |
|---|---|---|---|
clang::TreeTransform<(anonymous namespace)::ExtractTypeForDeductionGuide>::TransformOMPAtClause(clang::OMPAtClause*) | SourceLocation getAtKindKwLoc() const { return KindKwLoc; } | movl 0x10(%rsi), %eax
movl 0x14(%rsi), %edx
movl 0xc(%rsi), %r8d
movl (%rsi), %ecx
movl 0x4(%rsi), %r9d
movq (%rdi), %rsi
movq 0x2f0(%rsi), %rdi
movl %eax, %esi
jmp 0xaa30ae
nop
| /clang/AST/OpenMPClause.h |
clang::TreeTransform<(anonymous namespace)::ExtractTypeForDeductionGuide>::TransformReferenceType(clang::TypeLocBuilder&, clang::ReferenceTypeLoc) | QualType
TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
ReferenceTypeLoc TL) {
const ReferenceType *T = TL.getTypePtr();
// Note that this works with the pointee-as-written.
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x4c622c
movq %rdx, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xbeeace
cmpq $0x10, %rax
jae 0xc08be9
xorl %r15d, %r15d
jmp 0xc08c66
movq (%r15),... | /Sema/TreeTransform.h |
clang::Sema::getTemplateInstantiationArgs(clang::NamedDecl const*, clang::DeclContext const*, bool, std::optional<llvm::ArrayRef<clang::TemplateArgument>>, bool, clang::FunctionDecl const*, bool, bool) | MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
const NamedDecl *ND, const DeclContext *DC, bool Final,
std::optional<ArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary,
const FunctionDecl *Pattern, bool ForConstraintInstantiation,
bool SkipForSpecialization) {
assert((ND... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x8(%rdi)
andl $0x0, 0x70(%rdi)
leaq 0x80(%rsp), %rbx
movq %rdi... | /Sema/SemaTemplateInstantiate.cpp |
clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformPseudoObjectExpr(clang::PseudoObjectExpr*) | ExprResult
TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
// Rebuild the syntactic form. The original syntactic form has
// opaque-value expressions in it, so strip those away and rebuild
// the result. This is a really awful way of doing this, but the
// better solution (rebuilding ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x300(%rax), %rdi
callq 0xb22cce
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc1433e
cmpq $0x1, %rax
jne 0xc25dca
pushq $0x1
popq %r15
jmp 0xc25dfc
movq %rax, %r14
movq %rax, %r15
andq $-0x2, %r14
movq %r14, %rdi
movl $0x1ed, %esi # imm = 0x1... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformOMPTargetParallelGenericLoopDirective(clang::OMPTargetParallelGenericLoopDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
OMPTargetParallelGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_target_parallel_loop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().T... | 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 $0x6d
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc38da8
movq %rax,... | /Sema/TreeTransform.h |
clang::TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl*) | Decl *
TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
ClassTemplatePartialSpecializationDecl *D) {
ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
// Lookup the already-instantiated declaration in the instantiation
// of the class templat... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xe349d6
movq 0x18(%r14), %rdi
movq 0x28(%rax), %rsi
callq 0xe1ea34
cmpq $0x8, %rax
jae 0xc44d56
xorl %eax, %eax
jmp 0xc44d91
movq %rax, %r15
testb $0x4, %r15b
sete %al
andq $-0x8, %r15
sete %cl
orb %al, %cl
jne 0xc44d6e
movq (%r15),... | /Sema/SemaTemplateInstantiateDecl.cpp |
clang::TemplateTypeParmDecl::isPackExpansion() const | bool isPackExpansion() const {
if (!isParameterPack())
return false;
if (const TypeConstraint *TC = getTypeConstraint())
if (TC->hasExplicitTemplateArgs())
for (const auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
if (ArgLoc.getArgument().containsUnexpandedParameterPac... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xe32cdc
testb %al, %al
je 0xc48506
testb $0x4, 0x3c(%rbx)
je 0xc48506
movq 0x58(%rbx), %rax
movq 0x40(%rax), %r14
testq %r14, %r14
je 0xc48506
movl 0x8(%r14), %r15d
addq $0x10, %r14
shlq $0x5, %r15
testq %r15, %r15
setne %bl
je 0xc48508
movq %r14, %rdi
callq 0xf8c... | /clang/AST/DeclTemplate.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformObjCMessageExpr(clang::ObjCMessageExpr*) | ExprResult
TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
&ArgChange... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3f(%rsp), %r15
movb $0x0, (%r15)
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movzwl 0x18(%rsi), %... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformObjCBridgedCastExpr(clang::ObjCBridgedCastExpr*) | ExprResult TreeTransform<Derived>::
TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
TypeSourceInfo *TSInfo
= getDerived().TransformType(E->getTypeInfoAsWritten());
if (!TSInfo)
return ExprError();
ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
if (Result.isInvalid())
return... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rsi
callq 0xc4f224
pushq $0x1
popq %r12
testq %rax, %rax
je 0xc584b1
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0xc530de
cmpq $0x1, %rax
jne 0xc584c0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformCUDAKernelCallExpr(clang::CUDAKernelCallExpr*) | ExprResult
TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
return ExprError();
// Transform exec config.
ExprResult EC = getDerived().TransformCallExpr(E->getConfi... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x3(%rsi), %eax
movq (%rsi,%rax), %rsi
callq 0xc530de
pushq $0x1
popq %r13
cmpq $0x1, %rax
je 0xc58cbb
movq %rax, %r15
movzbl 0x3(%r14), %eax
movq 0x8(%r14,%rax), %rsi
movq %rbx, %rdi
callq 0xc586dc
cmpq $0x1,... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformCXXUnresolvedConstructExpr(clang::CXXUnresolvedConstructExpr*) | ExprResult
TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
CXXUnresolvedConstructExpr *E) {
TypeSourceInfo *T =
getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
return ExprError();
bool ArgumentChanged = false;
Sm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rsi
andq $-0x8, %rsi
callq 0xc68592
testq %rax, %rax
je 0xc58e54
movq %rax, %r14
leaq 0x17(%rsp), %r12
movb $0x0, (%r12)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000,... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformDependentScopeDeclRefExpr(clang::DependentScopeDeclRefExpr*, bool, clang::TypeSourceInfo**) | ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
DependentScopeDeclRefExpr *E, bool IsAddressOfOperand,
TypeSourceInfo **RecoveryTSI) {
assert(E->getQualifierLoc());
NestedNameSpecifierLoc QualifierLoc =
getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
if (!Q... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq 0x10(%rsi), %rsi
movq 0x18(%r14), %rdx
xorl %r15d, %r15d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc5b62c
testq %rax, %rax
je 0xc5b357
movq %rax... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformObjCAutoreleasePoolStmt(clang::ObjCAutoreleasePoolStmt*) | StmtResult
TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
ObjCAutoreleasePoolStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
if (Body.isInvalid())
return StmtError();
// If nothing changed, just retain... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
xorl %edx, %edx
callq 0xc5d93c
cmpq $0x1, %rax
jne 0xc5e937
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 0xc5e94d
cmpq %rax, 0x10(%rbx)
... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformOMPExecutableDirective(clang::OMPExecutableDirective*) | StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
OMPExecutableDirective *D) {
// Transform the clauses
llvm::SmallVector<OMPClause *, 16> TClauses;
ArrayRef<OMPClause *> Clauses = D->clauses();
TClauses.reserve(Clauses.size());
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movq 0x18(%rsi), %rbp
testq %rbp, %rbp
movq %rsi, 0x28(%rsp)
je 0xc63ac1
movl (%rbp), %r14d
addq $0x1... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformOMPCopyinClause(clang::OMPCopyinClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
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_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x6338e8
movl 0x10(%... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformOMPMessageClause(clang::OMPMessageClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) {
ExprResult E = getDerived().TransformExpr(C->getMessageString());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPMessageClause(
C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(),
C->getE... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xc530de
cmpq $0x1, %rax
jne 0xc65e91
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rsi
movl 0xc(%r14), %ecx
movl (%r14), %edx
movl 0x4(%r14), %r8d
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
addq $0x8... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformOMPXDynCGroupMemClause(clang::OMPXDynCGroupMemClause*) | OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
OMPXDynCGroupMemClause *C) {
ExprResult Size = getDerived().TransformExpr(C->getSize());
if (Size.isInvalid())
return nullptr;
return getDerived().RebuildOMPXDynCGroupMemClause(
Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->ge... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xc530de
cmpq $0x1, %rax
jne 0xc661c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andq $-0x2, %rax
movl 0xc(%r14), %ecx
movl (%r14), %edx
movl 0x4(%r14), %r8d
movq (%rbx), %rsi
movq 0x2f0(%rsi), %rdi
movq %rax, %rs... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool)::$_0::operator()() const::SpecialMemberTypeInfoRebuilder>::TransformTypeWithDeducedTST(clang::TypeSourceInfo*) | TypeSourceInfo *
TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *DI) {
if (!isa<DependentNameType>(DI->getType()))
return TransformType(DI);
// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
getDerived().... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
cmpb $0x14, 0x10(%rcx)
jne 0xc6867d
leaq 0x8(%r12), %r14
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, 0x8(%rdi)
callq 0xfacccc
movq (%r12), %r15
cmpq $... | /Sema/TreeTransform.h |
clang::Sema::CheckParameterPacksForExpansion(clang::SourceLocation, clang::SourceRange, llvm::ArrayRef<std::pair<llvm::PointerUnion<clang::TemplateTypeParmType const*, clang::NamedDecl*>, clang::SourceLocation>>, clang::MultiLevelTemplateArgumentList const&, bool&, bool&, std::optional<unsigned int>&) | bool Sema::CheckParameterPacksForExpansion(
SourceLocation EllipsisLoc, SourceRange PatternRange,
ArrayRef<UnexpandedParameterPack> Unexpanded,
const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
bool &RetainExpansion, std::optional<unsigned> &NumExpansions) {
ShouldExpand = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r13
movq 0x120(%rsp), %r12
movq 0x118(%rsp), %rax
movq 0x110(%rsp), %rdx
movb $0x1, (%rdx)
xorl %edx, %edx
movb %dl, (%rax)
andq $0x0, 0x48(%rsp)
andl $0x0, 0x50(%rsp)
movb %dl, 0x24(%rsp)
shlq $0x4, %r8
... | /Sema/SemaTemplateVariadic.cpp |
clang::Sema::BuildPackIndexingExpr(clang::Expr*, clang::SourceLocation, clang::Expr*, clang::SourceLocation, llvm::ArrayRef<clang::Expr*>, bool) | ExprResult
Sema::BuildPackIndexingExpr(Expr *PackExpression, SourceLocation EllipsisLoc,
Expr *IndexExpr, SourceLocation RSquareLoc,
ArrayRef<Expr *> ExpandedExprs, bool EmptyPack) {
std::optional<int64_t> Index;
if (!IndexExpr->isInstantiationDependent()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %r14d
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xf0(%rsp), %rsi
movq %rbx, 0x48(%rsp)
movb $0x0, 0x38(%rsp)
testb $0x40, 0x1(%rcx)
jne 0xc6ca4f
movl %edx, 0x28(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x100(%r15), %r13
mov... | /Sema/SemaTemplateVariadic.cpp |
clang::RecursiveASTVisitor<(anonymous namespace)::CollectUnexpandedParameterPacksVisitor>::TraverseVarHelper(clang::VarDecl*) | bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
TRY_TO(TraverseDeclaratorHelper(D));
// Default params are taken care of when we traverse the ParmVarDecl.
if (!isa<ParmVarDecl>(D) &&
(!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode()))
TRY_TO(TraverseStmt(D->getInit())... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc71b1c
testb %al, %al
je 0xc71b12
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x28, %eax
je 0xc71b0e
movq %r14, %rdi
callq 0xe11aa2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc6ae7a
testb %al, %al
je 0xc71b12
movb $0x1, %al
jmp 0xc71b14
xorl %eax, %... | /clang/AST/RecursiveASTVisitor.h |
clang::Sema::BuildReferenceType(clang::QualType, bool, clang::SourceLocation, clang::DeclarationName) | QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
SourceLocation Loc,
DeclarationName Entity) {
assert(Context.getCanonicalType(T) != Context.OverloadTy &&
"Unresolved overloaded function type");
// C++0x [dcl.ref]p6:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq %rsi, %r15
andq $-0x10, %r15
movb $0x1, %r12b
testl %edx, %edx
jne 0xc7990f
movq (%r15), %rdi
callq 0xb1c43c
testq %rax, %rax
setne %r12b
movq (%r... | /Sema/SemaType.cpp |
checkExtParameterInfos(clang::Sema&, llvm::ArrayRef<clang::QualType>, clang::FunctionProtoType::ExtProtoInfo const&, llvm::function_ref<clang::SourceLocation (unsigned int)>) | static void checkExtParameterInfos(Sema &S, ArrayRef<QualType> paramTypes,
const FunctionProtoType::ExtProtoInfo &EPI,
llvm::function_ref<SourceLocation(unsigned)> getParamLoc) {
assert(EPI.ExtParameterInfos && "shouldn't get here without param infos");
bool emittedError = f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq %r8, 0x8(%rax)
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
movzwl (%rdx), %edx
andl $0x1f, %edx
leaq 0x2c(%rsp), %rsi
movl %edx, (%rsi)
lea... | /Sema/SemaType.cpp |
clang::Sema::BuildMemberPointerType(clang::QualType, clang::QualType, clang::SourceLocation, clang::DeclarationName) | QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
SourceLocation Loc,
DeclarationName Entity) {
// Verify that we're not building a pointer to pointer to function with
// exception specification.
if (CheckDistantExceptionS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x906fce
testb %al, %al
je 0xc7bb96
addq $0x8, %r14
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
mov... | /Sema/SemaType.cpp |
clang::Sema::BuildCountAttributedArrayOrPointerType(clang::QualType, clang::Expr*, bool, bool) | QualType Sema::BuildCountAttributedArrayOrPointerType(QualType WrappedTy,
Expr *CountExpr,
bool CountInBytes,
bool OrNull) {
assert(WrappedTy->isIncompleteA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, -0x8(%rax)
movq 0x10(%rdx), %rsi
leaq 0x28(%rsp),... | /Sema/SemaType.cpp |
clang::Sema::BuiltinDecay(clang::QualType, clang::SourceLocation) | QualType Sema::BuiltinDecay(QualType BaseType, SourceLocation Loc) {
QualType Underlying = BaseType.getNonReferenceType();
if (Underlying->isArrayType())
return Context.getDecayedType(Underlying);
if (Underlying->isFunctionType())
return BuiltinAddPointer(BaseType, Loc);
SplitQualType Split = Underlyi... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
callq 0x75e968
movq %rax, 0x8(%rsp)
movq %rax, %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movzbl 0x10(%rcx), %ecx
leal -0x2(%rcx), %edx
cmpl $0x4, %edx
ja... | /Sema/SemaType.cpp |
clang::Sema::BuiltinAddReference(clang::QualType, clang::UnaryTransformType::UTTKind, clang::SourceLocation) | QualType Sema::BuiltinAddReference(QualType BaseType, UTTKind UKind,
SourceLocation Loc) {
assert(LangOpts.CPlusPlus);
QualType Reference =
BaseType.isReferenceable()
? BuildReferenceType(BaseType,
UKind == UnaryTransformType::AddLval... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movq %rsp, %r15
movq %rsi, (%r15)
movq %r15, %rdi
callq 0x9cabac
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
je 0xc8608b
xorl %edx, %edx
testl %ebp, %ebp
sete %dl
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %ecx
c... | /Sema/SemaType.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::MacroQualifiedType const*, clang::SourceLocation, llvm::DenseMapInfo<clang::MacroQualifiedType const*, void>, llvm::detail::DenseMapPair<clang::MacroQualifiedType const*, clang::SourceLocation>>, clang::MacroQualifiedType const*, clang::SourceLocation, llvm::DenseMapInfo<clang::... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xc869aa
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0xc8c476
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0xc8c470
mov... | /llvm/ADT/DenseMap.h |
shouldHaveNullability(clang::QualType) | static bool shouldHaveNullability(QualType T) {
return T->canHaveNullability(/*ResultIfUnknown=*/false) &&
// For now, do not infer/require nullability on C++ smart pointers.
// It's unclear whether the pragma's behavior is useful for C++.
// e.g. treating type-aliases and template-type-par... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $-0x10, %rbx
movq (%rbx), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0xfaa88e
testb %al, %al
je 0xc8c64b
movq (%rbx), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
andb $-0x2, %al
cmpb $0x2e, %al
setne %bpl
movl %ebp, %eax
addq $... | /Sema/SemaType.cpp |
(anonymous namespace)::DeclaratorLocFiller::VisitMatrixTypeLoc(clang::MatrixTypeLoc) | void VisitMatrixTypeLoc(MatrixTypeLoc TL) {
fillMatrixTypeLoc(TL, Chunk.getAttrs());
} | movq 0x10(%rdi), %rcx
movq 0x18(%rcx), %rax
movl 0x20(%rcx), %ecx
shlq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xc8e415
movq (%rax,%rdx), %rdi
movq 0x40(%rdi), %r8
addq $0x8, %rdx
cmpw $0xae, 0x8(%r8)
jne 0xc8e3d9
movl 0x10(%rdi), %eax
movl %eax, (%rsi)
movq 0x48(%rdi), %rax
andq $-0x4, %rax
movq %rax, 0x10(%rsi)... | /Sema/SemaType.cpp |
clang::TypeLocVisitor<(anonymous namespace)::TypeSpecLocFiller, void>::Visit(clang::TypeLoc) | bool hasLocalQualifiers() const {
return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
} | testb $0xf, %sil
jne 0xc8e416
movq (%rsi), %rax
movzbl 0x10(%rax), %eax
leaq 0x5c29c4(%rip), %rcx # 0x12515c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xc8ebb8
movq 0x18(%rdi), %rax
movl 0x110(%rax), %eax
jmp 0xc8eccf
movq %rdx, %rsi
jmp 0xc8eb38
movq 0x18(%rdi), %rax
movl 0x10c(%rax), %eax
jmp 0xc8... | /clang/AST/Type.h |
(anonymous namespace)::UninitValsDiagReporter::hasAlwaysUninitializedUse(llvm::SmallVector<clang::UninitUse, 2u> const*) | static void checkRecursiveFunction(Sema &S, const FunctionDecl *FD,
const Stmt *Body, AnalysisDeclContext &AC) {
FD = FD->getCanonicalDecl();
// Only run on non-templated functions and non-templated members of
// templated classes.
if (FD->getTemplatedKind() != FunctionDecl::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rdi), %r13d
movq %r13, %r12
shlq $0x6, %r12
leaq (%rbx,%r12), %r15
shrl $0x2, %r13d
testq %r13, %r13
jle 0xc986a9
movq %rbx, %rdi
callq 0xc98ac4
testb %al, %al
jne 0xc986de
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0xc98ac4
testb %al, ... | /Sema/AnalysisBasedWarnings.cpp |
clang::RecursiveASTVisitor<CallableVisitor>::TraverseDeclContextHelper(clang::DeclContext*) | bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
if (!DC)
return true;
for (auto *Child : DC->decls()) {
if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))
TRY_TO(TraverseDecl(Child));
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xca6068
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4d1a72
movq %rax, %r14
movq %rdx, %r15
cmpq %r15, %r14
sete %bpl
je 0xca606b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca5a06
testb %al, %al
jne 0xca605e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca5a... | /clang/AST/RecursiveASTVisitor.h |
clang::RecursiveASTVisitor<CallableVisitor>::VisitOpenACCClauseList(llvm::ArrayRef<clang::OpenACCClause const*>) | bool RecursiveASTVisitor<Derived>::VisitOpenACCClauseList(
ArrayRef<const OpenACCClause *> Clauses) {
for (const auto *C : Clauses)
TRY_TO(VisitOpenACCClause(C));
// if (const auto *WithCond = dyn_cast<OopenACCClauseWithCondition>(C);
// WithCond && WIthCond->hasConditionExpr()) {
// TRY_TO(Tr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x3, %rbx
xorl %ecx, %ecx
movq %rcx, %r12
cmpq %rcx, %rbx
je 0xcb34e0
movq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0xcb34f2
leaq 0x8(%r12), %rcx
testb %al, %al
jne 0xcb34c3
cmpq %r12, %rbx
sete %al
addq $0x8, %r... | /clang/AST/RecursiveASTVisitor.h |
clang::sema::shouldTrackImplicitObjectArg(clang::CXXMethodDecl const*) | static bool shouldTrackImplicitObjectArg(const CXXMethodDecl *Callee) {
if (auto *Conv = dyn_cast_or_null<CXXConversionDecl>(Callee))
if (isRecordWithAttr<PointerAttr>(Conv->getConversionType()))
return true;
if (!isInStlNamespace(Callee->getParent()))
return false;
if (!isRecordWithAttr<PointerAttr... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0xcb7b97
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x22, %eax
jne 0xcb7b97
movq %rbx, %rdi
callq 0x8b5f20
movq %rax, %rdi
callq 0xcb682e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xcb7e63
movq %rbx, %rdi
callq 0x4d2f20
movq... | /Sema/CheckExprLifetime.cpp |
(anonymous namespace)::JumpScopeChecker::BuildScopeInformation(clang::Decl*, unsigned int&) | void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) {
// If this decl causes a new scope, push and switch to it.
std::pair<unsigned,unsigned> Diags = GetDiagForGotoScopeDecl(S, D);
if (Diags.first || Diags.second) {
Scopes.push_back(GotoScope(ParentScope, Diags.first, Diags.second,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x1c(%rsi), %eax
andl $0x7f, %eax
leal -0x2c(%rax), %ecx
cmpl $-0x7, %ecx
setb %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
je 0xcba53d
testq %r15, %r15
sete %cl
leal -0x40(%rax), %edx
cmpl $-... | /Sema/JumpDiagnostics.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::Stmt*, unsigned int, llvm::DenseMapInfo<clang::Stmt*, void>, llvm::detail::DenseMapPair<clang::Stmt*, unsigned int>>, clang::Stmt*, unsigned int, llvm::DenseMapInfo<clang::Stmt*, void>, llvm::detail::DenseMapPair<clang::Stmt*, unsigned int>>::moveFromOldBuckets(llvm::detail::Den... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xcba47c
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0xcba9ce
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0xcba9c8
mov... | /llvm/ADT/DenseMap.h |
clang::RecursiveASTVisitor<(anonymous namespace)::StmtUSEFinder>::TraverseRecordHelper(clang::RecordDecl*) | bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
// We shouldn't traverse D->getTypeForDecl(); it's a result of
// declaring the type, not something that was written in the source.
TRY_TO(TraverseDeclTemplateParameterLists(D));
TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x78(%r14), %rax
testb $0x4, %al
jne 0xcdc266
xorl %ecx, %ecx
jmp 0xcdc270
movq %rax, %rcx
andq $-0x8, %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %r15
jae 0xcdc28e
andq $-0x8, %rax
movq 0x18(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %rbx... | /clang/AST/RecursiveASTVisitor.h |
clang::api_notes::(anonymous namespace)::ReadCommonEntityInfo(unsigned char const*&, clang::api_notes::CommonEntityInfo&) | void ReadCommonEntityInfo(const uint8_t *&Data, CommonEntityInfo &Info) {
uint8_t UnavailableBits = *Data++;
Info.Unavailable = (UnavailableBits >> 1) & 0x01;
Info.UnavailableInSwift = UnavailableBits & 0x01;
if ((UnavailableBits >> 2) & 0x01)
Info.setSwiftPrivate(static_cast<bool>((UnavailableBits >> 3) & ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movzbl (%rax), %eax
movl %eax, %ecx
shrb %cl
andb $0x1, %cl
movb 0x20(%rsi), %dl
andb $-0x4, %dl
orb %cl, %dl
leal (%rax,%rax), %ecx
andb $0x2, %cl
orb %dl, %c... | /APINotes/APINotesReader.cpp |
clang::api_notes::APINotesWriter::addContext(std::optional<clang::api_notes::ContextID>, llvm::StringRef, clang::api_notes::ContextKind, clang::api_notes::ContextInfo const&, llvm::VersionTuple) | ContextID APINotesWriter::addContext(std::optional<ContextID> ParentCtxID,
llvm::StringRef Name, ContextKind Kind,
const ContextInfo &Info,
llvm::VersionTuple SwiftVersion) {
IdentifierID NameID = Implementa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %r9, 0x10(%rsp)
movl %r8d, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xd02b36
movq %rax, %r12
btq $0x20, %r14
pushq $-0x1
popq %rbx
cmovbl %r14d, %ebx
shrq... | /APINotes/APINotesWriter.cpp |
llvm::OnDiskChainedHashTableGenerator<clang::api_notes::(anonymous namespace)::ObjCPropertyTableInfo>::resize(unsigned long) | void resize(size_t NewSize) {
Bucket *NewBuckets = static_cast<Bucket *>(
safe_calloc(NewSize, sizeof(Bucket)));
// Populate NewBuckets with the old entries.
for (size_t I = 0; I < NumBuckets; ++I)
for (Item *E = Buckets[I].Head; E;) {
Item *N = E->Next;
E->Next = nullptr;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x466ed7
movq %rax, %r15
movl (%rbx), %eax
movq 0x68(%rbx), %rdi
leaq -0x1(%r14), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jae 0xd053e8
movq %rdx, %rsi
shlq $0x4, %rsi
movq 0x8(%rdi,%rsi), %rsi
testq %rsi, %rsi
je 0... | /llvm/Support/OnDiskHashTable.h |
llvm::OnDiskChainedHashTableGenerator<clang::api_notes::(anonymous namespace)::GlobalFunctionTableInfo>::resize(unsigned long) | void resize(size_t NewSize) {
Bucket *NewBuckets = static_cast<Bucket *>(
safe_calloc(NewSize, sizeof(Bucket)));
// Populate NewBuckets with the old entries.
for (size_t I = 0; I < NumBuckets; ++I)
for (Item *E = Buckets[I].Head; E;) {
Item *N = E->Next;
E->Next = nullptr;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x466ed7
movq %rax, %r15
movl (%rbx), %eax
movq 0x68(%rbx), %rdi
leaq -0x1(%r14), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jae 0xd072ea
movq %rdx, %rsi
shlq $0x4, %rsi
movq 0x8(%rdi,%rsi), %rsi
testq %rsi, %rsi
je 0... | /llvm/Support/OnDiskHashTable.h |
llvm::OnDiskChainedHashTableGenerator<clang::api_notes::(anonymous namespace)::TypedefTableInfo>::resize(unsigned long) | void resize(size_t NewSize) {
Bucket *NewBuckets = static_cast<Bucket *>(
safe_calloc(NewSize, sizeof(Bucket)));
// Populate NewBuckets with the old entries.
for (size_t I = 0; I < NumBuckets; ++I)
for (Item *E = Buckets[I].Head; E;) {
Item *N = E->Next;
E->Next = nullptr;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x466ed7
movq %rax, %r15
movl (%rbx), %eax
movq 0x68(%rbx), %rdi
leaq -0x1(%r14), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jae 0xd0861a
movq %rdx, %rsi
shlq $0x4, %rsi
movq 0x8(%rdi,%rsi), %rsi
testq %rsi, %rsi
je 0... | /llvm/Support/OnDiskHashTable.h |
llvm::DenseMapBase<llvm::DenseMap<clang::api_notes::StoredObjCSelector, llvm::PointerEmbeddedInt<unsigned int, 31>, llvm::DenseMapInfo<clang::api_notes::StoredObjCSelector, void>, llvm::detail::DenseMapPair<clang::api_notes::StoredObjCSelector, llvm::PointerEmbeddedInt<unsigned int, 31>>>, clang::api_notes::StoredObjCS... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0xd09087
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x38(%rsp), %rbx
orl $-0x1, -0x8(%rbx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x200000000, %rdx # imm = 0x200000000
movq %rdx, -0x8(%rcx)
leaq 0x10(%rsp), %r14
m... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<clang::api_notes::ContextTableKey, std::pair<unsigned int, llvm::SmallVector<std::pair<llvm::VersionTuple, clang::api_notes::ContextInfo>, 1u>>, llvm::DenseMapInfo<clang::api_notes::ContextTableKey, void>, llvm::detail::DenseMapPair<clang::api_notes::ContextTableKey, std::pair<unsigned int, llvm::SmallVe... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
leal -0x1(%rsi), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r14, %rdi
callq 0xd03464
testq %rbx, %rbx
je 0xd094ae
imulq $0xd8, %r15, %r15
leaq (%rbx,%r15), %rdx
movq %r14, %rdi
movq %rbx, %... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair<llvm::VersionTuple, clang::api_notes::GlobalFunctionInfo>, 1u>, llvm::DenseMapInfo<clang::api_notes::SingleDeclTableKey, void>, llvm::detail::DenseMapPair<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd038ea
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0xd0a3b6
movl (%r14), %eax
movl 0x4(%r14), %ecx
movl %eax, %edx
andl %ecx, %edx
cmpl $-0x1, %edx
je 0xd0a3ad
xorl $-0x2, %eax
xorl $-0x2, %ecx
or... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair<llvm::VersionTuple, clang::api_notes::TagInfo>, 1u>>* llvm::DenseMapBase<llvm::DenseMap<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair<llvm::VersionTuple, clang::api_notes::TagInfo>, 1u>, llvm::DenseMapInfo<c... | BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
ValueArgs &&... Values) {
TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);
TheBucket->getFirst() = std::forward<KeyArg>(Key);
::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
return ... | pushq %rbx
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdx, %rsi
callq 0xd0a70e
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, 0x10(%rax)
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair<llvm::VersionTuple, clang::api_notes::TypedefInfo>, 1u>, llvm::DenseMapInfo<clang::api_notes::SingleDeclTableKey, void>, llvm::detail::DenseMapPair<clang::api_notes::SingleDeclTableKey, llvm::SmallVector<std::pair<l... | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0xd0a976
movq %rsi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0xcf5a5c
decl %ebp
andl %ebp, %eax
movl (%r14), %esi
movl 0x4(%r14), %edi
pushq $0x1
popq %r8
xorl %edx, %edx
movl %eax, %ecx
imulq $0xc8, %rc... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::CFGBuilder::addLocalScopeForStmt(clang::Stmt*) | void CFGBuilder::addLocalScopeForStmt(Stmt *S) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return;
LocalScope *Scope = nullptr;
// For compound statement we will be creating explicit scope.
if (CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
for (auto *BI... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x148(%rdi), %rax
cmpb $0x0, 0x33(%rax)
jne 0xd24400
cmpb $0x0, 0x34(%rax)
jne 0xd24400
cmpb $0x1, 0x37(%rax)
jne 0xd24462
cmpb $-0x17, (%r14)
jne 0xd2443f
movl 0x4(%r14), %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
xorl %r15d, %r15... | /Analysis/CFG.cpp |
bool llvm::is_contained<llvm::SmallVector<clang::LabelDecl*, 8u>&, clang::LabelDecl*>(llvm::SmallVector<clang::LabelDecl*, 8u>&, clang::LabelDecl* const&) | bool is_contained(R &&Range, const E &Element) {
if constexpr (detail::HasMemberContains<R, E>)
return Range.contains(Element);
else if constexpr (detail::HasMemberFind<R, E>)
return Range.find(Element) != Range.end();
else
return std::find(adl_begin(Range), adl_end(Range), Element) !=
adl_... | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0xd25403
movl 0x8(%rbx), %ecx
shlq $0x3, %rcx
addq (%rbx), %rcx
cmpq %rcx, %rax
setne %al
popq %rbx
retq
| /llvm/ADT/STLExtras.h |
clang::RecursiveASTVisitor<isInCoroutineStmt(clang::Stmt const*, clang::CFGBlock const*)::Checker>::TraverseConceptReference(clang::ConceptReference*) | bool RecursiveASTVisitor<Derived>::TraverseConceptReference(
ConceptReference *CR) {
if (!getDerived().shouldTraversePostOrder())
TRY_TO(VisitConceptReference(CR));
TRY_TO(TraverseNestedNameSpecifierLoc(CR->getNestedNameSpecifierLoc()));
TRY_TO(TraverseDeclarationNameInfo(CR->getConceptNameInfo()));
if ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xd37d5a
testb %al, %al
je 0xd37d4f
movq 0x28(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xd37dca
testb %al, %al
je 0xd37d4f
movq 0x40(%r14), %rs... | /clang/AST/RecursiveASTVisitor.h |
llvm::DenseMap<clang::ValueDecl const*, bool, llvm::DenseMapInfo<clang::ValueDecl const*, void>, llvm::detail::DenseMapPair<clang::ValueDecl const*, bool>>::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 0xd3ef77
movl %ebp, %edi
shlq $0x4, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0xd3ef79
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::DenseMap<clang::ValueDecl const*, unsigned int, llvm::DenseMapInfo<clang::ValueDecl const*, void>, llvm::detail::DenseMapPair<clang::ValueDecl const*, unsigned int>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
callq 0xd3f134
movq %rbx, %rdi
movl %eax, %esi
callq 0xd3f156
testb %al, %al
je 0xd3f12c
movq %rbx, %rdi
popq %rbx
jmp 0xd3f188
andq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
void (anonymous namespace)::ThreadSafetyAnalyzer::getMutexIDs<clang::AcquireCapabilityAttr const>((anonymous namespace)::CapExprSet&, clang::AcquireCapabilityAttr const*, clang::Expr const*, clang::NamedDecl const*, clang::threadSafety::til::SExpr*) | void ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr,
const Expr *Exp, const NamedDecl *D,
til::SExpr *Self) {
if (Attr->args_size() == 0) {
// The mutex held is the "this" object.
CapabilityExpr Cp = SxBuilder.tr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movl 0x24(%rdx), %r15d
testq %r15, %r15
je 0xd3fdb8
movq 0x28(%rdx), %rax
movq %rax, 0x18(%rsp)
movq %r12, 0x10(%rsp)
leaq 0x68(%r12), %rbp
shlq $0x3, %r15
xorl %r12d, %r12d
cmpq %r12,... | /Analysis/ThreadSafety.cpp |
llvm::DenseMapBase<llvm::SmallDenseMap<clang::Expr const*, clang::threadSafety::til::LiteralPtr*, 4u, llvm::DenseMapInfo<clang::Expr const*, void>, llvm::detail::DenseMapPair<clang::Expr const*, clang::threadSafety::til::LiteralPtr*>>, clang::Expr const*, clang::threadSafety::til::LiteralPtr*, llvm::DenseMapInfo<clang:... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0xd4793e
testb %al, %al
je 0xd413a7
movq 0x8(%rsp), %r14
movq %rbx, %rdi
callq 0xd3f9da
movq %rax, %rdx
jmp 0xd413b2
movq %rbx, %rdi
callq 0xd413be
movq %rax, %r14
movq %r14, %rax
ad... | /llvm/ADT/DenseMap.h |
clang::threadSafety::til::PrettyPrinter<clang::threadSafety::til::StdPrinter, std::ostream>::printBasicBlock(clang::threadSafety::til::BasicBlock const*, std::ostream&) | void printBasicBlock(const BasicBlock *E, StreamType &SS) {
SS << "BB_" << E->blockID() << ":";
if (E->parent())
SS << " BB_" << E->parent()->blockID();
newline(SS);
for (const auto *A : E->arguments())
printBBInstr(A, SS);
for (const auto *I : E->instructions())
printBBInstr(I, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x51845f(%rip), %rsi # 0x125c868
movq %rdx, %rdi
callq 0x436b50
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
movl 0x20(%r15), %esi
andl %ebp, %esi
movq %rax, %rdi
callq 0x436930
leaq 0... | /clang/Analysis/Analyses/ThreadSafetyTraverse.h |
llvm::DenseMap<clang::ValueDecl const*, bool, llvm::DenseMapInfo<clang::ValueDecl const*, void>, llvm::detail::DenseMapPair<clang::ValueDecl const*, bool>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0xd3ef58
testq %r14, %r14
je 0xd45dea
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ThreadSafetyAnalyzer::warnIfMutexNotHeld((anonymous namespace)::FactSet const&, clang::NamedDecl const*, clang::Expr const*, clang::threadSafety::AccessKind, clang::Expr*, clang::threadSafety::ProtectedOperationKind, clang::threadSafety::til::LiteralPtr*, clang::SourceLocation) | void ThreadSafetyAnalyzer::warnIfMutexNotHeld(
const FactSet &FSet, const NamedDecl *D, const Expr *Exp, AccessKind AK,
Expr *MutexExp, ProtectedOperationKind POK, til::LiteralPtr *Self,
SourceLocation Loc) {
LockKind LK = getLockKindFromAccessKind(AK);
CapabilityExpr Cp = SxBuilder.translateAttrExpr(Mu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %rax
movl %r8d, %r14d
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq 0x148(%rsp), %r9
movq %rdi, 0x30(%rsp)
leaq 0x68(%rdi), %rsi
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rdx
movq %r15, ... | /Analysis/ThreadSafety.cpp |
clang::RecursiveASTVisitor<clang::ast_matchers::MatchDescendantVisitor>::TraverseTemplateInstantiations(clang::VarTemplateDecl*) | bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
VarTemplateDecl *D) {
for (auto *SD : D->specializations()) {
for (auto *RD : SD->redecls()) {
switch (
cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
case TSK_Undeclared:
case TSK_ImplicitInsta... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x78e802
movq %rax, %r15
movq %rdx, %r14
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r15, (%rsp)
cmpq %r14, %r15
je 0xd65ce8
movq %r12, %rdi
callq 0x78e828
movq %rax, %rsi
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%r... | /clang/AST/RecursiveASTVisitor.h |
clang::RecursiveASTVisitor<clang::ast_matchers::MatchDescendantVisitor>::TraverseTemplateInstantiations(clang::ClassTemplateDecl*) | bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
ClassTemplateDecl *D) {
for (auto *SD : D->specializations()) {
for (auto *RD : SD->redecls()) {
assert(!cast<CXXRecordDecl>(RD)->isInjectedClassName());
switch (
cast<ClassTemplateSpecializationDecl>(RD)->getSpecializati... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa86268
movq %rax, %r15
movq %rdx, %r14
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r15, (%rsp)
cmpq %r14, %r15
je 0xd65e1e
movq %r12, %rdi
callq 0xaf6a92
movq %rax, %rsi
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%r... | /clang/AST/RecursiveASTVisitor.h |
clang::ast_matchers::internal::BindableMatcher<clang::Stmt> clang::ast_matchers::internal::makeDynCastAllOfComposite<clang::Stmt, clang::ArrayInitIndexExpr>(llvm::ArrayRef<clang::ast_matchers::internal::Matcher<clang::ArrayInitIndexExpr> const*>) | BindableMatcher<T>
makeDynCastAllOfComposite(ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
return BindableMatcher<T>(
makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xd6af16
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd69b44
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rbx... | /clang/ASTMatchers/ASTMatchersInternal.h |
clang::ast_matchers::internal::VariadicOperatorMatcher<clang::ast_matchers::internal::VariadicOperatorMatcher<clang::ast_matchers::internal::PolymorphicMatcher<clang::ast_matchers::internal::matcher_hasOperatorName0Matcher, void (clang::ast_matchers::internal::TypeList<clang::BinaryOperator, clang::CXXOperatorCallExpr,... | operator Matcher<T>() const & {
return DynTypedMatcher::constructVariadic(
Op, ASTNodeKind::getFromNodeKind<T>(),
getMatchers<T>(std::index_sequence_for<Ps...>()))
.template unconditionalConvertTo<T>();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl (%rsi), %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd6c0ce
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movl $0x12b, %edx # imm = 0x12B
movq %r14, %rcx
callq 0xd8b4cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd6bf2... | /clang/ASTMatchers/ASTMatchersInternal.h |
clang::ast_matchers::internal::BindableMatcher<clang::Stmt> clang::ast_matchers::internal::makeDynCastAllOfComposite<clang::Stmt, clang::CallExpr>(llvm::ArrayRef<clang::ast_matchers::internal::Matcher<clang::CallExpr> const*>) | BindableMatcher<T>
makeDynCastAllOfComposite(ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
return BindableMatcher<T>(
makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xd6cb0d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd69b44
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rbx... | /clang/ASTMatchers/ASTMatchersInternal.h |
clang::ast_matchers::internal::BindableMatcher<clang::Stmt> clang::ast_matchers::internal::makeDynCastAllOfComposite<clang::Stmt, clang::CXXConstructExpr>(llvm::ArrayRef<clang::ast_matchers::internal::Matcher<clang::CXXConstructExpr> const*>) | BindableMatcher<T>
makeDynCastAllOfComposite(ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
return BindableMatcher<T>(
makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xd6d346
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd69b44
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rbx... | /clang/ASTMatchers/ASTMatchersInternal.h |
clang::ast_matchers::internal::BindableMatcher<clang::DeclStmt> clang::ast_matchers::internal::makeAllOfComposite<clang::DeclStmt>(llvm::ArrayRef<clang::ast_matchers::internal::Matcher<clang::DeclStmt> const*>) | BindableMatcher<T>
makeAllOfComposite(ArrayRef<const Matcher<T> *> InnerMatchers) {
// For the size() == 0 case, we return a "true" matcher.
if (InnerMatchers.empty()) {
return BindableMatcher<T>(TrueMatcher());
}
// For the size() == 1 case, we simply return that one matcher.
// No need to wrap it in a v... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpq $0x1, %rdx
je 0xd73f6c
testq %rdx, %rdx
jne 0xd73f95
movq %rsp, %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0xd74044
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq %rax... | /clang/ASTMatchers/ASTMatchersInternal.h |
clang::ASTContext::DeepCollectObjCIvars(clang::ObjCInterfaceDecl const*, bool, llvm::SmallVectorImpl<clang::ObjCIvarDecl const*>&) const | void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
bool leafClass,
SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
DeepCollectObjCIvars(SuperClass, false, Ivars);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xe27d6a
testq %rax, %rax
je 0xd9acbc
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd9ac8a
movq %r14, %rdi
testb %bpl, %bpl
je 0xd9ace2
callq 0xe2a... | /AST/ASTContext.cpp |
clang::ASTContext::createMangleContext(clang::TargetInfo const*) | MangleContext *ASTContext::createMangleContext(const TargetInfo *T) {
if (!T)
T = Target;
switch (T->getCXXABI().getKind()) {
case TargetCXXABI::AppleARM64:
case TargetCXXABI::Fuchsia:
case TargetCXXABI::GenericAArch64:
case TargetCXXABI::GenericItanium:
case TargetCXXABI::GenericARM:
case TargetCXX... | testq %rsi, %rsi
jne 0xd9bcb6
movq 0x4348(%rdi), %rsi
cmpl $0x9, 0x154(%rsi)
movq 0x828(%rdi), %rax
movq 0x8(%rax), %rsi
ja 0xd9bcd1
xorl %edx, %edx
jmp 0xf1ba2a
xorl %edx, %edx
jmp 0xf377d8
| /AST/ASTContext.cpp |
clang::ASTContext::getSubstTemplateTemplateParm(clang::TemplateName, clang::Decl*, unsigned int, std::optional<unsigned int>) const | TemplateName ASTContext::getSubstTemplateTemplateParm(
TemplateName Replacement, Decl *AssociatedDecl, unsigned Index,
std::optional<unsigned> PackIndex) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmStorage::Profile(ID, Replacement, AssociatedDecl,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x2000000000, %rcx # imm = 0x2000000000
movq %rcx, -0x8(%rax)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %ecx... | /AST/ASTContext.cpp |
clang::ASTContext::mayExternalize(clang::Decl const*) const | bool ASTContext::mayExternalize(const Decl *D) const {
bool IsInternalVar =
isa<VarDecl>(D) &&
basicGVALinkageForVariable(*this, cast<VarDecl>(D)) == GVA_Internal;
bool IsExplicitDeviceVar = (D->hasAttr<CUDADeviceAttr>() &&
!D->getAttr<CUDADeviceAttr>()->isImplicit()) ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1c(%rsi), %eax
andl $0x7f, %eax
addl $-0x25, %eax
cmpl $0x6, %eax
ja 0xdbb52a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdb7c74
testl %eax, %eax
sete %bpl
jmp 0xdbb52c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7cd57a
testb %al, %al... | /AST/ASTContext.cpp |
llvm::DenseMap<clang::CXXRecordDecl const*, std::unique_ptr<llvm::SmallVector<std::unique_ptr<clang::VPtrInfo, std::default_delete<clang::VPtrInfo>>, 2u>, std::default_delete<llvm::SmallVector<std::unique_ptr<clang::VPtrInfo, std::default_delete<clang::VPtrInfo>>, 2u>>>, llvm::DenseMapInfo<clang::CXXRecordDecl const*, ... | 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 0xdbd291
movl %ebp, %edi
shlq $0x4, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0xdbd293
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 |
bool llvm::DenseMapBase<llvm::DenseMap<clang::QualType, unsigned int, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, unsigned int>>, clang::QualType, unsigned int, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, unsigned int>>::LookupBucketF... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xdbd60c
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movq %rsi, %r8
shrq $0x9, %r8
xorl %esi, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %eax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $0x1, %al
cmpq %rbx, %rsi
je 0xdbd... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<clang::VarDecl const*, clang::BlockVarCopyInit, llvm::DenseMapInfo<clang::VarDecl const*, void>, llvm::detail::DenseMapPair<clang::VarDecl const*, clang::BlockVarCopyInit>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0xdbe5f8
testq %r14, %r14
je 0xdc17da
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq... | /llvm/ADT/DenseMap.h |
clang::DeclContext::getLookupParent() | DeclContext *DeclContext::getLookupParent() {
// FIXME: Find a better way to identify friends.
if (isa<FunctionDecl>(this))
if (getParent()->getRedeclContext()->isFileContext() &&
getLexicalParent()->getRedeclContext()->isRecord())
return getLexicalParent();
// A lookup within the call operator... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
andl $0x7f, %eax
addl $-0x1f, %eax
cmpl $0x5, %eax
ja 0xe1dc79
movq %rbx, %rdi
callq 0x4d2fb8
movq %rax, %rdi
callq 0xe1dca6
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0xe1dc4b
testl %eax, %eax
jne 0xe1dc79
movq %rbx, %rdi
callq 0x... | /AST/DeclBase.cpp |
clang::DeclContext::getPrimaryContext() | DeclContext *DeclContext::getPrimaryContext() {
switch (getDeclKind()) {
case Decl::ExternCContext:
case Decl::LinkageSpec:
case Decl::Export:
case Decl::TopLevelStmt:
case Decl::Block:
case Decl::Captured:
case Decl::OMPDeclareReduction:
case Decl::OMPDeclareMapper:
case Decl::RequiresExprBody:
... | pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
andl $0x7f, %eax
cmpl $0x18, %eax
ja 0xe1dedb
leaq 0x453257(%rip), %rcx # 0x12710e8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rax
popq %rbx
retq
movq 0x28(%rbx), %rax
leaq 0x28(%rax), %rbx
jmp 0xe1debc
leaq -0x30(%rbx), %rdi
callq 0x67d42a
jmp... | /AST/DeclBase.cpp |
(anonymous namespace)::EvalInfo::CheckArraySize(clang::SourceLocation, unsigned int, unsigned long, bool) | bool CheckArraySize(SourceLocation Loc, unsigned BitWidth,
uint64_t ElemCount, bool Diag) {
// FIXME: GH63562
// APValue stores array extents as unsigned,
// so anything that is greater that unsigned would overflow when
// constructing the array, we catch this here.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %r15d
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, 0x10(%rsp)
movq 0x10(%rdi), %rdi
callq 0xfa22e0
cmpl %r12d, %eax
setae %al
movq %rbx, %rcx
shrq $0x20, %rcx
sete %cl
testb %cl, %al
jne 0xe60bd5
xorl %ebx,... | /AST/ExprConstant.cpp |
llvm::APSInt::operator^(llvm::APSInt const&) const | APSInt operator^(const APSInt &RHS) const {
assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
return APSInt(static_cast<const APInt &>(*this) ^ RHS, IsUnsigned);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x48b344
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4956a8
movb 0xc(%r14), %al
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%r15)
movq (... | /llvm/ADT/APSInt.h |
llvm::APSInt::operator%(llvm::APSInt const&) const | APSInt operator%(const APSInt &RHS) const {
assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
return IsUnsigned ? APSInt(urem(RHS), true) : APSInt(srem(RHS), false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xc(%rsi)
je 0xe70797
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x494134
movb $0x1, %bpl
jmp 0xe707a4
movq %rsp, %r14
movq %r14, %rdi
callq 0x4942ce
xorl %ebp, %ebp
movl 0x8(%r14), %r15d
movq (%r14), %r12
andl $0x0, 0x8... | /llvm/ADT/APSInt.h |
bool clang::interp::InitGlobal<(clang::interp::PrimType)7, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int) | bool InitGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
const Pointer &P = S.P.getGlobal(I);
P.deref<T>() = S.Stk.pop<T>();
P.initialize();
return true;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
movl %edx, %ecx
movq 0xe0(%rax), %rax
movq (%rax,%rcx,8), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf149f4
movq 0xb0(%rbx), %rdi
callq 0xed70d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xe9b57e
movq %rbx, (%rax)
movq %r14, %rdi
callq 0xf1... | /AST/Interp/Interp.h |
bool clang::interp::InitGlobalTemp<(clang::interp::PrimType)1, clang::interp::Integral<8u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int, clang::LifetimeExtendedTemporaryDecl const*) | bool InitGlobalTemp(InterpState &S, CodePtr OpPC, uint32_t I,
const LifetimeExtendedTemporaryDecl *Temp) {
const Pointer &Ptr = S.P.getGlobal(I);
const T Value = S.Stk.peek<T>();
APValue APV = Value.toAPValue(S.getCtx());
APValue *Cached = Temp->getOrCreateValue(true);
*Cached = APV;
a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdi, %r14
movq 0xa8(%rdi), %rax
movl %edx, %ecx
movq 0xe0(%rax), %rax
movq (%rax,%rcx,8), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf149f4
movq 0xb0(%r14), %rdi
callq 0xed686e
movb (%rax), %al
leaq 0xf(%rsp... | /AST/Interp/Interp.h |
bool clang::interp::LoadPop<(clang::interp::PrimType)11, clang::interp::Floating>(clang::interp::InterpState&, clang::interp::CodePtr) | bool LoadPop(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLoad(S, OpPC, Ptr))
return false;
if (!Ptr.isBlockPointer())
return false;
S.Stk.push<T>(Ptr.deref<T>());
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xe9af06
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xf08415
cmpl $0x0, 0x28(%r15)
sete %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0xec0b3e
movq 0xb0(%r14), ... | /AST/Interp/Interp.h |
bool clang::interp::SetField<(clang::interp::PrimType)4, clang::interp::Integral<32u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int) | bool SetField(InterpState &S, CodePtr OpPC, uint32_t I) {
const T &Value = S.Stk.pop<T>();
const Pointer &Obj = S.Stk.peek<Pointer>();
if (!CheckNull(S, OpPC, Obj, CSK_Field))
return false;
if (!CheckRange(S, OpPC, Obj, CSK_Field))
return false;
const Pointer &Field = Obj.atField(I);
if (!CheckStore... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0xb0(%rdi), %rdi
callq 0xed6b6e
movl %eax, %ebx
movq 0xb0(%r15), %rdi
callq 0xed5494
movq %rax, %r12
pushq $0x2
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf07baa... | /AST/Interp/Interp.h |
bool clang::interp::StoreBitFieldPop<(clang::interp::PrimType)6, clang::interp::Integral<64u, true>>(clang::interp::InterpState&, clang::interp::CodePtr) | bool StoreBitFieldPop(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
if (const auto *FD = Ptr.getField())
Ptr.deref<T>() = Value.truncate(FD->getB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0xb0(%rdi), %rdi
callq 0xed6e48
movq %rax, %r14
movq %rax, (%rsp)
movq 0xb0(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xe9af06
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xf087fc
movl %eax, %ebx
tes... | /AST/Interp/Interp.h |
clang::interp::IntegralAP<true>::bitOr(clang::interp::IntegralAP<true>, clang::interp::IntegralAP<true>, unsigned int, clang::interp::IntegralAP<true>*) | static bool bitOr(IntegralAP A, IntegralAP B, unsigned OpBits,
IntegralAP *R) {
*R = IntegralAP(A.V | B.V);
return false;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x48b344
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4957b1
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x48b344
movq ... | /AST/Interp/IntegralAP.h |
unsigned short clang::interp::IntegralAP<true>::truncateCast<unsigned short, true>(llvm::APInt const&) | static T truncateCast(const APInt &V) {
constexpr unsigned BitSize = sizeof(T) * 8;
if (BitSize >= V.getBitWidth()) {
APInt Extended;
if constexpr (InputSigned)
Extended = V.sext(BitSize);
else
Extended = V.zext(BitSize);
return std::is_signed_v<T> ? Extended.getSExtValue... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
cmpl $0x10, 0x8(%rdi)
ja 0xedb10f
leaq 0x8(%rsp), %rbx
movl $0x1, 0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x18(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x493274
movq %rbx, %rdi
movq %r14, %rsi
callq 0x468326
movq %r14, %rdi
callq 0x468360
jmp 0xedb11f
leaq ... | /AST/Interp/IntegralAP.h |
bool clang::interp::IncDecHelper<clang::interp::Integral<8u, true>, (clang::interp::IncDecOp)1, (clang::interp::PushVal)0>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Pointer const&) | bool IncDecHelper(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
assert(!Ptr.isDummy());
if constexpr (std::is_same_v<T, Boolean>) {
if (!S.getLangOpts().CPlusPlus14)
return Invalid(S, OpPC);
}
const T &Value = Ptr.deref<T>();
T Result;
if constexpr (DoPush == PushVal::Yes)
S.Stk.push<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xe9b2de
movb (%rax), %bpl
decb %bpl
jno 0xedcf9b
leaq 0x10(%rsp), %r15
movl $0x1, 0x8(%r15)
andq $0x0, (%r15)
movb $0x0, 0xc(%r15)
leaq 0x20(%rsp), %r12
pushq $0x9
po... | /AST/Interp/Interp.h |
bool clang::interp::CheckShift<clang::interp::Integral<8u, false>, clang::interp::Integral<32u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Integral<8u, false> const&, clang::interp::Integral<32u, true> const&, unsigned int) | bool CheckShift(InterpState &S, CodePtr OpPC, const LT &LHS, const RT &RHS,
unsigned Bits) {
if (RHS.isNegative()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %r8d, 0x4(%rsp)
movl (%rcx), %eax
testl %eax, %eax
jns 0xee693f
movq 0xc0(%rbx), %rdi
movq %r15, %rsi
callq 0xf13e1e
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorl %ebp,... | /AST/Interp/Interp.h |
bool clang::interp::DoShift<clang::interp::Integral<16u, true>, clang::interp::Integral<32u, true>, (clang::interp::ShiftDir)0>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Integral<16u, true>&, clang::interp::Integral<32u, true>&) | inline bool DoShift(InterpState &S, CodePtr OpPC, LT &LHS, RT &RHS) {
const unsigned Bits = LHS.bitWidth();
// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (S.getLangOpts().OpenCL)
RT::bitAnd(RHS, RT::from(LHS.bitWidth() - 1, RHS.bitWidth()),
RHS.bitWidth(), &RHS);
if (R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xf1ab82
testb $0x40, 0x2f(%rax)
movl (%r14), %eax
jne 0xee8a8f
testl %eax, %eax
jns 0xee8a95
movq 0xc0(%rbx), %rdi
movq %r12, %rsi
callq 0xf13e1e
leaq 0x10(%rsp), %rs... | /AST/Interp/Interp.h |
bool clang::interp::CheckShift<clang::interp::Integral<16u, true>, clang::interp::Integral<64u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Integral<16u, true> const&, clang::interp::Integral<64u, true> const&, unsigned int) | bool CheckShift(InterpState &S, CodePtr OpPC, const LT &LHS, const RT &RHS,
unsigned Bits) {
if (RHS.isNegative()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r13d
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl %r8d, 0x4(%rsp)
movq (%rcx), %rax
testq %rax, %rax
jns 0xee9477
movq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0xf13e1e
leaq 0x8(%rsp), %rsi
movq %r... | /AST/Interp/Interp.h |
bool clang::interp::CheckShift<clang::interp::Integral<64u, true>, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Integral<64u, true> const&, clang::interp::Integral<64u, false> const&, unsigned int) | bool CheckShift(InterpState &S, CodePtr OpPC, const LT &LHS, const RT &RHS,
unsigned Bits) {
if (RHS.isNegative()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movl %r8d, 0xc(%rsp)
cmpl $0x2, %r8d
jb 0xef2928
movl %r8d, %eax
cmpq %rax, (%r14)
jb 0xef2928
movq 0xc0(%rbx), %rdi
movq %r12, %rsi
callq 0xf13e7a
movq %rax, %r15
movq %r13... | /AST/Interp/Interp.h |
bool clang::interp::CheckShift<clang::interp::IntegralAP<false>, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<false> const&, clang::interp::Integral<64u, false> const&, unsigned int) | bool CheckShift(InterpState &S, CodePtr OpPC, const LT &LHS, const RT &RHS,
unsigned Bits) {
if (RHS.isNegative()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, 0xc(%rsp)
cmpl $0x2, %r8d
jb 0xef7ca4
movq %rcx, %r15
movl %r8d, %eax
cmpq %rax, (%rcx)
jb 0xef7ca4
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
callq 0xf13e7a
movq %rax, %r12
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xed64ce... | /AST/Interp/Interp.h |
bool clang::interp::DoShift<clang::interp::IntegralAP<false>, clang::interp::IntegralAP<true>, (clang::interp::ShiftDir)0>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<false>&, clang::interp::IntegralAP<true>&) | inline bool DoShift(InterpState &S, CodePtr OpPC, LT &LHS, RT &RHS) {
const unsigned Bits = LHS.bitWidth();
// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (S.getLangOpts().OpenCL)
RT::bitAnd(RHS, RT::from(LHS.bitWidth() - 1, RHS.bitWidth()),
RHS.bitWidth(), &RHS);
if (R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x8(%rdx), %r13d
callq 0xf1ab82
testb $0x40, 0x2f(%rax)
je 0xef8514
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x48b344
movl 0x8(%r15), %esi
decl %esi
movl 0x8(%r14), ... | /AST/Interp/Interp.h |
bool clang::interp::CheckShift<clang::interp::IntegralAP<true>, clang::interp::Integral<32u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<true> const&, clang::interp::Integral<32u, false> const&, unsigned int) | bool CheckShift(InterpState &S, CodePtr OpPC, const LT &LHS, const RT &RHS,
unsigned Bits) {
if (RHS.isNegative()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
movl %r8d, 0xc(%rsp)
cmpl $0x2, %r8d
jb 0xefae93
cmpl %r8d, (%r15)
jb 0xefae93
movq 0xc0(%rbx), %rdi
movq %r12, %rsi
callq 0xf13e7a
movq %rax, %r14
leaq 0x20(%rsp), %r13
mov... | /AST/Interp/Interp.h |
bool clang::interp::AddSubMulHelper<clang::interp::Integral<8u, true>, &clang::interp::Integral<8u, true>::sub(clang::interp::Integral<8u, true>, clang::interp::Integral<8u, true>, unsigned int, clang::interp::Integral<8u, true>*), std::minus>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int, clang::in... | bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS,
const T &RHS) {
// Fast path - add the numbers with fixed width.
T Result;
if (!OpFW(LHS, RHS, Bits, &Result)) {
S.Stk.push<T>(Result);
return true;
}
// If for some reason evaluation continues, use t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb (%rcx), %r13b
movb (%r8), %r14b
movl %r13d, %eax
subb %r14b, %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq 0xb0(%rdi), %rdi
callq 0xed67b2
cmpb %r... | /AST/Interp/Interp.h |
llvm::SmallVectorTemplateBase<clang::interp::DynamicAllocator::Allocation, false>::moveElementsForGrow(clang::interp::DynamicAllocator::Allocation*) | 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
leaq (%rdi,%rax,8), %rsi
callq 0xf06dd2
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
popq %rbx
jmp 0xf06dac
| /llvm/ADT/SmallVector.h |
llvm::DenseMap<clang::Expr const*, clang::interp::DynamicAllocator::AllocationSite, llvm::DenseMapInfo<clang::Expr const*, void>, llvm::detail::DenseMapPair<clang::Expr const*, clang::interp::DynamicAllocator::AllocationSite>>::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 0xf071ad
movl %ebp, %eax
imulq $0x50, %rax, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0xf071af
xorl %eax, %eax
testl %ebp, %ebp
setne %cl
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
re... | /llvm/ADT/DenseMap.h |
diagnoseNonConstVariable(clang::interp::InterpState&, clang::interp::CodePtr, clang::ValueDecl const*) | static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC,
const ValueDecl *VD) {
if (!S.getLangOpts().CPlusPlus)
return;
const SourceInfo &Loc = S.Current->getSource(OpPC);
if (const auto *VarD = dyn_cast<VarDecl>(VD);
VarD && VarD->getType().isConstQualifi... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
callq 0xf1ab82
testb $0x4, 0x1(%rax)
je 0xf078da
movq 0xc0(%rbx), %rdi
movq %r15, %rsi
callq 0xf13e1e
movq %rax, (%rsp)
movl 0x1c(%r14), %eax
andl $0x7f, %eax
leal -0x2c(%rax), %ecx
cmpl $-0x7, %ecx
se... | /AST/Interp/Interp.cpp |
clang::interp::CheckCallable(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Function const*) | bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {
if (F->isVirtual() && !S.getLangOpts().CPlusPlus20) {
const SourceLocation &Loc = S.Current->getLocation(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
return false;
}
if (F->isConstexpr() && F->hasBody() &&
(F->g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xeff9d4
testb %al, %al
je 0xf089c8
movq %rbx, %rdi
callq 0xf1ab82
testb $0x40, 0x1(%rax)
jne 0xf089c8
movq 0xc0(%rbx), %rdi
movq %r15, %rsi
callq 0xf13ebc
xorl %r12d,... | /AST/Interp/Interp.cpp |
void clang::interp::InterpStack::discard<clang::interp::IntegralAP<false>>() | void discard() {
#ifndef NDEBUG
assert(!ItemTypes.empty());
assert(ItemTypes.back() == toPrimType<T>());
ItemTypes.pop_back();
#endif
T *Ptr = &peekInternal<T>();
Ptr->~T();
shrink(aligned_size<T>());
} | pushq %rbx
movq %rdi, %rbx
callq 0xed73c0
movq %rax, %rdi
callq 0x468360
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf144b2
nop
| /AST/Interp/InterpStack.h |
clang::interp::Floating::bitcastFromMemory(std::byte const*, llvm::fltSemantics const&) | static Floating bitcastFromMemory(const std::byte *Buff,
const llvm::fltSemantics &Sem) {
size_t Size = APFloat::semanticsSizeInBits(Sem);
llvm::APInt API(Size, true);
llvm::LoadIntFromMemory(API, (const uint8_t *)Buff, Size / 8);
return Floating(APFloat(Sem, API));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x489202
movl %eax, %ebp
movq %rsp, %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x468308
shrl $0x3, %ebp
movq %r14, %rdi
movq %r12, %rsi
movl ... | /AST/Interp/Floating.h |
llvm::detail::DenseMapPair<clang::RecordDecl const*, clang::interp::Record*>* llvm::DenseMapBase<llvm::DenseMap<clang::RecordDecl const*, clang::interp::Record*, llvm::DenseMapInfo<clang::RecordDecl const*, void>, llvm::detail::DenseMapPair<clang::RecordDecl const*, clang::interp::Record*>>, clang::RecordDecl const*, c... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0xf194e3
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0xf194e5
incl 0x8... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.