name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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->getModifierLoc(), C->getEndLoc());
} | 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), %rdi
movl %edx, (%rsp)
movq %rax, %rdx
callq 0xaa4460
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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 nullptr;
Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
} | 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(%r14), %r13d
shlq $0x3, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x8296f8
movq 0x50(%r14,%rbp), %rsi
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x82972b
andq $-0x2, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x8296cb
movl 0xc(%r14), %eax
movl (%r14), %edx
movl 0x4(%r14), %esi
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movl %eax, 0x4(%rcx)
movl %esi, 0x8(%rcx)
movq 0x18(%rsp), %rsi
movl 0x20(%rsp), %edx
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
callq 0xaaa7f6
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x633cd8
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
if (!NameInfo.getName())
return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
// Transform all the decls.
if (E) {
auto *ULE = cast<UnresolvedLookupExpr>(E);
UnresolvedSet<8> Decls;
for (auto *D : ULE->decls()) {
NamedDecl *InstD =
cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
Decls.addDecl(InstD, InstD->getAccess());
}
UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
SemaRef.Context, /*NamingClass=*/nullptr,
ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
/*ADL=*/true, Decls.begin(), Decls.end(),
/*KnownDependent=*/false, /*KnownInstantiationDependent=*/false));
} else
UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPInReductionClause(
Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
} | 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, %rdi
callq 0x6338e8
leaq 0x60(%r14), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%r14), %r13d
shlq $0x3, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x82987b
movq 0x60(%r14,%rbp), %rsi
movq %rbx, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x829ac5
andq $-0x2, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x82984a
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x75a106
movups 0x48(%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x58(%r14), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8298f1
leaq 0xb8(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x821238
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movaps %xmm0, (%r12)
cmpq $0x0, (%r12)
je 0x829ab5
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movl 0x10(%r14), %eax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,8), %rcx
leaq (%rcx,%rax,8), %rcx
leaq (%rcx,%rax,8), %rcx
leaq (%rcx,%rax,8), %rbp
leaq (,%rax,8), %rax
addq %rbp, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %r15
cmpq 0x8(%rsp), %rbp
je 0x829a36
movq (%rbp), %rax
testq %rax, %rax
je 0x829a1e
leaq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x38(%rsp)
xorl %ecx, %ecx
cmpb $0x19, (%rax)
setne %cl
shll $0x4, %ecx
leaq (%rax,%rcx), %r12
addq $0x40, %r12
movl 0x4(%rax), %r13d
shlq $0x3, %r13
testq %r13, %r13
je 0x8299b8
movq (%r12), %rsi
andq $-0x8, %rsi
movq %rbx, %rdi
callq 0x81d820
movl 0x1c(%rax), %esi
shrl $0xd, %esi
andl $0x3, %esi
orq %rax, %rsi
movq %r15, %rdi
callq 0x6ddc58
addq $0x8, %r12
addq $-0x8, %r13
jmp 0x829985
movq (%rbx), %rax
movq 0x100(%rax), %r12
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0x75a186
movq %rdx, %rcx
movq 0x30(%rsp), %r10
movl 0x38(%rsp), %edx
leaq (%r10,%rdx,8), %r11
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
leaq 0x10(%rsp), %r8
pushq $0x1
popq %r9
pushq $0x0
pushq $0x0
pushq %r11
pushq %r10
callq 0xe9382e
addq $0x20, %rsp
leaq 0xb8(%rsp), %rdi
movq %rax, %rsi
callq 0x63144a
movq %r15, %rdi
callq 0x64b0a4
jmp 0x829a2d
leaq 0xb8(%rsp), %rdi
xorl %esi, %esi
callq 0x63144a
addq $0x8, %rbp
jmp 0x829939
movq 0x148(%rsp), %rsi
movl 0x150(%rsp), %edx
movl 0xc(%r14), %r8d
movl 0x30(%r14), %r9d
movl (%r14), %ecx
movl 0x4(%r14), %eax
leaq 0xb8(%rsp), %r14
movq (%r14), %rdi
movl 0x8(%r14), %r10d
movq %rdi, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq (%rbx), %rdi
movq 0x2f0(%rdi), %rdi
subq $0x30, %rsp
movups 0x60(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
leaq 0x40(%rsp), %r10
movq %r10, 0x10(%rsp)
leaq 0xb0(%rsp), %r10
movq %r10, 0x8(%rsp)
movl %eax, (%rsp)
callq 0xaa6d98
addq $0x30, %rsp
movq %rax, %r15
movq %r14, %rdi
callq 0x633cd8
jmp 0x829ab8
xorl %r15d, %r15d
leaq 0x88(%rsp), %rdi
callq 0x4f0656
leaq 0x148(%rsp), %rdi
callq 0x633cd8
movq %r15, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa1b36
nop
| /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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa19d0
nop
| /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->getModifierLoc(), C->getEndLoc());
} | 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), %rdi
movl %edx, (%rsp)
movq %rax, %rdx
callq 0xaa4810
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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 (transformOMPMappableExprListClause<Derived, OMPToClause>(
*this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
return nullptr;
return getDerived().RebuildOMPToClause(
C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
} | 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 $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andq $0x0, (%rsp)
movaps %xmm0, 0x50(%rsp)
andl $0x0, 0x8(%rsp)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xd8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %esi
leaq 0x158(%rsp), %r12
movq %r12, %rdi
callq 0x6338e8
leaq 0x68(%rbx), %r13
movq %rbx, 0x18(%rsp)
movl 0x10(%rbx), %ebx
shlq $0x3, %rbx
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x82b2ea
movq (%r13,%rbp), %rsi
movq %r14, %rdi
callq 0x80d386
cmpq $0x1, %rax
je 0x82b530
andq $-0x2, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x82b2b9
movq 0x18(%rsp), %rbx
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x82b31a
movq 0x30(%rbx), %rdx
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x81dc62
testq %rax, %rax
je 0x82b530
movq %rax, %rsi
jmp 0x82b31e
xorl %edx, %edx
xorl %esi, %esi
leaq 0x40(%rsp), %rdi
callq 0x75a106
movups 0x38(%rbx), %xmm0
movaps %xmm0, (%rsp)
movq 0x48(%rbx), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rsp)
je 0x82b373
leaq 0x78(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x821238
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movaps %xmm0, (%r12)
cmpq $0x0, (%r12)
je 0x82b52d
movl 0x10(%rbx), %eax
leaq (,%rax,8), %rbp
addq %r13, %rbp
leaq (,%rax,8), %r12
addq %rbp, %r12
leaq 0x78(%rsp), %r15
cmpq %r12, %rbp
je 0x82b48f
movq (%rbp), %rax
testq %rax, %rax
je 0x82b477
leaq 0x88(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x80(%rsp)
xorl %ecx, %ecx
cmpb $0x19, (%rax)
setne %cl
shll $0x4, %ecx
leaq (%rax,%rcx), %r13
addq $0x40, %r13
movl 0x4(%rax), %ebx
shlq $0x3, %rbx
testq %rbx, %rbx
je 0x82b413
movq (%r13), %rsi
andq $-0x8, %rsi
movq %r14, %rdi
callq 0x81d820
movl 0x1c(%rax), %esi
shrl $0xd, %esi
andl $0x3, %esi
orq %rax, %rsi
movq %r15, %rdi
callq 0x6ddc58
addq $0x8, %r13
addq $-0x8, %rbx
jmp 0x82b3e0
movq (%r14), %rax
movq 0x100(%rax), %r13
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x75a186
movq %rdx, %rcx
movq 0x78(%rsp), %r10
movl 0x80(%rsp), %edx
leaq (%r10,%rdx,8), %r11
movq %r13, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %rsp, %r8
pushq $0x1
popq %r9
pushq $0x0
pushq $0x0
pushq %r11
pushq %r10
callq 0xe9382e
addq $0x20, %rsp
leaq 0xc8(%rsp), %rdi
movq %rax, %rsi
callq 0x63144a
movq %r15, %rdi
callq 0x64b0a4
jmp 0x82b486
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
callq 0x63144a
addq $0x8, %rbp
jmp 0x82b391
movq 0x18(%rsp), %rcx
leaq 0x50(%rcx), %rsi
movl 0x60(%rcx), %eax
addq $0x58, %rcx
movq 0x158(%rsp), %r9
movl 0x160(%rsp), %edx
movq 0xc8(%rsp), %rdi
movl 0xd0(%rsp), %r8d
movq %rdi, 0x78(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq (%r14), %rdx
movq 0x2f0(%rdx), %rdi
subq $0x40, %rsp
movups 0xb8(%rsp), %xmm0
movups %xmm0, 0x28(%rsp)
movups 0x70(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
leaq 0x64(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movl %eax, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
pushq $0x2
popq %rdx
leaq 0x80(%rsp), %r9
movq %rdx, %r8
callq 0xaa9658
addq $0x40, %rsp
movq %rax, %r15
jmp 0x82b530
xorl %r15d, %r15d
leaq 0xc8(%rsp), %rdi
callq 0x633cd8
leaq 0x48(%rsp), %rdi
callq 0x4f0656
leaq 0x158(%rsp), %rdi
callq 0x633cd8
movq %r15, %rax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 that
// nominates a class other than with an elaborated-type-specifier with neither
// a nested-name-specifier nor a simple-template-id, it is attached to the
// module to which the friend is attached ([basic.link]).
if (New->getFriendObjectKind() &&
Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) {
New->setLocalOwningModule(Old->getOwningModule());
makeMergedDefinitionVisible(New);
return false;
}
Module *NewM = New->getOwningModule();
Module *OldM = Old->getOwningModule();
if (NewM && NewM->isPrivateModule())
NewM = NewM->Parent;
if (OldM && OldM->isPrivateModule())
OldM = OldM->Parent;
if (NewM == OldM)
return false;
if (NewM && OldM) {
// A module implementation unit has visibility of the decls in its
// implicitly imported interface.
if (NewM->isModuleImplementation() && OldM == ThePrimaryInterface)
return false;
// Partitions are part of the module, but a partition could import another
// module, so verify that the PMIs agree.
if ((NewM->isModulePartition() || OldM->isModulePartition()) &&
getASTContext().isInSameModule(NewM, OldM))
return false;
}
bool NewIsModuleInterface = NewM && NewM->isNamedModule();
bool OldIsModuleInterface = OldM && OldM->isNamedModule();
if (NewIsModuleInterface || OldIsModuleInterface) {
// C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]:
// if a declaration of D [...] appears in the purview of a module, all
// other such declarations shall appear in the purview of the same module
Diag(New->getLocation(), diag::err_mismatched_owning_module)
<< New
<< NewIsModuleInterface
<< (NewIsModuleInterface ? NewM->getFullModuleName() : "")
<< OldIsModuleInterface
<< (OldIsModuleInterface ? OldM->getFullModuleName() : "");
Diag(Old->getLocation(), diag::note_previous_declaration);
New->setInvalidDecl();
return true;
}
return false;
} | 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, %rdi
callq 0xe10828
cmpq %rax, %r15
je 0x83b03e
movq %r14, %rdi
callq 0x707640
movq %rax, -0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa5700e
jmp 0x83b187
movq %r12, %rdi
callq 0x707640
movq %rax, %r13
movq %r14, %rdi
callq 0x707640
movq %rax, %r15
testq %r13, %r13
je 0x83b066
cmpl $0x7, 0x24(%r13)
jne 0x83b069
movq 0x28(%r13), %r13
jmp 0x83b069
xorl %r13d, %r13d
testq %r15, %r15
je 0x83b07b
cmpl $0x7, 0x24(%r15)
jne 0x83b07e
movq 0x28(%r15), %r15
jmp 0x83b07e
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x83b187
testq %r13, %r13
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x83b0dc
movl 0x24(%r13), %eax
cmpl $0x3, %eax
jne 0x83b0ad
cmpq 0x2b60(%rbx), %r15
je 0x83b187
andl $-0x2, %eax
cmpl $0x4, %eax
je 0x83b0c1
movl 0x24(%r15), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x83b0e1
movq 0x100(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xd96170
testb %al, %al
je 0x83b0e1
jmp 0x83b187
testq %r13, %r13
je 0x83b0fd
movl 0x24(%r13), %ecx
cmpq $0x7, %rcx
ja 0x83b0fd
shll $0x3, %ecx
movabsq $0x100010101010000, %rax # imm = 0x100010101010000
shrq %cl, %rax
jmp 0x83b0ff
xorl %eax, %eax
movb %al, 0xd(%rsp)
testq %r15, %r15
je 0x83b122
movl 0x24(%r15), %ecx
cmpl $0x7, %ecx
ja 0x83b122
movl $0xbc, %edx
btl %ecx, %edx
jae 0x83b122
movb $0x1, 0xc(%rsp)
jmp 0x83b12b
movb $0x0, 0xc(%rsp)
testb %al, %al
je 0x83b187
addq $0x8, %rbx
movl 0x18(%r12), %edx
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0xef7, %ecx # imm = 0xEF7
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x79c4bf
leaq 0xd(%rsp), %rbp
movq %rax, %rdi
movq %rbp, %rsi
callq 0x78a537
movq %rax, %r12
movb (%rbp), %bpl
cmpb $0x1, %bpl
jne 0x83b19b
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1072c2c
jmp 0x83b1b1
xorl %eax, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa47525(%rip), %rsi # 0x12826c7
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x450adc
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x795ea0
leaq 0xc(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x78a537
movq %rax, %r12
movb (%r13), %r13b
cmpb $0x1, %r13b
jne 0x83b1ec
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1072c2c
jmp 0x83b202
leaq 0xa474d4(%rip), %rsi # 0x12826c7
leaq 0x38(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x450adc
leaq 0x38(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x795ea0
movq %r15, %rdi
callq 0x436d30
testb %r13b, %r13b
leaq 0x18(%rsp), %rdi
callq 0x436d30
testb %bpl, %bpl
leaq 0x58(%rsp), %rdi
callq 0x78b0f8
movl 0x18(%r14), %edx
leaq 0xb8(%rsp), %r14
pushq $0x73
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r14, %rdi
callq 0x78b0f8
movq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0xe19692
movb $0x1, %al
jmp 0x83b189
nop
| /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()
->getNonTransparentContext()
->isFileContext() ||
!Old->getLexicalDeclContext()
->getNonTransparentContext()
->isFileContext())
return false;
bool IsNewExported = New->isInExportDeclContext();
bool IsOldExported = Old->isInExportDeclContext();
// It should be irrevelant if both of them are not exported.
if (!IsNewExported && !IsOldExported)
return false;
if (IsOldExported)
return false;
// If the Old declaration are not attached to named modules
// and the New declaration are attached to global module.
// It should be fine to allow the export since it doesn't change
// the linkage of declarations. See
// https://github.com/llvm/llvm-project/issues/98583 for details.
if (!Old->isInNamedModule() && New->getOwningModule() &&
New->getOwningModule()->isImplicitGlobalModule())
return false;
assert(IsNewExported);
auto Lk = Old->getFormalLinkage();
int S = 0;
if (Lk == Linkage::Internal)
S = 1;
else if (Lk == Linkage::Module)
S = 2;
Diag(New->getLocation(), diag::err_redeclaration_non_exported) << New << S;
Diag(Old->getLocation(), diag::note_previous_declaration);
return true;
} | 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
testl %eax, %eax
jne 0x83b327
movq 0x10(%r14), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0x83b2c4
movq 0x8(%rdi), %rdi
callq 0xe1db2c
movzwl 0x8(%rax), %eax
andl $0x7f, %eax
cmpl $0x15, %eax
je 0x83b2d9
testl %eax, %eax
jne 0x83b327
movq %r15, %rdi
callq 0xe1d8ce
movl %eax, %ebp
movq %r14, %rdi
callq 0xe1d8ce
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x83b3bf
testb %bpl, %bpl
je 0x83b3bf
movq %r14, %rdi
callq 0xe1d9ea
testb %al, %al
jne 0x83b32e
movq %r15, %rdi
callq 0x707640
testq %rax, %rax
je 0x83b32e
movq %r15, %rdi
callq 0x707640
cmpl $0x8, 0x24(%rax)
jne 0x83b32e
xorl %eax, %eax
jmp 0x83b3bf
movq %r14, %rdi
callq 0xe1007c
andl $0x0, 0xc(%rsp)
cmpb $0x5, %al
je 0x83b351
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x83b359
movl $0x1, 0xc(%rsp)
jmp 0x83b359
movl $0x2, 0xc(%rsp)
addq $0x8, %rbx
movl 0x18(%r15), %edx
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x11b6, %ecx # imm = 0x11B6
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x79c4bf
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x7a3ec7
movq %r15, %rdi
callq 0x78b0f8
movl 0x18(%r14), %edx
leaq 0x18(%rsp), %r14
pushq $0x73
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r14, %rdi
callq 0x78b0f8
movb $0x1, %al
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 previous. Make sure that this is actually the most recent
// redeclaration, or we can build invalid chains. If the most recent
// redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
First = PrevDecl->getFirstDecl();
assert(First->RedeclLink.isFirst() && "Expected first");
decl_type *MostRecent = First->getNextRedeclaration();
RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
// If the declaration was previously visible, a redeclaration of it remains
// visible even if it wouldn't be visible by itself.
static_cast<decl_type*>(this)->IdentifierNamespace |=
MostRecent->getIdentifierNamespace() &
(Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
} else {
// Make this first.
First = static_cast<decl_type*>(this);
}
// First one will point to this one as latest.
First->RedeclLink.setLatest(static_cast<decl_type*>(this));
assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||
cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid());
} | 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(%rbx), %rdi
movq %rdi, 0x8(%rbx)
addq $0x40, %rdi
addq $-0x40, %rbx
movq %rbx, %rsi
popq %rbx
jmp 0x70d8fe
| /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);
auto VisitBase = [&] (const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl();
DeclarationName Name = MD->getDeclName();
if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
// We really want to find the base class destructor here.
QualType T = Context.getTypeDeclType(BaseRecord);
CanQualType CT = Context.getCanonicalType(T);
Name = Context.DeclarationNames.getCXXDestructorName(CT);
}
for (NamedDecl *BaseND : BaseRecord->lookup(Name)) {
CXXMethodDecl *BaseMD =
dyn_cast<CXXMethodDecl>(BaseND->getCanonicalDecl());
if (!BaseMD || !BaseMD->isVirtual() ||
IsOverride(MD, BaseMD, /*UseMemberUsingDeclRules=*/false,
/*ConsiderCudaAttrs=*/true))
continue;
if (!CheckExplicitObjectOverride(MD, BaseMD))
continue;
if (Overridden.insert(BaseMD).second) {
MD->addOverriddenMethod(BaseMD);
CheckOverridingFunctionReturnType(MD, BaseMD);
CheckOverridingFunctionAttributes(MD, BaseMD);
CheckOverridingFunctionExceptionSpec(MD, BaseMD);
CheckIfOverriddenFunctionIsMarkedFinal(MD, BaseMD);
}
// A method can only override one function from each base class. We
// don't track indirectly overridden methods from bases of bases.
return true;
}
return false;
};
DC->lookupInBases(VisitBase, Paths);
return !Overridden.empty();
} | 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, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x79e6ca
leaq 0x8(%rsp), %rdx
movq %r12, (%rdx)
movq %r14, 0x8(%rdx)
leaq 0x20(%rsp), %r14
movq %r14, 0x10(%rdx)
leaq 0x1f438(%rip), %rsi # 0x871d30
movq %rbx, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe0b86c
movl 0x14(%r14), %eax
cmpl 0x18(%r14), %eax
setne %bl
movq %r15, %rdi
callq 0x79e90e
movq %r14, %rdi
callq 0x45228c
movl %ebx, %eax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x85b14e
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x8738a2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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.Current == Right.Current;
} | 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 %rbx, %r14
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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.Current == Right.Current;
} | 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 %rbx, %r14
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x875475
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x89b680
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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
: diag::warn_unknown_attribute_ignored)
<< AL << AL.getRange();
AL.setInvalid();
return true;
}
return false;
} | 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
cmovael %eax, %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x760e16
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
orb $0x1, 0x32(%rbx)
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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 ::new (Context) DLLImportAttr(Context, CI);
} | 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 0x99e047(%rip), %rsi # 0x1218b7e
movq %rbx, %rdi
callq 0x7a0055
movq %rbx, %rdi
callq 0x78b0f8
jmp 0x87ab86
movq %r15, %rdi
callq 0x788640
testb %al, %al
je 0x87ab5a
xorl %r15d, %r15d
jmp 0x87ab86
movl $0x850, %edi # imm = 0x850
addq 0x100(%r14), %rdi
pushq $0x28
popq %rsi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, %r15
movq 0x100(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xde9b3e
movq %r15, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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<DLLExportAttr>())
return nullptr;
return ::new (Context) DLLExportAttr(Context, CI);
} | 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 %rsp, %rsi
movq %r12, %rdi
callq 0x87ac3c
movq %r12, %rdi
callq 0x78b0f8
movq %r15, %rdi
callq 0x86b106
movq %r15, %rdi
callq 0x742170
testb %al, %al
je 0x87ac01
xorl %r15d, %r15d
jmp 0x87ac2d
movl $0x850, %edi # imm = 0x850
addq 0x100(%r14), %rdi
pushq $0x28
popq %rsi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, %r15
movq 0x100(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xde99a4
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x87ac83
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x89c5f8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x88904b
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x89c96e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x8890e3
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x89ca5c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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
// already in decls_begin()/decls_end().
}
return true;
} | 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
addq $0x8, %rdx
movq %rbx, %rdi
callq 0x893756
addq $0x18, %r14
testb %al, %al
jne 0x89895a
jmp 0x898982
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 (%rdi), %rax
callq *0x20(%rax)
jmp 0x898c04
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75ce8c
movl 0x58(%rbx), %ecx
movq 0x8(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x898c3c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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_end(Range);
} | 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.Current == Right.Current;
} | 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 %rbx, %r14
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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();
SourceLocation SpellingLoc = Loc;
if (getSourceManager().isMacroArgExpansion(Loc))
SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
return;
if (MD->size_overridden_methods() > 0) {
auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {
unsigned DiagID =
Inconsistent && !Diags.isIgnored(DiagInconsistent, MD->getLocation())
? DiagInconsistent
: DiagSuggest;
Diag(MD->getLocation(), DiagID) << MD->getDeclName();
const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
};
if (isa<CXXDestructorDecl>(MD))
EmitDiag(
diag::warn_inconsistent_destructor_marked_not_override_overriding,
diag::warn_suggest_destructor_marked_not_override_overriding);
else
EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
diag::warn_suggest_function_marked_not_override_overriding);
}
} | 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 %r14, %r14
je 0x8a602c
testb $0x2, 0x1d(%r14)
jne 0x8a602c
movq %r14, %rdi
callq 0x8a5cca
testb %al, %al
jne 0x8a602c
movl 0x18(%r14), %r15d
movq 0x118(%rbx), %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x107f4ec
testb %al, %al
je 0x8a5fb6
movq 0x118(%rbx), %rdi
movl %r15d, %esi
callq 0x107f56e
movq %rax, %r15
movq 0x118(%rbx), %rdi
movl %r15d, %esi
callq 0x55ae2e
testl %eax, %eax
je 0x8a5fdb
movq 0x118(%rbx), %rdi
movl %eax, %esi
callq 0x4d3fa2
testb %al, %al
jne 0x8a602c
movq %r14, %rdi
callq 0xe24286
testl %eax, %eax
je 0x8a602c
leaq 0xf(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x1c(%r14), %eax
andl $0x7f, %eax
leaq 0x18(%rsp), %rdi
cmpl $0x21, %eax
jne 0x8a601d
movl $0x19a5, %esi # imm = 0x19A5
movl $0x1afd, %edx # imm = 0x1AFD
jmp 0x8a6027
movl $0x19a6, %esi # imm = 0x19A6
movl $0x1afe, %edx # imm = 0x1AFE
callq 0x8a6036
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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(),
UPPC_RequiresClause))
return ExprError();
return ConstraintExpr;
} | 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
movq %r14, %rdi
callq 0xc6ade2
testb %al, %al
pushq $0x1
popq %rbx
cmoveq %r15, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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.empty()) {
Diag(MD->getLocation(), diag::warn_overloaded_virtual)
<< MD << (OverloadedMethods.size() > 1);
NoteHiddenVirtualMethods(MD, OverloadedMethods);
}
} | 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, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8a5ce2
cmpl $0x0, 0x8(%r15)
je 0x8add00
leaq 0x8(%rbx), %rsi
movl 0x18(%r14), %edx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movl $0x1a64, %ecx # imm = 0x1A64
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x833394
leaq 0x18(%rsp), %r12
cmpl $0x2, 0x8(%r12)
leaq 0xf(%rsp), %rsi
setae (%rsi)
movq %rax, %rdi
callq 0x77c590
movq %r14, %rdi
callq 0x78b0f8
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8a5e48
leaq 0x18(%rsp), %rdi
callq 0x791452
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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->needsImplicitCopyConstructor());
DeclaringSpecialMember DSM(*this, ClassDecl,
CXXSpecialMemberKind::CopyConstructor);
if (DSM.isAlreadyBeingDeclared())
return nullptr;
QualType ClassType = Context.getTypeDeclType(ClassDecl);
QualType ArgType = ClassType;
ArgType = Context.getElaboratedType(ElaboratedTypeKeyword::None, nullptr,
ArgType, nullptr);
bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
if (Const)
ArgType = ArgType.withConst();
LangAS AS = getDefaultCXXMethodAddrSpace();
if (AS != LangAS::Default)
ArgType = Context.getAddrSpaceQualType(ArgType, AS);
ArgType = Context.getLValueReferenceType(ArgType);
bool Constexpr = defaultedSpecialMemberIsConstexpr(
*this, ClassDecl, CXXSpecialMemberKind::CopyConstructor, Const);
DeclarationName Name
= Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(ClassType));
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationNameInfo NameInfo(Name, ClassLoc);
// An implicitly-declared copy constructor is an inline public
// member of its class.
CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
ExplicitSpecifier(), getCurFPFeatures().isFPConstrained(),
/*isInline=*/true,
/*isImplicitlyDeclared=*/true,
Constexpr ? ConstexprSpecKind::Constexpr
: ConstexprSpecKind::Unspecified);
CopyConstructor->setAccess(AS_public);
CopyConstructor->setDefaulted();
setupImplicitSpecialMemberType(CopyConstructor, Context.VoidTy, ArgType);
if (getLangOpts().CUDA)
CUDA().inferTargetForImplicitSpecialMember(
ClassDecl, CXXSpecialMemberKind::CopyConstructor, CopyConstructor,
/* ConstRHS */ Const,
/* Diagnose */ false);
// During template instantiation of special member functions we need a
// reliable TypeSourceInfo for the parameter types in order to allow functions
// to be substituted.
TypeSourceInfo *TSI = nullptr;
if (inTemplateInstantiation() && ClassDecl->isLambda())
TSI = Context.getTrivialTypeSourceInfo(ArgType);
// Add the parameter to the constructor.
ParmVarDecl *FromParam =
ParmVarDecl::Create(Context, CopyConstructor, ClassLoc, ClassLoc,
/*IdentifierInfo=*/nullptr, ArgType,
/*TInfo=*/TSI, SC_None, nullptr);
CopyConstructor->setParams(FromParam);
CopyConstructor->setTrivial(
ClassDecl->needsOverloadResolutionForCopyConstructor()
? SpecialMemberIsTrivial(CopyConstructor,
CXXSpecialMemberKind::CopyConstructor)
: ClassDecl->hasTrivialCopyConstructor());
CopyConstructor->setTrivialForCall(
ClassDecl->hasAttr<TrivialABIAttr>() ||
(ClassDecl->needsOverloadResolutionForCopyConstructor()
? SpecialMemberIsTrivial(CopyConstructor,
CXXSpecialMemberKind::CopyConstructor,
TAH_ConsiderTrivialABI)
: ClassDecl->hasTrivialCopyConstructorForCall()));
// Note that we have declared this constructor.
++getASTContext().NumImplicitCopyConstructorsDeclared;
Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
if (ShouldDeleteSpecialMember(CopyConstructor,
CXXSpecialMemberKind::CopyConstructor)) {
ClassDecl->setImplicitCopyConstructorIsDeleted();
SetDeclDeleted(CopyConstructor, ClassLoc);
}
if (S)
PushOnScopeChains(CopyConstructor, S, false);
ClassDecl->addDecl(CopyConstructor);
return CopyConstructor;
} | 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, %rsi
xorl %edx, %edx
callq 0x7344c0
movq %rax, %r13
movq 0x100(%rbx), %rdi
pushq $0x6
popq %rsi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0xdac6e6
movq %rax, %r12
movq %r14, %rdi
callq 0x8aff62
movzbl %al, %r15d
movq %r15, %rbp
orq %r12, %rbp
movq %rbx, %rdi
callq 0x78aa34
testl %eax, %eax
je 0x8b36d8
movq 0x100(%rbx), %rdi
movq %rbp, %rsi
movl %eax, %edx
callq 0xd9b956
movq %rax, %rbp
movq 0x100(%rbx), %rdi
movq %rbp, %rsi
pushq $0x1
popq %rbp
movl %ebp, %edx
callq 0xd9d434
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8affa5
movl %eax, %ebp
movl $0x43a0, %edi # imm = 0x43A0
addq 0x100(%rbx), %rdi
movq %r13, %rax
andq $-0x10, %rax
andl $0x7, %r13d
orq 0x8(%rax), %r13
movq %r13, %rsi
callq 0xe18dae
movq %r15, 0x50(%rsp)
movl 0x18(%r14), %r15d
leaq 0x70(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x64b05c
movq 0x100(%rbx), %r12
leaq 0xe8(%rbx), %rdi
callq 0x83c8be
movzbl %bpl, %ecx
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movups %xmm0, 0x28(%rsp)
movl %ecx, 0x20(%rsp)
pushq $0x1
popq %rcx
movl %ecx, 0x18(%rsp)
andq $0x0, 0x38(%rsp)
movl %ecx, 0x10(%rsp)
andq $0x0, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, 0x44(%rsp)
movl %r15d, %edx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe247e6
movq %rax, %r15
andb $-0x61, 0x1d(%rax)
orb $0x2, 0x53(%rax)
movq 0x100(%rbx), %rax
movq 0x47e8(%rax), %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x48(%rsp), %rcx
callq 0x8bb9b6
movq 0xf0(%rbx), %rax
testb $0x10, 0x3c(%rax)
je 0x8b3803
movq 0x298(%rbx), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
movq %r15, %rcx
movq 0x50(%rsp), %r8
xorl %r9d, %r9d
callq 0x834bfe
movl 0x2cf8(%rbx), %eax
cmpl 0x31f4(%rbx), %eax
jbe 0x8b3827
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x8b3827
testb $0x10, 0xa(%rax)
jne 0x8b39a5
xorl %eax, %eax
movq 0x100(%rbx), %rdi
movq %r15, %rsi
addq $0x48, %rsi
movq 0x48(%rsp), %r9
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq %rax, (%rsp)
movl 0x44(%rsp), %ecx
movl %ecx, %edx
xorl %r8d, %r8d
callq 0xe12688
leaq 0x58(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x75ede8
movq %r14, %rdi
callq 0x8b3612
testb %al, %al
je 0x8b388d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b263c
jmp 0x8b3895
movq %r14, %rdi
callq 0x86e7ea
movzbl %al, %eax
shll $0x7, %eax
movl $0xffffff7f, %ecx # imm = 0xFFFFFF7F
andl 0x52(%r15), %ecx
orl %eax, %ecx
movl %ecx, 0x52(%r15)
movq %r14, %rdi
callq 0x8ad656
testb %al, %al
je 0x8b38bc
movl 0x52(%r15), %ecx
jmp 0x8b38f5
movq %r14, %rdi
callq 0x8b3612
testb %al, %al
je 0x8b38e3
pushq $0x1
popq %rcx
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ecx, %edx
xorl %r8d, %r8d
callq 0x8b263c
movl 0x52(%r15), %ecx
jmp 0x8b38f1
movq %r14, %rdi
callq 0x8be870
movl 0x52(%r15), %ecx
xorl %ebp, %ebp
testb %al, %al
je 0x8b38fa
movl $0x100, %ebp # imm = 0x100
andl $0xfffffeff, %ecx # imm = 0xFFFFFEFF
orl %ebp, %ecx
movl %ecx, 0x52(%r15)
movq 0x100(%rbx), %rax
incl 0x5854(%rax)
leaq 0x40(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x78bd9e
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8bb87c
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b023a
testb %al, %al
je 0x8b3963
movq %r14, %rdi
callq 0x8be880
movq %rbx, %rdi
movq %r15, %rsi
movl 0x44(%rsp), %edx
xorl %ecx, %ecx
callq 0x8b0ec6
testq %r13, %r13
je 0x8b3978
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x83aac0
movq %r12, %rdi
movq %r15, %rsi
callq 0xe1e5f8
leaq 0x88(%rsp), %rdi
callq 0x8bbbd2
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x100(%rbx), %rdi
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0xd91190
jmp 0x8b3829
nop
| /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<FunctionType>()->getReturnType();
CallingConv CC =
ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
CXXRecordDecl *Lambda = Conv->getParent();
FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
FunctionDecl *Invoker =
CallOp->hasCXXExplicitFunctionObjectParameter() || CallOp->isStatic()
? CallOp
: Lambda->getLambdaStaticInvoker(CC);
if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
CallOp = InstantiateFunctionDeclaration(
CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
if (!CallOp)
return;
if (CallOp != Invoker) {
Invoker = InstantiateFunctionDeclaration(
Invoker->getDescribedFunctionTemplate(), TemplateArgs,
CurrentLocation);
if (!Invoker)
return;
}
}
if (CallOp->isInvalidDecl())
return;
// Mark the call operator referenced (and add to pending instantiations
// if necessary).
// For both the conversion and static-invoker template specializations
// we construct their body's in this function, so no need to add them
// to the PendingInstantiations.
MarkFunctionReferenced(CurrentLocation, CallOp);
if (Invoker != CallOp) {
// Fill in the __invoke function with a dummy implementation. IR generation
// will fill in the actual details. Update its type in case it contained
// an 'auto'.
Invoker->markUsed(Context);
Invoker->setReferenced();
Invoker->setType(Conv->getReturnType()->getPointeeType());
Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
}
// Construct the body of the conversion function { return __invoke; }.
Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(), VK_LValue,
Conv->getLocation());
assert(FunctionRef && "Can't refer to __invoke function?");
Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
Conv->setBody(CompoundStmt::Create(Context, Return, FPOptionsOverride(),
Conv->getLocation(), Conv->getLocation()));
Conv->markUsed(Context);
Conv->setReferenced();
if (ASTMutationListener *L = getASTMutationListener()) {
L->CompletedImplicitDefinition(Conv);
if (Invoker != CallOp)
L->CompletedImplicitDefinition(Invoker);
}
} | 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 0x18(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1ca6
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4dee4e
movl 0x10(%rax), %r13d
movq %rbx, %rdi
callq 0x6363bc
movq %rax, %rbp
movq %rax, %rdi
callq 0xe2288e
movq %rax, %r15
movq %rax, %rdi
callq 0xe13b8e
movq %r15, %r12
testb %al, %al
jne 0x8bec2c
movzwl 0x50(%r15), %eax
andl $0xe000, %eax # imm = 0xE000
movq %r15, %r12
cmpw $0x4000, %ax # imm = 0x4000
je 0x8bec2c
shrl $0x13, %r13d
andl $0x1f, %r13d
movq %rbp, %rdi
movl %r13d, %esi
callq 0xe228da
movq %rax, %r12
movq %rbx, %rdi
callq 0xe12ae2
testq %rax, %rax
je 0x8bec96
movq %rax, %r13
movq %r15, %rdi
callq 0xe12d0c
pushq $0x3
popq %r8
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
movl 0x4(%rsp), %ebp
movl %ebp, %ecx
callq 0xc4bf82
testq %rax, %rax
je 0x8bedac
movq %rax, %r15
cmpq %r12, %rax
je 0x8bec9a
movq %r12, %rdi
callq 0xe12d0c
pushq $0x3
popq %r8
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
movl %ebp, %ecx
callq 0xc4bf82
movq %rax, %r12
testq %rax, %rax
jne 0x8bec9a
jmp 0x8bedac
movl 0x4(%rsp), %ebp
testb $-0x80, 0x1c(%r15)
jne 0x8bedac
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x9346a0
cmpq %r15, %r12
je 0x8bed13
movq 0x100(%r14), %rsi
movq %r12, %rdi
callq 0xe1cda6
orb $0x8, 0x1d(%r12)
movq %rbx, %rdi
callq 0x4deab2
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1ca6
movq %rax, 0x30(%r12)
movq 0x100(%r14), %rsi
pushq $0x10
popq %rdi
pushq $0x8
popq %rdx
callq 0xf6553c
movq %rax, %r13
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x8bbd38
movq %r12, %rdi
movq %r13, %rsi
callq 0xe12dea
movq 0x30(%r12), %rdx
movl 0x18(%rbx), %r8d
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x9111fc
movl 0x18(%rbx), %esi
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb311a6
andq $-0x2, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x100(%r14), %rdi
movl 0x18(%rbx), %r8d
pushq $0x1
popq %rdx
xorl %ecx, %ecx
movl %r8d, %r9d
callq 0xf68272
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe12dea
movq 0x100(%r14), %rsi
movq %rbx, %rdi
callq 0xe1cda6
orb $0x8, 0x1d(%rbx)
movq %r14, %rdi
callq 0x787aa4
testq %rax, %rax
je 0x8bedac
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
cmpq %r15, %r12
je 0x8bedac
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x58(%rax)
leaq 0x10(%rsp), %rdi
callq 0x8b1e82
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
<< DecompType << (unsigned)Bindings.size()
<< (unsigned)NumElems.getLimitedValue(UINT_MAX)
<< toString(NumElems, 10) << (NumElems < Bindings.size());
return true;
}
unsigned I = 0;
for (auto *B : Bindings) {
SourceLocation Loc = B->getLocation();
ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
if (E.isInvalid())
return true;
E = GetInit(Loc, E.get(), I++);
if (E.isInvalid())
return true;
B->setBinding(ElemType, E.get());
}
return false;
} | 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
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0xcd4, %ecx # imm = 0xCD4
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x787c63
leaq 0x44(%rsp), %rsi
movl %ebx, (%rsi)
movq %rax, %rdi
callq 0x78fe52
movq %rax, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r12, %rdi
callq 0x4933fc
leaq 0x40(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x78fe52
movq %rax, %r14
leaq 0x48(%rsp), %r13
pushq $0xa
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x7b178c
movq %r14, %rdi
movq %r13, %rsi
callq 0x795ea0
movq %rax, %r14
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7c07a8
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x77c590
movq %r13, %rdi
callq 0x436d30
movq %r15, %rdi
callq 0x78b0f8
movb $0x1, %r15b
movl %r15d, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x20(%rsp)
leaq 0x108(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
shlq $0x3, %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
setne %r15b
je 0x8ce2bc
movq 0x28(%rsp), %rax
movq (%rax,%rbp,8), %r13
movl 0x18(%r13), %r12d
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
pushq $0x1
popq %rcx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x9111fc
cmpq $0x1, %rax
je 0x8ce2bc
andq $-0x2, %rax
movq 0x10(%rsp), %rdi
movl %r12d, %esi
movq %rax, %rdx
movl %ebp, %ecx
callq *0x18(%rsp)
cmpq $0x1, %rax
je 0x8ce2bc
andq $-0x2, %rax
movq 0x100(%rsp), %rcx
movq %rcx, 0x30(%r13)
movq %rax, 0x40(%r13)
incq %rbp
addq $-0x8, %rbx
jmp 0x8ce2f5
| /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*>>, clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*, llvm::DenseMapInfo<clang::CXXRecordDecl*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*>>::InsertIntoBucketImpl<clang::CXXRecordDecl*>(clang::CXXRecordDecl* const&, clang::CXXRecordDecl* const&, llvm::detail::DenseMapPair<clang::CXXRecordDecl*, clang::ConstructorUsingShadowDecl*>*) | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl 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(%rbx)
movq (%rsp), %rax
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x8d5907
decl 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x8d592a
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8d5802
jmp 0x8d58f4
nop
| /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
xorl %r15d, %r15d
jmp 0x8dfd41
movl 0xc(%r14), %eax
btl $0x1e, %eax
jae 0x8dfd3e
shll $0x3, %eax
movq 0x10(%r14,%rax), %rsi
testq %rsi, %rsi
je 0x8dfd3e
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8d7bc2
testb %al, %al
je 0x8dfd41
movb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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, %rbp
callq 0x4cfae0
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r14
cmpq %r15, 0x10(%rsp)
jne 0x8dffc6
cmpq %r14, 0x18(%rsp)
je 0x8dffe9
movq %r12, %rdi
callq 0x4cfb22
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x8d7bc2
testb %al, %al
je 0x8dfff7
movq %r12, %rdi
callq 0x4cfb38
jmp 0x8dffb8
addq $0x8, %r13
movq %rbp, %rdi
movq 0x8(%rsp), %rax
jmp 0x8dff89
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8d7bc2
jmp 0x8dfff9
| /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::Identifier:
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Super:
return true;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
break;
}
return true;
} | 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
ja 0x8e4cb9
pushq $0x67
popq %rcx
btl %eax, %ecx
jb 0x8e4cb9
movq %rsp, %rdi
callq 0xf41042
movq %r14, %rdi
movq %rax, %rsi
callq 0x8c5706
testb %al, %al
jne 0x8e4cb9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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 *any* difference in
// method signature.
bool strictSelectorMatch =
receiverIdOrClass &&
!getDiagnostics().isIgnored(diag::warn_strict_multiple_method_decl,
R.getBegin());
if (strictSelectorMatch) {
for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_strict)) {
issueDiagnostic = true;
break;
}
}
}
// If we didn't see any strict differences, we won't see any loose
// differences. In ARC, however, we also need to check for loose
// mismatches, because most of them are errors.
if (!strictSelectorMatch ||
(issueDiagnostic && getLangOpts().ObjCAutoRefCount))
for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
// This checks if the methods differ in type mismatch.
if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_loose) &&
!isAcceptableMethodMismatch(Methods[0], Methods[I])) {
issueDiagnostic = true;
if (getLangOpts().ObjCAutoRefCount)
issueError = true;
break;
}
}
if (issueDiagnostic) {
if (issueError)
Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
else if (strictSelectorMatch)
Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
else
Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
Diag(Methods[0]->getBeginLoc(),
issueError ? diag::note_possibility : diag::note_using)
<< Methods[0]->getSourceRange();
for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
Diag(Methods[I]->getBeginLoc(), diag::note_also_found)
<< Methods[I]->getSourceRange();
}
}
} | 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 %al, %al
je 0x8f274d
xorl %ecx, %ecx
movl %ecx, 0xc(%rsp)
movl 0x8(%rbx), %r12d
pushq $0x1
popq %r13
movq (%rsp), %r15
cmpl %r13d, %r12d
je 0x8f2798
movq (%rbx), %rax
movq (%rax), %rsi
movl %r13d, %r14d
movq (%rax,%r14,8), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x8ee260
testb %al, %al
jne 0x8f26c1
movq (%rbx), %rax
movq (%rax), %rbp
testb $0x2, 0x3a(%rbp)
je 0x8f26c9
movq (%rax,%r14,8), %r15
movq %rbp, %rdi
callq 0xe292d0
movl %r12d, %r14d
movl %eax, %r12d
movq %r15, %rdi
callq 0xe292d0
cmpb %al, %r12b
movq (%rsp), %r15
jne 0x8f26c9
movq 0x28(%rbp), %rax
movq %rax, 0x28(%rsp)
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8f26c9
movl %r14d, %r12d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x106de50
movq %rax, %rdi
movq %rdx, %rsi
leaq 0xb4e29b(%rip), %rdx # 0x144093c
pushq $0x6
popq %rcx
callq 0x476ce5
testb %al, %al
jne 0x8f26c9
movq 0x50(%rbp), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x78fdc0
testb %al, %al
je 0x8f26c9
incl %r13d
jmp 0x8f2621
movq %r15, %rdi
callq 0x7a6c3c
testb $0x8, 0x6b(%rax)
jne 0x8f2703
cmpb $0x0, 0xc(%rsp)
jne 0x8f27a3
leaq 0x10(%rsp), %r15
movl (%r15), %edx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq (%rsp), %r14
movq %r14, %rsi
movl $0x19f2, %ecx # imm = 0x19F2
jmp 0x8f27bf
movq %r15, %r14
leaq 0x10(%rsp), %r15
movl (%r15), %edx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0xab7, %ecx # imm = 0xAB7
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x8f2943
movq %rax, %rdi
movq %r15, %rsi
callq 0x78a7b2
movq %r12, %rdi
callq 0x78b0f8
pushq $0x71
jmp 0x8f27e9
movl 0x8(%rbx), %r14d
pushq $0x1
popq %rbp
movl %ebp, %r15d
movq (%rsp), %r12
cmpl %r15d, %r14d
je 0x8f2884
movq (%rbx), %rax
movq (%rax), %rsi
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdx
movq %r12, %rdi
movl %ebp, %ecx
callq 0x8ee260
incl %r15d
testb %al, %al
jne 0x8f275b
movq %r12, %rdi
callq 0x7a6c3c
movb $0x1, %cl
testb $0x8, 0x6b(%rax)
jne 0x8f2611
jmp 0x8f27a3
cmpb $0x0, 0xc(%rsp)
je 0x8f2884
leaq 0x10(%rsp), %r15
movl (%r15), %edx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq (%rsp), %r14
movq %r14, %rsi
movl $0x1aee, %ecx # imm = 0x1AEE
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x8f2943
movq %rax, %rdi
movq %r15, %rsi
callq 0x78a7b2
movq %r12, %rdi
callq 0x78b0f8
pushq $0x7a
popq %rcx
pushq $0x1
popq %r13
movq (%rbx), %rax
movq (%rax), %rax
movl 0x18(%rax), %edx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7a6d9e
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
movl 0x8(%rbx), %r14d
pushq $0x65
popq %rbp
jmp 0x8f287f
movl %r13d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movl 0x18(%rax), %edx
movq %r15, %rdi
movq (%rsp), %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x7a6d9e
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x20(%rsp)
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
callq 0x75caca
movq %r15, %rdi
callq 0x78b0f8
incl %r13d
cmpl %r13d, %r14d
jne 0x8f2837
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&
"cannot be direct & operand and have a trailing lparen");
if (SS.isInvalid())
return ExprError();
TemplateArgumentListInfo TemplateArgsBuffer;
// Decompose the UnqualifiedId into the following data.
DeclarationNameInfo NameInfo;
const TemplateArgumentListInfo *TemplateArgs;
DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
DeclarationName Name = NameInfo.getName();
IdentifierInfo *II = Name.getAsIdentifierInfo();
SourceLocation NameLoc = NameInfo.getLoc();
if (II && II->isEditorPlaceholder()) {
// FIXME: When typed placeholders are supported we can create a typed
// placeholder expression node.
return ExprError();
}
// This specially handles arguments of attributes appertains to a type of C
// struct field such that the name lookup within a struct finds the member
// name, which is not the case for other contexts in C.
if (isAttrContext() && !getLangOpts().CPlusPlus && S->isClassScope()) {
// See if this is reference to a field of struct.
LookupResult R(*this, NameInfo, LookupMemberName);
// LookupName handles a name lookup from within anonymous struct.
if (LookupName(R, S)) {
if (auto *VD = dyn_cast<ValueDecl>(R.getFoundDecl())) {
QualType type = VD->getType().getNonReferenceType();
// This will eventually be translated into MemberExpr upon
// the use of instantiated struct fields.
return BuildDeclRefExpr(VD, type, VK_LValue, NameLoc);
}
}
}
// Perform the required lookup.
LookupResult R(*this, NameInfo,
(Id.getKind() == UnqualifiedIdKind::IK_ImplicitSelfParam)
? LookupObjCImplicitSelfParam
: LookupOrdinaryName);
if (TemplateKWLoc.isValid() || TemplateArgs) {
// Lookup the template name again to correctly establish the context in
// which it was found. This is really unfortunate as we already did the
// lookup to determine that it was a template name in the first place. If
// this becomes a performance hit, we can work harder to preserve those
// results until we get here but it's likely not worth it.
AssumedTemplateKind AssumedTemplate;
if (LookupTemplateName(R, S, SS, /*ObjectType=*/QualType(),
/*EnteringContext=*/false, TemplateKWLoc,
&AssumedTemplate))
return ExprError();
if (R.wasNotFoundInCurrentInstantiation() || SS.isInvalid())
return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
IsAddressOfOperand, TemplateArgs);
} else {
bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
LookupParsedName(R, S, &SS, /*ObjectType=*/QualType(),
/*AllowBuiltinCreation=*/!IvarLookupFollowUp);
// If the result might be in a dependent base class, this is a dependent
// id-expression.
if (R.wasNotFoundInCurrentInstantiation() || SS.isInvalid())
return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
IsAddressOfOperand, TemplateArgs);
// If this reference is in an Objective-C method, then we need to do
// some special Objective-C lookup, too.
if (IvarLookupFollowUp) {
ExprResult E(ObjC().LookupInObjCMethod(R, S, II, true));
if (E.isInvalid())
return ExprError();
if (Expr *Ex = E.getAs<Expr>())
return Ex;
}
}
if (R.isAmbiguous())
return ExprError();
// This could be an implicitly declared function reference if the language
// mode allows it as a feature.
if (R.empty() && HasTrailingLParen && II &&
getLangOpts().implicitFunctionsAllowed()) {
NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
if (D) R.addDecl(D);
}
// Determine whether this name might be a candidate for
// argument-dependent lookup.
bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
if (R.empty() && !ADL) {
if (SS.isEmpty() && getLangOpts().MSVCCompat) {
if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
TemplateKWLoc, TemplateArgs))
return E;
}
// Don't diagnose an empty lookup for inline assembly.
if (IsInlineAsmIdentifier)
return ExprError();
// If this name wasn't predeclared and if this is not a function
// call, diagnose the problem.
TypoExpr *TE = nullptr;
DefaultFilterCCC DefaultValidator(II, SS.isValid() ? SS.getScopeRep()
: nullptr);
DefaultValidator.IsAddressOfOperand = IsAddressOfOperand;
assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&
"Typo correction callback misconfigured");
if (CCC) {
// Make sure the callback knows what the typo being diagnosed is.
CCC->setTypoName(II);
if (SS.isValid())
CCC->setTypoNNS(SS.getScopeRep());
}
// FIXME: DiagnoseEmptyLookup produces bad diagnostics if we're looking for
// a template name, but we happen to have always already looked up the name
// before we get here if it must be a template name.
if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator, nullptr,
std::nullopt, nullptr, &TE)) {
if (TE && KeywordReplacement) {
auto &State = getTypoExprState(TE);
auto BestTC = State.Consumer->getNextCorrection();
if (BestTC.isKeyword()) {
auto *II = BestTC.getCorrectionAsIdentifierInfo();
if (State.DiagHandler)
State.DiagHandler(BestTC);
KeywordReplacement->startToken();
KeywordReplacement->setKind(II->getTokenID());
KeywordReplacement->setIdentifierInfo(II);
KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin());
// Clean up the state associated with the TypoExpr, since it has
// now been diagnosed (without a call to CorrectDelayedTyposInExpr).
clearDelayedTypo(TE);
// Signal that a correction to a keyword was performed by returning a
// valid-but-null ExprResult.
return (Expr*)nullptr;
}
State.Consumer->resetCorrectionStream();
}
return TE ? TE : ExprError();
}
assert(!R.empty() &&
"DiagnoseEmptyLookup returned false but added no results");
// If we found an Objective-C instance variable, let
// LookupInObjCMethod build the appropriate expression to
// reference the ivar.
if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
R.clear();
ExprResult E(ObjC().LookupInObjCMethod(R, S, Ivar->getIdentifier()));
// In a hopelessly buggy code, Objective-C instance variable
// lookup fails and no expression will be built to reference it.
if (!E.isInvalid() && !E.get())
return ExprError();
return E;
}
}
// This is guaranteed from this point on.
assert(!R.empty() || ADL);
// Check whether this might be a C++ implicit instance member access.
// C++ [class.mfct.non-static]p3:
// When an id-expression that is not part of a class member access
// syntax and not used to form a pointer to member is used in the
// body of a non-static member function of class X, if name lookup
// resolves the name in the id-expression to a non-static non-type
// member of some class C, the id-expression is transformed into a
// class member access expression using (*this) as the
// postfix-expression to the left of the . operator.
//
// But we don't actually need to do this for '&' operands if R
// resolved to a function or overloaded function set, because the
// expression is ill-formed if it actually works out to be a
// non-static member function:
//
// C++ [expr.ref]p4:
// Otherwise, if E1.E2 refers to a non-static member function. . .
// [t]he expression can be used only as the left-hand operand of a
// member function call.
//
// There are other safeguards against such uses, but it's important
// to get this right here so that we don't end up making a
// spuriously dependent expression if we're inside a dependent
// instance method.
if (isPotentialImplicitMemberAccess(SS, R, IsAddressOfOperand))
return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs,
S);
if (TemplateArgs || TemplateKWLoc.isValid()) {
// In C++1y, if this is a variable template id, then check it
// in BuildTemplateIdExpr().
// The single lookup result must be a variable template declaration.
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId && Id.TemplateId &&
Id.TemplateId->Kind == TNK_Var_template) {
assert(R.getAsSingle<VarTemplateDecl>() &&
"There should only be one declaration found.");
}
return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
}
return BuildDeclarationNameExpr(SS, R, ADL);
} | 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(%rsp)
leaq 0x210(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
andq $0x0, 0x100(%rax)
leaq 0x58(%rsp), %rbp
andq $0x0, (%rbp)
andl $0x0, 0x8(%rbp)
andq $0x0, 0x10(%rbp)
leaq 0x200(%rsp), %rdx
leaq 0x90(%rsp), %r8
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rcx
callq 0x9118f8
movq (%rbp), %rax
movq %rax, %rcx
andq $-0x8, %rcx
xorl %r12d, %r12d
testb $0x7, %al
cmoveq %rcx, %r12
movl 0x8(%rbp), %ebp
testq %r12, %r12
je 0x90ca21
movq %r12, %rdi
callq 0x7a899a
testb %al, %al
je 0x90ca21
pushq $0x1
popq %r13
jmp 0x90cc56
movl %ebp, 0x48(%rsp)
movq 0x1208(%rbx), %rax
movl 0x1210(%rbx), %ecx
imulq $0x290, %rcx, %rcx # imm = 0x290
cmpl $0x2, -0x30(%rax,%rcx)
movq %r15, %rbp
jne 0x90cafc
movq 0xf0(%rbx), %rax
testb $0x4, 0x1(%rax)
jne 0x90cafc
testb $0x20, 0x8(%rbp)
je 0x90cafc
leaq 0xe8(%rsp), %rbp
leaq 0x58(%rsp), %rdx
pushq $0x3
popq %rcx
movq %rbp, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x75e8d8
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rbp
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa57e66
testb %al, %al
je 0x90caef
leaq 0xe8(%rsp), %rdi
callq 0x75dea2
testq %rax, %rax
je 0x90caef
movl 0x1c(%rax), %ecx
andl $0x7f, %ecx
addl $-0x32, %ecx
cmpl $-0x1b, %ecx
jb 0x90caef
movq 0x30(%rax), %rcx
leaq 0x190(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, %r14
callq 0x75e968
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl 0x48(%rsp), %r8d
xorl %r9d, %r9d
callq 0x9111fc
jmp 0x90cc46
leaq 0xe8(%rsp), %rdi
callq 0x643428
xorl %eax, %eax
cmpl $0x8, (%r13)
pushq $0xc
popq %rcx
cmovnel %eax, %ecx
leaq 0xe8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x75e8d8
movl 0x40(%rsp), %r13d
testl %r13d, %r13d
setne %al
movq 0x90(%rsp), %rcx
movq %rcx, 0x50(%rsp)
testq %rcx, %rcx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x90cb94
movl %r13d, %eax
btsq $0x20, %rax
leaq 0x190(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
movl $0x1, 0x10(%rsp)
leaq 0xe8(%rsp), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xb4f72e
testb %al, %al
je 0x90cc0b
pushq $0x1
popq %r13
jmp 0x90cc49
xorl %ebp, %ebp
testq %r12, %r12
je 0x90cbb1
cmpq $0x0, 0x8(%r14)
jne 0x90cbb1
movq %rbx, %rdi
callq 0x78a9d6
testq %rax, %rax
setne %bpl
movl %ebp, %eax
xorb $0x1, %al
andl $0x0, (%rsp)
movzbl %al, %r9d
leaq 0xe8(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xa5864c
cmpl $0x1, (%r13)
je 0x90cbf0
movq %r14, %rdi
callq 0x62ed78
testb %al, %al
je 0x90cc78
movzbl 0x350(%rsp), %r8d
leaq 0x58(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r9d, %r9d
jmp 0x90cc41
cmpl $0x1, 0xe8(%rsp)
je 0x90cc25
movq %r14, %rdi
callq 0x62ed78
testb %al, %al
je 0x90ccb1
movzbl 0x350(%rsp), %r8d
leaq 0x58(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movq 0x50(%rsp), %r9
callq 0xb5073e
movq %rax, %r13
leaq 0xe8(%rsp), %rdi
callq 0x643428
leaq 0x200(%rsp), %rdi
callq 0x6d9e52
movq %r13, %rax
addq $0x318, %rsp # imm = 0x318
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %bpl, %bpl
movq %r15, %rbp
je 0x90ccb1
movq 0x2d8(%rbx), %rdi
leaq 0xe8(%rsp), %rsi
pushq $0x1
popq %r8
movq %rbp, %rdx
movq %r12, %rcx
callq 0xa1ed4e
cmpq $0x1, %rax
je 0x90cb8b
movq %rax, %r13
andq $-0x2, %r13
jne 0x90cc49
pushq $0x1
popq %r13
cmpl $0x5, 0xe8(%rsp)
je 0x90cc49
testq %r12, %r12
je 0x90cd0c
cmpl $0x0, 0xf8(%rsp)
jne 0x90cd0c
cmpb $0x0, 0x44(%rsp)
je 0x90cd0c
movq 0xf0(%rbx), %rdi
callq 0x839d20
testb %al, %al
je 0x90cd0c
movq %rbx, %rdi
movl 0x48(%rsp), %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x839d50
testq %rax, %rax
je 0x90cd0c
leaq 0xe8(%rsp), %rdi
movq %rax, %rsi
callq 0x7a89f8
movzbl 0x44(%rsp), %ecx
leaq 0xe8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9125f0
movl %eax, %r15d
testb %al, %al
jne 0x90d14f
cmpl $0x0, 0xf8(%rsp)
jne 0x90d14f
movb %r15b, 0x44(%rsp)
movq %r14, %rdi
callq 0x62f022
testb %al, %al
je 0x90cf9a
movq 0xf0(%rbx), %rax
testb $0x20, (%rax)
je 0x90cf9a
movq 0x100(%rbx), %rax
movq %rax, 0x88(%rsp)
movq %rbx, %rdi
callq 0x9b6bdc
cmpq $0x10, %rax
movq %rax, 0x48(%rsp)
jae 0x90cda7
movq 0x230(%rbx), %rdi
movzwl 0x8(%rdi), %eax
andl $0x7c, %eax
cmpw $0x20, %ax
jne 0x90cf9a
addq $-0x48, %rdi
callq 0x6363bc
jmp 0x90cdbf
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1ca6
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1e8a
movq %rax, %r15
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x90cf9a
movq %r15, %rdi
callq 0x78ea92
testb %al, %al
je 0x90cf9a
movq %r15, %rdi
callq 0xe20a20
testb %al, %al
je 0x90cf9a
movl 0x60(%rsp), %edx
leaq 0x8(%rbx), %rsi
leaq 0x190(%rsp), %r15
movq %r15, %rdi
movq %rdx, 0x80(%rsp)
movl $0x14d5, %ecx # imm = 0x14D5
xorl %r8d, %r8d
callq 0x7a6d9e
movq 0x58(%rsp), %rax
leaq 0xa0(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x788932
leaq 0x98(%rsp), %rsi
movq %rax, %rdi
callq 0x838872
movq 0x48(%rsp), %rax
cmpq $0x10, %rax
jae 0x90ceec
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rax
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x98(%rsp), %rax
movq 0x30(%rax), %rcx
pushq $0x1
popq %rdx
movq 0x88(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf40a78
movq 0x80(%rsp), %rdx
movq %rdx, %rcx
shlq $0x20, %rcx
orq %rdx, %rcx
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x75a0e8
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
callq 0x75a186
leaq 0x58(%rsp), %r8
movq %r15, %rdi
movq %rax, %rsi
movl 0x40(%rsp), %ecx
movq 0x50(%rsp), %r9
callq 0xe93ac8
movq %rax, %r15
leaq 0xa8(%rsp), %rdi
callq 0x4f0656
jmp 0x90cf80
leaq 0x9071cf(%rip), %rdx # 0x12140c2
leaq 0xa0(%rsp), %r15
pushq $0x6
popq %rcx
movq %r15, %rdi
movq 0x80(%rsp), %rsi
xorl %r8d, %r8d
callq 0x55aafc
leaq 0x190(%rsp), %rdi
movq %r15, %rsi
callq 0x75ca52
leaq 0xb8(%rsp), %rdi
callq 0x436d30
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x58(%rsp), %xmm1
movups %xmm1, 0x18(%rsp)
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
pushq $0x1
popq %rcx
movq 0x88(%rsp), %rdi
xorl %esi, %esi
movq 0x48(%rsp), %rdx
xorl %r8d, %r8d
movl 0x40(%rsp), %r9d
callq 0xe95a26
movq %rax, %r15
leaq 0x190(%rsp), %rdi
callq 0x78b0f8
testq %r15, %r15
je 0x90cf9a
movq %r15, %r13
jmp 0x90cc49
cmpb $0x0, 0x360(%rsp)
jne 0x90cc49
andq $0x0, 0x70(%rsp)
movq 0x358(%rsp), %r8
movq 0x8(%r14), %rax
movl $0x1010101, 0xa8(%rsp) # imm = 0x1010101
movw $0x1, 0xac(%rsp)
movb $0x0, 0xae(%rsp)
movq %r12, 0xb0(%rsp)
movq %rax, 0xb8(%rsp)
leaq 0x106ea12(%rip), %rcx # 0x197ba00
addq $0x10, %rcx
movq %rcx, 0xa0(%rsp)
movb 0x350(%rsp), %cl
movb %cl, 0xaf(%rsp)
testq %r8, %r8
je 0x90d01c
movq %r12, 0x10(%r8)
testq %rax, %rax
je 0x90d024
movq %rax, 0x18(%r8)
jmp 0x90d024
leaq 0xa0(%rsp), %r8
xorps %xmm0, %xmm0
movaps %xmm0, 0x1f0(%rsp)
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
leaq 0xe8(%rsp), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x911c3a
testb %al, %al
je 0x90d0ed
movq 0x368(%rsp), %r12
movq 0x70(%rsp), %rsi
testq %rsi, %rsi
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x90d0dd
movq %rbx, %rdi
callq 0xa5ee50
movq %rax, %r14
movq (%rax), %rdi
callq 0xa5ba2a
leaq 0x190(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x9126d8
cmpl $0x0, 0x18(%r15)
je 0x90d0c0
movq 0x1a0(%rsp), %rax
cmpq $0x0, (%rax)
je 0x90d1e6
movq (%r14), %rax
andq $0x0, 0x1b0(%rax)
leaq 0x190(%rsp), %rdi
callq 0x7606e8
movq 0x70(%rsp), %rsi
testq %rsi, %rsi
pushq $0x1
popq %r13
cmovneq %rsi, %r13
jmp 0x90cc49
leaq 0xe8(%rsp), %rdi
callq 0x83a558
testq %rax, %rax
je 0x90d14a
movq %rax, %r15
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
callq 0x7a8a12
movq 0x2d8(%rbx), %rdi
movq 0x28(%r15), %rax
movq %rax, %rcx
andq $-0x8, %rcx
xorl %edx, %edx
testb $0x7, %al
cmovneq %rdx, %rcx
movq %r14, %rsi
movq %rbp, %rdx
xorl %r8d, %r8d
callq 0xa1ed4e
movq %rax, %r13
cmpq $0x1, %rax
adcq $0x0, %r13
jmp 0x90cc49
movb 0x44(%rsp), %r15b
movzbl 0x350(%rsp), %ecx
leaq 0xe8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa0dc2a
movq 0x90(%rsp), %r9
testb %al, %al
je 0x90d198
leaq 0xe8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl 0x40(%rsp), %edx
movq %r9, %r8
movq %rbp, %r9
callq 0xa0dcc6
jmp 0x90cc46
movl 0x40(%rsp), %edx
testl %edx, %edx
sete %al
testq %r9, %r9
sete %cl
testb %cl, %al
jne 0x90d1c7
movzbl %r15b, %r8d
leaq 0xe8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5ab2c
jmp 0x90cc46
movzbl %r15b, %ecx
leaq 0xe8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x912720
jmp 0x90cc46
movq 0x190(%rsp), %rax
movq %rax, %rcx
andq $-0x8, %rcx
xorl %r15d, %r15d
testb $0x7, %al
cmoveq %rcx, %r15
cmpq $0x0, 0x18(%r14)
je 0x90d219
addq $0x8, %r14
leaq 0x190(%rsp), %rsi
movq %r14, %rdi
callq 0x788e40
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andl $0x0, 0x10(%r12)
movzwl (%r15), %eax
andl $0x1ff, %eax # imm = 0x1FF
movw %ax, 0x10(%r12)
movq %r15, 0x8(%r12)
leaq 0x190(%rsp), %r14
movl 0x34(%r14), %eax
movl %eax, (%r12)
movq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xa5ee9e
movq %r14, %rdi
callq 0x7606e8
xorl %r13d, %r13d
jmp 0x90cc49
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::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 the semantic expressions and
// rebinding OVEs as necessary) doesn't work; we'd need
// TreeTransform to not strip away implicit conversions.
Expr *newSyntacticForm = SemaRef.PseudoObject().recreateSyntacticForm(E);
ExprResult result = getDerived().TransformExpr(newSyntacticForm);
if (result.isInvalid()) return ExprError();
// If that gives us a pseudo-object result back, the pseudo-object
// expression must have been an lvalue-to-rvalue conversion which we
// should reapply.
if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
result = SemaRef.PseudoObject().checkRValue(result.get());
return result;
} | 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 = 0x1ED
callq 0x82bc80
testb %al, %al
je 0x945326
movq (%rbx), %rax
movq 0x300(%rax), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb21b94
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformObjCBoxedExpr(clang::ObjCBoxedExpr*) | 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().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
} | 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
popq %r14
jmp 0xa132aa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::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 operand rather than transforming it
// separately.
// FIXME: getCurScope() should not be used during template instantiation.
// We should pick up the set of unqualified lookup results for operator
// co_await during the initial parse.
ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
getSema().getCurScope(), E->getKeywordLoc());
// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoawaitExpr(
E->getKeywordLoc(), Operand.get(),
cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit());
} | 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(%r15), %edx
callq 0x82fb46
movl 0x10(%r15), %ebp
andq $-0x2, %rbx
andq $-0x2, %rax
testb $0x4, 0x2(%r15)
movq (%r14), %rdi
jne 0x9479f3
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82fbfa
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x82e998
cmpq $0x1, %rax
je 0x9479a2
movq (%r14), %rdi
andq $-0x2, %rax
pushq $0x1
popq %r8
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82febc
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::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 ExprError();
if (!getDerived().AlwaysRebuild() &&
TSInfo == E->getTypeInfoAsWritten() &&
Result.get() == E->getSubExpr())
return E;
return SemaRef.ObjC().BuildObjCBridgedCast(
E->getLParenLoc(), E->getBridgeKind(), E->getBridgeKeywordLoc(), TSInfo,
Result.get());
} | 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 %r12
popq %r14
popq %r15
retq
andq $-0x2, %rax
cmpq 0x18(%rbx), %r14
jne 0x947d48
cmpq %rax, 0x10(%rbx)
je 0x947d75
movq (%r15), %rcx
movq 0x2d8(%rcx), %rdi
movzbl 0x28(%rbx), %edx
andl $0x3, %edx
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %ecx
movq %r14, %r8
movq %rax, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa1e248
movq %rbx, %r12
jmp 0x947d29
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformCXXPseudoDestructorExpr(clang::CXXPseudoDestructorExpr*) | ExprResult
TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
CXXPseudoDestructorExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
return ExprError();
ParsedType ObjectTypePtr;
bool MayBePseudoDestructor = false;
Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
E->getOperatorLoc(),
E->isArrow()? tok::arrow : tok::period,
ObjectTypePtr,
MayBePseudoDestructor);
if (Base.isInvalid())
return ExprError();
QualType ObjectType = ObjectTypePtr.get();
NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
if (QualifierLoc) {
QualifierLoc
= getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
if (!QualifierLoc)
return ExprError();
}
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
PseudoDestructorTypeStorage Destroyed;
if (E->getDestroyedTypeInfo()) {
TypeSourceInfo *DestroyedTypeInfo
= getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
ObjectType, nullptr, SS);
if (!DestroyedTypeInfo)
return ExprError();
Destroyed = DestroyedTypeInfo;
} else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
// We aren't likely to be able to resolve the identifier down to a type
// now anyway, so just retain the identifier.
Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
E->getDestroyedTypeLoc());
} else {
// Look for a destructor known with the given name.
ParsedType T = SemaRef.getDestructorName(
*E->getDestroyedTypeIdentifier(), E->getDestroyedTypeLoc(),
/*Scope=*/nullptr, SS, ObjectTypePtr, false);
if (!T)
return ExprError();
Destroyed
= SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
E->getDestroyedTypeLoc());
}
TypeSourceInfo *ScopeTypeInfo = nullptr;
if (E->getScopeTypeInfo()) {
CXXScopeSpec EmptySS;
ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
if (!ScopeTypeInfo)
return ExprError();
}
return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
E->getOperatorLoc(),
E->isArrow(),
SS,
ScopeTypeInfo,
E->getColonColonLoc(),
E->getTildeLoc(),
Destroyed);
} | 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)
movq (%rbx), %rdi
andq $-0x2, %rax
movl 0x1c(%r15), %ecx
testb $0x1, 0x18(%r15)
pushq $0x25
popq %rsi
pushq $0x1a
popq %rbp
movl %ebp, %r8d
cmovnel %esi, %r8d
movq %rdx, (%rsp)
xorl %esi, %esi
movq %rax, %rdx
callq 0x9c61d2
pushq $0x1
popq %r13
cmpq $0x1, %rax
je 0x948b93
movq %rax, %r14
movq 0x58(%rsp), %r12
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
testq %rsi, %rsi
je 0x948850
movq %rbx, %rdi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x94e86a
testq %rax, %rax
je 0x948b93
movq %rax, %rsi
jmp 0x948852
xorl %esi, %esi
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x75a106
movq 0x40(%r15), %rax
movl %eax, %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
movq %rax, %rsi
andq $-0x8, %rsi
sete %dl
orb %cl, %dl
je 0x9488f6
cmpq $0x10, %r12
jb 0x9488a1
movq %r12, %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
testb $0x4, 0x11(%rcx)
jne 0x948a42
movq (%rbx), %rdi
xorl %ecx, %ecx
testb $0x4, %al
cmoveq %rcx, %rsi
movl 0x48(%r15), %edx
movq 0x58(%rsp), %r9
andl $0x0, (%rsp)
leaq 0x80(%rsp), %r8
xorl %ecx, %ecx
callq 0x9b4720
testq %rax, %rax
je 0x948976
movq (%rbx), %rcx
movq 0x100(%rcx), %r13
movq %rax, %rdi
xorl %esi, %esi
callq 0xc7c004
movl 0x48(%r15), %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0xd91190
jmp 0x94890e
leaq 0x80(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x95bf20
testq %rax, %rax
je 0x948976
leaq 0xd0(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xe934c8
movq (%r13), %r10
movl 0x8(%r13), %r13d
movq %r14, 0x40(%rsp)
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x94897f
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rcx
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq %rbx, %rdi
movq %r12, %rdx
movq %r10, %r14
callq 0x95bf20
movq %rax, %r12
leaq 0xd8(%rsp), %rdi
callq 0x4f0656
movq %r14, %r10
movq %r12, %r9
testq %r12, %r12
jne 0x948982
pushq $0x1
popq %r13
jmp 0x948b86
xorl %r9d, %r9d
movq 0x40(%rsp), %r14
andq $-0x2, %r14
movl 0x1c(%r15), %edx
movb 0x18(%r15), %sil
movl 0x38(%r15), %r8d
movl 0x3c(%r15), %r15d
movq %r10, 0x70(%rsp)
movl %r13d, 0x40(%rsp)
movl %r13d, 0x78(%rsp)
testb $-0x80, 0x1(%r14)
jne 0x948b51
movl %r10d, %eax
shrb $0x2, %al
movq %r10, %r13
andq $-0x8, %r13
setne %cl
testb %cl, %al
jne 0x948b51
movq 0x8(%r14), %r12
movq %r12, 0x60(%rsp)
andq $-0x10, %r12
movq (%r12), %rdi
testb $0x1, %sil
movl %edx, 0x3c(%rsp)
movb %sil, 0x36(%rsp)
movl %r8d, 0x38(%rsp)
je 0x948a59
movq %r9, 0x50(%rsp)
movq %r10, 0x48(%rsp)
callq 0x4ed6fe
movq 0x48(%rsp), %r10
movq 0x50(%rsp), %r9
testq %rax, %rax
je 0x948a77
movq (%r12), %rdi
callq 0x79d066
movq 0x48(%rsp), %r10
movl 0x38(%rsp), %r8d
movb 0x36(%rsp), %sil
movl 0x3c(%rsp), %edx
movq 0x50(%rsp), %r9
movq 0x20(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
jmp 0x948a5d
movl 0x48(%r15), %r13d
orq $0x4, %rsi
testb $0x4, %al
pushq $0x4
popq %r10
cmovneq %rsi, %r10
jmp 0x948929
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x948b51
cmpb $0x2e, 0x10(%rax)
jne 0x948b51
xorl %r15d, %r15d
testb $0x4, %r10b
cmoveq %r13, %r15
movq (%rbx), %rax
movl $0x43a0, %edi # imm = 0x43A0
addq 0x100(%rax), %rdi
movq (%r15), %rsi
movq %rsi, %rax
andq $-0x10, %rax
andl $0x7, %esi
orq 0x8(%rax), %rsi
movq %r9, %r12
callq 0xe18e7a
leaq 0x130(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movl 0x40(%rsp), %edx
callq 0x64b05c
movq %r15, 0x10(%rbp)
testq %r12, %r12
je 0x948b0c
movq (%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4ed7f2
testq %rax, %rax
je 0x948ba8
movq (%rbx), %rax
movq 0x100(%rax), %rsi
movq (%r12), %rcx
addq $0x8, %r12
leaq 0x80(%rsp), %rdi
xorl %edx, %edx
movq %r12, %r8
movl 0x38(%rsp), %r9d
callq 0x759fe0
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
movq %rbp, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movzbl 0x36(%rsp), %r8d
andl $0x1, %r8d
leaq 0x80(%rsp), %r9
movq %r14, %rsi
movq 0x60(%rsp), %rdx
movl 0x3c(%rsp), %ecx
callq 0xa0e986
jmp 0x948b83
movq (%rbx), %rdi
movups 0x70(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movl %r15d, 0x8(%rsp)
testb $0x1, %sil
pushq $0x25
popq %rax
cmovnel %eax, %ebp
movl %r8d, (%rsp)
leaq 0x80(%rsp), %r8
movq %r14, %rsi
movl %ebp, %ecx
callq 0x9c6896
movq %rax, %r13
leaq 0x88(%rsp), %rdi
callq 0x4f0656
movq %r13, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r15
addq $0x8, %r15
movq (%r12), %rax
leaq 0x8(%r12), %rcx
leaq 0xc0(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0xfacccc
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
movl $0xd60, %ecx # imm = 0xD60
xorl %r8d, %r8d
callq 0x7a6d9e
movq (%r12), %rax
leaq 0xb8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x79503c
movq (%rbx), %rcx
movq 0xf0(%rcx), %rcx
movl (%rcx), %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
leaq 0x6c(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0x77c488
movq %r14, %rdi
callq 0x78b0f8
jmp 0x948976
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformOMPTaskLoopDirective(clang::OMPTaskLoopDirective*) | StmtResult
TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().OpenMP().StartOpenMPDSABlock(
OMPD_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x56
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x957c7a
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformOMPFinalClause(clang::OMPFinalClause*) | 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->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 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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa0b7c
nop
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformOMPXAttributeClause(clang::OMPXAttributeClause*) | 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->getEndLoc());
} | 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(%rsp), %r15
cmpq %rbp, %r13
je 0x95a313
movq (%r12,%rbp), %rsi
movq %r15, %rdi
callq 0x826654
addq $0x8, %rbp
jmp 0x95a2fc
leaq 0x8(%rsp), %r15
movq (%r15), %rsi
movl 0x8(%r15), %edx
movl 0xc(%r14), %r8d
movl (%r14), %ecx
movl 0x4(%r14), %r9d
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
callq 0xab261a
movq %rax, %rbx
movq %r15, %rdi
callq 0x8266a4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformOMPSeverityClause(clang::OMPSeverityClause*) | 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::PointerLikeTypeTraits<clang::ConstantExpr*>>>*>)::ComplexRemove>::TransformOMPSimdlenClause(clang::OMPSimdlenClause*) | 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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa0ea4
nop
| /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, %rdi
callq 0x97195e
incq %r15
jmp 0x9745fa
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
| /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().getLangOpts().CPlusPlus23);
// P2718R0 - Lifetime extension in range-based for loops.
if (getSema().getLangOpts().CPlusPlus23) {
auto &LastRecord = getSema().ExprEvalContexts.back();
LastRecord.InLifetimeExtendingContext = true;
}
StmtResult Init =
S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
if (Init.isInvalid())
return StmtError();
StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
if (Range.isInvalid())
return StmtError();
// Before c++23, ForRangeLifetimeExtendTemps should be empty.
assert(getSema().getLangOpts().CPlusPlus23 ||
getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty());
auto ForRangeLifetimeExtendTemps =
getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps;
StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
if (Begin.isInvalid())
return StmtError();
StmtResult End = getDerived().TransformStmt(S->getEndStmt());
if (End.isInvalid())
return StmtError();
ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
return StmtError();
if (Cond.get())
Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
if (Cond.isInvalid())
return StmtError();
if (Cond.get())
Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
return StmtError();
if (Inc.get())
Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
if (LoopVar.isInvalid())
return StmtError();
StmtResult NewStmt = S;
if (getDerived().AlwaysRebuild() ||
Init.get() != S->getInit() ||
Range.get() != S->getRangeStmt() ||
Begin.get() != S->getBeginStmt() ||
End.get() != S->getEndStmt() ||
Cond.get() != S->getCond() ||
Inc.get() != S->getInc() ||
LoopVar.get() != S->getLoopVarStmt()) {
NewStmt = getDerived().RebuildCXXForRangeStmt(
S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
// Might not have attached any initializer to the loop variable.
getSema().ActOnInitializerError(
cast<DeclStmt>(LoopVar.get())->getSingleDecl());
return StmtError();
}
}
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
return StmtError();
// Body has changed but we didn't rebuild the for-range statement. Rebuild
// it now so we have a new statement to attach the body to.
if (Body.get() != S->getBody() && NewStmt.get() == S) {
NewStmt = getDerived().RebuildCXXForRangeStmt(
S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
if (NewStmt.isInvalid())
return StmtError();
}
if (NewStmt.get() == S)
return S;
return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0xf0(%rdi), %rax
movq (%rax), %rax
andl $0x8000, %eax # imm = 0x8000
movl %eax, %ecx
shrl $0xf, %ecx
movq %rdi, 0x88(%rsp)
movb %cl, 0x90(%rsp)
testq %rax, %rax
je 0x986c52
pushq $0x6
popq %rsi
pushq $0x3
popq %rcx
xorl %edx, %edx
callq 0x92fd8c
movq (%rbx), %rax
movq 0xf0(%rax), %rcx
testb $-0x80, 0x1(%rcx)
je 0x986c52
movq 0x1208(%rax), %rcx
movl 0x1210(%rax), %eax
imulq $0x290, %rax, %rax # imm = 0x290
movb $0x1, -0x27(%rcx,%rax)
movq 0x10(%r14), %rsi
pushq $0x1
popq %r15
testq %rsi, %rsi
je 0x986c77
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
movq %rax, %r12
cmpq $0x1, %rax
jne 0x986c7a
jmp 0x986fc6
xorl %r12d, %r12d
movq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
cmpq $0x1, %rax
je 0x986fc6
movq %rax, %r13
movq (%rbx), %rax
movq 0x1208(%rax), %rcx
movl 0x1210(%rax), %eax
imulq $0x290, %rax, %rax # imm = 0x290
leaq (%rcx,%rax), %rsi
addq $-0x80, %rsi
leaq 0x98(%rsp), %rdi
callq 0x82b9c4
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
pushq $0x1
popq %r15
cmpq $0x1, %rax
je 0x986fb9
movq %rax, %rbp
movq 0x28(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
cmpq $0x1, %rax
je 0x986fb9
movq %rax, 0x58(%rsp)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x974b2a
cmpq $0x1, %rax
je 0x986fb9
andq $-0x2, %rax
je 0x986d50
movq (%rbx), %rdi
movl 0x54(%r14), %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x938c56
cmpq $0x1, %rax
je 0x986fb9
andq $-0x2, %rax
je 0x986d50
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c5d36
andq $-0x2, %rax
movq %rax, 0x48(%rsp)
jmp 0x986d59
movq $0x0, 0x48(%rsp)
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x974b2a
cmpq $0x1, %rax
je 0x986fb9
andq $-0x2, %rax
je 0x986d8b
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c5d36
andq $-0x2, %rax
movq %rax, 0x50(%rsp)
jmp 0x986d94
movq $0x0, 0x50(%rsp)
movq 0x40(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
cmpq $0x1, %rax
je 0x986fb9
movq %rax, %rdi
movq (%rbx), %rax
andq $-0x2, %r12
cmpl $-0x1, 0x3218(%rax)
movq 0x58(%rsp), %rcx
movq %rdi, 0x60(%rsp)
jne 0x986e1d
cmpq %r12, 0x10(%r14)
jne 0x986e1d
movq %r13, %rax
andq $-0x2, %rax
cmpq %rax, 0x18(%r14)
jne 0x986e1d
movq %rbp, %rax
andq $-0x2, %rax
cmpq %rax, 0x20(%r14)
jne 0x986e1d
movq %rcx, %rax
andq $-0x2, %rax
cmpq %rax, 0x28(%r14)
jne 0x986e1d
movq 0x48(%rsp), %rax
cmpq %rax, 0x30(%r14)
jne 0x986e1d
movq 0x50(%rsp), %rax
cmpq %rax, 0x38(%r14)
jne 0x986e1d
movq %rdi, %rax
andq $-0x2, %rax
cmpq %rax, 0x40(%r14)
je 0x986fe8
movl 0x8(%r14), %esi
movl 0x50(%r14), %edx
movl 0x54(%r14), %r8d
movq %r13, %r9
andq $-0x2, %r9
movq %rbp, %rax
andq $-0x2, %rax
andq $-0x2, %rcx
movq %rdi, %r11
andq $-0x2, %r11
movl 0x58(%r14), %edi
movq 0x98(%rsp), %r10
movq %r10, 0x78(%rsp)
movl 0xa0(%rsp), %r10d
movq %r10, 0x80(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movl %edi, 0x28(%rsp)
movq %r11, 0x40(%rsp)
movq %r11, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rcx
callq 0x98c4ac
cmpq $0x1, %rax
jne 0x986ecc
movq 0x40(%rsp), %rax
cmpq %rax, 0x40(%r14)
je 0x986ec9
movq (%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x859dfa
pushq $0x1
popq %r15
jmp 0x986fb9
pushq $0x1
popq %rax
movq %rax, 0x40(%rsp)
movq 0x48(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x982caa
cmpq $0x1, %rax
je 0x986fb9
andq $-0x2, %rax
movq 0x40(%rsp), %rsi
andq $-0x2, %rsi
cmpq %r14, %rsi
jne 0x986fa1
cmpq %rax, 0x48(%r14)
je 0x986fa1
movq %rax, 0x40(%rsp)
movl 0x8(%r14), %esi
movl 0x50(%r14), %edx
movl 0x54(%r14), %r8d
andq $-0x2, %r13
andq $-0x2, %rbp
movq 0x58(%rsp), %rdi
andq $-0x2, %rdi
movq 0x60(%rsp), %r9
andq $-0x2, %r9
movl 0x58(%r14), %eax
movq 0x98(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movl 0xa0(%rsp), %ecx
movq %rcx, 0x70(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movl %eax, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rbp, (%rsp)
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r9
callq 0x98c4ac
cmpq $0x1, %rax
je 0x986fb9
movq %rax, %rsi
andq $-0x2, %rsi
movq 0x40(%rsp), %rax
cmpq %r14, %rsi
je 0x986fb6
movq %rbx, %rdi
movq %rax, %rdx
callq 0x98c66c
movq %rax, %r15
jmp 0x986fb9
movq %r14, %r15
leaq 0x98(%rsp), %rdi
callq 0x69fba0
leaq 0x88(%rsp), %rdi
callq 0x629670
movq %r15, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
jmp 0x986ecc
| /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().TransformExpr(E->getKeyExpr());
if (Key.isInvalid())
return ExprError();
// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
return E;
return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
Base.get(), Key.get(),
E->getAtIndexMethodDecl(),
E->setAtIndexMethodDecl());
} | 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, %r15
andq $-0x2, %rax
movq 0x28(%r14), %r8
movq 0x30(%r14), %r9
movq (%rbx), %rcx
movq 0x2d8(%rcx), %rdi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xa13e6c
| /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() &&
Base.get() == E->getBase())
return E;
return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
E->getOpLoc(),
E->isArrow());
} | 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
movl %eax, 0x3c(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq (%r14), %rax
movq 0x100(%rax), %rax
movq 0x4380(%rax), %rdi
leaq 0x8f6b04(%rip), %rsi # 0x1286f9b
pushq $0x3
popq %rdx
callq 0x4febb2
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x64b05c
movq (%r14), %rdi
movq 0x8(%rbx), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movq %r15, 0x10(%rsp)
movq %rbx, %rsi
movl %ebp, %ecx
movl 0x3c(%rsp), %r8d
movq %r12, %r9
callq 0xa0e986
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4f0656
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
&ArgChanged))
return ExprError();
if (!getDerived().AlwaysRebuild() &&
Callee.get() == E->getCallee() &&
!ArgChanged)
return SemaRef.MaybeBindToTemporary(E);
// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
= ((Expr *)Callee.get())->getSourceRange().getBegin();
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
if (E->hasStoredFPFeatures()) {
FPOptionsOverride NewOverrides = E->getFPFeatures();
getSema().CurFPFeatures =
NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
}
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
Args,
E->getRParenLoc());
} | 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(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movl (%r14), %eax
movl 0x10(%r14), %edx
movl %eax, %ecx
shrl $0x18, %ecx
addq %r14, %rcx
shrl $0xf, %eax
andl $0x8, %eax
leaq (%rax,%rcx), %rsi
addq $0x8, %rsi
pushq $0x1
popq %rcx
leaq 0x40(%rsp), %r8
movq %rbx, %rdi
callq 0x9a0eb6
testb %al, %al
je 0x9931c3
pushq $0x1
popq %rbx
jmp 0x99324b
andq $-0x2, %r15
movq %r15, %rdi
callq 0xf67396
movq %rax, %r12
movq (%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x78d30a
testb $0x10, 0x2(%r14)
je 0x99321d
movq %r14, %rdi
callq 0x74b956
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq (%rbx), %rax
movq 0xf0(%rax), %rsi
movq %r13, %rdi
callq 0x6cc4d2
movq (%rbx), %rcx
movl %eax, 0xe8(%rcx)
movq (%r13), %rax
movq %rax, 0x790(%rcx)
movq 0x40(%rsp), %rcx
movl 0x48(%rsp), %r8d
movl 0x14(%r14), %r9d
andq $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x9a68f8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x78d334
leaq 0x40(%rsp), %rdi
callq 0x633cd8
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /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 StmtError();
return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
Block.get());
} | 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, %r15
andq $-0x2, %rax
movq (%rbx), %rdi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xb328c4
nop
| /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 means that our
// correction itself is ambiguous, so stop now.
if (IsAmbiguous)
break;
// If the transform is still valid after checking for any new typos,
// it's good to go.
if (!Res.isInvalid())
break;
// The transform was invalid, see if we have any TypoExprs with untried
// correction candidates.
if (!CheckAndAdvanceTypoExprCorrectionStreams())
break;
}
// If we found a valid result, double check to make sure it's not ambiguous.
if (!IsAmbiguous && !Res.isInvalid() && !AmbiguousTypoExprs.empty()) {
auto SavedTransformCache =
llvm::SmallDenseMap<TypoExpr *, ExprResult, 2>(TransformCache);
// Ensure none of the TypoExprs have multiple typo correction candidates
// with the same edit length that pass all the checks and filters.
while (!AmbiguousTypoExprs.empty()) {
auto TE = AmbiguousTypoExprs.back();
// TryTransform itself can create new Typos, adding them to the TypoExpr map
// and invalidating our TypoExprState, so always fetch it instead of storing.
SemaRef.getTypoExprState(TE).Consumer->saveCurrentPosition();
TypoCorrection TC = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection();
TypoCorrection Next;
do {
// Fetch the next correction by erasing the typo from the cache and calling
// `TryTransform` which will iterate through corrections in
// `TransformTypoExpr`.
TransformCache.erase(TE);
ExprResult AmbigRes = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous);
if (!AmbigRes.isInvalid() || IsAmbiguous) {
SemaRef.getTypoExprState(TE).Consumer->resetCorrectionStream();
SavedTransformCache.erase(TE);
Res = ExprError();
IsAmbiguous = true;
break;
}
} while ((Next = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection()) &&
Next.getEditDistance(false) == TC.getEditDistance(false));
if (IsAmbiguous)
break;
AmbiguousTypoExprs.remove(TE);
SemaRef.getTypoExprState(TE).Consumer->restoreSavedPosition();
TransformCache[TE] = SavedTransformCache[TE];
}
TransformCache = std::move(SavedTransformCache);
}
// Wipe away any newly created TypoExprs that we don't know about. Since we
// clear any invalid TypoExprs in `CheckForRecursiveTypos`, this is only
// possible if a `TypoExpr` is created during a transformation but then
// fails before we can discover it.
auto &SemaTypoExprs = SemaRef.TypoExprs;
for (auto Iterator = SemaTypoExprs.begin(); Iterator != SemaTypoExprs.end();) {
auto TE = *Iterator;
auto FI = find(TypoExprs, TE);
if (FI != TypoExprs.end()) {
Iterator++;
continue;
}
SemaRef.clearDelayedTypo(TE);
Iterator = SemaTypoExprs.erase(Iterator);
}
SemaRef.TypoExprs = std::move(SavedTypoExprs);
return Res;
} | 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
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rbp
movq %r15, 0x8(%rsp)
movq %r12, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9d2fe8
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x9d2e58
movq %rax, %r14
cmpb $0x0, (%r15)
jne 0x9cb443
cmpq $0x1, %r14
jne 0x9cb443
movq 0x50(%rbx), %r13
movl 0x58(%rbx), %r12d
shlq $0x3, %r12
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x9cb435
movq (%r13,%r15), %rsi
movq %rsi, 0x30(%rsp)
movq (%rbx), %rdi
callq 0xa5ee50
movq %rax, %r14
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x9d309e
movq (%r14), %rax
movq 0x1b0(%rax), %rcx
testq %rcx, %rcx
je 0x9cb435
cmpq $0x0, 0x38(%rax)
jne 0x9cb426
movl 0x48(%rax), %edx
cmpq %rdx, %rcx
jb 0x9cb426
andq $0x0, 0x1b0(%rax)
addq $0x8, %r15
jmp 0x9cb3d3
movq 0x8(%rsp), %r15
movq 0x20(%rsp), %r12
jmp 0x9cb398
pushq $0x1
popq %r14
movq 0x8(%rsp), %r15
movq 0x20(%rsp), %r12
cmpb $0x0, (%r15)
je 0x9cb453
movq %r14, 0x8(%rsp)
jmp 0x9cb6a0
cmpq $0x1, %r14
jne 0x9cb466
pushq $0x1
popq %rax
movq %rax, 0x8(%rsp)
jmp 0x9cb6a0
cmpl $0x0, 0x90(%rbx)
je 0x9cb449
leaq 0x70(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x88(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9d3058
leaq 0xb0(%rsp), %rbp
movl 0x90(%rbx), %eax
testq %rax, %rax
je 0x9cb74e
movq 0x88(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rsi
movq %rsi, 0x10(%rsp)
movq (%rbx), %rdi
callq 0xa5ee50
movq (%rax), %rax
movq 0x1b0(%rax), %rcx
movq %rcx, 0x1b8(%rax)
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0xa5ee50
movq (%rax), %rdi
callq 0x9d307c
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x9126d8
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
leaq 0xd0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, 0xc8(%rsp)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x16(%rax)
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9d309e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9d2fe8
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x9d2e58
cmpq $0x1, %rax
jne 0x9cb635
cmpb $0x1, (%r15)
je 0x9cb635
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0xa5ee50
movq (%rax), %rdi
callq 0x9d307c
movq %rbp, %rdi
movq %rax, %rsi
callq 0x9d30cc
cmpq $0x0, (%rax)
je 0x9cb5b4
movq %rbp, %rdi
xorl %esi, %esi
callq 0x86b626
movq %rbp, %r13
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x86b626
cmpl %eax, %ebp
movq %r13, %rbp
je 0x9cb52c
testb $0x1, (%r15)
jne 0x9cb758
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %r13
movq %r13, %rsi
callq 0x9d3116
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0xa5ee50
movq (%rax), %rax
movq 0x1b8(%rax), %rcx
movq %rcx, 0x1b0(%rax)
leaq 0x88(%rsp), %rdi
movq %r13, %rsi
callq 0x9ed5e0
movq %rbp, %r13
movq %rax, %rbp
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9ed5e0
movq 0x8(%rbp), %rcx
movq %r13, %rbp
movq %rcx, 0x8(%rax)
movq %r13, %rdi
callq 0x7606e8
leaq 0x30(%rsp), %rdi
callq 0x7606e8
jmp 0x9cb492
movq (%rbx), %rdi
leaq 0x10(%rsp), %r14
movq (%r14), %rsi
callq 0xa5ee50
movq (%rax), %rax
andq $0x0, 0x1b0(%rax)
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0x9d309e
movb $0x1, (%r15)
pushq $0x1
popq %rax
movq %rax, 0x8(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x7606e8
leaq 0x30(%rsp), %rdi
callq 0x7606e8
leaq 0x88(%rsp), %r12
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x9d3180
movq %r12, %rdi
callq 0x9d31b8
movq (%rbx), %r14
leaq 0x27c0(%r14), %r15
movq 0x27c0(%r14), %rax
leaq 0x38(%rbx), %r12
leaq 0x30(%rsp), %r13
movq %rax, %rbp
movl 0x27c8(%r14), %ecx
leaq (%rax,%rcx,8), %rax
cmpq %rax, %rbp
je 0x9cb717
movq (%rbp), %rax
movq %rax, 0x30(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x9d31ca
movl 0x58(%rbx), %ecx
shlq $0x3, %rcx
addq 0x50(%rbx), %rcx
cmpq %rcx, %rax
je 0x9cb6f7
addq $0x8, %rbp
jmp 0x9cb712
movq (%rbx), %rdi
movq 0x30(%rsp), %rsi
callq 0xa5ee9e
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9d31e0
movq %rax, %rbp
movq (%r15), %rax
jmp 0x9cb6bd
movl $0x27c0, %edi # imm = 0x27C0
addq (%rbx), %rdi
leaq 0x108(%rsp), %rbx
movq %rbx, %rsi
callq 0x9d321e
movq %rbx, %rdi
callq 0x7916dc
movq 0x8(%rsp), %rax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rsp)
jmp 0x9cb683
movq %r14, 0x8(%rsp)
jmp 0x9cb66c
| /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().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
return E;
return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
E->getOpcode(),
SubExpr.get());
} | 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
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
andq $-0x2, %rax
cmpl $-0x1, 0x3218(%rdi)
jne 0x9d4b82
cmpq %rax, 0x10(%rbx)
je 0x9d4b61
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
shrl $0x12, %ecx
andl $0x1f, %ecx
xorl %esi, %esi
movq %rax, %r8
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x916acc
nop
| /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->getQualifierLoc());
if (!QualifierLoc)
return ExprError();
}
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
ValueDecl *Member
= cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
E->getMemberDecl()));
if (!Member)
return ExprError();
NamedDecl *FoundDecl = E->getFoundDecl();
if (FoundDecl == E->getMemberDecl()) {
FoundDecl = Member;
} else {
FoundDecl = cast_or_null<NamedDecl>(
getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
if (!FoundDecl)
return ExprError();
}
if (!getDerived().AlwaysRebuild() &&
Base.get() == E->getBase() &&
QualifierLoc == E->getQualifierLoc() &&
Member == E->getMemberDecl() &&
FoundDecl == E->getFoundDecl() &&
!E->hasExplicitTemplateArgs()) {
// Skip for member expression of (this->f), rebuilt thisi->f is needed
// for Openmp where the field need to be privatizized in the case.
if (!(isa<CXXThisExpr>(E->getBase()) &&
getSema().OpenMP().isOpenMPRebuildMemberExpr(
cast<ValueDecl>(Member)))) {
// Mark it referenced in the new context regardless.
// FIXME: this is a bit instantiation-specific.
SemaRef.MarkMemberReferenced(E);
return E;
}
}
TemplateArgumentListInfo TransArgs;
if (E->hasExplicitTemplateArgs()) {
TransArgs.setLAngleLoc(E->getLAngleLoc());
TransArgs.setRAngleLoc(E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
E->getNumTemplateArgs(),
TransArgs))
return ExprError();
}
// FIXME: Bogus source location for the operator
SourceLocation FakeOperatorLoc =
SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;
DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
if (MemberNameInfo.getName()) {
MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
if (!MemberNameInfo.getName())
return ExprError();
}
return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
E->isArrow(),
QualifierLoc,
TemplateKWLoc,
MemberNameInfo,
Member,
FoundDecl,
(E->hasExplicitTemplateArgs()
? &TransArgs : nullptr),
FirstQualifierInScope);
} | 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)
jmp 0x9d74ed
movq %r13, %rdi
callq 0x4cf494
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9dfa82
testq %rax, %rax
je 0x9d7964
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x82bda4
movl %eax, %r14d
movq 0x18(%r13), %rsi
movq %rbx, %rdi
callq 0x9dfa4e
testq %rax, %rax
je 0x9d7964
movq %rax, %r12
movq %r13, %rdi
callq 0x74bc4a
andq $-0x8, %rax
movq %r12, %rcx
cmpq %rax, 0x18(%r13)
je 0x9d753c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9dfa4e
movq %rax, %rcx
testq %rax, %rax
je 0x9d7964
movq %rcx, 0x20(%rsp)
movq (%rbx), %rax
cmpl $-0x1, 0x3218(%rax)
jne 0x9d759a
movq %rbp, %rax
andq $-0x2, %rax
cmpq %rax, 0x10(%r13)
jne 0x9d759a
movq %r13, %rdi
callq 0x4cf494
xorq 0x8(%rsp), %rax
xorq 0x10(%rsp), %rdx
orq %rax, %rdx
jne 0x9d759a
cmpq 0x18(%r13), %r12
jne 0x9d759a
movq %r13, %rdi
callq 0x74bc4a
andq $-0x8, %rax
cmpq %rax, 0x20(%rsp)
jne 0x9d759a
movq %r13, %rdi
callq 0x4cf4ec
testb %al, %al
je 0x9d7979
movq %r14, 0x58(%rsp)
leaq 0x150(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
andq $0x0, 0x100(%rax)
movq %r13, %rdi
callq 0x4cf4ec
testb %al, %al
je 0x9d761e
movq %r13, %rdi
callq 0x4cf4fa
leaq 0x140(%rsp), %r15
movl %eax, 0x110(%r15)
movq %r13, %rdi
callq 0x82bdc4
movl %eax, 0x114(%r15)
movq %r13, %rdi
callq 0x4cf4a8
movq %rax, %r14
movq %r13, %rdi
callq 0x4cf4c2
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r15, %rcx
callq 0x9e262e
testb %al, %al
jne 0x9d78a2
movq (%rbx), %r14
movq 0x10(%r13), %rdi
callq 0xf67396
shrq $0x20, %rax
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x781630
movl %eax, 0x1c(%rsp)
movq 0x18(%r13), %rax
movq 0x20(%r13), %rcx
movq 0x28(%rax), %rax
movl 0x28(%r13), %edx
movq %rax, 0x30(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
testq %rax, %rax
je 0x9d7696
leaq 0x90(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9e2416
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movups (%r14), %xmm0
movaps %xmm0, (%r15)
cmpq $0x0, (%r15)
je 0x9d78a2
andq $-0x2, %rbp
movl (%r13), %r14d
movl %r14d, %r15d
shrl $0x12, %r15d
andl $0x1, %r15d
movq %r13, %rdi
callq 0x4cf4ec
xorl %ecx, %ecx
testb %al, %al
leaq 0x140(%rsp), %rax
cmoveq %rcx, %rax
movq %rax, 0x50(%rsp)
movq %r12, 0x28(%rsp)
movq (%rbx), %rdi
movq %rbp, %rsi
movl %r15d, %ebp
movl %r15d, %edx
callq 0xa11cc8
movq %rax, %r13
cmpq $0x0, 0x28(%r12)
je 0x9d78ab
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x75a106
andq $-0x2, %r13
pushq $0x1
popq %r15
testb $0x2, 0x2(%r13)
jne 0x9d7898
btl $0x12, %r14d
movq 0x8(%r13), %r12
jae 0x9d774a
movq %r12, %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x28, 0x10(%rax)
jne 0x9d7898
movq (%rbx), %rsi
leaq 0x90(%rsp), %r15
leaq 0x30(%rsp), %rdx
pushq $0x3
popq %rcx
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x75e8d8
movq %r15, %rdi
movq 0x20(%rsp), %rsi
callq 0x7a89f8
movq %r15, %rdi
callq 0xa4cbee
movq (%rbx), %rax
movq 0x1208(%rax), %rcx
movl 0x1210(%rax), %eax
imulq $0x290, %rax, %rax # imm = 0x290
movl -0x290(%rcx,%rax), %eax
cmpl $0x3, %eax
movq 0x58(%rsp), %r14
ja 0x9d7856
cmpl $0x2, %eax
je 0x9d7856
movq %r13, %rdi
callq 0xe505b6
testb %al, %al
je 0x9d7856
leaq 0x28(%rsp), %rdi
callq 0x82bde4
testb %al, %al
je 0x9d7856
movq 0x8(%r13), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1ca6
andq $-0x10, %rax
movq (%rax), %rdi
callq 0xfa1e8a
testq %rax, %rax
je 0x9d7856
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, %rdx
andq $-0x8, %rdx
testb $0x4, %cl
je 0x9d780d
movq (%rdx), %rdx
leaq -0x40(%rdx), %rcx
testq %rdx, %rdx
cmoveq %rdx, %rcx
movq %rcx, 0x10(%rsp)
leaq 0x40(%rcx), %rsi
testq %rdx, %rdx
cmoveq %rdx, %rsi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %rdi
callq 0x73358c
movq 0x8(%rsp), %rdi
testb %al, %al
jne 0x9d7856
movq 0x10(%rsp), %rsi
callq 0xe0b7c0
testb %al, %al
je 0x9d79ac
movq (%rbx), %rdi
subq $0x8, %rsp
leaq 0x68(%rsp), %r9
movq %r13, %rsi
movq %r12, %rdx
movl 0x24(%rsp), %ecx
movl %ebp, %r8d
pushq $0x0
pushq $0x0
pushq $0x0
pushq 0x70(%rsp)
pushq %r15
pushq $0x0
pushq %r14
callq 0xa10a6e
addq $0x40, %rsp
movq %rax, %r15
leaq 0x90(%rsp), %rdi
callq 0x643428
leaq 0x68(%rsp), %rdi
jmp 0x9d7952
pushq $0x1
popq %r15
jmp 0x9d7957
movq (%rbx), %rdi
andq $-0x2, %r13
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %r12, %r8
callq 0x912bba
pushq $0x1
popq %r15
cmpq $0x1, %rax
je 0x9d7957
andq $-0x2, %rax
btl $0x12, %r14d
jb 0x9d78fb
testb $0x3, 0x1(%rax)
jne 0x9d78fb
movq (%rbx), %rdi
movq %rax, %rsi
callq 0xa36f72
cmpq $0x1, %rax
je 0x9d7957
andq $-0x2, %rax
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r8
movaps %xmm0, 0x20(%r8)
movaps %xmm0, 0x10(%r8)
movaps %xmm0, (%r8)
movq (%rbx), %rdi
movq 0x20(%rsp), %rcx
movl 0x1c(%rcx), %r10d
shrl $0xd, %r10d
andl $0x3, %r10d
orq %rcx, %r10
leaq 0x30(%rsp), %r11
movq %rax, %rsi
movl %ebp, %edx
movl 0x1c(%rsp), %ecx
movq %r12, %r9
pushq %r11
pushq %r10
callq 0xa116dc
popq %rcx
popq %rdx
movq %rax, %r15
leaq 0x98(%rsp), %rdi
callq 0x4f0656
leaq 0x140(%rsp), %rdi
callq 0x6d9e52
movq %r15, %rax
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r13), %rax
cmpb $0x61, (%rax)
jne 0x9d799c
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
movq %r12, %rsi
callq 0xa80530
testb %al, %al
jne 0x9d759a
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x93802a
movq %r13, %r15
jmp 0x9d7964
movq (%rbx), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsi), %rdx
movl 0x18(%rsi), %r8d
pushq $0x1
popq %rcx
xorl %r9d, %r9d
callq 0x9111fc
jmp 0x9d7888
| /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().TransformType(E->getControllingType());
if (ControllingExpr.isInvalid() && !ControllingType)
return ExprError();
SmallVector<Expr *, 4> AssocExprs;
SmallVector<TypeSourceInfo *, 4> AssocTypes;
for (const GenericSelectionExpr::Association Assoc : E->associations()) {
TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
if (TSI) {
TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
if (!AssocType)
return ExprError();
AssocTypes.push_back(AssocType);
} else {
AssocTypes.push_back(nullptr);
}
ExprResult AssocExpr =
getDerived().TransformExpr(Assoc.getAssociationExpr());
if (AssocExpr.isInvalid())
return ExprError();
AssocExprs.push_back(AssocExpr.get());
}
if (!ControllingType)
return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
E->getDefaultLoc(),
E->getRParenLoc(),
ControllingExpr.get(),
AssocTypes,
AssocExprs);
return getDerived().RebuildGenericSelectionExpr(
E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(),
ControllingType, AssocTypes, AssocExprs);
} | 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(%rsp)
movq $0x0, 0x38(%rsp)
jmp 0x9d7db7
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x9d39ae
cmpq $0x1, %rax
jne 0x9d7da4
pushq $0x1
popq %rbx
jmp 0x9d7f51
movq %rax, 0x38(%rsp)
movb $0x1, 0x2f(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0xa8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movl 0x10(%r15), %r13d
movl %r13d, %eax
shrl $0x1e, %eax
andl $0x1, %eax
leaq (%r15,%rax,8), %r14
addq $0x20, %r14
andl $0x7fff, %r13d # imm = 0x7FFF
leal (%rax,%r13), %ecx
movq %r15, 0x60(%rsp)
leaq (%r15,%rcx,8), %rcx
addq $0x20, %rcx
xorl $0x1, %eax
leaq (%rcx,%rax,8), %r12
shll $0x3, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x9d7e80
movq (%r14,%rbp), %r15
movq (%r12,%rbp), %rsi
testq %rsi, %rsi
je 0x9d7e41
movq %rbx, %rdi
callq 0x9db694
testq %rax, %rax
je 0x9d7e78
leaq 0x68(%rsp), %rdi
movq %rax, %rsi
jmp 0x9d7e48
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x820902
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9d7e78
andq $-0x2, %rax
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x9d7e18
pushq $0x1
popq %rbx
jmp 0x9d7f3a
movq 0x60(%rsp), %rax
movl 0x4(%rax), %esi
movl 0x14(%rax), %edx
movl 0x18(%rax), %ecx
cmpb $0x0, 0x2f(%rsp)
je 0x9d7ee7
movq 0x38(%rsp), %r9
andq $-0x2, %r9
movq 0x68(%rsp), %rax
movl 0x70(%rsp), %edi
movq 0x98(%rsp), %r8
movl 0xa0(%rsp), %r10d
movq %r8, 0x50(%rsp)
movq %r10, 0x58(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
movq (%rbx), %rdi
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
pushq $0x1
popq %r8
jmp 0x9d7f32
movq 0x68(%rsp), %rax
movl 0x70(%rsp), %edi
movq 0x98(%rsp), %r8
movl 0xa0(%rsp), %r9d
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
movq (%rbx), %rdi
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %r8d, %r8d
movq 0x30(%rsp), %r9
callq 0x90f998
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x82098a
leaq 0x98(%rsp), %rdi
callq 0x633cd8
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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();
ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
return ExprError();
if (!getDerived().AlwaysRebuild() &&
Cond.get() == E->getCond() &&
LHS.get() == E->getLHS() &&
RHS.get() == E->getRHS())
return E;
return getDerived().RebuildConditionalOperator(Cond.get(),
E->getQuestionLoc(),
LHS.get(),
E->getColonLoc(),
RHS.get());
} | 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, %rdi
callq 0x9d39ae
cmpq $0x1, %rax
jne 0x9db5a1
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rcx
andq $-0x2, %r15
cmpl $-0x1, 0x3218(%rcx)
jne 0x9db5d1
cmpq %r15, 0x18(%rbx)
jne 0x9db5d1
movq %r12, %rcx
andq $-0x2, %rcx
cmpq %rcx, 0x20(%rbx)
jne 0x9db5d1
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rcx, 0x28(%rbx)
je 0x9db5fa
andq $-0x2, %r12
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %r8d
andq $-0x2, %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %rax, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9ed22e
movq %rbx, %r13
jmp 0x9db594
nop
| /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 TemplateArgument");
case TemplateArgument::Integral:
case TemplateArgument::NullPtr:
case TemplateArgument::Declaration:
case TemplateArgument::StructuralValue: {
// Transform a resolved template argument straight to a resolved template
// argument. We get here when substituting into an already-substituted
// template type argument during concept satisfaction checking.
QualType T = Arg.getNonTypeTemplateArgumentType();
QualType NewT = getDerived().TransformType(T);
if (NewT.isNull())
return true;
ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration
? Arg.getAsDecl()
: nullptr;
ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
getDerived().getBaseLocation(), D))
: nullptr;
if (D && !NewD)
return true;
if (NewT == T && D == NewD)
Output = Input;
else if (Arg.getKind() == TemplateArgument::Integral)
Output = TemplateArgumentLoc(
TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT),
TemplateArgumentLocInfo());
else if (Arg.getKind() == TemplateArgument::NullPtr)
Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
TemplateArgumentLocInfo());
else if (Arg.getKind() == TemplateArgument::Declaration)
Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT),
TemplateArgumentLocInfo());
else if (Arg.getKind() == TemplateArgument::StructuralValue)
Output = TemplateArgumentLoc(
TemplateArgument(getSema().Context, NewT, Arg.getAsStructuralValue()),
TemplateArgumentLocInfo());
else
llvm_unreachable("unexpected template argument kind");
return false;
}
case TemplateArgument::Type: {
TypeSourceInfo *DI = Input.getTypeSourceInfo();
if (!DI)
DI = InventTypeSourceInfo(Input.getArgument().getAsType());
DI = getDerived().TransformType(DI);
if (!DI)
return true;
Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
return false;
}
case TemplateArgument::Template: {
NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
if (QualifierLoc) {
QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
if (!QualifierLoc)
return true;
}
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
TemplateName Template = getDerived().TransformTemplateName(
SS, Arg.getAsTemplate(), Input.getTemplateNameLoc());
if (Template.isNull())
return true;
Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
QualifierLoc, Input.getTemplateNameLoc());
return false;
}
case TemplateArgument::TemplateExpansion:
llvm_unreachable("Caller should expand pack expansions");
case TemplateArgument::Expression: {
// Template argument expressions are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
getSema(),
Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
: Sema::ExpressionEvaluationContext::ConstantEvaluated,
Sema::ReuseLambdaContextDecl, /*ExprContext=*/
Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);
Expr *InputExpr = Input.getSourceExpression();
if (!InputExpr)
InputExpr = Input.getArgument().getAsExpr();
ExprResult E = getDerived().TransformExpr(InputExpr);
E = SemaRef.ActOnConstantExpression(E);
if (E.isInvalid())
return true;
Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
return false;
}
}
// Work around bogus GCC warning
return true;
} | 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
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xf8ccb8
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
callq 0x9dfa16
cmpq $0x10, %rax
jb 0x9e0618
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl (%r14), %eax
cmpl $0x2, %eax
jne 0x9e02f1
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x9e02f1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9dfa4e
testq %rax, %rax
jne 0x9e02f5
jmp 0x9e0618
xorl %eax, %eax
xorl %ebx, %ebx
xorq %r12, %r13
xorq %rax, %rbx
orq %r13, %rbx
jne 0x9e0444
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movq 0x10(%rsp), %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %ebp, %ebp
jmp 0x9e0618
movq %r14, %rdi
callq 0x4c5dfc
movq %rdx, %r12
xorl %r13d, %r13d
testq %rax, %rax
je 0x9e04c2
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9dfa82
testq %rax, %rax
je 0x9e0618
movq %rdx, %r12
jmp 0x9e04c4
movq (%r15), %rdi
xorb $0x1, %cl
movzbl %cl, %esi
shll $0x2, %esi
movq %rdi, 0x20(%rsp)
movb $0x1, 0x28(%rsp)
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x9340d4
movq 0x18(%r14), %rsi
andq $-0x4, %rsi
jne 0x9e0389
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x9d39ae
movq (%r15), %rdi
movq %rax, %rsi
callq 0x937836
cmpq $0x1, %rax
sete %bpl
je 0x9e03c2
movq %rax, %rcx
andq $-0x2, %rcx
andq $-0x4, %rax
incq %rax
movl $0x8, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x629670
jmp 0x9e0618
movq %rbx, %r12
movq 0x18(%r14), %rsi
andq $-0x4, %rsi
jne 0x9e03f6
movq 0x8(%r14), %rsi
movq (%r15), %rax
movq 0x100(%rax), %rdi
xorl %edx, %edx
callq 0xd91190
movq %rax, %rsi
movq %r15, %rdi
callq 0x9db694
testq %rax, %rax
je 0x9e0618
movq %rax, %rbx
movq (%rax), %rsi
leaq 0x20(%rsp), %r14
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8c79e
andq $-0x4, %rbx
orq $0x2, %rbx
movq 0x10(%r14), %rax
movq %rax, 0x10(%r12)
movups (%r14), %xmm0
movups %xmm0, (%r12)
movq %rbx, 0x18(%r12)
jmp 0x9e0618
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl (%r14), %ecx
cmpl $0x2, %ecx
je 0x9e05c4
cmpl $0x3, %ecx
je 0x9e05ab
cmpl $0x4, %ecx
jne 0x9e05dd
movq (%r15), %rax
movq 0x100(%rax), %rbx
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ee566
leaq 0x20(%rsp), %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xf8c8f2
movq 0x10(%r14), %rax
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%r14), %xmm0
movups %xmm0, (%rcx)
andq $0x0, 0x18(%rcx)
movq %r15, %rdi
callq 0x468360
jmp 0x9e0618
xorl %eax, %eax
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rsp)
movq %rax, %rsi
movq %r12, %rdx
callq 0x75a106
movq %r14, %rdi
callq 0x81ebe4
movl $0x7ffffffe, %ecx # imm = 0x7FFFFFFE
andl (%r14), %ecx
cmpl $0x6, %ecx
jne 0x9e0508
movq 0x18(%r14), %rcx
andq $-0x4, %rcx
movl 0x10(%rcx), %r13d
andl $0x0, (%rsp)
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9e07ba
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
callq 0xf8df04
movl %eax, %ebp
testb %al, %al
jne 0x9e059f
movq %rbx, %r13
movq (%r15), %rax
movq 0x100(%rax), %rsi
movq 0x18(%rsp), %rax
movl $0x7ffffffe, %ecx # imm = 0x7FFFFFFE
andl (%r14), %ecx
cmpl $0x6, %ecx
movl $0x0, %r8d
jne 0x9e0569
movq 0x18(%r14), %rcx
andq $-0x4, %rcx
movl 0x10(%rcx), %r8d
leaq 0x70(%rsp), %rbx
movq $0x6, -0x18(%rbx)
movq %rax, -0x10(%rbx)
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
xorl %r9d, %r9d
callq 0xf8da54
movups -0x18(%rbx), %xmm0
movups -0x8(%rbx), %xmm1
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
leaq 0x28(%rsp), %rdi
callq 0x4f0656
jmp 0x9e0618
leaq 0x20(%rsp), %rbx
pushq $0x1
popq %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xf8c79e
jmp 0x9e0600
leaq 0x20(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xf8c7ae
jmp 0x9e0600
movq (%r15), %rax
movq 0x100(%rax), %rsi
movq 0x8(%r14), %rcx
leaq 0x20(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0xf8c8f8
movq 0x10(%rbx), %rax
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%rbx), %xmm0
movups %xmm0, (%rcx)
andq $0x0, 0x18(%rcx)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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>(D)) {
// A valid resolved using typename pack expansion decl can have multiple
// UsingDecls, but they must each have exactly one type, and it must be
// the same type in every case. But we must have at least one expansion!
if (UPD->expansions().empty()) {
getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
<< UPD->isCXXClassMember() << UPD;
return QualType();
}
// We might still have some unresolved types. Try to pick a resolved type
// if we can. The final instantiation will check that the remaining
// unresolved types instantiate to the type we pick.
QualType FallbackT;
QualType T;
for (auto *E : UPD->expansions()) {
QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
if (ThisT.isNull())
continue;
else if (ThisT->getAs<UnresolvedUsingType>())
FallbackT = ThisT;
else if (T.isNull())
T = ThisT;
else
assert(getSema().Context.hasSameType(ThisT, T) &&
"mismatched resolved types in using pack expansion");
}
return T.isNull() ? FallbackT : T;
} else if (auto *Using = dyn_cast<UsingDecl>(D)) {
assert(Using->hasTypename() &&
"UnresolvedUsingTypenameDecl transformed to non-typename using");
// A valid resolved using typename decl points to exactly one type decl.
assert(++Using->shadow_begin() == Using->shadow_end());
UsingShadowDecl *Shadow = *Using->shadow_begin();
if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), Loc))
return QualType();
return SemaRef.Context.getUsingType(
Shadow, SemaRef.Context.getTypeDeclType(
cast<TypeDecl>(Shadow->getTargetDecl())));
} else {
assert(isa<UnresolvedUsingTypenameDecl>(D) &&
"UnresolvedUsingTypenameDecl transformed to non-using decl");
return SemaRef.Context.getTypeDeclType(
cast<UnresolvedUsingTypenameDecl>(D));
}
} | 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(%r15), %r13d
testq %r13, %r13
je 0x9e1fcc
shlq $0x3, %r13
xorl %ebx, %ebx
movq $0x0, 0x28(%rsp)
movq $0x0, 0x38(%rsp)
cmpq %rbx, %r13
je 0x9e1f49
movq 0x40(%r15,%rbx), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x9e1e90
cmpq $0x10, %rax
jb 0x9e1f3c
movq %rax, %r12
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x820dd4
testq %rax, %rax
je 0x9e1f2a
movq %r12, 0x38(%rsp)
jmp 0x9e1f3c
movq 0x28(%rsp), %rax
cmpq $0x10, %rax
cmovbq %r12, %rax
movq %rax, 0x28(%rsp)
addq $0x8, %rbx
jmp 0x9e1ef5
xorl %ebx, %ebx
jmp 0x9e2031
movq 0x28(%rsp), %rax
cmpq $0x10, %rax
movq 0x38(%rsp), %rbx
cmovaeq %rax, %rbx
jmp 0x9e2031
cmpl $0x4d, %eax
jne 0x9e201a
movq 0x30(%rdx), %r15
andq $-0x8, %r15
movq (%r14), %rdi
movq 0x40(%r15), %rsi
andl $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
xorl %ebx, %ebx
leaq 0x34(%rsp), %rdx
pushq $0x1
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x909a26
testb %al, %al
jne 0x9e2031
movq (%r14), %rax
movq 0x100(%rax), %rbx
movq 0x40(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7344c0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdab738
jmp 0x9e202e
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x48(%rsp), %r14
xorl %ebx, %ebx
movq %r14, %rdi
movl %ebp, %edx
movl $0x13a2, %ecx # imm = 0x13A2
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
callq 0x79de2c
leaq 0x27(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x77c590
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x820d54
movq %r14, %rdi
callq 0x78b0f8
jmp 0x9e2031
movq (%r14), %rax
movq 0x100(%rax), %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x7344c0
movq %rax, %rbx
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x4a
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x14
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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().TransformOMPExecutableDirective(D);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x9
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x4
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9e8e7e
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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() == S->getTarget())
return S;
return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
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, 0x3218(%rdi)
jne 0x9e6008
cmpq %rax, 0x10(%rbx)
je 0x9e5fd8
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb2f73a
nop
| /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) {
for (unsigned I = 0; I != NumInputs; ++I) {
// If requested, drop call arguments that need to be dropped.
if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
if (ArgChanged)
*ArgChanged = true;
break;
}
if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
Expr *Pattern = Expansion->getPattern();
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
// Determine whether the set of unexpanded parameter packs can and should
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
std::optional<unsigned> NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
Pattern->getSourceRange(),
Unexpanded,
Expand, RetainExpansion,
NumExpansions))
return true;
if (!Expand) {
// The transform has determined that we should perform a simple
// transformation on the pack expansion, producing another pack
// expansion.
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
ExprResult OutPattern = getDerived().TransformExpr(Pattern);
if (OutPattern.isInvalid())
return true;
ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
Expansion->getEllipsisLoc(),
NumExpansions);
if (Out.isInvalid())
return true;
if (ArgChanged)
*ArgChanged = true;
Outputs.push_back(Out.get());
continue;
}
// Record right away that the argument was changed. This needs
// to happen even if the array expands to nothing.
if (ArgChanged) *ArgChanged = true;
// The transform has determined that we should perform an elementwise
// expansion of the pattern. Do so.
for (unsigned I = 0; I != *NumExpansions; ++I) {
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
ExprResult Out = getDerived().TransformExpr(Pattern);
if (Out.isInvalid())
return true;
if (Out.get()->containsUnexpandedParameterPack()) {
Out = getDerived().RebuildPackExpansion(
Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
if (Out.isInvalid())
return true;
}
Outputs.push_back(Out.get());
}
// If we're supposed to retain a pack expansion, do so by temporarily
// forgetting the partially-substituted parameter pack.
if (RetainExpansion) {
ForgetPartiallySubstitutedPackRAII Forget(getDerived());
ExprResult Out = getDerived().TransformExpr(Pattern);
if (Out.isInvalid())
return true;
Out = getDerived().RebuildPackExpansion(
Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
if (Out.isInvalid())
return true;
Outputs.push_back(Out.get());
}
continue;
}
ExprResult Result =
IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
: getDerived().TransformExpr(Inputs[I]);
if (Result.isInvalid())
return true;
if (Result.get() != Inputs[I] && ArgChanged)
*ArgChanged = true;
Outputs.push_back(Result.get());
}
return false;
} | 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, 0x4(%rsp)
movq %rbx, 0x30(%rsp)
movq %rsi, 0x10(%rsp)
je 0x9e7aa7
movq %r13, %rdi
callq 0xe50468
testb %al, %al
jne 0x9e7bdf
movq 0x10(%rsp), %rax
movq (%rax), %r13
cmpb $0x17, (%r13)
je 0x9e7ab5
cmpb $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rdi
je 0x9e7b78
movq %r13, %rsi
xorl %edx, %edx
callq 0x9e77ce
movq 0x10(%rsp), %rbx
jmp 0x9e7b8e
cmpb $0x17, (%r13)
movq %rsi, %rbx
jne 0x9e7b81
movq 0x18(%r13), %r14
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x40(%rsp)
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0xc6bade
movl 0x14(%r13), %r15d
movq 0x8(%rsp), %r12
movq (%r12), %rbx
movl 0x3218(%rbx), %eax
movl %eax, (%rsp)
orl $-0x1, 0x3218(%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9e7bc7
andq $-0x2, %rax
xorl %ecx, %ecx
subl $0x1, %r15d
movl 0x10(%r13), %edx
setae %cl
shlq $0x20, %rcx
orq %rcx, %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x9e7c06
cmpq $0x1, %rax
je 0x9e7bc7
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0x9e7b4f
movb $0x1, (%r14)
andq $-0x2, %rax
movq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
movl (%rsp), %eax
movl %eax, 0x3218(%rbx)
leaq 0x38(%rsp), %rdi
callq 0x80ef16
jmp 0x9e7bb1
movq 0x18(%rsp), %rax
leaq (%rax,%rbx,8), %rbx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9e7beb
andq $-0x2, %rax
testq %r14, %r14
je 0x9e7ba6
cmpq %rax, (%rbx)
je 0x9e7ba6
movb $0x1, (%r14)
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
movq 0x30(%rsp), %rbx
incq %rbx
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
jmp 0x9e7a42
movl (%rsp), %eax
movl %eax, 0x3218(%rbx)
leaq 0x38(%rsp), %rdi
callq 0x80ef16
movb $0x1, %r15b
jmp 0x9e7beb
testq %r14, %r14
je 0x9e7be8
movb $0x1, (%r14)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa0fd2
nop
| /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;
Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyprivateClause(
Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
} | 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(%r14), %r13d
shlq $0x3, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x9e9a02
movq 0x18(%r14,%rbp), %rsi
movq %rbx, %rdi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9e9a28
andq $-0x2, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x9e99d5
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
movl 0xc(%r14), %r8d
movl (%r14), %ecx
movl 0x4(%r14), %r9d
movq (%rbx), %rax
movq 0x2f0(%rax), %rdi
callq 0xaa837a
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x633cd8
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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;
Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPLastprivateClause(
Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
C->getLParenLoc(), C->getEndLoc());
} | 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(%r14), %r13d
shlq $0x3, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x9eacda
movq 0x40(%r14,%rbp), %rsi
movq %rbx, %rdi
callq 0x9d39ae
cmpq $0x1, %rax
je 0x9ead19
andq $-0x2, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x63144a
addq $0x8, %rbp
jmp 0x9eacad
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
movl 0x30(%r14), %ecx
movl 0x34(%r14), %r8d
movl 0x38(%r14), %r9d
movl 0xc(%r14), %eax
movl (%r14), %r10d
movl 0x4(%r14), %r11d
movq (%rbx), %rdi
movq 0x2f0(%rdi), %rdi
subq $0x8, %rsp
pushq %r11
pushq %rax
pushq %r10
callq 0xaa5a8e
addq $0x20, %rsp
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x633cd8
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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())
return ExprError();
Base =
getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow());
if (Base.isInvalid())
return ExprError();
BaseType = Base.get()->getType();
} else {
BaseType = getDerived().TransformType(Old->getBaseType());
}
NestedNameSpecifierLoc QualifierLoc;
if (Old->getQualifierLoc()) {
QualifierLoc =
getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
if (!QualifierLoc)
return ExprError();
}
SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName);
// Transform the declaration set.
if (TransformOverloadExprDecls(Old, /*RequiresADL*/ false, R))
return ExprError();
// Determine the naming class.
if (Old->getNamingClass()) {
CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
if (!NamingClass)
return ExprError();
R.setNamingClass(NamingClass);
}
TemplateArgumentListInfo TransArgs;
if (Old->hasExplicitTemplateArgs()) {
TransArgs.setLAngleLoc(Old->getLAngleLoc());
TransArgs.setRAngleLoc(Old->getRAngleLoc());
if (getDerived().TransformTemplateArguments(
Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
return ExprError();
}
// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;
return getDerived().RebuildUnresolvedMemberExpr(
Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
TemplateKWLoc, FirstQualifierInScope, R,
(Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr));
} | 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(%r14), %rsi
testq %rsi, %rsi
je 0x9f5352
movq 0x30(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9ffcb6
testq %rax, %rax
je 0x9f5509
movq %rax, %r13
movq %rdx, 0x8(%rsp)
jmp 0x9f535e
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x9c7bc6
cmpq $0x1, %rax
je 0x9f5509
movq (%rbx), %rdi
andq $-0x2, %rax
movzbl 0x2(%r14), %edx
shrl $0x3, %edx
andl $0x1, %edx
movq %rax, %rsi
callq 0xa11cc8
cmpq $0x1, %rax
je 0x9f5509
movq %rax, %r15
andq $-0x2, %r15
movq 0x8(%r15), %r12
jmp 0x9f52de
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x8219b0
movq %rax, 0x18(%rsp)
movq (%rbx), %rsi
leaq 0x10(%r14), %rdx
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x75e8d8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbp, %rcx
callq 0xa02df8
pushq $0x1
popq %rbp
testb %al, %al
jne 0x9f54ff
movq %r14, %rdi
callq 0xe95eea
testq %rax, %rax
je 0x9f53d0
movq %r14, %rdi
callq 0xe95eea
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9ffc82
testq %rax, %rax
je 0x9f54ff
movq %rax, 0xb8(%rsp)
movq %r12, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
andq $0x0, 0x100(%rax)
movq %r14, %rdi
callq 0x4cf3f4
testb %al, %al
je 0x9f545a
movq %r14, %rdi
callq 0x4cf458
leaq 0x100(%rsp), %r12
movl %eax, 0x110(%r12)
movq %r14, %rdi
callq 0x8219c6
movl %eax, 0x114(%r12)
movq %r14, %rdi
callq 0x4cf402
movq %rax, %rbp
movq %r14, %rdi
callq 0x4cf43a
movq %rbx, %rdi
movq %rbp, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0xa02b74
testb %al, %al
je 0x9f545a
pushq $0x1
popq %rbp
jmp 0x9f54f2
movl 0x48(%r14), %eax
movl %eax, 0x4(%rsp)
movzbl 0x2(%r14), %r12d
shrl $0x3, %r12d
andl $0x1, %r12d
movq %r14, %rdi
callq 0x4cf3f4
xorl %ecx, %ecx
testb %al, %al
leaq 0x100(%rsp), %rbp
cmoveq %rcx, %rbp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r14, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0x75a106
movq (%rbx), %rdi
subq $0x8, %rsp
movq %r15, %rsi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl %r12d, %r8d
movq %r14, %r9
pushq $0x0
pushq $0x0
pushq $0x0
pushq %rbp
leaq 0x80(%rsp), %rax
pushq %rax
pushq $0x0
pushq 0x50(%rsp)
callq 0xa10a6e
addq $0x40, %rsp
movq %rax, %rbp
leaq 0x28(%rsp), %rdi
callq 0x4f0656
leaq 0x100(%rsp), %rdi
callq 0x6d9e52
leaq 0x58(%rsp), %rdi
callq 0x643428
movq %rbp, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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(E->getBase());
if (Base.isInvalid())
return ExprError();
// We don't need to transform the property; it will never change.
// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
Base.get() == E->getBase())
return E;
if (E->isExplicitProperty())
return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
E->getExplicitProperty(),
E->getLocation());
return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
SemaRef.Context.PseudoObjectTy,
E->getImplicitPropertyGetter(),
E->getImplicitPropertySetter(),
E->getLocation());
} | 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)
jne 0x9f57b4
movq %r14, %rcx
andq $-0x2, %rcx
movq 0x28(%rbx), %rdx
andq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x9f5883
movq 0x10(%rbx), %r12
andq $-0x2, %r14
testb $0x4, %r12b
jne 0x9f5837
andq $-0x8, %r12
movl 0x20(%rbx), %ebx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq 0x28(%r12), %rsi
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movl %ebx, %edx
callq 0x64b05c
movq (%r15), %rdi
movq 0x8(%r14), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movq %r12, 0x10(%rsp)
movq %r14, %rsi
movl %ebx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0xa0e986
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4f0656
jmp 0x9f5883
movq 0x100(%rax), %rsi
movq 0x49d0(%rsi), %r15
andq $-0x8, %r12
movq 0x18(%rbx), %r13
andq $-0x8, %r13
movl 0x20(%rbx), %ebp
pushq $0x30
popq %rdi
pushq $0x8
popq %rdx
callq 0xf6553c
movq %rax, %rbx
movq %r14, 0x8(%rsp)
movl %ebp, (%rsp)
pushq $0x1
popq %r8
pushq $0x3
popq %r9
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x82bcaa
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 construct, Description]
// OpenMP [2.8.1, simd construct, Description]
// OpenMP [2.9.6, distribute construct, Description]
// The parameter of the ordered clause must be a constant
// positive integer expression if any.
if (NumForLoops && LParenLoc.isValid()) {
ExprResult NumForLoopsResult =
VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered);
if (NumForLoopsResult.isInvalid())
return nullptr;
NumForLoops = NumForLoopsResult.get();
} else {
NumForLoops = nullptr;
}
auto *Clause =
OMPOrderedClause::Create(getASTContext(), NumForLoops,
NumForLoops ? DSAStack->getAssociatedLoops() : 0,
StartLoc, LParenLoc, EndLoc);
DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops, Clause);
return Clause;
} | 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
movq %rbx, %rdi
movq %r8, %rsi
xorl %r8d, %r8d
callq 0xa99c1e
cmpq $0x1, %rax
je 0xaa10f5
movq %rax, %r12
andq $-0x2, %r12
jmp 0xaa109f
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x7a6c24
movq %rax, %rbp
testq %r12, %r12
je 0xaa10bb
movq 0x8(%rbx), %rdi
callq 0xa8259a
movl %eax, %r13d
movq %rbp, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl 0x4(%rsp), %r9d
callq 0xf4da52
movq %rax, %rbp
movq 0x8(%rbx), %rdi
callq 0xab4d24
movq %r12, 0x418(%rax)
movq %rbp, 0x420(%rax)
movb $0x1, 0x428(%rax)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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,
SourceLocation EndLoc) {
if (Kind == OMPC_DEPEND_unknown || Kind == OMPC_DEPEND_source ||
Kind == OMPC_DEPEND_sink || Kind == OMPC_DEPEND_depobj) {
SmallVector<unsigned> Except = {
OMPC_DEPEND_source, OMPC_DEPEND_sink, OMPC_DEPEND_depobj,
OMPC_DEPEND_outallmemory, OMPC_DEPEND_inoutallmemory};
if (getLangOpts().OpenMP < 51)
Except.push_back(OMPC_DEPEND_inoutset);
Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
<< getListOfPossibleValues(OMPC_depend, /*First=*/0,
/*Last=*/OMPC_DEPEND_unknown, Except)
<< getOpenMPClauseName(OMPC_update);
return nullptr;
}
return OMPUpdateClause::Create(getASTContext(), StartLoc, LParenLoc,
KindKwLoc, Kind, EndLoc);
} | 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 # 0x1240fcc
leaq 0x70(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x9, 0x10(%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x5
popq %rdx
callq 0xaa35ba
movq %r15, %rdi
callq 0x7a6c3c
cmpl $0x32, 0x40(%rax)
ja 0xaa2f20
leaq 0x10(%rsp), %rdi
pushq $0x7
popq %rsi
callq 0x4957e2
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movl $0x10b5, %ecx # imm = 0x10B5
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x10(%rsp), %rbx
movq (%rbx), %r8
movl 0x8(%rbx), %r9d
leaq 0x50(%rsp), %r15
pushq $0x14
popq %rsi
pushq $0xa
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0xaa3276
movq %r14, %rdi
movq %r15, %rsi
callq 0x795ea0
movq %rax, %r12
pushq $0x61
popq %rdi
callq 0x10c1141
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r12, %rdi
callq 0x787ea2
movq %r15, %rdi
callq 0x436d30
movq %r14, %rdi
callq 0x78b0f8
movq %rbx, %rdi
callq 0x468820
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x7a6c24
movq %rax, %rdi
movl %r13d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movl %r12d, %r8d
movl %ebp, %r9d
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf4db66
| /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 in OpenMP < 50.");
bool ErrorFound = false;
if (ModifierLoc.isValid() && Modifier == OMPC_DEVICE_unknown) {
std::string Values =
getListOfPossibleValues(OMPC_device, /*First=*/0, OMPC_DEVICE_unknown);
Diag(ModifierLoc, diag::err_omp_unexpected_clause_value)
<< Values << getOpenMPClauseName(OMPC_device);
ErrorFound = true;
}
Expr *ValExpr = Device;
Stmt *HelperValStmt = nullptr;
// OpenMP [2.9.1, Restrictions]
// The device expression must evaluate to a non-negative integer value.
ErrorFound = !isNonNegativeIntegerValue(ValExpr, SemaRef, OMPC_device,
/*StrictlyPositive=*/false) ||
ErrorFound;
if (ErrorFound)
return nullptr;
// OpenMP 5.0 [2.12.5, Restrictions]
// In case of ancestor device-modifier, a requires directive with
// the reverse_offload clause must be specified.
if (Modifier == OMPC_DEVICE_ancestor) {
if (!DSAStack->hasRequiresDeclWithClause<OMPReverseOffloadClause>()) {
SemaRef.targetDiag(
StartLoc,
diag::err_omp_device_ancestor_without_requires_reverse_offload);
ErrorFound = true;
}
}
OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
OpenMPDirectiveKind CaptureRegion =
getOpenMPCaptureRegionForClause(DKind, OMPC_device, getLangOpts().OpenMP);
if (CaptureRegion != OMPD_unknown &&
!SemaRef.CurContext->isDependentContext()) {
ValExpr = SemaRef.MakeFullExpr(ValExpr).get();
llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
ValExpr = tryBuildCapture(SemaRef, ValExpr, Captures).get();
HelperValStmt = buildPreInits(getASTContext(), Captures);
}
return new (getASTContext())
OMPDeviceClause(Modifier, ValExpr, HelperValStmt, CaptureRegion, StartLoc,
LParenLoc, ModifierLoc, EndLoc);
} | 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), %rbx
pushq $0x18
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xaa3276
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
movl $0x10b5, %ecx # imm = 0x10B5
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x78fcdb
movl %r14d, %ebx
movq %rax, %r14
pushq $0x18
popq %rdi
callq 0x10c1141
leaq 0x48(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
movl %ebx, %r14d
callq 0x787ea2
movq %r15, %rdi
callq 0x78b0f8
leaq 0x28(%rsp), %rdi
callq 0x436d30
leaq 0x28(%rsp), %rdi
movq %r13, (%rdi)
movq (%r12), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
pushq $0x18
popq %rdx
xorl %ebx, %ebx
pushq $0x63
popq %r9
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xaa25b4
andb %al, %bpl
cmpb $0x1, %bpl
jne 0xaa4685
cmpl $0x0, 0x20(%rsp)
jne 0xaa4581
movq 0x8(%r12), %rdi
callq 0xa98be2
testb %al, %al
jne 0xaa4581
movq (%r12), %rsi
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
movl 0x1c(%rsp), %edx
movl $0x101f, %ecx # imm = 0x101F
xorl %r8d, %r8d
callq 0x78b1fc
movq %rbx, %rdi
callq 0x78b0f8
movq 0x8(%r12), %rdi
callq 0xa80436
movl %eax, %ebx
movq %r12, %rdi
callq 0x7a6c3c
movl 0x40(%rax), %edx
pushq $0x18
popq %rsi
pushq $0x63
popq %rcx
movl %ebx, %edi
callq 0xaa21fc
movl %eax, %r13d
cmpl $0x63, %eax
jne 0xaa45b4
movq 0x28(%rsp), %rbp
jmp 0xaa45cd
movq (%r12), %rax
movq 0x230(%rax), %rdi
callq 0xe1c52c
movq 0x28(%rsp), %rbp
testb %al, %al
je 0xaa45d2
xorl %r15d, %r15d
jmp 0xaa4633
movq (%r12), %rdi
movq %rbp, %rsi
callq 0xaa23b2
movl %r14d, %ebp
movq %rax, %r14
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa23e2
movq (%r12), %rdi
leaq 0x79c612(%rip), %rcx # 0x1240c0e
pushq $0xe
popq %r8
movq %r14, %rsi
movl %ebp, %r14d
movq %rbx, %rdx
callq 0xaa23fc
movq %rax, %rbp
andq $-0x2, %rbp
movq %r12, %rdi
callq 0x7a6c24
movq %rax, %rdi
movq %rbx, %rsi
callq 0xaa250a
movq %rax, %r15
movq %rbx, %rdi
callq 0xaa259e
movq %r12, %rdi
callq 0x7a6c24
leaq 0x850(%rax), %rdi
pushq $0x30
popq %rsi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, %rbx
movl 0x1c(%rsp), %eax
movl %eax, (%rbx)
movl 0x150(%rsp), %eax
movl %eax, 0x4(%rbx)
movl $0x18, 0x8(%rbx)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x20(%rbx)
movl %r14d, 0x24(%rbx)
movq %rbp, 0x28(%rbx)
movq %r15, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq %rbx, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 modifier in OpenMP < 51.");
if (ModifierLoc.isValid() && Modifier == OMPC_NUMTASKS_unknown) {
std::string Values = getListOfPossibleValues(OMPC_num_tasks, /*First=*/0,
OMPC_NUMTASKS_unknown);
Diag(ModifierLoc, diag::err_omp_unexpected_clause_value)
<< Values << getOpenMPClauseName(OMPC_num_tasks);
return nullptr;
}
Expr *ValExpr = NumTasks;
Stmt *HelperValStmt = nullptr;
OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
// OpenMP [2.9.2, taskloop Constrcut]
// The parameter of the num_tasks clause must be a positive integer
// expression.
if (!isNonNegativeIntegerValue(
ValExpr, SemaRef, OMPC_num_tasks,
/*StrictlyPositive=*/true, /*BuildCapture=*/true,
DSAStack->getCurrentDirective(), &CaptureRegion, &HelperValStmt))
return nullptr;
return new (getASTContext())
OMPNumTasksClause(Modifier, ValExpr, HelperValStmt, CaptureRegion,
StartLoc, LParenLoc, ModifierLoc, EndLoc);
} | 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, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xaa3276
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl $0x10b5, %ecx # imm = 0x10B5
xorl %r8d, %r8d
callq 0x7a6d9e
movq %r12, %rdi
movq %r15, %rsi
callq 0x78fcdb
movq %rax, %rbx
movl %ebp, %edi
callq 0x10c1141
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x787ea2
movq %r12, %rdi
callq 0x78b0f8
movq %r15, %rdi
callq 0x436d30
jmp 0xaa4970
movl %ecx, (%rsp)
movl %r8d, 0x4(%rsp)
leaq 0x38(%rsp), %r14
movq %rdx, (%r14)
leaq 0x18(%rsp), %r12
andq $0x0, (%r12)
leaq 0x8(%rsp), %rax
movl $0x63, (%rax)
movq (%r13), %rbp
movq 0x8(%r13), %rdi
callq 0xa80436
pushq $0x3e
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbp, %rsi
movl %ecx, %r8d
movl %eax, %r9d
pushq %r12
leaq 0x10(%rsp), %rax
pushq %rax
callq 0xaa25b4
popq %rcx
popq %rdx
testb %al, %al
je 0xaa496d
movl 0xd0(%rsp), %ebp
movq %r13, %rdi
callq 0x7a6c24
leaq 0x850(%rax), %rdi
pushq $0x30
popq %rsi
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, %r14
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x8(%rsp), %edx
movl (%rsp), %esi
movl %esi, (%r14)
movl %ebp, 0x4(%r14)
movl $0x3e, 0x8(%r14)
movl 0x4(%rsp), %esi
movl %esi, 0x1c(%r14)
movl %r15d, 0x20(%r14)
movl %ebx, 0x24(%r14)
movq %rax, 0x28(%r14)
movq %rcx, 0x10(%r14)
movl %edx, 0x18(%r14)
jmp 0xaa4970
xorl %r14d, %r14d
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ListItemNotVar = false) {
ASTContext &Context = SemaRef.getASTContext();
bool IsClassType;
if (isConstNotMutableType(SemaRef, Type, AcceptIfMutable, &IsClassType)) {
unsigned Diag = ListItemNotVar ? diag::err_omp_const_list_item
: IsClassType ? diag::err_omp_const_not_mutable_variable
: diag::err_omp_const_variable;
SemaRef.Diag(ELoc, Diag) << getOpenMPClauseName(CKind);
if (!ListItemNotVar && D) {
const VarDecl *VD = dyn_cast<VarDecl>(D);
bool IsDecl = !VD || VD->isThisDeclarationADefinition(Context) ==
VarDecl::DeclarationOnly;
SemaRef.Diag(D->getLocation(),
IsDecl ? diag::note_previous_decl : diag::note_defined_here)
<< D;
}
return true;
}
return false;
} | 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), %eax
andl $0x1, %eax
xorl $0x1007, %eax # imm = 0x1007
cmpb $0x0, 0xc0(%rsp)
movl $0x1005, %ecx # imm = 0x1005
cmovel %eax, %ecx
addq $0x8, %r14
movq %r12, 0x8(%rsp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
xorl %r8d, %r8d
callq 0x7a6d9e
movl %ebp, %edi
callq 0x10c1141
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r12, %rdi
callq 0x787ea2
movq %r12, %rdi
movq 0x8(%rsp), %r12
callq 0x78b0f8
testq %r15, %r15
sete %al
orb 0xc0(%rsp), %al
jne 0xaaba70
movl 0x1c(%r15), %eax
andl $0x7f, %eax
addl $-0x2c, %eax
movl $0x16e6, %ecx # imm = 0x16E6
cmpl $-0x7, %eax
jb 0xaaba44
movq %r15, %rdi
movq %r12, %rsi
callq 0xe11714
testl %eax, %eax
movl $0x16e6, %eax # imm = 0x16E6
movl $0x1577, %ecx # imm = 0x1577
cmovel %eax, %ecx
movl 0x18(%r15), %edx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7a6d9e
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x8d75d0
movq %r15, %rdi
callq 0x78b0f8
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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->getUsedContext() == SemaRef.CurContext)
return E;
return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
} | 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 0xe4a970
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x918c34
pushq $0x1
popq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /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().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movq %rsi, %rbx
andq $0x0, 0x10(%rdx)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f0(%rax), %rdi
movl 0xc(%rsi), %r8d
pushq $0x69
popq %rsi
xorl %ecx, %ecx
callq 0xa82d3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb8b2b0
movq %rax, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
clang::TreeTransform<(anonymous namespace)::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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa1108
nop
| /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 operand rather than transforming it
// separately.
// FIXME: getCurScope() should not be used during template instantiation.
// We should pick up the set of unqualified lookup results for operator
// co_await during the initial parse.
ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
getSema().getCurScope(), E->getKeywordLoc());
// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoawaitExpr(
E->getKeywordLoc(), Operand.get(),
cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit());
} | 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(%r15), %edx
callq 0x82fb46
movl 0x10(%r15), %ebp
andq $-0x2, %rbx
andq $-0x2, %rax
testb $0x4, 0x2(%r15)
movq (%r14), %rdi
jne 0xb9a093
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82fbfa
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x82e998
cmpq $0x1, %rax
je 0xb9a042
movq (%r14), %rdi
andq $-0x2, %rax
pushq $0x1
popq %r8
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82febc
| /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().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
&ArgChanged))
return ExprError();
if (!getDerived().AlwaysRebuild() &&
Callee.get() == E->getCallee() &&
!ArgChanged)
return SemaRef.MaybeBindToTemporary(E);
// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
= ((Expr *)Callee.get())->getSourceRange().getBegin();
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
if (E->hasStoredFPFeatures()) {
FPOptionsOverride NewOverrides = E->getFPFeatures();
getSema().CurFPFeatures =
NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
}
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
Args,
E->getRParenLoc());
} | 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(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movl (%rbx), %eax
movl 0x10(%rbx), %edx
movl %eax, %ecx
shrl $0x18, %ecx
addq %rbx, %rcx
shrl $0xf, %eax
andl $0x8, %eax
leaq (%rax,%rcx), %rsi
addq $0x8, %rsi
pushq $0x1
popq %rcx
leaq 0x40(%rsp), %r8
movq %r14, %rdi
callq 0xba2bf2
testb %al, %al
je 0xb9a69d
pushq $0x1
popq %rbx
jmp 0xb9a746
movq (%r14), %r13
andq $-0x2, %r15
cmpl $-0x1, 0x3218(%r13)
jne 0xb9a6c3
movzbl 0x3(%rbx), %eax
cmpq %r15, (%rbx,%rax)
jne 0xb9a6c3
cmpb $0x0, 0x17(%rsp)
je 0xb9a764
movq %r15, %rdi
callq 0xf67396
movq %rax, %r12
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x78d30a
testb $0x10, 0x2(%rbx)
je 0xb9a718
movq %rbx, %rdi
callq 0x74b956
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq (%r14), %rax
movq 0xf0(%rax), %rsi
movq %r13, %rdi
callq 0x6cc4d2
movq (%r14), %rcx
movl %eax, 0xe8(%rcx)
movq (%r13), %rax
movq %rax, 0x790(%rcx)
movq 0x40(%rsp), %rcx
movl 0x48(%rsp), %r8d
movl 0x14(%rbx), %r9d
andq $0x0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xba7d26
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x78d334
leaq 0x40(%rsp), %rdi
callq 0x633cd8
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r13, %rdi
movq %rbx, %rsi
callq 0x9c58aa
movq %rax, %rbx
jmp 0xb9a746
| /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 (!getDerived().AlwaysRebuild() &&
LHS.get() == E->getLHS() &&
RHS.get() == E->getRHS())
return E;
return getDerived().RebuildArraySubscriptExpr(
LHS.get(),
/*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
} | 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
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r14), %rax
andq $-0x2, %r15
cmpl $-0x1, 0x3218(%rax)
movq 0x10(%rbx), %rdi
jne 0xb9cea5
cmpq %r15, %rdi
jne 0xb9cea5
movq %r12, %rax
andq $-0x2, %rax
cmpq %rax, 0x18(%rbx)
je 0xb9cecb
callq 0xf67aee
andq $-0x2, %r12
movl 0x4(%rbx), %r8d
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xba7aee
movq %rbx, %r13
jmp 0xb9ce6f
| /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 (!QualifierLoc)
return ExprError();
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.
DeclarationNameInfo NameInfo =
getDerived().TransformDeclarationNameInfo(E->getNameInfo());
if (!NameInfo.getName())
return ExprError();
if (!E->hasExplicitTemplateArgs()) {
if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() &&
// Note: it is sufficient to compare the Name component of NameInfo:
// if name has not changed, DNLoc has not changed either.
NameInfo.getName() == E->getDeclName())
return E;
return getDerived().RebuildDependentScopeDeclRefExpr(
QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
IsAddressOfOperand, RecoveryTSI);
}
TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs))
return ExprError();
return getDerived().RebuildDependentScopeDeclRefExpr(
QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
RecoveryTSI);
} | 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, %rbx
movq %rdx, 0x10(%rsp)
movl %ebp, 0x4(%rsp)
movq %r13, 0x8(%rsp)
testb $0x4, 0x2(%r14)
je 0xb9d248
movl 0x40(%r14), %r15d
leaq 0x20(%r14), %rbp
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xb9d59e
movq (%r13), %rax
testq %rax, %rax
je 0xb9d2c9
testb $0x4, 0x2(%r14)
je 0xb9d2d2
movl 0x38(%r14), %ecx
testl %ecx, %ecx
je 0xb9d2d2
movl 0x3c(%r14), %eax
leaq 0x40(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movabsq $0x800000000, %rsi # imm = 0x800000000
movq %rsi, -0x8(%rdx)
movl %ecx, 0x100(%rdx)
movl %eax, 0x104(%rdx)
leaq 0x48(%r14), %r13
movq %r14, %rdi
callq 0x4cf906
leaq 0x30(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0xb9d812
testb %al, %al
je 0xb9d31f
pushq $0x1
popq %r14
jmp 0xb9d34b
pushq $0x1
popq %r14
jmp 0xb9d355
movq (%r12), %rcx
cmpl $-0x1, 0x3218(%rcx)
movq 0x10(%rsp), %rdx
je 0xb9d30b
movzbl 0x4(%rsp), %eax
leaq 0x18(%rsp), %r8
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %ecx
xorl %r9d, %r9d
pushq 0x8(%rsp)
pushq %rax
callq 0xb9d784
popq %rcx
popq %rdx
movq %rax, %r14
jmp 0xb9d355
cmpq 0x10(%r14), %rbx
jne 0xb9d2e4
cmpq 0x18(%r14), %rdx
jne 0xb9d2e4
cmpq (%rbp), %rax
jne 0xb9d2e4
jmp 0xb9d355
movzbl 0x4(%rsp), %eax
leaq 0x18(%rsp), %r8
leaq 0x30(%rsp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
movl %r15d, %ecx
pushq 0x8(%rsp)
pushq %rax
callq 0xb9d784
popq %rcx
popq %rdx
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x6d9e52
movq %r14, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa19d0
nop
| /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->getModifierLoc(), C->getEndLoc());
} | 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), %rdi
movl %edx, (%rsp)
movq %rax, %rdx
callq 0xaa4810
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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->getExprLoc(), /*Diagnose*/ false))
return {};
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
if (Method->isImplicitObjectMemberFunction()) {
// An instance method that's referenced in a form that doesn't
// look like a member pointer is just invalid.
if (!R.HasFormOfMemberPointer)
return {};
return S.Context.getMemberPointerType(Fn->getType(),
S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
}
if (!R.IsAddressOfOperand) return Fn->getType();
return S.Context.getPointerType(Fn->getType());
} | 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
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0xbad694
testb %al, %al
jne 0xbb6018
testq %rbx, %rbx
je 0xbb5fed
movl 0x1c(%rbx), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
jne 0xbb5fed
movq %rbx, %rdi
callq 0xe24220
testb %al, %al
je 0xbb5fed
cmpb $0x1, 0xa(%r15)
jne 0xbb6015
movq 0x100(%r14), %r14
movq 0x30(%rbx), %r15
movq %rbx, %rdi
callq 0x6363bc
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7344c0
andq $-0x10, %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd9d738
cmpb $0x0, 0x8(%r15)
je 0xbb600f
movq 0x100(%r14), %rdi
movq 0x30(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd9978a
movq 0x30(%rbx), %r12
jmp 0xbb6018
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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 long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %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, %rax
cmpq %rbx, %rdx
setbe %sil
cmpq %rbx, %rax
seta %bpl
andb %sil, %bpl
cmpb $0x1, %bpl
je 0xbb60ac
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %rcx, %rsi
callq 0xbb60c0
testb %bpl, %bpl
je 0xbb605d
imulq $0x18, %r15, %rbx
addq (%r14), %rbx
jmp 0xbb605d
movq %rbx, %rax
subq %rdx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, %r15
jmp 0xbb6093
nop
| /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(), Sema::ExpressionEvaluationContext::Unevaluated);
ArrayRef<TemplateArgument> PackArgs;
TemplateArgument ArgStorage;
// Find the argument list to transform.
if (E->isPartiallySubstituted()) {
PackArgs = E->getPartialArguments();
} else if (E->isValueDependent()) {
UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
bool ShouldExpand = false;
bool RetainExpansion = false;
std::optional<unsigned> NumExpansions;
if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
Unexpanded,
ShouldExpand, RetainExpansion,
NumExpansions))
return ExprError();
// If we need to expand the pack, build a template argument from it and
// expand that.
if (ShouldExpand) {
auto *Pack = E->getPack();
if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
ArgStorage = getSema().Context.getPackExpansionType(
getSema().Context.getTypeDeclType(TTPD), std::nullopt);
} else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
} else {
auto *VD = cast<ValueDecl>(Pack);
ExprResult DRE = getSema().BuildDeclRefExpr(
VD, VD->getType().getNonLValueExprType(getSema().Context),
VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
E->getPackLoc());
if (DRE.isInvalid())
return ExprError();
ArgStorage = new (getSema().Context)
PackExpansionExpr(getSema().Context.DependentTy, DRE.get(),
E->getPackLoc(), std::nullopt);
}
PackArgs = ArgStorage;
}
}
// If we're not expanding the pack, just transform the decl.
if (!PackArgs.size()) {
auto *Pack = cast_or_null<NamedDecl>(
getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
if (!Pack)
return ExprError();
return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(),
std::nullopt, std::nullopt);
}
// Try to compute the result without performing a partial substitution.
std::optional<unsigned> Result = 0;
for (const TemplateArgument &Arg : PackArgs) {
if (!Arg.isPackExpansion()) {
Result = *Result + 1;
continue;
}
TemplateArgumentLoc ArgLoc;
InventTemplateArgumentLoc(Arg, ArgLoc);
// Find the pattern of the pack expansion.
SourceLocation Ellipsis;
std::optional<unsigned> OrigNumExpansions;
TemplateArgumentLoc Pattern =
getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
OrigNumExpansions);
// Substitute under the pack expansion. Do not expand the pack (yet).
TemplateArgumentLoc OutPattern;
Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
/*Uneval*/ true))
return true;
// See if we can determine the number of arguments from the result.
std::optional<unsigned> NumExpansions =
getSema().getFullyPackExpandedSize(OutPattern.getArgument());
if (!NumExpansions) {
// No: we must be in an alias template expansion, and we're going to need
// to actually expand the packs.
Result = std::nullopt;
break;
}
Result = *Result + *NumExpansions;
}
// Common case: we could determine the number of expansions without
// substituting.
if (Result)
return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
*Result, std::nullopt);
TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
E->getPackLoc());
{
TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
typedef TemplateArgumentLocInventIterator<
Derived, const TemplateArgument*> PackLocIterator;
if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
PackLocIterator(*this, PackArgs.end()),
TransformedPackArgs, /*Uneval*/true))
return ExprError();
}
// Check whether we managed to fully-expand the pack.
// FIXME: Is it possible for us to do so and not hit the early exit path?
SmallVector<TemplateArgument, 8> Args;
bool PartialSubstitution = false;
for (auto &Loc : TransformedPackArgs.arguments()) {
Args.push_back(Loc.getArgument());
if (Loc.getArgument().isPackExpansion())
PartialSubstitution = true;
}
if (PartialSubstitution)
return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
std::nullopt, Args);
return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
E->getPackLoc(), E->getRParenLoc(),
Args.size(), std::nullopt);
} | 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 0x92fd8c
movl 0x1c(%rbx), %eax
testl %eax, %eax
setne %cl
testb %cl, 0x2(%rbx)
je 0xbba816
movl %eax, %eax
leaq 0x28(%rbx), %r15
imulq $0x18, %rax, %r12
movq %rbx, 0x20(%rsp)
leaq (%rbx,%r12), %rax
addq $0x28, %rax
movq %rax, 0x50(%rsp)
movq %r15, 0x58(%rsp)
testq %r12, %r12
je 0xbba85e
movq %r15, %rdi
callq 0xf8cc60
testb %al, %al
je 0xbba806
movq %r13, 0x60(%rsp)
andl $0x0, 0x80(%rsp)
andq $0x0, 0x88(%rsp)
andq $0x0, 0x98(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x80(%rsp), %rdx
callq 0xbc2d02
andl $0x0, 0x2c(%rsp)
movb $0x0, 0x6c(%rsp)
movq (%r14), %rsi
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %r13
leaq 0x198(%rsp), %r14
movq %r14, %rdi
leaq 0x2c(%rsp), %rdx
leaq 0x68(%rsp), %rcx
callq 0xc6ca94
andl $0x0, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
andq $0x0, 0x48(%rsp)
movq (%r13), %rbp
movl 0x3218(%rbp), %ebx
orl $-0x1, 0x3218(%rbp)
movq %r13, %rdi
movq %r14, %rsi
leaq 0x30(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0xbc27e8
testb %al, %al
jne 0xbba8af
movq (%r13), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xc6cc76
movabsq $0x100000000, %rcx # imm = 0x100000000
testq %rcx, %rax
movq %r13, %r14
je 0xbba8bd
movq 0x60(%rsp), %r13
addl %eax, %r13d
movl %ebx, 0x3218(%rbp)
jmp 0xbba809
incl %r13d
addq $0x18, %r15
addq $-0x18, %r12
jmp 0xbba6f9
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xbc1b7e
testq %rax, %rax
je 0xbba8b5
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %ecx
movl 0x18(%rbx), %r8d
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq (%r14), %rdx
movq 0x100(%rdx), %rdi
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, %rdx
xorl %r9d, %r9d
jmp 0xbba8a2
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdx
movl 0x10(%rax), %esi
movl 0x14(%rax), %ecx
movl 0x18(%rax), %r8d
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movl %r13d, %r9d
movabsq $0x100000000, %rax # imm = 0x100000000
orq %rax, %r9
movq (%r14), %rax
movq 0x100(%rax), %rdi
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xe95f5c
movq %rax, %rbx
jmp 0xbbaa0d
movl %ebx, 0x3218(%rbp)
pushq $0x1
popq %rbx
jmp 0xbbaa0d
movl %ebx, 0x3218(%rbp)
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
leaq 0x90(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rbx # imm = 0x800000000
movq %rbx, -0x8(%rcx)
movl %eax, 0x100(%rcx)
movl %eax, 0x104(%rcx)
leaq 0x80(%rsp), %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r14, %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0xbc2534
testb %al, %al
je 0xbba91e
pushq $0x1
popq %rbx
jmp 0xbbaa00
leaq 0x1a8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbx, -0x8(%rax)
movq 0x80(%rsp), %r15
movl 0x88(%rsp), %r13d
shlq $0x5, %r13
xorl %ebp, %ebp
leaq 0x198(%rsp), %r12
testq %r13, %r13
je 0xbba971
movq %r12, %rdi
movq %r15, %rsi
callq 0x6ce27c
movq %r15, %rdi
callq 0xf8cc60
orb %al, %bpl
addq $0x20, %r15
addq $-0x20, %r13
jmp 0xbba94c
movq 0x20(%rsp), %rax
movl 0x10(%rax), %esi
movl 0x14(%rax), %ecx
movq 0x20(%rax), %rdx
movl 0x18(%rax), %r8d
testb $0x1, %bpl
je 0xbba9bb
movq 0x198(%rsp), %rax
movl 0x1a0(%rsp), %edi
movq %rax, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movq (%r14), %rax
movq 0x100(%rax), %rdi
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %r9d, %r9d
jmp 0xbba9eb
movl 0x1a0(%rsp), %r9d
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
orq %rax, %r9
movq (%r14), %rax
movq 0x100(%rax), %rdi
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xe95f5c
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x6ddcc0
leaq 0x80(%rsp), %rdi
callq 0x6d9e52
leaq 0x70(%rsp), %rdi
callq 0x629670
movq %rbx, %rax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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.
EnterExpressionEvaluationContext Ctx(
SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
Sema::ReuseLambdaContextDecl);
RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
getSema().Context, getSema().CurContext,
E->getBody()->getBeginLoc());
Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false);
ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body,
E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);
for (ParmVarDecl *Param : TransParams)
if (Param)
Param->setDeclContext(Body);
// On failure to transform, TransformRequiresTypeParams returns an expression
// in the event that the transformation of the type params failed in some way.
// It is expected that this will result in a 'not satisfied' Requires clause
// when instantiating.
if (!TypeParamResult.isUnset())
return TypeParamResult;
SmallVector<concepts::Requirement *, 4> TransReqs;
if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
TransReqs))
return ExprError();
for (concepts::Requirement *Req : TransReqs) {
if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
if (ER->getReturnTypeRequirement().isTypeConstraint()) {
ER->getReturnTypeRequirement()
.getTypeConstraintTemplateParameterList()->getParam(0)
->setDeclContext(Body);
}
}
}
return getDerived().RebuildRequiresExpr(
E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams,
E->getRParenLoc(), TransReqs, E->getRBraceLoc());
} | 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, -0x8(%rax)
leaq 0x110(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
movq $0x10, -0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rdi), %rdi
movq %rdi, 0x60(%rsp)
movb $0x1, 0x68(%rsp)
xorl %r13d, %r13d
pushq $0x3
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x9340d4
movq (%rbx), %rax
movq 0x100(%rax), %r15
movq 0x230(%rax), %r12
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xe23868
movq (%rbx), %rsi
leaq 0x28(%rax), %r12
testq %rax, %rax
movq %rax, 0x48(%rsp)
cmoveq %rax, %r12
leaq 0x70(%rsp), %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x63635a
leaq 0x30(%r14), %rsi
movq %r14, 0x40(%rsp)
movl 0x10(%r14), %edx
leaq 0xf8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xc8(%rsp), %r15
movq %r15, (%rsp)
leaq 0x128(%rsp), %r9
movq %rbx, %rdi
movq %rsi, 0x28(%rsp)
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbcd086
movl %eax, %ebp
movq (%r15), %r14
movl 0x8(%r15), %r15d
shlq $0x3, %r15
cmpq %r13, %r15
je 0xbbadb3
movq (%r14,%r13), %rdi
testq %rdi, %rdi
je 0xbbadad
movq %r12, %rsi
callq 0xe1c7d0
addq $0x8, %r13
jmp 0xbbad97
testb %bpl, %bpl
je 0xbbadc0
pushq $0x1
popq %rbx
jmp 0xbbb0af
leaq 0xa8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
movq 0x40(%rsp), %rcx
movl 0x10(%rcx), %eax
movl 0x14(%rcx), %ebp
movq 0x28(%rsp), %rcx
leaq (%rcx,%rax,8), %r15
shlq $0x3, %rbp
xorl %r14d, %r14d
movq %rbp, 0x50(%rsp)
movq %r15, 0x28(%rsp)
cmpq %r14, %rbp
je 0xbbafe4
movq (%r15,%r14), %r13
movl (%r13), %eax
testl %eax, %eax
je 0xbbae4a
cmpl $0x2, %eax
jbe 0xbbae70
cmpb $0x1, 0x18(%r13)
jne 0xbbaeaa
movq (%rbx), %rdi
cmpl $-0x1, 0x3218(%rdi)
je 0xbbafbe
movq 0x10(%r13), %rcx
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
callq 0x9c887e
jmp 0xbbaecf
cmpl $0x1, 0x10(%r13)
jne 0xbbae84
movq (%rbx), %rdi
cmpl $-0x1, 0x3218(%rdi)
je 0xbbafbe
movq 0x8(%r13), %rsi
andq $-0x8, %rsi
callq 0x9c8724
jmp 0xbbaecf
cmpl $0x1, 0x28(%r13)
movq 0x8(%r13), %r15
jne 0xbbaed7
orq $0x2, %r15
jmp 0xbbaf23
movq 0x8(%r13), %rsi
andq $-0x8, %rsi
movq %rbx, %rdi
callq 0xbaf644
testq %rax, %rax
je 0xbbafdc
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c8582
jmp 0xbbaecf
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0xbb9d04
cmpq $0x1, %rax
je 0xbbafdc
andq $-0x2, %rax
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x9c8760
movq %rax, %r13
jmp 0xbbafb9
andq $-0x4, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbb9d04
movq %rax, %r15
cmpq $0x2, %rax
jb 0xbbaf10
movq %r15, %rbp
andq $-0x2, %rbp
movq %rbp, %rdi
callq 0x658bae
testb %al, %al
je 0xbbaf1a
movq (%rbx), %rdi
movq %rbp, %rsi
callq 0x90ab10
movq %rax, %r15
cmpq $0x1, %r15
je 0xbbafdc
andq $-0x4, %r15
movq 0x50(%rsp), %rbp
movb $0x0, 0x38(%rsp)
movq 0x18(%r13), %rax
cmpq $0x7, %rax
ja 0xbbaf3a
andq $0x0, 0x30(%rsp)
jmp 0xbbaf67
testb $0x4, %al
jne 0xbbaf5e
andq $-0x8, %rax
movq %rax, 0x58(%rsp)
je 0xbbafd7
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x710d98
jmp 0xbbaf6c
andq $-0x4, %rax
movq %rax, 0x30(%rsp)
movb $0x1, 0x38(%rsp)
movl %r15d, %eax
andl $0x2, %eax
shrl %eax
andq $-0x4, %r15
sete %cl
orb %al, %cl
movl (%r13), %eax
movl 0x10(%r13), %ecx
movq 0x30(%rsp), %r8
movq (%rbx), %rdi
je 0xbbafa1
xorl %edx, %edx
cmpl $0x1, %eax
sete %dl
movq %r15, %rsi
callq 0x9c86d4
jmp 0xbbafb1
xorl %edx, %edx
cmpl $0x1, %eax
sete %dl
movq %r15, %rsi
callq 0x9c8204
movq %rax, %r13
movq 0x28(%rsp), %r15
testq %r13, %r13
je 0xbbafdc
leaq 0x98(%rsp), %rdi
movq %r13, %rsi
callq 0x675a32
addq $0x8, %r14
jmp 0xbbadff
xorl %r13d, %r13d
jmp 0xbbafb4
pushq $0x1
popq %rbx
jmp 0xbbb0a2
movq 0x98(%rsp), %r14
movl 0xa0(%rsp), %r15d
shlq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0xbbb03b
movq (%r14,%r13), %rax
movl (%rax), %ecx
addl $-0x3, %ecx
cmpl $-0x2, %ecx
jb 0xbbb035
movq 0x18(%rax), %rax
cmpq $0x8, %rax
setb %cl
movl %eax, %edx
andl $0x4, %edx
shrl $0x2, %edx
orb %cl, %dl
jne 0xbbb035
andq $-0x8, %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0xe1c7d0
addq $0x8, %r13
jmp 0xbbaffb
movq 0x40(%rsp), %r10
movl 0x4(%r10), %esi
movl 0x20(%r10), %ecx
movq 0xc8(%rsp), %r8
movl 0xd0(%rsp), %r9d
movl 0x24(%r10), %eax
movq 0x98(%rsp), %rdx
movl 0xa0(%rsp), %edi
movl 0x28(%r10), %r10d
movq %rdx, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movq (%rbx), %rdx
movq 0x100(%rdx), %rdi
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, (%rsp)
movq 0x48(%rsp), %rdx
callq 0xe54d56
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x67682e
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xbbb0fa
movq 0x70(%rsp), %rcx
movq %rax, 0x230(%rcx)
movq 0x80(%rsp), %rax
movq %rax, 0x210(%rcx)
movq 0x88(%rsp), %rax
movq %rax, 0x2740(%rcx)
movl 0x90(%rsp), %eax
movl %eax, 0x50(%rcx)
movl 0x94(%rsp), %eax
movl %eax, 0xa38(%rcx)
leaq 0x60(%rsp), %rdi
callq 0x629670
leaq 0xf8(%rsp), %rdi
callq 0x6e4fde
leaq 0x128(%rsp), %rdi
callq 0x6e4ff2
leaq 0xc8(%rsp), %rdi
callq 0x6767e4
movq %rbx, %rax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ExprError();
return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
Sub.get(), BCE->getEndLoc());
} | 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), %esi
movl 0x24(%r14), %r8d
movq (%rbx), %rdi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x7ab004
| /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're allocating (if any).
std::optional<Expr *> ArraySize;
if (E->isArray()) {
ExprResult NewArraySize;
if (std::optional<Expr *> OldArraySize = E->getArraySize()) {
NewArraySize = getDerived().TransformExpr(*OldArraySize);
if (NewArraySize.isInvalid())
return ExprError();
}
ArraySize = NewArraySize.get();
}
// Transform the placement arguments (if any).
bool ArgumentChanged = false;
SmallVector<Expr*, 8> PlacementArgs;
if (getDerived().TransformExprs(E->getPlacementArgs(),
E->getNumPlacementArgs(), true,
PlacementArgs, &ArgumentChanged))
return ExprError();
// Transform the initializer (if any).
Expr *OldInit = E->getInitializer();
ExprResult NewInit;
if (OldInit)
NewInit = getDerived().TransformInitializer(OldInit, true);
if (NewInit.isInvalid())
return ExprError();
// Transform new operator and delete operator.
FunctionDecl *OperatorNew = nullptr;
if (E->getOperatorNew()) {
OperatorNew = cast_or_null<FunctionDecl>(
getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
if (!OperatorNew)
return ExprError();
}
FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
OperatorDelete = cast_or_null<FunctionDecl>(
getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
if (!OperatorDelete)
return ExprError();
}
if (!getDerived().AlwaysRebuild() &&
AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
ArraySize == E->getArraySize() &&
NewInit.get() == OldInit &&
OperatorNew == E->getOperatorNew() &&
OperatorDelete == E->getOperatorDelete() &&
!ArgumentChanged) {
// Mark any declarations we need as referenced.
// FIXME: instantiation-specific.
if (OperatorNew)
SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
if (OperatorDelete)
SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);
if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
QualType ElementType
= SemaRef.Context.getBaseElementType(E->getAllocatedType());
if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
}
}
}
return E;
}
QualType AllocType = AllocTypeInfo->getType();
if (!ArraySize) {
// If no array size was specified, but the new expression was
// instantiated with an array type (e.g., "new T" where T is
// instantiated with "int[4]"), extract the outer bound from the
// array type as our array size. We do this with constant and
// dependently-sized array types.
const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
if (!ArrayT) {
// Do nothing
} else if (const ConstantArrayType *ConsArrayT
= dyn_cast<ConstantArrayType>(ArrayT)) {
ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
SemaRef.Context.getSizeType(),
/*FIXME:*/ E->getBeginLoc());
AllocType = ConsArrayT->getElementType();
} else if (const DependentSizedArrayType *DepArrayT
= dyn_cast<DependentSizedArrayType>(ArrayT)) {
if (DepArrayT->getSizeExpr()) {
ArraySize = DepArrayT->getSizeExpr();
AllocType = DepArrayT->getElementType();
}
}
}
return getDerived().RebuildCXXNewExpr(
E->getBeginLoc(), E->isGlobalNew(),
/*FIXME:*/ E->getBeginLoc(), PlacementArgs,
/*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
} | 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 0x82e35a
testb $0x1, %dl
je 0xbbf4b0
movq %r14, %rdi
movq %rax, %rsi
callq 0xbb9d04
movq %rax, %r12
cmpq $0x1, %rax
jne 0xbbf4b3
jmp 0xbbf76d
xorl %r12d, %r12d
andq $-0x2, %r12
movl (%rbx), %eax
movb $0x1, %r13b
leaq 0x4f(%rsp), %r9
movb $0x0, (%r9)
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rdx # imm = 0x800000000
movq %rdx, -0x8(%rcx)
movl %eax, %ecx
shrl $0x13, %ecx
andl $0x1, %ecx
btl $0x16, %eax
adcl $0x0, %ecx
leaq (%rbx,%rcx,8), %rsi
addq $0x38, %rsi
movl 0x4(%rbx), %edx
pushq $0x1
popq %rcx
leaq 0x88(%rsp), %r8
movq %r14, %rdi
callq 0xbc8164
pushq $0x1
popq %rbp
testb %al, %al
jne 0xbbf760
movl %r13d, 0x60(%rsp)
movl (%rbx), %eax
movq $0x0, 0x68(%rsp)
btl $0x16, %eax
movl $0x0, %r13d
jae 0xbbf570
leaq 0x38(%rbx), %rcx
shrl $0x10, %eax
andl $0x8, %eax
movq (%rcx,%rax), %r13
testq %r13, %r13
je 0xbbf564
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0xbc7f20
movq %rax, 0x68(%rsp)
cmpq $0x1, %rax
jne 0xbbf570
jmp 0xbbf760
movq $0x0, 0x68(%rsp)
xorl %r13d, %r13d
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xbbf58b
movq %r14, %rdi
callq 0xbc1b7e
testq %rax, %rax
jne 0xbbf58d
jmp 0xbbf760
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xbbf5ad
movq %r14, %rdi
callq 0xbc1b7e
testq %rax, %rax
jne 0xbbf5af
jmp 0xbbf760
xorl %eax, %eax
movq (%r14), %rcx
cmpl $-0x1, 0x3218(%rcx)
jne 0xbbf618
cmpq 0x20(%rbx), %r15
jne 0xbbf618
movq %rax, %rbp
movq %rbx, %rdi
callq 0x82e35a
movl 0x60(%rsp), %edi
movl %edi, %ecx
xorb $0x1, %cl
cmpb %dl, %dil
setne %sil
orb %cl, %sil
jne 0xbbf5e6
cmpq %rax, %r12
jmp 0xbbf5e9
cmpb %dl, %dil
movq %rbp, %r8
jne 0xbbf618
movq 0x68(%rsp), %rax
andq $-0x2, %rax
cmpq %rax, %r13
jne 0xbbf618
movq 0x50(%rsp), %rax
cmpq 0x10(%rbx), %rax
jne 0xbbf618
cmpq 0x18(%rbx), %r8
jne 0xbbf618
cmpb $0x0, 0x4f(%rsp)
je 0xbbf782
movq (%r15), %rsi
movl 0x60(%rsp), %r13d
testb %r13b, %r13b
movq %rsi, 0x50(%rsp)
jne 0xbbf6b7
movq (%r14), %rax
movq 0x100(%rax), %rdi
callq 0xd9a1e6
testq %rax, %rax
je 0xbbf6b7
movq %rax, %rbp
movb 0x10(%rax), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0xbbf699
movq (%r14), %rax
movq 0x100(%rax), %r12
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4edd74
movq (%r14), %rax
movq 0x100(%rax), %rdi
callq 0xdaf028
movl 0x28(%rbx), %ecx
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xe4c4f8
movq %rax, %r12
movq %r13, %rdi
callq 0x468360
jmp 0xbbf6ab
movq %r12, 0x58(%rsp)
cmpb $0x4, %al
jne 0xbbf6bc
movq 0x28(%rbp), %r12
testq %r12, %r12
je 0xbbf6bc
movq 0x20(%rbp), %rax
movq %rax, 0x50(%rsp)
movb $0x1, %r13b
movq %r12, 0x58(%rsp)
movl %r13d, %r12d
movl (%rbx), %r13d
movl 0x28(%rbx), %ebp
shrl $0x12, %r13d
andl $0x1, %r13d
movq 0x88(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x90(%rsp), %eax
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
callq 0x74e094
movq 0x30(%rbx), %rcx
movq 0x68(%rsp), %r8
andq $-0x2, %r8
movq 0x58(%rsp), %rdx
movq %rdx, 0x78(%rsp)
movb %r12b, 0x80(%rsp)
movq (%r14), %rdi
movabsq $0x100000001, %rsi # imm = 0x100000001
imulq %rbp, %rsi
movups 0x78(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r15, 0x18(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl %ebp, (%rsp)
movl %r13d, %edx
movl %ebp, %ecx
movq 0x60(%rsp), %r8
movq 0x70(%rsp), %r9
callq 0x9b8562
movq %rax, %rbp
leaq 0x88(%rsp), %rdi
callq 0x633cd8
movq %rbp, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%rsp), %rdx
testq %rdx, %rdx
je 0xbbf79d
movq (%r14), %rdi
movl 0x28(%rbx), %esi
pushq $0x1
popq %rcx
callq 0x9346a0
movq %rbp, %r8
testq %r8, %r8
je 0xbbf7b3
movq (%r14), %rdi
movl 0x28(%rbx), %esi
pushq $0x1
popq %rcx
movq %r8, %rdx
callq 0x9346a0
testb $0x8, 0x2(%rbx)
je 0xbbf82e
movq %rbx, %rdi
callq 0x82e36e
andq $-0x10, %rax
movq (%rax), %rax
testb $0x4, 0x11(%rax)
jne 0xbbf82e
movq (%r14), %rax
movq 0x100(%rax), %r15
movq %rbx, %rdi
callq 0x82e36e
movq %r15, %rdi
movq %rax, %rsi
callq 0xd99884
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xbbf82e
cmpb $0x2e, 0x10(%rdi)
jne 0xbbf82e
callq 0xfa5a44
movq (%r14), %rdi
movq %rax, %rsi
callq 0xa59d88
testq %rax, %rax
je 0xbbf82e
movq (%r14), %rdi
movl 0x28(%rbx), %esi
pushq $0x1
popq %rcx
movq %rax, %rdx
callq 0x9346a0
movq %rbx, %rbp
jmp 0xbbf760
| /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(),
cast<LabelDecl>(LD));
} | 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
nop
| /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(
S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
Sema::ConditionKind::Switch);
if (Cond.isInvalid())
return StmtError();
// Rebuild the switch statement.
StmtResult Switch =
getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
Init.get(), Cond, S->getRParenLoc());
if (Switch.isInvalid())
return StmtError();
// Transform the body of the switch statement.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
return StmtError();
// Complete the switch statement.
return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
Body.get());
} | 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, %r12
movl 0x4(%r14), %ebp
movq %r14, %rdi
callq 0xf69a64
movq %rax, %r15
movq %r14, %rdi
callq 0x749b50
leaq 0x20(%rsp), %r13
pushq $0x2
popq %r9
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0xbc7e7c
pushq $0x1
popq %r15
cmpb $0x0, 0x10(%r13)
jne 0xbc3e65
movl 0x4(%r14), %esi
movl 0x10(%r14), %edx
andq $-0x2, %r12
movl 0x14(%r14), %r8d
movq (%rbx), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rcx
callq 0xb2acda
cmpq $0x1, %rax
je 0xbc3e65
movq %rax, %r12
movq %r14, %rdi
callq 0x749b6c
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xbc348e
cmpq $0x1, %rax
je 0xbc3e65
movl 0x4(%r14), %esi
andq $-0x2, %r12
andq $-0x2, %rax
movq (%rbx), %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0xb2ae06
movq %rax, %r15
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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);
getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
return Res;
} | 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, %rbx
movq (%r14), %rax
movq 0x2f0(%rax), %rdi
movq %rbx, %rsi
andq $-0x2, %rsi
callq 0xa83044
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Sema/TreeTransform.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.