name string | code string | asm string | file string |
|---|---|---|---|
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPDeviceClause(clang::OMPDeviceClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDevice());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPDeviceClause(
C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
C->getModifie... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x828e81
xorl %eax, %eax
jmp 0x828ead
movl 0x20(%r14), %esi
andq $-0x2, %rax
movl 0x1c(%r14), %r8d
movl 0x24(%r14), %r9d
movl (%r14), %ecx
movl 0x4(%r14), %edx
movq (%rbx), %rdi
movq 0x2f0(%rdi), %r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPHasDeviceAddrClause(clang::OMPHasDeviceAddrClause*) | OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
OMPHasDeviceAddrClause *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 nullpt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %esi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x6338e8
movl 0x10(... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPInReductionClause(clang::OMPInReductionClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *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;
V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x158(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %esi
leaq 0x148(%rsp), %r12
movq %r12, %r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPNocontextClause(clang::OMPNocontextClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
return nullptr;
return getDerived().RebuildOMPNocontextClause(
Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x82a3d5
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<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPNovariantsClause(clang::OMPNovariantsClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
return nullptr;
return getDerived().RebuildOMPNovariantsClause(
Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc(... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x82a4df
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<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPNumTasksClause(clang::OMPNumTasksClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTasks());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPNumTasksClause(
C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
C->ge... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
callq 0x80d386
cmpq $0x1, %rax
jne 0x82a525
xorl %eax, %eax
jmp 0x82a551
movl 0x20(%r14), %esi
andq $-0x2, %rax
movl 0x1c(%r14), %r8d
movl 0x24(%r14), %r9d
movl (%r14), %ecx
movl 0x4(%r14), %edx
movq (%rbx), %rdi
movq 0x2f0(%rdi), %r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::AdjustConstraintDepth>::TransformOMPToClause(clang::OMPToClause*) | OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (tran... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rsi), %eax
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
movl %ecx, 0x24(%rsp)
movl %eax, 0x28(%rsp)
movl %edx, 0x2c(%rsp)
leaq 0x168(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq... | /Sema/TreeTransform.h |
clang::Expr::hasPlaceholderType(clang::BuiltinType::Kind) const | QualType getType() const { return TR; } | movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x82bca8
cmpb $0xd, 0x10(%rcx)
jne 0x82bca8
movl 0x10(%rcx), %eax
shrl $0x13, %eax
andl $0x1ff, %eax # imm = 0x1FF
cmpl %esi, %eax
sete %al
retq
nop
| /clang/AST/Expr.h |
clang::Sema::CheckRedeclarationModuleOwnership(clang::NamedDecl*, clang::NamedDecl*) | bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) {
// [module.interface]p7:
// A declaration is attached to a module as follows:
// - If the declaration is a non-dependent friend declaration that nominates a
// function with a declarator-id that is a qualified-id or template-id or th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movzwl 0x1e(%rsi), %eax
testw $0x180, %ax # imm = 0x180
je 0x83b03e
movq %r14, %rdi
callq 0xe10828
movq %rax, %r15
movq %r12, %rd... | /Sema/SemaDecl.cpp |
clang::Sema::CheckRedeclarationExported(clang::NamedDecl*, clang::NamedDecl*) | bool Sema::CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old) {
// [module.interface]p1:
// An export-declaration shall inhabit a namespace scope.
//
// So it is meaningless to talk about redeclaration which is not at namespace
// scope.
if (!New->getLexicalDeclContext()
->getNonTranspare... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0x83b29c
movq 0x8(%rdi), %rdi
callq 0xe1db2c
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0x83b2b1
t... | /Sema/SemaDecl.cpp |
clang::Redeclarable<clang::TypedefNameDecl>::setPreviousDecl(clang::TypedefNameDecl*) | void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
// Note: This routine is implemented here because we need both NamedDecl
// and Redeclarable to be defined.
assert(RedeclLink.isFirst() &&
"setPreviousDecl on a decl already in a redeclaration chain");
if (PrevDecl) {
// Point to... | pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x83df55
movq 0x48(%rsi), %rdi
movq %rdi, 0x8(%rbx)
addq $0x40, %rdi
callq 0x7487b6
movq %rax, %rcx
andq $-0x4, %rcx
movq %rcx, (%rbx)
movl $0x260000, %ecx # imm = 0x260000
andl 0x1c(%rax), %ecx
orl %ecx, -0x24(%rbx)
movq 0x8(%rbx), %rdi
jmp 0x83df5d
leaq -0x40(%rb... | /clang/AST/Decl.h |
clang::Sema::AddOverriddenMethods(clang::CXXRecordDecl*, clang::CXXMethodDecl*) | bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
llvm::SmallPtrSet<const CXXMethodDecl*, 4> Overridden;
// Look for methods in base classes that this method might override.
CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
/*DetectVirtual=*/false);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq %rdx, (%r12)
leaq 0x40(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x4, -0x10(%rax)
andl $0x0, -0x8(%rax)
leaq 0x60(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, ... | /Sema/SemaDecl.cpp |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::UsedAttr*>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::UsedAttr* 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 0x85b12a
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x8738b4
jmp 0x85b179
cmpb $0x1, 0x5c(%rbx)
jne 0x85b179
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x85b14c
movq... | /clang/Sema/SemaBase.h |
llvm::DenseMap<clang::CXXMethodDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXMethodDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXMethodDecl 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 0x86e84a
movq %rbx, %rdi
movl %eax, %esi
callq 0x86e86c
testb %al, %al
je 0x86e842
movq %rbx, %rdi
popq %rbx
jmp 0x86e89e
andq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
clang::operator==(clang::specific_attr_iterator<clang::AsmLabelAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::AsmLabelAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Curr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
jae 0x870280
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x8702a4
movq (%r14), %r14
jmp 0x870296
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8702a4
movq (%rbx), %rbx
cmpq %r... | /clang/AST/AttrIterator.h |
clang::operator==(clang::specific_attr_iterator<clang::ConstAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::ConstAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Curr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
jae 0x872890
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x8728b4
movq (%r14), %r14
jmp 0x8728a6
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8728b4
movq (%rbx), %rbx
cmpq %r... | /clang/AST/AttrIterator.h |
clang::IFuncAttr* clang::getSpecificAttr<clang::IFuncAttr, llvm::SmallVector<clang::Attr*, 4u>>(llvm::SmallVector<clang::Attr*, 4u> const&) | inline SpecificAttr *getSpecificAttr(const Container& container) {
specific_attr_iterator<SpecificAttr, Container> i =
specific_attr_begin<SpecificAttr>(container);
if (i != specific_attr_end<SpecificAttr>(container))
return *i;
else
return nullptr;
} | pushq %rax
movq (%rdi), %rax
movq %rax, (%rsp)
movl 0x8(%rdi), %ecx
leaq (%rax,%rcx,8), %rsi
movq %rax, %rdi
callq 0x873be2
testb %al, %al
je 0x873bde
movq %rsp, %rdi
callq 0x873bec
jmp 0x873be0
xorl %eax, %eax
popq %rcx
retq
| /clang/AST/AttrIterator.h |
clang::SemaBase::SemaDiagnosticBuilder const& clang::SemaBase::SemaDiagnosticBuilder::operator<<<clang::AllocAlignAttr*, void>(clang::AllocAlignAttr*&&) const | const SemaDiagnosticBuilder &operator<<(T &&V) const {
if (ImmediateDiag)
*ImmediateDiag << std::move(V);
else if (PartialDiagId)
getDeviceDeferredDiags()[Fn][*PartialDiagId].second << std::move(V);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x875451
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x89b692
jmp 0x8754a0
cmpb $0x1, 0x5c(%rbx)
jne 0x8754a0
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x875473
movq... | /clang/Sema/SemaBase.h |
clang::Sema::CheckAttrTarget(clang::ParsedAttr const&) | bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
// Check whether the attribute is valid on the current target.
if (!AL.existsInTarget(Context.getTargetInfo())) {
Diag(AL.getLoc(), AL.isRegularKeywordAttribute()
? diag::err_keyword_not_supported_on_target
: ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100(%rdi), %rax
movq 0x4348(%rax), %rsi
movq %rbx, %rdi
callq 0x760ea4
movl %eax, %ebp
testb %al, %al
jne 0x8757f1
addq $0x8, %r14
movl 0x10(%rbx), %edx
btl $0x19, 0x1c(%rbx)
movl $0xa5, %eax
pushq $0x1f
popq %rcx
cmovae... | /Sema/SemaDeclAttr.cpp |
clang::Sema::mergeDLLImportAttr(clang::Decl*, clang::AttributeCommonInfo const&) | DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D,
const AttributeCommonInfo &CI) {
if (D->hasAttr<DLLExportAttr>()) {
Diag(CI.getLoc(), diag::warn_attribute_ignored) << "'dllimport'";
return nullptr;
}
if (D->hasAttr<DLLImportAttr>())
return nullptr;
return :... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x742170
testb %al, %al
je 0x87ab49
addq $0x8, %r14
movl 0x10(%rbx), %edx
movq %rsp, %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x83, %ecx
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x99e04... | /Sema/SemaDeclAttr.cpp |
clang::Sema::mergeDLLExportAttr(clang::Decl*, clang::AttributeCommonInfo const&) | DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D,
const AttributeCommonInfo &CI) {
if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
D->dropAttr<DLLImportAttr>();
}
if (D->hasAttr<DLLExpor... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x86af0a
movq %rax, (%rsp)
testq %rax, %rax
je 0x87abf0
leaq 0x8(%r14), %rsi
movl 0x10(%rax), %edx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x83, %ecx
xorl %r8d, %r8d
callq 0x7a6d9e
movq ... | /Sema/SemaDeclAttr.cpp |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::DLLImportAttr*>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::DLLImportAttr* 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 0x87ac5f
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x89c60a
jmp 0x87acae
cmpb $0x1, 0x5c(%rbx)
jne 0x87acae
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x87ac81
movq... | /clang/Sema/SemaBase.h |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::ReqdWorkGroupSizeAttr const*>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::ReqdWorkGroupSizeAttr 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 0x889027
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x89c980
jmp 0x889076
cmpb $0x1, 0x5c(%rbx)
jne 0x889076
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x889049
movq... | /clang/Sema/SemaBase.h |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::WorkGroupSizeHintAttr const*>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::WorkGroupSizeHintAttr 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 0x8890bf
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x89ca6e
jmp 0x88910e
cmpb $0x1, 0x5c(%rbx)
jne 0x88910e
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x8890e1
movq... | /clang/Sema/SemaBase.h |
clang::RecursiveASTVisitor<(anonymous namespace)::ArgumentDependenceChecker>::TraverseCXXRecordHelper(clang::CXXRecordDecl*) | bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
if (!TraverseRecordHelper(D))
return false;
if (D->isCompleteDefinition()) {
for (const auto &I : D->bases()) {
TRY_TO(TraverseCXXBaseSpecifier(I));
}
// We don't traverse the friends or the conversions, as they are... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8988d2
testb %al, %al
je 0x898980
movb $0x1, %bpl
testb $0x1, 0x4a(%r14)
je 0x898982
movq %r14, %rdi
callq 0x4d3726
movq %rax, %r14
movq %rdx, %r15
cmpq %r15, %r14
sete %bpl
je 0x898982
movq 0x10(%r14), %rdx
movq (%rdx), %rsi... | /clang/AST/RecursiveASTVisitor.h |
clang::SemaBase::SemaDiagnosticBuilder const& clang::operator<<<clang::AttributeArgumentNType>(clang::SemaBase::SemaDiagnosticBuilder const&, clang::AttributeArgumentNType 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 0x898be0
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x898c4c
jmp 0x898c2f
cmpb $0x1, 0x5c(%rbx)
jne 0x898c2f
movq %rbx, %rdi
callq 0x7a6d94
movq %rax, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x898c02
movq... | /clang/Sema/SemaBase.h |
bool llvm::is_contained<llvm::iterator_range<clang::ParamIdx*>, clang::ParamIdx>(llvm::iterator_range<clang::ParamIdx*>&&, clang::ParamIdx 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
movq 0x8(%rbx), %rsi
callq 0x89941b
cmpq 0x8(%rbx), %rax
setne %al
popq %rbx
retq
| /llvm/ADT/STLExtras.h |
clang::operator==(clang::specific_attr_iterator<clang::ReqdWorkGroupSizeAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::ReqdWorkGroupSizeAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Curr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq %rsi, %rdi
jae 0x89c912
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x89c936
movq (%r14), %r14
jmp 0x89c928
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x89c936
movq (%rbx), %rbx
cmpq %r... | /clang/AST/AttrIterator.h |
clang::OpenCLIntelReqdSubGroupSizeAttr* clang::getSpecificAttr<clang::OpenCLIntelReqdSubGroupSizeAttr, llvm::SmallVector<clang::Attr*, 4u>>(llvm::SmallVector<clang::Attr*, 4u> const&) | inline SpecificAttr *getSpecificAttr(const Container& container) {
specific_attr_iterator<SpecificAttr, Container> i =
specific_attr_begin<SpecificAttr>(container);
if (i != specific_attr_end<SpecificAttr>(container))
return *i;
else
return nullptr;
} | pushq %rax
movq (%rdi), %rax
movq %rax, (%rsp)
movl 0x8(%rdi), %ecx
leaq (%rax,%rcx,8), %rsi
movq %rax, %rdi
callq 0x89cacc
testb %al, %al
je 0x89cac8
movq %rsp, %rdi
callq 0x89cad6
jmp 0x89caca
xorl %eax, %eax
popq %rcx
retq
| /clang/AST/AttrIterator.h |
clang::Sema::DiagnoseAbsenceOfOverrideControl(clang::NamedDecl*, bool) | void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent) {
if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
return;
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
return;
SourceLocation Loc = MD->getLocation();
SourceL... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movb %dl, 0xf(%rsp)
testb $-0x80, 0x1c(%rsi)
jne 0x8a602c
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8a5cb2
testb %al, %al
jne 0x8a602c
movl 0x1c(%r15), %eax
andl $0x7c, %eax
xorl %r14d, %r14d
cmpl $0x20, %eax
cmoveq %r15, %r14
movq %r14, 0x10(%rsp)
testq %... | /Sema/SemaDeclCXX.cpp |
clang::Sema::ActOnRequiresClause(clang::ActionResult<clang::Expr*, true>) | ExprResult Sema::ActOnRequiresClause(ExprResult ConstraintExpr) {
if (ConstraintExpr.isInvalid())
return ExprError();
ConstraintExpr = CorrectDelayedTyposInExpr(ConstraintExpr);
if (ConstraintExpr.isInvalid())
return ExprError();
if (DiagnoseUnexpandedParameterPack(ConstraintExpr.get(),
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
cmpq $0x1, %rsi
je 0x8a7448
movq %rdi, %r14
leaq -0x27372a(%rip), %r8 # 0x633cec
leaq 0xf(%rsp), %r9
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x630cdc
cmpq $0x1, %rax
je 0x8a7448
movq %rax, %r15
movq %rax, %rsi
andq $-0x2, %rsi
pushq $0x17
popq %rdx... | /Sema/SemaDeclCXX.cpp |
clang::Sema::DiagnoseHiddenVirtualMethods(clang::CXXMethodDecl*) | void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {
if (MD->isInvalidDecl())
return;
if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
return;
SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
FindHiddenVirtualMethods(MD, OverloadedMethods);
if (!OverloadedMethods.empt... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
testb $-0x80, 0x1c(%rsi)
jne 0x8add0a
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rdi), %rdi
movl 0x18(%rsi), %edx
movl $0x1a64, %esi # imm = 0x1A64
callq 0x4fbfd8
testb %al, %al
jne 0x8add0a
leaq 0x28(%rsp), %rax
movq %rax, -0... | /Sema/SemaDeclCXX.cpp |
clang::Sema::DeclareImplicitCopyConstructor(clang::CXXRecordDecl*) | CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
CXXRecordDecl *ClassDecl) {
// C++ [class.copy]p4:
// If the class definition does not explicitly declare a copy
// constructor, one is declared implicitly.
assert(ClassDecl->needsImplicitCopyConstr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8bbac6
cmpb $0x0, 0x38(%r12)
je 0x8b3678
xorl %r15d, %r15d
jmp 0x8b3983
movq 0x100(%rbx), %rdi
movq %r14, ... | /Sema/SemaDeclCXX.cpp |
clang::Sema::DefineImplicitLambdaToFunctionPointerConversion(clang::SourceLocation, clang::CXXConversionDecl*) | void Sema::DefineImplicitLambdaToFunctionPointerConversion(
SourceLocation CurrentLocation,
CXXConversionDecl *Conv) {
SynthesizedFunctionScope Scope(*this, Conv);
assert(!Conv->getReturnType()->isUndeducedType());
QualType ConvRT = Conv->getType()->castAs<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, 0x4(%rsp)
movq %rdi, %r14
addq $0x48, %rdx
testq %rbx, %rbx
cmoveq %rbx, %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x8b18f4
movq 0x30(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4dee4e
movq 0... | /Sema/SemaDeclCXX.cpp |
checkSimpleDecomposition(clang::Sema&, llvm::ArrayRef<clang::BindingDecl*>, clang::ValueDecl*, clang::QualType, llvm::APSInt const&, clang::QualType, llvm::function_ref<clang::ActionResult<clang::Expr*, true> (clang::SourceLocation, clang::Expr*, unsigned int)>) | static bool checkSimpleDecomposition(
Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
if ((int64_t)Bindings.size() != NumElems) {
S.Diag(Src->get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r12
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
movq %r8, 0x30(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, %rdi
movq %rdx, %rsi
callq 0x7b2a40
testb %al, %al
je 0x8ce2d1
addq $0x8, %r14
movl 0x18(%r15), %edx... | /Sema/SemaDeclCXX.cpp |
clang::DeclContext::specific_decl_iterator<clang::FunctionTemplateDecl>::SkipToNextDecl() | void SkipToNextDecl() {
while (*Current && !isa<SpecificDecl>(*Current))
++Current;
} | movq (%rdi), %rax
testq %rax, %rax
je 0x8d4f12
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
cmpl $0x44, %ecx
je 0x8d4f12
movq 0x8(%rax), %rax
andq $-0x8, %rax
movq %rax, (%rdi)
jmp 0x8d4ef5
retq
nop
| /clang/AST/DeclBase.h |
llvm::detail::DenseMapPair<clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*>* llvm::DenseMapBase<llvm::DenseMap<clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*, llvm::DenseMapInfo<clang::CXXRecordDecl*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*>>, cla... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %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 0x8d590f
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x8d5911
incl 0x8... | /llvm/ADT/DenseMap.h |
clang::RecursiveASTVisitor<clang::Sema::DiagnoseImmediateEscalatingReason(clang::FunctionDecl*)::ImmediateEscalatingExpressionsVisitor>::TraverseTemplateParameterListHelper(clang::TemplateParameterList*) | bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
TemplateParameterList *TPL) {
if (TPL) {
for (NamedDecl *D : *TPL) {
TRY_TO(TraverseDecl(D));
}
if (Expr *RequiresClause = TPL->getRequiresClause()) {
TRY_TO(TraverseStmt(RequiresClause));
}
}
return true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %r15b
testq %rsi, %rsi
je 0x8dfd41
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %r15d
shll $0x3, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x8dfd16
movq 0x10(%r14,%r12), %rsi
movq %rbx, %rdi
callq 0x8a1e3a
addq $0x8, %r12
testb %al, %al
jne 0x8dfcf7
... | /clang/AST/RecursiveASTVisitor.h |
clang::RecursiveASTVisitor<clang::Sema::DiagnoseImmediateEscalatingReason(clang::FunctionDecl*)::ImmediateEscalatingExpressionsVisitor>::TraverseOpenACCAssociatedStmtConstruct(clang::OpenACCAssociatedStmtConstruct*) | bool RecursiveASTVisitor<Derived>::TraverseOpenACCAssociatedStmtConstruct(
OpenACCAssociatedStmtConstruct *S) {
TRY_TO(TraverseOpenACCConstructStmt(S));
TRY_TO(TraverseStmt(S->getAssociatedStmt()));
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %r13
movq %rsi, (%rsp)
movq 0x20(%rsi), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %r12
movq %rax, 0x8(%rsp)
cmpq %rax, %r13
je 0x8e0008
movq (%r13), %rsi
movq %rdi, ... | /clang/AST/RecursiveASTVisitor.h |
clang::RecursiveASTVisitor<(anonymous namespace)::FindCXXThisExpr>::TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc) | bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
NestedNameSpecifierLoc NNS) {
if (!NNS)
return true;
if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
switch (NNS.getNestedNameSpecifier()->getKind()) {
case NestedNameSpecifier::... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movb $0x1, %bl
testq %rsi, %rsi
je 0x8e4cb9
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
andq $-0x8, %rsi
je 0x8e4c8b
movq %r14, %rdi
callq 0x8e4c56
testb %al, %al
je 0x8e4cb7
movq %r15, %rdi
callq 0xf40b02
cmpl $0x6, %eax
... | /clang/AST/RecursiveASTVisitor.h |
clang::SemaObjC::DiagnoseMultipleMethodInGlobalPool(llvm::SmallVectorImpl<clang::ObjCMethodDecl*>&, clang::Selector, clang::SourceRange, bool) | void SemaObjC::DiagnoseMultipleMethodInGlobalPool(
SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R,
bool receiverIdOrClass) {
// We found multiple methods, so we may have to complain.
bool issueDiagnostic = false, issueError = false;
// We support a warning which complains about *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
testl %r8d, %r8d
movq %rdi, (%rsp)
je 0x8f260f
movq %rcx, %r15
callq 0x7a6c30
movq %rax, %rdi
movl $0x1aee, %esi # imm = 0x1AEE
movl %r15d, %edx
callq 0x4fbfd8
testb %... | /Sema/SemaDeclObjC.cpp |
clang::Sema::ActOnIdExpression(clang::Scope*, clang::CXXScopeSpec&, clang::SourceLocation, clang::UnqualifiedId&, bool, bool, clang::CorrectionCandidateCallback*, bool, clang::Token*) | ExprResult
Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
SourceLocation TemplateKWLoc, UnqualifiedId &Id,
bool HasTrailingLParen, bool IsAddressOfOperand,
CorrectionCandidateCallback *CCC,
bool IsInlineAsmIdentifier, T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movl %r9d, %ebp
movq %r8, %r13
movl %ecx, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x62ed78
testb %al, %al
je 0x90c999
pushq $0x1
popq %r13
jmp 0x90cc63
movl %ebp, 0x44(%r... | /Sema/SemaExpr.cpp |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | 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 0x9436b4
cmpq $0x1, %rax
jne 0x9452f4
pushq $0x1
popq %r15
jmp 0x945326
movq %rax, %r14
movq %rax, %r15
andq $-0x2, %r14
movq %r14, %rdi
movl $0x1ed, %esi # imm = 0x1... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | ExprResult
TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
return ExprError();
if (!getDerived().AlwaysRebuild() &&
SubExpr.get() == E->getSubExpr())
return E;
return getDerived().Rebuil... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x9436b4
cmpq $0x1, %rax
jne 0x946452
pushq $0x1
popq %rbx
jmp 0x946479
andq $-0x2, %rax
cmpq %rax, 0x10(%rbx)
je 0x946479
movq 0x20(%rbx), %rsi
movq (%r14), %rcx
movq 0x2d8(%rcx), %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
/*NotCopyInit*/ false);
if (Operand.isInvalid())
return ExprError();
// Rebuild the common-expr from the o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rsi
xorl %edx, %edx
callq 0x956448
cmpq $0x1, %rax
jne 0x9479b0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
movq 0x260(%rdi), %rsi
movl 0x10(%r... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | 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 0x94a5da
pushq $0x1
popq %r12
testq %rax, %rax
je 0x947d29
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x9436b4
cmpq $0x1, %rax
jne 0x947d38
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | ExprResult
TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
CXXPseudoDestructorExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
return ExprError();
ParsedType ObjectTypePtr;
bool MayBePseudoDestructor ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9436b4
cmpq $0x1, %rax
jne 0x9487d5
pushq $0x1
popq %r13
jmp 0x948b93
leaq 0x58(%rsp), %r9
andq $0x0, (%r9)
leaq 0x37(%rsp), %rdx
movb $0x0, (%rdx)
m... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | StmtResult
TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().g... | 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 $0x56
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x957c7a
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
return nullptr;
return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
C->getLPare... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9436b4
cmpq $0x1, %rax
jne 0x958e05
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<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | OMPClause *
TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *C) {
SmallVector<const Attr *> NewAttrs;
for (auto *A : C->getAttrs())
NewAttrs.push_back(getDerived().TransformAttr(A));
return getDerived().RebuildOMPXAttributeClause(
NewAttrs, C->getBeginLoc(), C->getLParenLoc(), C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%rax)
movq 0x10(%rsi), %r12
movl 0x18(%rsi), %r13d
shlq $0x3, %r13
xorl %ebp, %ebp
leaq 0x8(... | /Sema/TreeTransform.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | SourceLocation getSeverityKindKwLoc() 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 0xaa3192
nop
| /clang/AST/OpenMPClause.h |
clang::TreeTransform<RemoveNestedImmediateInvocation(clang::Sema&, clang::Sema::ExpressionEvaluationContextRecord&, std::reverse_iterator<llvm::PointerIntPair<clang::ConstantExpr*, 1u, unsigned int, llvm::PointerLikeTypeTraits<clang::ConstantExpr*>, llvm::PointerIntPairInfo<clang::ConstantExpr*, 1u, llvm::PointerLikeTy... | OMPClause *
TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSimdlen());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPSimdlenClause(
E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9436b4
cmpq $0x1, %rax
jne 0x95aa93
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 |
bool clang::RecursiveASTVisitor<ImmediateCallVisitor>::TraverseDeclTemplateParameterLists<clang::FunctionDecl>(clang::FunctionDecl*) | bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) {
for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) {
TemplateParameterList *TPL = D->getTemplateParameterList(i);
TraverseTemplateParameterListHelper(TPL);
}
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x38(%rbx), %rax
testb $0x4, %al
jne 0x974606
xorl %ecx, %ecx
jmp 0x974610
movq %rax, %rcx
andq $-0x8, %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %r15
jae 0x97462e
andq $-0x8, %rax
movq 0x18(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %r14... | /clang/AST/RecursiveASTVisitor.h |
clang::TreeTransform<EnsureImmediateInvocationInDefaultArgs>::TransformCXXForRangeStmt(clang::CXXForRangeStmt*) | StmtResult
TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
EnterExpressionEvaluationContext ForRangeInitContext(
getSema(), Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
/*LambdaContextDecl=*/nullptr,
Sema::ExpressionEvaluationContextRecord::EK_Other,
getSema(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0xf0(%rdi), %rax
movq (%rax), %rax
andl $0x8000, %eax # imm = 0x8000
movl %eax, %ecx
shrl $0xf, %ecx
movq %rdi, 0x88(%rsp)
movb %cl, 0x90(%rsp)
testq %rax, %rax
je 0x986c52... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformToPE>::TransformObjCSubscriptRefExpr(clang::ObjCSubscriptRefExpr*) | ExprResult
TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
return ExprError();
// Transform the key expression.
ExprResult Key = getDerived().TransformE... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0x9336b2
cmpq $0x1, %rax
je 0x98fe29
movq %rax, %r15
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x9336b2
cmpq $0x1, %rax
jne 0x98fe32
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x10(%r14), %esi
andq $-0x2, %r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformToPE>::TransformObjCIsaExpr(clang::ObjCIsaExpr*) | ExprResult
TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
return ExprError();
// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x9336b2
cmpq $0x1, %rax
jne 0x99044e
pushq $0x1
popq %rbx
jmp 0x9904f5
movq %rax, %rbx
andq $-0x2, %rbx
movl 0x18(%r15), %r13d
movl 0x1c(%r15), %ebp
movzbl 0x20(%r15), %eax
mov... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformToPE>::TransformCallExpr(clang::CallExpr*) | ExprResult
TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
return ExprError();
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().Transf... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x3(%rsi), %eax
movq (%rsi,%rax), %rsi
callq 0x9336b2
cmpq $0x1, %rax
jne 0x993167
pushq $0x1
popq %rbx
jmp 0x993255
movq %rax, %r15
leaq 0x17(%rsp), %r9
movb $0x0, (%r9)
leaq 0x50(%rsp), %rax
movq %rax, -0x10... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformToPE>::TransformSEHExceptStmt(clang::SEHExceptStmt*) | StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
if (FilterExpr.isInvalid())
return StmtError();
StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
return StmtE... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9336b2
cmpq $0x1, %rax
je 0x99d1e3
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x9a004e
cmpq $0x1, %rax
jne 0x99d1ec
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x8(%r14), %esi
andq $-0x2, %r1... | /Sema/TreeTransform.h |
(anonymous namespace)::TransformTypos::RecursiveTransformLoop(clang::Expr*, bool&) | ExprResult RecursiveTransformLoop(Expr *E, bool &IsAmbiguous) {
ExprResult Res;
auto SavedTypoExprs = std::move(SemaRef.TypoExprs);
SemaRef.TypoExprs.clear();
while (true) {
Res = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
// Recursion encountered an ambiguous correction. This m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x27c0, %esi # imm = 0x27C0
addq (%rdi), %rsi
leaq 0x108(%rsp), %rdi
callq 0x9d2e38
movq (%rbx), %rax
andl $0x0, 0x27c8(%rax)
leaq 0xa8(%rbx), %rax... | /Sema/SemaExprCXX.cpp |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformUnaryOperator(clang::UnaryOperator*) | ExprResult
TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
ExprResult SubExpr;
if (E->getOpcode() == UO_AddrOf)
SubExpr = TransformAddressOfOperand(E->getSubExpr());
else
SubExpr = TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
return ExprError();
if (!getDerived().Al... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7c0000, %eax # imm = 0x7C0000
andl (%rsi), %eax
movq 0x10(%rsi), %rsi
cmpl $0x100000, %eax # imm = 0x100000
jne 0x9d4b53
callq 0x9e2046
jmp 0x9d4b58
callq 0x9d39ae
cmpq $0x1, %rax
jne 0x9d4b6c
pushq $0x1
popq %rbx
movq %rbx, %rax
a... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformMemberExpr(clang::MemberExpr*) | ExprResult
TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
return ExprError();
NestedNameSpecifierLoc QualifierLoc;
if (E->hasQualifier()) {
QualifierLoc
= getDerived().TransformNestedNameSpecifierLoc(E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9d39ae
pushq $0x1
popq %r15
cmpq $0x1, %rax
je 0x9d7964
movq %rax, %rbp
testb $0x8, 0x2(%r13)
jne 0x9d74c2
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformGenericSelectionExpr(clang::GenericSelectionExpr*) | ExprResult
TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
ExprResult ControllingExpr;
TypeSourceInfo *ControllingType = nullptr;
if (E->isExprPredicate())
ControllingExpr = getDerived().TransformExpr(E->getControllingExpr());
else
ControllingType = getDerived().Transfor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x10(%rsi), %eax
btl $0x1e, %eax
jb 0x9d7d8a
andl $0x7fff, %eax # imm = 0x7FFF
movq 0x20(%r15,%rax,8), %rsi
movq %rbx, %rdi
callq 0x9db694
movq %rax, 0x30(%rsp)
testq %rax, %rax
sete 0x2f(%r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformConditionalOperator(clang::ConditionalOperator*) | ExprResult
TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
return ExprError();
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
return ExprError();
ExprResul... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x9d39ae
pushq $0x1
popq %r13
cmpq $0x1, %rax
je 0x9db594
movq %rax, %r15
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9db594
movq %rax, %r12
movq 0x28(%rbx), %rsi
movq %r14, %... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformTemplateArgument(clang::TemplateArgumentLoc const&, clang::TemplateArgumentLoc&, bool) | bool TreeTransform<Derived>::TransformTemplateArgument(
const TemplateArgumentLoc &Input, TemplateArgumentLoc &Output,
bool Uneval) {
const TemplateArgument &Arg = Input.getArgument();
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Pack:
llvm_unreachable("Unexpected Tem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl (%rsi), %eax
movb $0x1, %bpl
decl %eax
cmpl $0x7, %eax
ja 0x9e0618
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x843707(%rip), %rdx # 0x122399c
movslq (%rdx,%rax,4), %rax
a... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::RebuildUnresolvedUsingType(clang::SourceLocation, clang::Decl*) | QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
Decl *D) {
assert(D && "no decl found");
if (D->isInvalidDecl()) return QualType();
// FIXME: Doesn't account for ObjCInterfaceDecl!
if (auto *UPD = dyn_cast<UsingPackDecl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %esi, 0x34(%rsp)
movl 0x1c(%rdx), %eax
testb %al, %al
js 0x9e1f42
movq %rdi, %r14
andl $0x7f, %eax
xorl %r15d, %r15d
cmpl $0x34, %eax
cmoveq %rdx, %r15
movq %r15, 0x40(%rsp)
testq %r15, %r15
je 0x9e1f60
movl %esi, %ebp
movl 0x38(%r1... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformOMPTargetParallelForSimdDirective(clang::OMPTargetParallelForSimdDirective*) | StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
OMPTargetParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().Trans... | 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 $0x4a
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformOMPDistributeParallelForDirective(clang::OMPDistributeParallelForDirective*) | StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
OMPDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().Transf... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x14
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformOMPCancellationPointDirective(clang::OMPCancellationPointDirective*) | StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
OMPCancellationPointDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_cancellation_point, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecuta... | 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 $0x9
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, ... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformOMPBarrierDirective(clang::OMPBarrierDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_barrier, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getS... | 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 $0x4
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, ... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformIndirectGotoStmt(clang::IndirectGotoStmt*) | StmtResult
TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
ExprResult Target = getDerived().TransformExpr(S->getTarget());
if (Target.isInvalid())
return StmtError();
Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
if (!getDerived().AlwaysRebuild() &&
Target.get()... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x9d39ae
cmpq $0x1, %rax
jne 0x9e5fe3
pushq $0x1
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
andq $-0x2, %rax
movq %rax, %rsi
callq 0x9c5d36
movq (%r14), %rdi
andq $-0x2, %rax
cmpl $-0x1... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformExprs(clang::Expr* const*, unsigned int, bool, llvm::SmallVectorImpl<clang::Expr*>&, bool*) | bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
unsigned NumInputs,
bool IsCall,
SmallVectorImpl<Expr *> &Outputs,
bool *ArgChanged) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movq %r8, %r12
movl %ecx, 0x4(%rsp)
movq %rdi, 0x8(%rsp)
movl %edx, %ebp
xorl %ebx, %ebx
movq %rsi, 0x18(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
addq $-0x1, %rbp
setb %r15b
jae 0x9e7beb
movq (%rsi), %r13
cmpb $0x0,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::TransformTypos>::TransformOMPCollapseClause(clang::OMPCollapseClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPCollapseClause(
E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9d39ae
cmpq $0x1, %rax
jne 0x9e9961
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<(anonymous namespace)::TransformTypos>::TransformOMPCopyprivateClause(clang::OMPCopyprivateClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *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;
V... | 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<(anonymous namespace)::TransformTypos>::TransformOMPLastprivateClause(clang::OMPLastprivateClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *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;
V... | 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::CorrectDelayedTyposInExpr(clang::Expr*, clang::VarDecl*, bool, llvm::function_ref<clang::ActionResult<clang::Expr*, true> (clang::Expr*)>)::TyposReplace>::TransformUnresolvedMemberExpr(clang::UnresolvedMemberExpr*) | ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
UnresolvedMemberExpr *Old) {
// Transform the base of the expression.
ExprResult Base((Expr *)nullptr);
QualType BaseType;
if (!Old->isImplicitAccess()) {
Base = getDerived().TransformExpr(Old->getBase());
if (Base.isInvalid())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe95da2
pushq $0x1
popq %rbp
testb %al, %al
je 0x9f530b
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x9ffc4a
movq %rax, %r12
xorl %r15d, %r15d
movq 0x28(%r1... | /Sema/TreeTransform.h |
clang::TreeTransform<clang::Sema::CorrectDelayedTyposInExpr(clang::Expr*, clang::VarDecl*, bool, llvm::function_ref<clang::ActionResult<clang::Expr*, true> (clang::Expr*)>)::TyposReplace>::TransformObjCPropertyRefExpr(clang::ObjCPropertyRefExpr*) | ExprResult
TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
// 'super' and types never change. Property never changes. Just
// retain the existing expression.
if (!E->isObjectReceiver())
return E;
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq 0x28(%rsi), %rsi
testb $0x6, %sil
jne 0x9f5883
movq %rdi, %r15
andq $-0x8, %rsi
callq 0x9c7bc6
cmpq $0x1, %rax
jne 0x9f578d
pushq $0x1
popq %rbx
jmp 0x9f5883
movq %rax, %r14
movq (%r15), %rax
cmpl $-0x1, 0x3218(%rax)... | /Sema/TreeTransform.h |
llvm::DenseMap<clang::DeclarationName, llvm::TinyPtrVector<clang::NamedDecl*>, llvm::DenseMapInfo<clang::DeclarationName, void>, llvm::detail::DenseMapPair<clang::DeclarationName, llvm::TinyPtrVector<clang::NamedDecl*>>>::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 0xa629f9
movl %ebp, %edi
shlq $0x4, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0xa629fb
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 |
clang::SemaOpenMP::ActOnOpenMPOrderedClause(clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::Expr*) | OMPClause *SemaOpenMP::ActOnOpenMPOrderedClause(SourceLocation StartLoc,
SourceLocation EndLoc,
SourceLocation LParenLoc,
Expr *NumForLoops) {
// OpenMP [2.7.1, loop construc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, 0x4(%rsp)
movl %esi, %r15d
movq %rdi, %rbx
testq %r8, %r8
setne %al
testl %ecx, %ecx
setne %cl
andb %al, %cl
xorl %r13d, %r13d
cmpb $0x1, %cl
jne 0xaa109c
pushq $0x45
popq %rdx
pushq $0x1
popq %rcx
xorl %ebp, %ebp
m... | /Sema/SemaOpenMP.cpp |
clang::SemaOpenMP::ActOnOpenMPUpdateClause(clang::OpenMPDependClauseKind, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation) | OMPClause *SemaOpenMP::ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,
SourceLocation KindKwLoc,
SourceLocation StartLoc,
SourceLocation LParenLoc,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r15
cmpl $0xa, %esi
ja 0xaa2faf
movl $0x470, %eax # imm = 0x470
btl %r12d, %eax
jae 0xaa2faf
movups 0x79e0e3(%rip), %xmm0 # 0x124... | /Sema/SemaOpenMP.cpp |
clang::SemaOpenMP::ActOnOpenMPDeviceClause(clang::OpenMPDeviceClauseModifier, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation) | OMPClause *SemaOpenMP::ActOnOpenMPDeviceClause(
OpenMPDeviceClauseModifier Modifier, Expr *Device, SourceLocation StartLoc,
SourceLocation LParenLoc, SourceLocation ModifierLoc,
SourceLocation EndLoc) {
assert((ModifierLoc.isInvalid() || getLangOpts().OpenMP >= 50) &&
"Unexpected device modifier ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r9d, %r14d
movl %r8d, 0x24(%rsp)
movl %ecx, 0x1c(%rsp)
movq %rdx, %r13
movq %rdi, %r12
testl %r9d, %r9d
sete %al
movl %esi, 0x20(%rsp)
cmpl $0x2, %esi
setne %bpl
orb %al, %bpl
jne 0xaa4511
leaq 0x28(%rsp),... | /Sema/SemaOpenMP.cpp |
clang::SemaOpenMP::ActOnOpenMPNumTasksClause(clang::OpenMPNumTasksClauseModifier, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation) | OMPClause *SemaOpenMP::ActOnOpenMPNumTasksClause(
OpenMPNumTasksClauseModifier Modifier, Expr *NumTasks,
SourceLocation StartLoc, SourceLocation LParenLoc,
SourceLocation ModifierLoc, SourceLocation EndLoc) {
assert((ModifierLoc.isInvalid() || getLangOpts().OpenMP >= 51) &&
"Unexpected num_tasks ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebx
movl %esi, %r15d
movq %rdi, %r13
testl %r9d, %r9d
sete %al
cmpl $0x1, %esi
setne %sil
orb %al, %sil
jne 0xaa48b4
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
pushq $0x3e
popq %rbp
pushq $0x1
popq %rcx
movq %r15, %rdi
movl %ebp... | /Sema/SemaOpenMP.cpp |
rejectConstNotMutableType(clang::Sema&, clang::ValueDecl const*, clang::QualType, llvm::omp::Clause, clang::SourceLocation, bool, bool) | static bool rejectConstNotMutableType(Sema &SemaRef, const ValueDecl *D,
QualType Type, OpenMPClauseKind CKind,
SourceLocation ELoc,
bool AcceptIfMutable = true,
bool L... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %r13d
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq 0x100(%rdi), %r12
leaq 0x7(%rsp), %rcx
movq %rdx, %rsi
movl %r9d, %edx
callq 0xab5447
movl %eax, %ebx
testb %al, %al
je 0xaaba70
movzbl 0x7(%rsp)... | /Sema/SemaOpenMP.cpp |
clang::TreeTransform<(anonymous namespace)::ConstraintRefersToContainingTemplateChecker>::TransformCXXDefaultInitExpr(clang::CXXDefaultInitExpr*) | ExprResult
TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
FieldDecl *Field = cast_or_null<FieldDecl>(
getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
if (!Field)
return ExprError();
if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
E->getUs... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %r14
movq %r14, %rsi
callq 0xb81acc
testq %r14, %r14
je 0xb7ca88
movq (%r15), %r15
cmpl $-0x1, 0x3218(%r15)
jne 0xb7ca6e
cmpq 0x10(%rbx), %r14
jne 0xb7ca6e
movq 0x18(%rbx), %rax
cmpq 0x230(%r15), %rax
je 0xb7ca8b
movq %rbx, %rdi
callq 0xe... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::ConstraintRefersToContainingTemplateChecker>::TransformOMPMaskedDirective(clang::OMPMaskedDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_masked, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x69
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb8b2b0
movq %rax,... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::ConstraintRefersToContainingTemplateChecker>::TransformOMPNumTeamsClause(clang::OMPNumTeamsClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTeams());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPNumTeamsClause(
E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
callq 0xb529b6
cmpq $0x1, %rax
jne 0xb8d8e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andq $-0x2, %rax
movl 0x1c(%r14), %ecx
movl (%r14), %edx
movl 0x4(%r14), %r8d
movq (%rbx), %rsi
movq 0x2f0(%rsi), %rdi
movq %rax, %r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::CurrentInstantiationRebuilder>::TransformCoawaitExpr(clang::CoawaitExpr*) | ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
/*NotCopyInit*/ false);
if (Operand.isInvalid())
return ExprError();
// Rebuild the common-expr from the o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rsi
xorl %edx, %edx
callq 0xba29ae
cmpq $0x1, %rax
jne 0xb9a050
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
movq 0x260(%rdi), %rsi
movl 0x10(%r... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::CurrentInstantiationRebuilder>::TransformCallExpr(clang::CallExpr*) | ExprResult
TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
return ExprError();
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().Transf... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x3(%rsi), %eax
movq (%rsi,%rax), %rsi
callq 0xb67660
cmpq $0x1, %rax
jne 0xb9a643
pushq $0x1
popq %rbx
jmp 0xb9a750
movq %rax, %r15
leaq 0x17(%rsp), %r9
movb $0x0, (%r9)
leaq 0x50(%rsp), %rax
movq %rax, -0x10... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::CurrentInstantiationRebuilder>::TransformArraySubscriptExpr(clang::ArraySubscriptExpr*) | ExprResult
TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
return ExprError();
ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
return ExprError();
if (!getDeriv... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0xb67660
pushq $0x1
popq %r13
cmpq $0x1, %rax
je 0xb9ce6f
movq %rax, %r15
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xb67660
cmpq $0x1, %rax
jne 0xb9ce7c
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
pop... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::CurrentInstantiationRebuilder>::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 0xb679ac
testq %rax, %rax
je 0xb9d2c9
movq %rax... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::CurrentInstantiationRebuilder>::TransformOMPNovariantsClause(clang::OMPNovariantsClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
return nullptr;
return getDerived().RebuildOMPNovariantsClause(
Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc(... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xb67660
cmpq $0x1, %rax
jne 0xba65c3
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<(anonymous namespace)::CurrentInstantiationRebuilder>::TransformOMPNumTasksClause(clang::OMPNumTasksClause*) | OMPClause *
TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTasks());
if (E.isInvalid())
return nullptr;
return getDerived().RebuildOMPNumTasksClause(
C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
C->ge... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
callq 0xb67660
cmpq $0x1, %rax
jne 0xba6609
xorl %eax, %eax
jmp 0xba6635
movl 0x20(%r14), %esi
andq $-0x2, %rax
movl 0x1c(%r14), %r8d
movl 0x24(%r14), %r9d
movl (%r14), %ecx
movl 0x4(%r14), %edx
movq (%rbx), %rdi
movq 0x2f0(%rdi), %r... | /Sema/TreeTransform.h |
GetTypeOfFunction(clang::Sema&, clang::OverloadExpr::FindResult const&, clang::FunctionDecl*) | static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
FunctionDecl *Fn) {
// We may need to deduce the return type of the function now.
if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
S.DeduceReturnType(Fn, R.Expression->ge... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0xf0(%rdi), %rax
testb $0x10, 0x1(%rax)
je 0xbb5f8d
movq %rbx, %rdi
callq 0x4deab2
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x7bacd8
testb %al, %al
je 0xbb5f8d
movq (%r15), %rdi
callq 0xe4a970
xorl %r12d, %r12d
... | /Sema/SemaTemplateDeduction.cpp |
clang::Sema::OriginalCallArg const* llvm::SmallVectorTemplateCommon<clang::Sema::OriginalCallArg, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::Sema::OriginalCallArg, true>>(llvm::SmallVectorTemplateBase<clang::Sema::OriginalCallArg, true>*, clang::Sema::OriginalCallArg const&, unsigned l... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %edx
addq %rax, %rcx
cmpq %rdx, %rcx
ja 0xbb606b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rdx
imulq $0x18, %rax, %rax
addq %rdx, %... | /llvm/ADT/SmallVector.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformSizeOfPackExpr(clang::SizeOfPackExpr*) | ExprResult
TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
// If E is not value-dependent, then nothing will change when we transform it.
// Note: This is an instantiation-centric view.
if (!E->isValueDependent())
return E;
EnterExpressionEvaluationContext Unevaluated(
getSema(),... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, %rbx
testb $0x1, 0x2(%rsi)
je 0xbbaa17
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, 0x70(%rsp)
movb $0x1, 0x78(%rsp)
xorl %r13d, %r13d
pushq $0x3
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x92fd... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformRequiresExpr(clang::RequiresExpr*) | ExprResult
TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
SmallVector<ParmVarDecl*, 4> TransParams;
SmallVector<QualType, 4> TransParamTypes;
Sema::ExtParameterInfoBuilder ExtParamInfos;
// C++2a [expr.prim.req]p2
// Expressions appearing within a requirement-body are unevaluated operands.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x138(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformBuiltinBitCastExpr(clang::BuiltinBitCastExpr*) | ExprResult
TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
TypeSourceInfo *TSI =
getDerived().TransformType(BCE->getTypeInfoAsWritten());
if (!TSI)
return ExprError();
ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
if (Sub.isInvalid())
return ExprEr... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0xbaf644
testq %rax, %rax
je 0xbbe23e
movq %rax, %r15
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xbb9d04
cmpq $0x1, %rax
jne 0xbbe247
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
andq $-0x2, %rax
movl 0x20(%r14), %... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformCXXNewExpr(clang::CXXNewExpr*) | ExprResult
TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
// Transform the type that we're allocating
TypeSourceInfo *AllocTypeInfo =
getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
if (!AllocTypeInfo)
return ExprError();
// Transform the size of the array we'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0xbcd628
pushq $0x1
popq %rbp
testq %rax, %rax
je 0xbbf76d
movq %rax, %r15
movl (%rbx), %eax
btl $0x13, %eax
jb 0xbbf48a
xorl %r13d, %r13d
jmp 0xbbf4bc
movq %rbx, %rdi
callq 0x8... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformAddrLabelExpr(clang::AddrLabelExpr*) | ExprResult
TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
E->getLabel());
if (!LD)
return ExprError();
return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0xbc1b7e
testq %rax, %rax
je 0xbc0c8e
movl 0x10(%r14), %esi
movl 0x14(%r14), %edx
movq (%rbx), %rdi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92fc5a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::SubstituteDeducedTypeTransform>::TransformSwitchStmt(clang::SwitchStmt*) | StmtResult
TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
return StmtError();
// Transform the condition.
Sema::ConditionResult Cond = getDerived().TransformCondition(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, 0x1(%rsi)
jne 0xbc3d98
xorl %esi, %esi
jmp 0xbc3d9c
movq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbc348e
cmpq $0x1, %rax
jne 0xbc3db5
pushq $0x1
popq %r15
jmp 0xbc3e65
movq %rax... | /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::ExtractTypeForDeductionGuide>::TransformOMPInterchangeDirective(clang::OMPInterchangeDirective*) | StmtResult TreeTransform<Derived>::TransformOMPInterchangeDirective(
OMPInterchangeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
movq %rsi, %rbx
andl $0x0, 0x8(%rdx)
movq %rdi, %r14
andq $0x0, 0x10(%rdx)
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0x8(%rsi), %esi
movl 0xc(%rbx), %r8d
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc035b6
movq %rax, ... | /Sema/TreeTransform.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.