name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
clang::OptionalDiagnostic::operator<<(llvm::APFloat const&)
|
OptionalDiagnostic &operator<<(const llvm::APFloat &F) {
if (Diag) {
// FIXME: Force the precision of the source value down so we don't
// print digits which are usually useless (we don't really care here if
// we truncate a digit by accident in edge cases). Ideally,
// APFloat::toString would automatically print the shortest
// representation which rounds to the correct value, but it's a bit
// tricky to implement. Could use std::to_chars.
unsigned precision = llvm::APFloat::semanticsPrecision(F.getSemantics());
precision = (precision * 59 + 195) / 196;
SmallVector<char, 32> Buffer;
F.toString(Buffer, precision);
*Diag << StringRef(Buffer.data(), Buffer.size());
}
return *this;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1004f0
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x6995e
imull $0x3b, %eax, %eax
addl $0xc3, %eax
imulq $0x5397829d, %rax, %rdx # imm = 0x5397829D
shrq $0x26, %rdx
leaq 0x18(%rsp), %r12
movq %r12, -0x18(%r12)
movq $0x0, -0x10(%r12)
movq $0x20, -0x8(%r12)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x701be
movq (%rbx), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x964fa
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1004f0
callq 0x3c3a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/clang/AST/OptionalDiagnostic.h
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::ArrayExprEvaluator>::VisitExprWithCleanups(clang::ExprWithCleanups const*)
|
bool VisitExprWithCleanups(const ExprWithCleanups *E) {
FullExpressionRAII Scope(Info);
return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
movl 0x110(%rbx), %ebp
movq 0x20(%rbx), %rax
leaq 0x88(%rax), %rdi
movl 0xa0(%rax), %esi
incl %esi
movl %esi, 0xa0(%rax)
callq 0x75350
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x100842
testb %al, %al
je 0x101469
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x12e024
movl %eax, %r14d
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x10146c
xorl %r14d, %r14d
cmpl $-0x1, %ebp
je 0x10147d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x12e024
movq 0x20(%rbx), %rax
decl 0x90(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::ArrayExprEvaluator>::VisitBinaryOperator(clang::BinaryOperator const*)
|
bool VisitBinaryOperator(const BinaryOperator *E) {
switch (E->getOpcode()) {
default:
return Error(E);
case BO_Comma:
VisitIgnoredValue(E->getLHS());
return StmtVisitorTy::Visit(E->getRHS());
case BO_PtrMemD:
case BO_PtrMemI: {
LValue Obj;
if (!HandleMemberPointerAccess(Info, E, Obj))
return false;
APValue Result;
if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
return false;
return DerivedSuccess(Result, E);
}
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
shrl $0x12, %eax
andl $0x3f, %eax
cmpl $0x2, %eax
jae 0x101912
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r12
movaps %xmm0, -0x40(%r12)
xorl %r14d, %r14d
movq %r14, -0x30(%r12)
orb $0x1, -0x28(%r12)
movq %r14, -0x18(%r12)
movq %r12, -0x10(%r12)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%r12)
movq (%rbx), %rdi
leaq 0x50(%rsp), %rdx
movq %r15, %rsi
movl $0x1, %ecx
callq 0xf55ca
testq %rax, %rax
je 0x1018fe
leaq 0x8(%rsp), %r8
movl $0x0, (%r8)
movq (%rbx), %rdi
movq 0x8(%r15), %rdx
leaq 0x50(%rsp), %rcx
movq %r15, %rsi
xorl %r9d, %r9d
callq 0xe3166
movl %eax, %r14d
testb %al, %al
je 0x1018ed
movq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x86dda
cmpl $0x2, 0x8(%rsp)
jb 0x1018fe
leaq 0x8(%rsp), %rdi
callq 0x86f80
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0x101950
callq 0x3c3a0
jmp 0x101950
cmpl $0x20, %eax
jne 0x10193d
movq 0x10(%r15), %rsi
movq (%rbx), %rdi
callq 0xef7c3
movq 0x18(%r15), %rsi
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x100842
movq %rbx, %rdi
movq %r15, %rsi
movl $0x6e, %edx
callq 0x10223c
xorl %r14d, %r14d
movl %r14d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::RecordExprEvaluator>::VisitStmtExpr(clang::StmtExpr const*)
|
bool VisitStmtExpr(const StmtExpr *E) {
// We will have checked the full-expressions inside the statement expression
// when they were completed, and don't need to check them again now.
llvm::SaveAndRestore NotCheckingForUB(Info.CheckingForUndefinedBehavior,
false);
const CompoundStmt *CS = E->getSubStmt();
if (CS->body_empty())
return true;
BlockScopeRAII Scope(Info);
for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
BE = CS->body_end();
/**/; ++BI) {
if (BI + 1 == BE) {
const Expr *FinalExpr = dyn_cast<Expr>(*BI);
if (!FinalExpr) {
Info.FFDiag((*BI)->getBeginLoc(),
diag::note_constexpr_stmt_expr_unsupported);
return false;
}
return this->Visit(FinalExpr) && Scope.destroy();
}
APValue ReturnValue;
StmtResult Result = { ReturnValue, nullptr };
EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
if (ESR != ESR_Succeeded) {
// FIXME: If the statement-expression terminated due to 'return',
// 'break', or 'continue', it would be nice to propagate that to
// the outer statement evaluation rather than bailing out.
if (ESR != ESR_Failed)
Info.FFDiag((*BI)->getBeginLoc(),
diag::note_constexpr_stmt_expr_unsupported);
return false;
}
}
llvm_unreachable("Return from function from the loop above.");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rdi), %rbx
movb 0x393(%rbx), %r15b
movb $0x0, 0x393(%rbx)
movq 0x10(%rsi), %rbp
cmpl $0x0, 0x4(%rbp)
je 0x106497
movq %rdi, %r14
movb %r15b, 0x7(%rsp)
movq %rbx, 0x10(%rsp)
movl 0x110(%rbx), %eax
movq %rax, 0x8(%rsp)
movl %eax, 0x18(%rsp)
movq 0x20(%rbx), %rax
leaq 0x88(%rax), %rdi
movl 0xa0(%rax), %esi
incl %esi
movl %esi, 0xa0(%rax)
callq 0x75350
movl 0x4(%rbp), %r13d
addq $0x10, %rbp
shlq $0x3, %r13
cmpq $0x8, %r13
je 0x106468
addq $-0x8, %r13
leaq 0x30(%rsp), %r15
leaq 0x20(%rsp), %r12
movl $0x0, 0x30(%rsp)
movq %r15, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq (%r14), %rsi
movq (%rbp), %rdx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0xebe7d
cmpl $0x2, %eax
jne 0x10649f
cmpl $0x2, 0x30(%rsp)
jb 0x10645e
movq %r15, %rdi
callq 0x86f80
addq $0x8, %rbp
addq $-0x8, %r13
jne 0x106423
movq (%rbp), %rsi
movb (%rsi), %al
addb $0x7f, %al
cmpb $-0x7f, %al
ja 0x1064da
movq (%r14), %r14
movq %rsi, %rdi
callq 0x20f4ea
xorl %ebp, %ebp
movq %r14, %rdi
movl %eax, %esi
movl $0x8e6, %edx # imm = 0x8E6
xorl %ecx, %ecx
callq 0x1cdb32
jmp 0x10653e
movb $0x1, %bpl
jmp 0x10654d
testl %eax, %eax
je 0x1064c0
movq (%r14), %r14
movq (%rbp), %rdi
callq 0x20f4ea
movq %r14, %rdi
movl %eax, %esi
movl $0x8e6, %edx # imm = 0x8E6
xorl %ecx, %ecx
callq 0x1cdb32
cmpl $0x2, 0x30(%rsp)
movb 0x7(%rsp), %r15b
jb 0x1064d6
leaq 0x30(%rsp), %rdi
callq 0x86f80
xorl %ebp, %ebp
jmp 0x106543
movq %r14, %rdi
callq 0x104696
testb %al, %al
je 0x10653c
movl 0x110(%rbx), %r14d
movq %r14, %rdi
shlq $0x5, %rdi
addq $-0x20, %rdi
incq %r14
movq 0x8(%rsp), %r12
decq %r14
cmpq %r12, %r14
setbe %bpl
jbe 0x10652b
leaq -0x20(%rdi), %r15
addq 0x108(%rbx), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xee1ee
movq %r15, %rdi
testb %al, %al
jne 0x106500
movl %r12d, 0x110(%rbx)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
jmp 0x10653e
xorl %ebp, %ebp
movb 0x7(%rsp), %r15b
leaq 0x10(%rsp), %rdi
callq 0xee172
movb %r15b, 0x393(%rbx)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::RecordExprEvaluator::VisitInitListExpr(clang::InitListExpr const*)
|
bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
if (E->isTransparent())
return Visit(E->getInit(0));
return VisitCXXParenListOrInitListExpr(E, E->inits());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd8f44
movq 0x10(%r14), %rdx
testb %al, %al
je 0x106b24
movq (%rdx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x104696
movq 0x18(%r14), %rax
subq %rdx, %rax
shrq $0x3, %rax
movl %eax, %ecx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x111b18
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::RecordExprEvaluator>::VisitConditionalOperator(clang::ConditionalOperator const*)
|
bool VisitConditionalOperator(const ConditionalOperator *E) {
bool IsBcpCall = false;
// If the condition (ignoring parens) is a __builtin_constant_p call,
// the result is a constant expression if it can be folded without
// side-effects. This is an important GNU extension. See GCC PR38377
// for discussion.
if (const CallExpr *CallCE =
dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
IsBcpCall = true;
// Always assume __builtin_constant_p(...) ? ... : ... is a potential
// constant expression; we can't check whether it's potentially foldable.
// FIXME: We should instead treat __builtin_constant_p as non-constant if
// it would return 'false' in this mode.
if (Info.checkingPotentialConstantExpression() && IsBcpCall)
return false;
FoldConstant Fold(Info, IsBcpCall);
if (!HandleConditionalOperator(E)) {
Fold.keepDiagnostics();
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0xd92f8
movb (%rax), %cl
addb $-0x5d, %cl
cmpb $-0x5, %cl
jae 0x107418
xorl %ebp, %ebp
jmp 0x107429
movq %rax, %rdi
callq 0xd7320
cmpl $0xd3, %eax
sete %bpl
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x107442
testb %al, %al
je 0x107442
xorl %ebx, %ebx
jmp 0x107623
movq (%rbx), %rdx
movq %rdx, 0x10(%rsp)
movb %bpl, 0x18(%rsp)
movq 0x18(%rdx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x107462
cmpl $0x0, 0x8(%rcx)
je 0x107466
xorl %eax, %eax
jmp 0x10746a
movb (%rax), %al
xorb $0x1, %al
movb %al, 0x19(%rsp)
movl 0x394(%rdx), %eax
movl %eax, 0x1c(%rsp)
testb %bpl, %bpl
je 0x107487
movl $0x2, 0x394(%rdx)
movq 0x18(%r14), %rdi
leaq 0xf(%rsp), %rsi
callq 0xefb79
testb %al, %al
je 0x1074b5
movzbl 0xf(%rsp), %eax
xorl $0x1, %eax
movq 0x20(%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0x104696
movl %eax, %ebx
jmp 0x107610
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1075e0
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0x1075e0
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x384(%r15), %ebp
leaq 0x30(%rsp), %r12
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x104696
movl 0x8(%r12), %eax
testq %r15, %r15
je 0x10754c
movq 0x18(%r15), %rcx
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0x1075d4
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x384(%r15), %ebp
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0xb4bfa
movl $0x0, 0x38(%rsp)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x104696
movl 0x38(%rsp), %eax
testq %r15, %r15
je 0x1075c0
movq 0x18(%r15), %rcx
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0x1075d4
movq %rbx, %rdi
movq %r14, %rsi
movl $0x891, %edx # imm = 0x891
callq 0x111ad8
leaq 0x30(%rsp), %rdi
callq 0xb4396
jmp 0x10760e
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0x10760e
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x104696
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x104696
xorl %ebx, %ebx
testb %bl, %bl
jne 0x107619
movb $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xfc570
movl %ebx, %eax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::FixedPointExprEvaluator>::VisitConstantExpr(clang::ConstantExpr const*)
|
bool VisitConstantExpr(const ConstantExpr *E) {
if (E->hasAPValueResult())
return DerivedSuccess(E->getAPValueResult(), E);
return StmtVisitorTy::Visit(E->getSubExpr());
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testb $-0x10, 0x2(%rsi)
je 0x108bff
movq %rsp, %rdi
callq 0xd48aa
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10a926
cmpl $0x2, -0x8(%r14)
jb 0x108bf5
movq %rsp, %rdi
callq 0x86f80
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1081c8
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::FixedPointExprEvaluator>::VisitBinaryConditionalOperator(clang::BinaryConditionalOperator const*)
|
bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
// Evaluate and cache the common expression. We treat it as a temporary,
// even though it's not quite the same thing.
LValue CommonLV;
if (!Evaluate(Info.CurrentCall->createTemporary(
E->getOpaqueValue(),
getStorageType(Info.Ctx, E->getOpaqueValue()),
ScopeKind::FullExpression, CommonLV),
Info, E->getCommon()))
return false;
return HandleConditionalOperator(E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x170(%rsp), %r13
movaps %xmm0, -0x40(%r13)
xorl %eax, %eax
movq %rax, -0x30(%r13)
orb $0x1, -0x28(%r13)
movq %rax, -0x18(%r13)
movq %r13, -0x10(%r13)
movabsq $0x800000000, %rbp # imm = 0x800000000
movq %rbp, -0x8(%r13)
movq (%rdi), %rax
movq 0x20(%rax), %r15
movq 0x38(%rsi), %r12
testb $0x3, 0x1(%r12)
je 0x10a5ef
movq 0x10(%rax), %rdi
movq 0x8(%r12), %rsi
movl $0x1, %edx
callq 0x8debe
movq %rax, %rdx
jmp 0x10a5f4
movq 0x8(%r12), %rdx
leaq 0x130(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xf0632
movq (%rbx), %rsi
movq 0x18(%r14), %rdx
movq %rax, %rdi
callq 0xe170f
testb %al, %al
je 0x10a79e
movq 0x20(%r14), %rdi
movq (%rbx), %rdx
leaq 0xf(%rsp), %rsi
callq 0xefb79
testb %al, %al
je 0x10a64f
movzbl 0xf(%rsp), %eax
xorl $0x1, %eax
movq 0x28(%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0x1081c8
movl %eax, %ebx
jmp 0x10a7a0
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x10a770
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0x10a770
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbp, -0x8(%rax)
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x384(%r15), %ebp
leaq 0x20(%rsp), %r12
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x1081c8
movl 0x8(%r12), %eax
testq %r15, %r15
je 0x10a6dc
movq 0x18(%r15), %rcx
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0x10a764
movq (%rbx), %r15
movq 0x18(%r15), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x384(%r15), %ebp
movq %r12, 0x8(%rax)
movl 0x28(%r15), %eax
incl %eax
movl %eax, 0x384(%r15)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0xb4bfa
movl $0x0, 0x28(%rsp)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x1081c8
movl 0x28(%rsp), %eax
testq %r15, %r15
je 0x10a750
movq 0x18(%r15), %rcx
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rcx)
movl %ebp, 0x384(%r15)
testl %eax, %eax
je 0x10a764
movq %rbx, %rdi
movq %r14, %rsi
movl $0x891, %edx # imm = 0x891
callq 0x10a8e6
leaq 0x20(%rsp), %rdi
callq 0xb4396
jmp 0x10a79e
movq (%rbx), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq 0x18(%r15), %rcx
orb %al, (%rcx)
testb %al, %al
je 0x10a79e
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x1081c8
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x1081c8
xorl %ebx, %ebx
movq 0x160(%rsp), %rdi
cmpq %r13, %rdi
je 0x10a7b2
callq 0x3c3a0
movl %ebx, %eax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
|
RetTy Visit(PTR(Stmt) S, ParamTys... P) {
// If we have a binary expr, dispatch to the subcode of the binop. A smart
// optimizer (e.g. LLVM) will fold this comparison into the switch stmt
// below.
if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
switch (BinOp->getOpcode()) {
case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator);
case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator);
case BO_Mul: DISPATCH(BinMul, BinaryOperator);
case BO_Div: DISPATCH(BinDiv, BinaryOperator);
case BO_Rem: DISPATCH(BinRem, BinaryOperator);
case BO_Add: DISPATCH(BinAdd, BinaryOperator);
case BO_Sub: DISPATCH(BinSub, BinaryOperator);
case BO_Shl: DISPATCH(BinShl, BinaryOperator);
case BO_Shr: DISPATCH(BinShr, BinaryOperator);
case BO_LT: DISPATCH(BinLT, BinaryOperator);
case BO_GT: DISPATCH(BinGT, BinaryOperator);
case BO_LE: DISPATCH(BinLE, BinaryOperator);
case BO_GE: DISPATCH(BinGE, BinaryOperator);
case BO_EQ: DISPATCH(BinEQ, BinaryOperator);
case BO_NE: DISPATCH(BinNE, BinaryOperator);
case BO_Cmp: DISPATCH(BinCmp, BinaryOperator);
case BO_And: DISPATCH(BinAnd, BinaryOperator);
case BO_Xor: DISPATCH(BinXor, BinaryOperator);
case BO_Or : DISPATCH(BinOr, BinaryOperator);
case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator);
case BO_LOr : DISPATCH(BinLOr, BinaryOperator);
case BO_Assign: DISPATCH(BinAssign, BinaryOperator);
case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator);
case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
case BO_Comma: DISPATCH(BinComma, BinaryOperator);
}
} else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
switch (UnOp->getOpcode()) {
case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator);
case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator);
case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator);
case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator);
case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator);
case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator);
case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator);
case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator);
case UO_Not: DISPATCH(UnaryNot, UnaryOperator);
case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator);
case UO_Real: DISPATCH(UnaryReal, UnaryOperator);
case UO_Imag: DISPATCH(UnaryImag, UnaryOperator);
case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator);
}
}
// Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
switch (S->getStmtClass()) {
default: llvm_unreachable("Unknown stmt kind!");
#define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT) \
case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
#include "clang/AST/StmtNodes.inc"
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x226823(%rip), %r15 # 0x331af8
leaq 0x226854(%rip), %r12 # 0x331b30
leaq 0x226791(%rip), %r13 # 0x331a74
movq %rsi, %rbx
movb (%rsi), %al
leal -0x77(%rax), %ecx
cmpb $-0x2, %cl
setb %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
je 0x10b30e
cmpb $0x4, %al
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movb $0x1, %cl
je 0x10b336
jmp 0x10b359
movl (%rbx), %eax
shrl $0x12, %eax
andl $0x3f, %eax
cmpl $0x20, %eax
ja 0x10b41e
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10d542
jmp 0x10b357
movl (%rbx), %edx
shrl $0x12, %edx
andl $0x1f, %edx
cmpl $0xd, %edx
ja 0x10b359
movslq (%r15,%rdx,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10b7cc
xorl %ecx, %ecx
testb %cl, %cl
je 0x10b437
movzbl (%rbx), %eax
addl $-0x3, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x10(%rbx), %rsi
jmp 0x10b2e3
movq 0x18(%rbx), %rsi
jmp 0x10b2e3
movq %rbx, %rdi
callq 0xb4478
movl %eax, %eax
movq 0x30(%rbx,%rax,8), %rsi
jmp 0x10b2e3
xorl %esi, %esi
testb $0x40, 0x2(%rbx)
je 0x10b2e3
jmp 0x10b370
movl 0x10(%rbx), %eax
movl %eax, %ecx
shrl $0xf, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
btl $0x1e, %eax
adcl $0x0, %ecx
movq 0x20(%rbx,%rcx,8), %rsi
jmp 0x10b2e3
movq 0x20(%rbx), %rsi
jmp 0x10b2e3
movzbl 0x30(%rbx), %eax
xorl $0x1, %eax
movq 0x18(%rbx,%rax,8), %rsi
jmp 0x10b2e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10dbb2
jmp 0x10b357
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x10b2c2
jmp 0x10b357
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10b5de
jmp 0x10b357
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10b6b8
jmp 0x10b357
movb $0x1, %cl
jmp 0x10b30c
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0x10dcd8
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10ddb0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c0fe
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10dd18
jmp 0x10b4bf
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d542
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c03c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c068
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10be74
movb $0x1, %al
jmp 0x10b437
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d4cc
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10bc18
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d434
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d71e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10bd5c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10b9fc
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10b7cc
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d968
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10be1e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c0a8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10bba8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10bd94
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10b832
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10beca
|
/clang/AST/StmtVisitor.h
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::ComplexExprEvaluator>::VisitConstantExpr(clang::ConstantExpr const*)
|
bool VisitConstantExpr(const ConstantExpr *E) {
if (E->hasAPValueResult())
return DerivedSuccess(E->getAPValueResult(), E);
return StmtVisitorTy::Visit(E->getSubExpr());
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testb $-0x10, 0x2(%rsi)
je 0x10ef32
movq %rsp, %r14
movq %r14, %rdi
callq 0xd48aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x111186
cmpl $0x2, (%r14)
jb 0x10ef28
movq %rsp, %rdi
callq 0x86f80
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x10e312
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::ComplexExprEvaluator>::VisitCXXDefaultInitExpr(clang::CXXDefaultInitExpr const*)
|
bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
TempVersionRAII RAII(*Info.CurrentCall);
// The initializer may not have been parsed yet, or might be erroneous.
if (!E->getExpr())
return Error(E);
SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
return StmtVisitorTy::Visit(E->getExpr());
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %r15
leaq 0x88(%r15), %rdi
movl 0xa0(%r15), %esi
incl %esi
movl %esi, 0xa0(%r15)
callq 0x75350
movq %r14, %rdi
callq 0x12ed5a
testq %rax, %rax
je 0x10fec0
movq (%rbx), %rax
movq 0x20(%rax), %r12
movq 0x40(%r12), %r13
testq %r13, %r13
jne 0x10fea1
movq %r14, 0x40(%r12)
movq %r14, %rdi
callq 0x12ed5a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10e312
testq %r13, %r13
jne 0x10fed2
movq %r13, 0x40(%r12)
jmp 0x10fed2
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6e, %edx
callq 0x1111f6
xorl %eax, %eax
decl 0x90(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AST/ExprConstant.cpp
|
handleTrivialCopy((anonymous namespace)::EvalInfo&, clang::ParmVarDecl const*, clang::Expr const*, clang::APValue&, bool)
|
static bool handleTrivialCopy(EvalInfo &Info, const ParmVarDecl *Param,
const Expr *E, APValue &Result,
bool CopyObjectRepresentation) {
// Find the reference argument.
CallStackFrame *Frame = Info.CurrentCall;
APValue *RefValue = Info.getParamSlot(Frame->Arguments, Param);
if (!RefValue) {
Info.FFDiag(E);
return false;
}
// Copy out the contents of the RHS object.
LValue RefLValue;
RefLValue.setFrom(Info.Ctx, *RefValue);
return handleLValueToRValueConversion(
Info, E, Param->getType().getNonReferenceType(), RefLValue, Result,
CopyObjectRepresentation);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x20(%rdi), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
movq %r12, %rcx
callq 0xe15a6
testq %rax, %rax
je 0x1144ac
movq %r14, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r14
movaps %xmm0, -0x40(%r14)
xorl %ecx, %ecx
movq %rcx, -0x30(%r14)
orb $0x1, -0x28(%r14)
movq %rcx, -0x18(%r14)
movq %r14, -0x10(%r14)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%r14)
movq 0x10(%r15), %rsi
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
callq 0xeb40a
movq 0x30(%r12), %r12
movq %r12, %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77c7e
testq %rax, %rax
je 0x11447b
movq %rax, %rdi
callq 0x77caa
movq %rax, %r12
movzbl %bpl, %r9d
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
callq 0xe3166
movl %eax, %ebp
movq 0x30(%r13), %rdi
cmpq %r14, %rdi
je 0x1144c0
callq 0x3c3a0
jmp 0x1144c0
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movl $0x6e, %edx
xorl %ecx, %ecx
callq 0x1cdc80
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::AtomicExprEvaluator>::VisitExprWithCleanups(clang::ExprWithCleanups const*)
|
bool VisitExprWithCleanups(const ExprWithCleanups *E) {
FullExpressionRAII Scope(Info);
return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
movl 0x110(%rbx), %ebp
movq 0x20(%rbx), %rax
leaq 0x88(%rax), %rdi
movl 0xa0(%rax), %esi
incl %esi
movl %esi, 0xa0(%rax)
callq 0x75350
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x1145c0
testb %al, %al
je 0x114e53
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x12e024
movl %eax, %r14d
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x114e56
xorl %r14d, %r14d
cmpl $-0x1, %ebp
je 0x114e67
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x12e024
movq 0x20(%rbx), %rax
decl 0x90(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::VectorExprEvaluator::VisitInitListExpr(clang::InitListExpr const*)
|
bool
VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
const VectorType *VT = E->getType()->castAs<VectorType>();
unsigned NumInits = E->getNumInits();
unsigned NumElements = VT->getNumElements();
QualType EltTy = VT->getElementType();
SmallVector<APValue, 4> Elements;
// The number of initializers can be less than the number of
// vector elements. For OpenCL, this can be due to nested vector
// initialization. For GCC compatibility, missing trailing elements
// should be initialized with zeroes.
unsigned CountInits = 0, CountElts = 0;
while (CountElts < NumElements) {
// Handle nested vector initialization.
if (CountInits < NumInits
&& E->getInit(CountInits)->getType()->isVectorType()) {
APValue v;
if (!EvaluateVector(E->getInit(CountInits), v, Info))
return Error(E);
unsigned vlen = v.getVectorLength();
for (unsigned j = 0; j < vlen; j++)
Elements.push_back(v.getVectorElt(j));
CountElts += vlen;
} else if (EltTy->isIntegerType()) {
llvm::APSInt sInt(32);
if (CountInits < NumInits) {
if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
return false;
} else // trailing integer zero.
sInt = Info.Ctx.MakeIntValue(0, EltTy);
Elements.push_back(APValue(sInt));
CountElts++;
} else {
llvm::APFloat f(0.0);
if (CountInits < NumInits) {
if (!EvaluateFloat(E->getInit(CountInits), f, Info))
return false;
} else // trailing float zero.
f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
Elements.push_back(APValue(f));
CountElts++;
}
CountInits++;
}
return Success(Elements, E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq 0x8(%rsi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x39, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x1182d4
callq 0x22549c
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %r15
subq 0x10(%rcx), %r15
movl 0x14(%rax), %edx
movq 0x20(%rax), %rsi
leaq 0xe8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
movl %edx, 0x40(%rsp)
testl %edx, %edx
sete %bpl
je 0x118749
shrq $0x3, %r15
movq %rsi, 0x58(%rsp)
andq $-0x10, %rsi
movq %rsi, 0x68(%rsp)
xorl %r12d, %r12d
leaq 0x70(%rsp), %r13
leaq 0x18(%rsp), %rbx
movl $0x0, 0xc(%rsp)
movq %r15, 0x38(%rsp)
movq %r14, 0x60(%rsp)
cmpl %r15d, %r12d
jae 0x11840f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rdx), %rdx
andq $-0x10, %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
andq $-0x10, %rdx
movq (%rdx), %rdx
movb 0x10(%rdx), %dl
addb $-0x37, %dl
cmpb $0x1, %dl
ja 0x11840f
movl $0x0, 0x70(%rsp)
movq (%rax,%rcx,8), %rsi
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
movq %rbx, %rdi
callq 0x11731e
movl %eax, %r13d
testb %al, %al
je 0x118481
movb %bpl, 0xb(%rsp)
movl 0x80(%rsp), %ebx
testq %rbx, %rbx
leaq 0xd8(%rsp), %rbp
je 0x1183ee
leaq (,%rbx,8), %rax
leaq (%rax,%rax,8), %r15
xorl %r14d, %r14d
movq 0x78(%rsp), %rsi
addq %r14, %rsi
movq %rbp, %rdi
callq 0xf219e
addq $0x48, %r14
cmpq %r14, %r15
jne 0x1183d5
addl 0xc(%rsp), %ebx
movl %ebx, 0xc(%rsp)
movq 0x60(%rsp), %r14
movq 0x38(%rsp), %r15
leaq 0x18(%rsp), %rbx
movb 0xb(%rsp), %bpl
jmp 0x118493
movq 0x68(%rsp), %rax
movq (%rax), %r15
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %r13
movb 0x10(%r13), %cl
cmpb $0xd, %cl
setne %al
testq %r13, %r13
sete %dl
orb %al, %dl
jne 0x11844d
movl 0x10(%r13), %eax
shrl $0x13, %eax
andl $0x1fc, %eax # imm = 0x1FC
addl $0xfffffe54, %eax # imm = 0xFFFFFE54
cmpl $0x14, %eax
setb %al
testb %dl, %dl
je 0x1184ef
testq %r13, %r13
sete %dl
cmpb $0x2d, %cl
setne %bl
orb %dl, %bl
jne 0x1184d4
movq %r13, %rdi
callq 0x226c68
testb $0x1, 0x4a(%rax)
jne 0x1184b7
cmpq $0x8, 0x80(%rax)
jae 0x1184b7
xorl %eax, %eax
jmp 0x1184d4
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl $0x6e, %edx
callq 0x11a5ce
cmpl $0x2, 0x70(%rsp)
jb 0x1184a4
leaq 0x70(%rsp), %rdi
callq 0x86f80
testb %r13b, %r13b
leaq 0x70(%rsp), %r13
jne 0x118734
jmp 0x118760
movq %r13, %rdi
callq 0x226c68
movsbq 0x4c(%rax), %rcx
shlq $0x20, %rcx
movl 0x48(%rax), %eax
orq %rcx, %rax
testq %rax, %rax
setns %al
testb %bl, %bl
leaq 0x18(%rsp), %rbx
je 0x1184ef
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xa, 0x10(%rax)
sete %al
testb $0x1, %al
leaq 0x70(%rsp), %r13
je 0x118542
movl $0x20, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x1, 0x24(%rsp)
movq 0x38(%rsp), %r15
cmpl %r15d, %r12d
jae 0x11858f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdi
movq (%r14), %rdx
movq %rbx, %rsi
callq 0xe30da
testb %al, %al
jne 0x1185d5
xorl %ebx, %ebx
jmp 0x118715
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x660de
movq 0x38(%rsp), %r15
cmpl %r15d, %r12d
jae 0x118602
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rsi
movq (%r14), %rax
movq %rax, 0x70(%rsp)
movq %rbx, 0x78(%rsp)
movq %r13, %rdi
callq 0x10b2c2
testb %al, %al
jne 0x11864f
xorl %ebx, %ebx
jmp 0x1186a3
movq (%r14), %rax
movq 0x10(%rax), %rsi
movq %r13, %rdi
xorl %edx, %edx
movq 0x58(%rsp), %rcx
callq 0x88d58
cmpl $0x41, 0x20(%rsp)
jb 0x1185bb
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1185bb
callq 0x3c180
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x20(%rsp)
movb 0x7c(%rsp), %al
movb %al, 0x24(%rsp)
movb %bpl, 0xb(%rsp)
movq %r14, %rbp
movl 0x20(%rsp), %eax
movl %eax, 0x50(%rsp)
cmpl $0x40, %eax
ja 0x1186af
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %r14
jmp 0x1186bf
movq (%r14), %rax
movq 0x10(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x8a572
movl $0x0, 0x44(%rsp)
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x44(%rsp), %rdx
callq 0xe357c
movq %r13, %rdi
xorl %esi, %esi
callq 0x6ee40
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x708b0
movq %rbx, %rdi
callq 0x66212
leaq 0xc0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x892a0
movq %r13, %rdi
leaq 0xb8(%rsp), %rsi
callq 0xeba00
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0xf52f2
cmpl $0x2, 0x70(%rsp)
jb 0x118690
movq %r13, %rdi
callq 0x86f80
leaq 0xc0(%rsp), %rdi
callq 0x66212
incl 0xc(%rsp)
movb $0x1, %bl
leaq 0x20(%rsp), %rdi
callq 0x66212
jmp 0x11872b
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70bce
movb 0x24(%rsp), %al
movb %al, 0x54(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0xc87de
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0xf52f2
cmpl $0x2, 0x70(%rsp)
jb 0x1186f1
movq %r13, %rdi
callq 0x86f80
cmpl $0x41, 0x50(%rsp)
movq %rbp, %r14
jb 0x11870a
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x11870a
callq 0x3c180
incl 0xc(%rsp)
movb $0x1, %bl
movb 0xb(%rsp), %bpl
cmpl $0x41, 0x20(%rsp)
jb 0x11872b
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x11872b
callq 0x3c180
testb %bl, %bl
leaq 0x18(%rsp), %rbx
je 0x118760
incl %r12d
movl 0xc(%rsp), %eax
cmpl 0x40(%rsp), %eax
setae %bpl
jb 0x118343
movq 0xd8(%rsp), %rsi
movl 0xe0(%rsp), %edx
movq %r14, %rdi
callq 0x11a834
leaq 0xd8(%rsp), %rdi
callq 0xf21c8
andb $0x1, %bpl
movl %ebp, %eax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::IntExprEvaluator>::VisitInitListExpr(clang::InitListExpr const*)
|
size_type size() const { return End-Begin; }
|
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl $0x1, %ecx
je 0x11c0b7
pushq %rax
movq %rsi, %rdx
testl %ecx, %ecx
jne 0x11c0bf
movq 0x8(%rdi), %rcx
xorl %esi, %esi
callq 0x11fb3c
movb $0x1, %al
jmp 0x11c0ce
movq (%rax), %rsi
jmp 0x116db0
movq %rdx, %rsi
movl $0x6e, %edx
callq 0x11fa52
xorl %eax, %eax
popq %rcx
retq
|
/clang/AST/ASTVector.h
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::IntExprEvaluator>::VisitExtVectorElementExpr(clang::ExtVectorElementExpr const*)
|
bool VisitExtVectorElementExpr(const ExtVectorElementExpr *E) {
APValue Val;
if (!Evaluate(Val, Info, E->getBase()))
return false;
if (Val.isVector()) {
SmallVector<uint32_t, 4> Indices;
E->getEncodedElementAccess(Indices);
if (Indices.size() == 1) {
// Return scalar.
return DerivedSuccess(Val.getVectorElt(Indices[0]), E);
} else {
// Construct new APValue vector.
SmallVector<APValue, 4> Elts;
for (unsigned I = 0; I < Indices.size(); ++I) {
Elts.push_back(Val.getVectorElt(Indices[I]));
}
APValue VecResult(Elts.data(), Indices.size());
return DerivedSuccess(VecResult, E);
}
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movl $0x0, (%rbx)
movq (%rdi), %rsi
movq 0x10(%r15), %rdx
movq %rbx, %rdi
callq 0xe170f
cmpl $0x8, (%rbx)
sete %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x11c2e6
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x400000000, %rbp # imm = 0x400000000
movq %rbp, -0x8(%r13)
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xdafb6
cmpl $0x1, 0x8(%r12)
jne 0x11c23e
movq 0x8(%rsp), %rax
movl (%rax), %eax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x11fa92
jmp 0x11c2d7
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbp, -0x8(%rax)
movl 0x10(%rsp), %edx
testl %edx, %edx
je 0x11c28b
xorl %r12d, %r12d
leaq 0xb8(%rsp), %r15
movq 0x8(%rsp), %rax
movl (%rax,%r12,4), %eax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0xf219e
movl 0x10(%rsp), %edx
incq %r12
cmpl %r12d, %edx
ja 0x11c261
movq 0xb8(%rsp), %rsi
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %r15
movups %xmm0, 0x8(%r15)
movl $0x8, (%r15)
movq %r15, %rdi
callq 0x86c8c
movq %r14, %rdi
movq %r15, %rsi
callq 0x11fa92
cmpl $0x2, (%r15)
jb 0x11c2ca
leaq 0x70(%rsp), %rdi
callq 0x86f80
leaq 0xb8(%rsp), %rdi
callq 0xf21c8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11c2e6
callq 0x3c3a0
cmpl $0x2, 0x28(%rsp)
jb 0x11c2f7
leaq 0x28(%rsp), %rdi
callq 0x86f80
movl %ebx, %eax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ExprConstant.cpp
|
(anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::IntExprEvaluator>::VisitCXXDynamicCastExpr(clang::CXXDynamicCastExpr const*)
|
bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
if (!Info.Ctx.getLangOpts().CPlusPlus20)
CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
return static_cast<Derived*>(this)->VisitCastExpr(E);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x10(%rdi), %rax
movq 0x830(%rax), %rax
testb $0x40, 0x1(%rax)
jne 0x11c3ec
movq %rbx, %rsi
movl $0x8a6, %edx # imm = 0x8A6
xorl %ecx, %ecx
callq 0x1cdd9c
testq %rax, %rax
je 0x11c3ec
movl $0x1, %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x96fba
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12002a
|
/AST/ExprConstant.cpp
|
addOrSubLValueAsInteger(clang::APValue&, llvm::APSInt const&, bool)
|
static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
bool IsSub) {
// Compute the new offset in the appropriate width, wrapping at 64 bits.
// FIXME: When compiling for a 32-bit target, we should use 32-bit
// offsets.
assert(!LVal.hasLValuePath() && "have designator for integer lvalue");
CharUnits &Offset = LVal.getLValueOffset();
uint64_t Offset64 = Offset.getQuantity();
uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
: Offset64 + Index64);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
callq 0x88e06
movq %rax, %r14
movq (%rax), %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x40, %edx
callq 0x894e0
cmpl $0x41, 0x8(%r12)
setb %al
movq (%r12), %rdi
cmovaeq %rdi, %r12
movq (%r12), %r15
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x12508b
callq 0x3c180
movq %r15, %rax
negq %rax
testb %bl, %bl
cmoveq %r15, %rax
addq %r13, %rax
movq %rax, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AST/ExprConstant.cpp
|
clang::CXXPseudoDestructorExpr::getEndLoc() const
|
static inline bool isPresent(const T &t) { return t != T(nullptr); }
|
movq 0x40(%rdi), %rax
movl %eax, %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0x12e67d
movl 0x48(%rdi), %eax
retq
pushq %rbx
subq $0x10, %rsp
movq (%rax), %rcx
addq $0x8, %rax
movq %rsp, %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x22d2de
movq %rbx, %rdi
callq 0x22d3b0
addq $0x10, %rsp
popq %rbx
retq
nop
|
/llvm/Support/Casting.h
|
clang::SubstNonTypeTemplateParmExpr::getParameterType(clang::ASTContext const&) const
|
QualType SubstNonTypeTemplateParmExpr::getParameterType(
const ASTContext &Context) const {
// Note that, for a class type NTTP, we will have an lvalue of type 'const
// T', so we can't just compute this from the type and value category.
if (isReferenceParameter())
return Context.getLValueReferenceType(getType());
return getType().getUnqualifiedType();
}
|
movq %rsi, %rax
testb $0x4, 0x18(%rdi)
movq 0x8(%rdi), %rsi
jne 0x12f041
movq %rsi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0x12f03c
pushq %rax
movq %rsi, %rdi
callq 0x225b78
addq $0x8, %rsp
andq $-0x10, %rax
retq
movq %rax, %rdi
movl $0x1, %edx
jmp 0x8debe
|
/AST/ExprCXX.cpp
|
clang::interp::Integral<64u, false>& clang::interp::Pointer::deref<clang::interp::Integral<64u, false>>() const
|
T &deref() const {
assert(isLive() && "Invalid pointer");
assert(isBlockPointer());
assert(asBlockPointer().Pointee);
assert(isDereferencable());
assert(Offset + sizeof(T) <=
asBlockPointer().Pointee->getDescriptor()->getAllocSize());
if (isArrayRoot())
return *reinterpret_cast<T *>(asBlockPointer().Pointee->rawData() +
asBlockPointer().Base + sizeof(InitMapPtr));
return *reinterpret_cast<T *>(asBlockPointer().Pointee->rawData() + Offset);
}
|
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
jne 0x13140e
movq %rbx, %rdi
callq 0x1746fa
cmpb $0x1, 0x33(%rax)
jne 0x13140e
movl 0x20(%rbx), %eax
cmpq %rax, (%rbx)
jne 0x13140e
movq 0x18(%rbx), %rax
movl 0x20(%rbx), %ecx
addq %rcx, %rax
addq $0x48, %rax
jmp 0x13141c
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
addq %rcx, %rax
addq $0x28, %rax
popq %rbx
retq
|
/AST/Interp/Pointer.h
|
clang::interp::FunctionPointer::toAPValue(clang::ASTContext const&) const
|
APValue toAPValue(const ASTContext &) const {
if (!Func)
return APValue(static_cast<Expr *>(nullptr), CharUnits::Zero(), {},
/*OnePastTheEnd=*/false, /*IsNull=*/true);
if (!Valid)
return APValue(static_cast<Expr *>(nullptr),
CharUnits::fromQuantity(getIntegerRepresentation()), {},
/*OnePastTheEnd=*/false, /*IsNull=*/false);
return APValue(Func->getDecl(), CharUnits::Zero(), {},
/*OnePastTheEnd=*/false, /*IsNull=*/false);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x13179e
movq %rsi, %r14
cmpb $0x0, 0x8(%rsi)
je 0x1317e8
movq 0x10(%rax), %rsi
leaq 0x10(%rsp), %r14
xorl %r13d, %r13d
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85f7a
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq (%r14), %r12
movq 0x8(%r14), %r14
movl %r13d, (%rbx)
movq %rbx, %rdi
callq 0x86ccc
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
jmp 0x131827
xorl %r13d, %r13d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85fac
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq (%r14), %r12
movq 0x8(%r14), %r14
movl %r13d, (%rbx)
movq %rbx, %rdi
callq 0x86ccc
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1
jmp 0x13182f
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85fac
movq (%r14), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq (%r15), %r12
movq 0x8(%r15), %r15
movl %r13d, (%rbx)
movq %rbx, %rdi
callq 0x86ccc
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r13
pushq %r13
callq 0x86cf2
addq $0x10, %rsp
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/AST/Interp/FunctionPointer.h
|
bool clang::interp::Add<(clang::interp::PrimType)3, clang::interp::Integral<16u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool Add(InterpState &S, CodePtr OpPC) {
const T &RHS = S.Stk.pop<T>();
const T &LHS = S.Stk.pop<T>();
const unsigned Bits = RHS.bitWidth() + 1;
return AddSubMulHelper<T, T::add, std::plus>(S, OpPC, Bits, LHS, RHS);
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c63e0
movzwl (%rax), %ebp
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c6414
movq 0xb0(%rbx), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c63e0
addw (%rax), %bp
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c6414
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movw %bp, (%rax)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::AllocN<(clang::interp::PrimType)5, clang::interp::Integral<32u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::PrimType, clang::Expr const*, bool)
|
inline bool AllocN(InterpState &S, CodePtr OpPC, PrimType T, const Expr *Source,
bool IsNoThrow) {
if (!CheckDynamicMemoryAllocation(S, OpPC))
return false;
SizeT NumElements = S.Stk.pop<SizeT>();
if (!CheckArraySize(S, OpPC, &NumElements, primSize(T), IsNoThrow)) {
if (!IsNoThrow)
return false;
// If this failed and is nothrow, just return a null ptr.
S.Stk.push<Pointer>(0, nullptr);
return true;
}
DynamicAllocator &Allocator = S.getAllocator();
Block *B = Allocator.allocate(Source, T, static_cast<size_t>(NumElements),
S.Ctx.getEvalID());
assert(B);
S.Stk.push<Pointer>(B, sizeof(InlineDescriptor));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1b495e
testb %al, %al
je 0x133c66
movq %r14, 0x10(%rsp)
movq 0xb0(%rbx), %r13
movl $0x8, %esi
movq %r13, %rdi
callq 0x1c63e0
movl (%rax), %r14d
movl $0x8, %esi
movq %r13, %rdi
callq 0x1c6414
leaq 0xc(%rsp), %r13
movl %r14d, (%r13)
movl %ebp, %edi
callq 0x1ca0b5
movzbl %r15b, %r8d
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x17a86e
testb %al, %al
je 0x133c33
leaq 0x30(%rbx), %rdi
movl 0xc(%rsp), %ecx
movq 0xb8(%rbx), %rax
movl 0x20(%rax), %r8d
movq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x1b1b34
movq %rax, %r14
movq 0xb0(%rbx), %rdi
movl $0x30, %esi
callq 0x1c636c
movl $0x10, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1c69c0
jmp 0x133c62
testb %r15b, %r15b
je 0x133c66
movq 0xb0(%rbx), %rdi
movl $0x30, %esi
callq 0x1c636c
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x1, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movb $0x1, %al
jmp 0x133c68
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Cast<(clang::interp::PrimType)1, (clang::interp::PrimType)10>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool Cast(InterpState &S, CodePtr OpPC) {
using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T;
S.Stk.push<U>(U::from(S.Stk.pop<T>()));
return true;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq 0xb0(%rdi), %rbx
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c6414
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c636c
testb %bpl, %bpl
setne (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Cast<(clang::interp::PrimType)6, (clang::interp::PrimType)10>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool Cast(InterpState &S, CodePtr OpPC) {
using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T;
S.Stk.push<U>(U::from(S.Stk.pop<T>()));
return true;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq 0xb0(%rdi), %rbx
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c63e0
movq (%rax), %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c6414
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c636c
testq %r14, %r14
setne (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::CastAP<(clang::interp::PrimType)8, clang::interp::IntegralAP<false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool CastAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
S.Stk.push<IntegralAP<false>>(
IntegralAP<false>::from(S.Stk.pop<T>(), BitWidth));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq 0xb0(%rdi), %rbx
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c63e0
movl 0x8(%rax), %ecx
movq %rsp, %r14
movl %ecx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, (%r14)
xorl %r12d, %r12d
movl %r12d, 0x8(%rax)
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c6414
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x17c5c2
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c636c
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movl %r12d, 0x8(%r15)
cmpl $0x41, 0x8(%r14)
jb 0x13d9c3
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13d9c3
callq 0x3c180
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::CastAP<(clang::interp::PrimType)9, clang::interp::IntegralAP<true>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool CastAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
S.Stk.push<IntegralAP<false>>(
IntegralAP<false>::from(S.Stk.pop<T>(), BitWidth));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq 0xb0(%rdi), %rbx
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c63e0
movl 0x8(%rax), %ecx
movq %rsp, %r14
movl %ecx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, (%r14)
xorl %r12d, %r12d
movl %r12d, 0x8(%rax)
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c6414
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x17c624
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c636c
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movl %r12d, 0x8(%r15)
cmpl $0x41, 0x8(%r14)
jb 0x13da5d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13da5d
callq 0x3c180
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::CastAPS<(clang::interp::PrimType)0, clang::interp::Integral<8u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool CastAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
S.Stk.push<IntegralAP<true>>(
IntegralAP<true>::from(S.Stk.pop<T>(), BitWidth));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq 0xb0(%rdi), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c63e0
movzbl (%rax), %ebp
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c6414
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x17c72a
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c636c
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::CastAPS<(clang::interp::PrimType)8, clang::interp::IntegralAP<false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool CastAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
S.Stk.push<IntegralAP<true>>(
IntegralAP<true>::from(S.Stk.pop<T>(), BitWidth));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq 0xb0(%rdi), %rbx
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c63e0
movl 0x8(%rax), %ecx
movq %rsp, %r14
movl %ecx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, (%r14)
xorl %r12d, %r12d
movl %r12d, 0x8(%rax)
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c6414
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x17cc54
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c636c
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movl %r12d, 0x8(%r15)
cmpl $0x41, 0x8(%r14)
jb 0x13e05f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13e05f
callq 0x3c180
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::CastIntegralFloating<(clang::interp::PrimType)2, clang::interp::Integral<16u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, llvm::fltSemantics const*, llvm::RoundingMode)
|
bool CastIntegralFloating(InterpState &S, CodePtr OpPC,
const llvm::fltSemantics *Sem,
llvm::RoundingMode RM) {
const T &From = S.Stk.pop<T>();
APSInt FromAP = From.toAPSInt();
Floating Result;
auto Status = Floating::fromIntegral(FromAP, *Sem, RM, Result);
S.Stk.push<Floating>(Result);
return CheckFloatResult(S, OpPC, Result, Status);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c63e0
movzwl (%rax), %r13d
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c6414
movl $0x10, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movb $0x0, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x174622
movl 0x10(%rsp), %eax
movl %eax, 0x20(%rsp)
cmpl $0x40, %eax
ja 0x13f713
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x13f722
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x70bce
movb 0x14(%rsp), %al
leaq 0x18(%rsp), %r12
movb %al, 0xc(%r12)
movsbl %bpl, %edx
leaq 0x28(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x17cfa0
movl %eax, %ebp
cmpl $0x41, 0x8(%r12)
jb 0x13f75d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x13f75d
callq 0x3c180
movq 0xb0(%r14), %rdi
movl $0x20, %esi
callq 0x1c636c
leaq 0x8(%rax), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0x892a0
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x1b47bc
movl %eax, %ebx
movq %r15, %rdi
callq 0x66212
cmpl $0x41, 0x10(%rsp)
jb 0x13f7b1
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13f7b1
callq 0x3c180
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::DecPop<(clang::interp::PrimType)7, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool DecPop(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLoad(S, OpPC, Ptr, AK_Decrement))
return false;
return IncDecHelper<T, IncDecOp::Dec, PushVal::No>(S, OpPC, Ptr);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x4, %ecx
callq 0x1b3ca4
movl %eax, %ebx
testb %al, %al
je 0x143f3e
movq %rsp, %r14
movq %r14, %rdi
callq 0x1313de
movq (%rax), %r15
decq %r15
movq %r14, %rdi
callq 0x1313de
movq %r15, (%rax)
movq %rsp, %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Interp.h
|
clang::interp::EvalEmitter::emitDecayPtrFnPtrPtr(clang::interp::SourceInfo const&)
|
bool isActive() const { return CurrentLabel == ActiveLabel; }
|
movl 0x334(%rdi), %eax
cmpl 0x338(%rdi), %eax
jne 0x14445d
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x328(%rdi)
movq 0x230(%rdi), %r14
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c63e0
movq (%rax), %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c6414
movq 0x230(%rbx), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x1, 0x28(%rbx)
movq %r15, 0x20(%rbx)
movl $0x30, %esi
callq 0x1c636c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c6a24
movq %rbx, %rdi
callq 0x1c6a58
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, %al
retq
|
/AST/Interp/EvalEmitter.h
|
bool clang::interp::InitBitField<(clang::interp::PrimType)2, clang::interp::Integral<16u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Record::Field const*)
|
bool InitBitField(InterpState &S, CodePtr OpPC, const Record::Field *F) {
assert(F->isBitField());
const T &Value = S.Stk.pop<T>();
const Pointer &Field = S.Stk.peek<Pointer>().atField(F->Offset);
Field.deref<T>() = Value.truncate(F->Decl->getBitWidthValue(S.getCtx()));
Field.activate();
Field.initialize();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movzwl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%rbx), %rdi
movl $0x30, %esi
callq 0x1c63e0
movl 0x8(%r14), %edx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1755fe
movq (%r14), %r14
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0xbe112
cmpl $0xf, %eax
ja 0x150b01
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
movswl %bp, %esi
notl %edx
leal -0x1(%rax), %ecx
movl $0x10000, %edi # imm = 0x10000
shll %cl, %edi
andl %esi, %edx
sarl $0x10, %edi
andl %esi, %edi
movl $0xffff, %ebp # imm = 0xFFFF
movl %eax, %ecx
shll %cl, %ebp
testl %edi, %edi
cmovel %edi, %ebp
orl %edx, %ebp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x131126
movw %bp, (%rax)
movq %rbx, %rdi
callq 0x1c78d2
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitBitField<(clang::interp::PrimType)5, clang::interp::Integral<32u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Record::Field const*)
|
bool InitBitField(InterpState &S, CodePtr OpPC, const Record::Field *F) {
assert(F->isBitField());
const T &Value = S.Stk.pop<T>();
const Pointer &Field = S.Stk.peek<Pointer>().atField(F->Offset);
Field.deref<T>() = Value.truncate(F->Decl->getBitWidthValue(S.getCtx()));
Field.activate();
Field.initialize();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq 0xb0(%rdi), %rbx
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c63e0
movl 0x8(%r15), %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1755fe
movq (%r15), %r15
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe112
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %r14d
cmpl $0x20, %eax
notl %r14d
cmovael %edx, %r14d
andl %ebp, %r14d
movq %rbx, %rdi
callq 0x1312c8
movl %r14d, (%rax)
movq %rbx, %rdi
callq 0x1c78d2
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitField<(clang::interp::PrimType)13, clang::interp::FunctionPointer>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool InitField(InterpState &S, CodePtr OpPC, uint32_t I) {
const T &Value = S.Stk.pop<T>();
const Pointer &Field = S.Stk.peek<Pointer>().atField(I);
Field.deref<T>() = Value;
Field.activate();
Field.initialize();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x1c63e0
movq (%rax), %r12
movb 0x8(%rax), %bpl
movl $0x10, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x1755fe
movq %r14, %rdi
callq 0x1316f2
movq %r12, (%rax)
movb %bpl, 0x8(%rax)
movq %r14, %rdi
callq 0x1c78d2
movq %r14, %rdi
callq 0x1c76c8
movq %r14, %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitFieldActive<(clang::interp::PrimType)10, clang::interp::Boolean>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool InitFieldActive(InterpState &S, CodePtr OpPC, uint32_t I) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.pop<Pointer>();
const Pointer &Field = Ptr.atField(I);
Field.deref<T>() = Value;
Field.activate();
Field.initialize();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x130c64
addl (%r14), %ebx
cmpl $0x1, 0x28(%r14)
jne 0x1542b8
movl %ebx, %eax
addq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
jmp 0x1542c9
movq 0x50(%rsp), %rsi
movl %ebx, %ecx
movq %rsp, %rdi
movl %ebx, %edx
callq 0x1c6994
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x131626
movb %bpl, (%rax)
movq %rbx, %rdi
callq 0x1c78d2
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
leaq 0x38(%rsp), %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitGlobal<(clang::interp::PrimType)1, clang::interp::Integral<8u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool InitGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
const Pointer &P = S.P.getGlobal(I);
P.deref<T>() = S.Stk.pop<T>();
P.initialize();
return true;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq 0xa8(%rdi), %rax
movl %edx, %ecx
movq 0xe0(%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1c6960
movq 0xb0(%r14), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c6414
movq %rbx, %rdi
callq 0x13109a
movb %bpl, (%rax)
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitPop<(clang::interp::PrimType)1, clang::interp::Integral<8u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool InitPop(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckInit(S, OpPC, Ptr))
return false;
Ptr.initialize();
new (&Ptr.deref<T>()) T(Value);
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1b4393
movl %eax, %ebx
testb %al, %al
je 0x1566f6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1c76c8
movq %r14, %rdi
callq 0x13109a
movb %bpl, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::InitThisFieldActive<(clang::interp::PrimType)14, clang::interp::MemberPointer>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool InitThisFieldActive(InterpState &S, CodePtr OpPC, uint32_t I) {
if (S.checkingPotentialConstantExpression())
return false;
const Pointer &This = S.Current->getThis();
if (!CheckThis(S, OpPC, This))
return false;
const Pointer &Field = This.atField(I);
Field.deref<T>() = S.Stk.pop<T>();
Field.activate();
Field.initialize();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x15908c
xorl %ebx, %ebx
jmp 0x159117
movq 0xc0(%r15), %r12
addq $0x28, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1b46f9
movl %eax, %ebx
testb %al, %al
je 0x159117
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x1755fe
movq 0xb0(%r15), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x1748c6
movq %r14, %rdi
callq 0x13184c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x1c6af8
movl 0x38(%r15), %eax
movl %eax, 0x38(%r12)
movq 0x30(%r15), %rax
movq %rax, 0x30(%r12)
movq %r15, %rdi
callq 0x1c6a58
movq %r14, %rdi
callq 0x1c78d2
movq %r14, %rdi
callq 0x1c76c8
movq %r14, %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::LoadPop<(clang::interp::PrimType)5, clang::interp::Integral<32u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool LoadPop(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLoad(S, OpPC, Ptr))
return false;
if (!Ptr.isBlockPointer())
return false;
S.Stk.push<T>(Ptr.deref<T>());
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1b3ca4
cmpl $0x0, 0x28(%r15)
sete %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x15aa3a
movq 0xb0(%r14), %r14
movq %rsp, %rdi
callq 0x1312c8
movq %rax, %r15
movl $0x8, %esi
movq %r14, %rdi
callq 0x1c636c
movl (%r15), %ecx
movl %ecx, (%rax)
movq %rsp, %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::LoadPop<(clang::interp::PrimType)12, clang::interp::Pointer>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool LoadPop(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLoad(S, OpPC, Ptr))
return false;
if (!Ptr.isBlockPointer())
return false;
S.Stk.push<T>(Ptr.deref<T>());
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1b3ca4
cmpl $0x0, 0x28(%r15)
sete %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x15acfe
movq 0xb0(%r14), %r14
movq %rsp, %rdi
callq 0x1316b2
movq %rax, %r15
movl $0x30, %esi
movq %r14, %rdi
callq 0x1c636c
movq %rax, %rdi
movq %r15, %rsi
callq 0x1c69ec
movq %rsp, %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::LoadPop<(clang::interp::PrimType)13, clang::interp::FunctionPointer>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool LoadPop(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLoad(S, OpPC, Ptr))
return false;
if (!Ptr.isBlockPointer())
return false;
S.Stk.push<T>(Ptr.deref<T>());
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1b3ca4
cmpl $0x0, 0x28(%r15)
sete %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x15ad78
movq 0xb0(%r14), %r14
movq %rsp, %rdi
callq 0x1316f2
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c636c
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %rsp, %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Mulc<(clang::interp::PrimType)0, clang::interp::Integral<8u, true>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Mulc(InterpState &S, CodePtr OpPC) {
const Pointer &RHS = S.Stk.pop<Pointer>();
const Pointer &LHS = S.Stk.pop<Pointer>();
const Pointer &Result = S.Stk.peek<Pointer>();
if constexpr (std::is_same_v<T, Floating>) {
APFloat A = LHS.atIndex(0).deref<Floating>().getAPFloat();
APFloat B = LHS.atIndex(1).deref<Floating>().getAPFloat();
APFloat C = RHS.atIndex(0).deref<Floating>().getAPFloat();
APFloat D = RHS.atIndex(1).deref<Floating>().getAPFloat();
APFloat ResR(A.getSemantics());
APFloat ResI(A.getSemantics());
HandleComplexComplexMul(A, B, C, D, ResR, ResI);
// Copy into the result.
Result.atIndex(0).deref<Floating>() = Floating(ResR);
Result.atIndex(0).initialize();
Result.atIndex(1).deref<Floating>() = Floating(ResI);
Result.atIndex(1).initialize();
Result.initialize();
} else {
// Integer element type.
const T &LHSR = LHS.atIndex(0).deref<T>();
const T &LHSI = LHS.atIndex(1).deref<T>();
const T &RHSR = RHS.atIndex(0).deref<T>();
const T &RHSI = RHS.atIndex(1).deref<T>();
unsigned Bits = LHSR.bitWidth();
// real(Result) = (real(LHS) * real(RHS)) - (imag(LHS) * imag(RHS))
T A;
if (T::mul(LHSR, RHSR, Bits, &A))
return false;
T B;
if (T::mul(LHSI, RHSI, Bits, &B))
return false;
if (T::sub(A, B, Bits, &Result.atIndex(0).deref<T>()))
return false;
Result.atIndex(0).initialize();
// imag(Result) = (real(LHS) * imag(RHS)) + (imag(LHS) * real(RHS))
if (T::mul(LHSR, RHSI, Bits, &A))
return false;
if (T::mul(LHSI, RHSR, Bits, &B))
return false;
if (T::add(A, B, Bits, &Result.atIndex(1).deref<T>()))
return false;
Result.atIndex(1).initialize();
Result.initialize();
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0xb0(%rdi), %rsi
leaq 0x78(%rsp), %rbp
movq %rbp, %rdi
callq 0x130c64
movq 0xb0(%rbx), %rsi
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x130c64
movq 0xb0(%rbx), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x17465e
movq %rbx, %rdi
callq 0x13100e
movq %rax, %r15
movq %rbx, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x13100e
movq %rax, %r12
movq %rbx, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x17465e
movq %rbx, %rdi
callq 0x13100e
movq %rax, %r13
movq %rbx, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x13100e
movq %rax, %rbp
movq %rbx, %rdi
callq 0x1c6a58
movb (%r15), %al
imulb (%r13)
jo 0x15ba12
movl %eax, %ebx
movq %r12, 0x10(%rsp)
movb (%r12), %al
imulb (%rbp)
jno 0x15b9a7
xorl %r14d, %r14d
jmp 0x15ba12
movl %eax, %r12d
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x17465e
leaq 0x18(%rsp), %rdi
callq 0x13100e
movl %ebx, %ecx
subb %r12b, %cl
movb %cl, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x1c6a58
cmpb %r12b, %bl
movq 0x10(%rsp), %r12
jo 0x15ba12
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x17465e
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movb (%r15), %al
imulb (%rbp)
jno 0x15ba3b
leaq 0x48(%rsp), %rdi
callq 0x1c6a58
leaq 0x78(%rsp), %rdi
callq 0x1c6a58
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movb (%r12), %al
imulb (%r13)
jo 0x15b9a2
movl %eax, %ebx
leaq 0x18(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x17465e
movq %r14, %rdi
callq 0x13100e
leal (%r15,%rbx), %ecx
movb %cl, (%rax)
movq %r14, %rdi
callq 0x1c6a58
addb %bl, %r15b
jo 0x15b9a2
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movq %r12, %rdi
callq 0x1c76c8
movb $0x1, %r14b
jmp 0x15ba12
|
/AST/Interp/Interp.h
|
bool clang::interp::Mulc<(clang::interp::PrimType)6, clang::interp::Integral<64u, true>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Mulc(InterpState &S, CodePtr OpPC) {
const Pointer &RHS = S.Stk.pop<Pointer>();
const Pointer &LHS = S.Stk.pop<Pointer>();
const Pointer &Result = S.Stk.peek<Pointer>();
if constexpr (std::is_same_v<T, Floating>) {
APFloat A = LHS.atIndex(0).deref<Floating>().getAPFloat();
APFloat B = LHS.atIndex(1).deref<Floating>().getAPFloat();
APFloat C = RHS.atIndex(0).deref<Floating>().getAPFloat();
APFloat D = RHS.atIndex(1).deref<Floating>().getAPFloat();
APFloat ResR(A.getSemantics());
APFloat ResI(A.getSemantics());
HandleComplexComplexMul(A, B, C, D, ResR, ResI);
// Copy into the result.
Result.atIndex(0).deref<Floating>() = Floating(ResR);
Result.atIndex(0).initialize();
Result.atIndex(1).deref<Floating>() = Floating(ResI);
Result.atIndex(1).initialize();
Result.initialize();
} else {
// Integer element type.
const T &LHSR = LHS.atIndex(0).deref<T>();
const T &LHSI = LHS.atIndex(1).deref<T>();
const T &RHSR = RHS.atIndex(0).deref<T>();
const T &RHSI = RHS.atIndex(1).deref<T>();
unsigned Bits = LHSR.bitWidth();
// real(Result) = (real(LHS) * real(RHS)) - (imag(LHS) * imag(RHS))
T A;
if (T::mul(LHSR, RHSR, Bits, &A))
return false;
T B;
if (T::mul(LHSI, RHSI, Bits, &B))
return false;
if (T::sub(A, B, Bits, &Result.atIndex(0).deref<T>()))
return false;
Result.atIndex(0).initialize();
// imag(Result) = (real(LHS) * imag(RHS)) + (imag(LHS) * real(RHS))
if (T::mul(LHSR, RHSI, Bits, &A))
return false;
if (T::mul(LHSI, RHSR, Bits, &B))
return false;
if (T::add(A, B, Bits, &Result.atIndex(1).deref<T>()))
return false;
Result.atIndex(1).initialize();
Result.initialize();
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0xb0(%rdi), %rsi
leaq 0x78(%rsp), %rbp
movq %rbp, %rdi
callq 0x130c64
movq 0xb0(%rbx), %rsi
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x130c64
movq 0xb0(%rbx), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rax, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x17465e
movq %r13, %rdi
callq 0x131352
movq %rax, %r14
movq %r13, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %r13
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x17465e
movq %r13, %rdi
callq 0x131352
movq %rax, %r15
movq %r13, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x17465e
movq %rbx, %rdi
callq 0x131352
movq %rax, %r13
movq %rbx, %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x131352
movq %rax, %rbp
movq %rbx, %rdi
callq 0x1c6a58
movq %r14, 0x10(%rsp)
movq (%r14), %r12
xorl %r14d, %r14d
imulq (%r13), %r12
jo 0x15c640
movq (%r15), %rbx
imulq (%rbp), %rbx
jno 0x15c5d1
xorl %r14d, %r14d
jmp 0x15c640
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
movq %r15, 0x8(%rsp)
callq 0x17465e
leaq 0x18(%rsp), %rdi
callq 0x131352
movq %r12, %rcx
subq %rbx, %rcx
movq %rcx, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x1c6a58
cmpq %rbx, %r12
jo 0x15c640
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x17465e
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movq 0x10(%rsp), %rax
movq (%rax), %r15
imulq (%rbp), %r15
jno 0x15c669
leaq 0x48(%rsp), %rdi
callq 0x1c6a58
leaq 0x78(%rsp), %rdi
callq 0x1c6a58
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq (%rax), %r14
imulq (%r13), %r14
jo 0x15c5cc
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq (%rsp), %r12
movq %r12, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x131352
leaq (%r15,%r14), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x1c6a58
addq %r14, %r15
jo 0x15c5cc
leaq 0x18(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17465e
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1c6a58
movq %r12, %rdi
callq 0x1c76c8
movb $0x1, %r14b
jmp 0x15c640
|
/AST/Interp/Interp.h
|
bool clang::interp::OffsetOf<(clang::interp::PrimType)0, clang::interp::Integral<8u, true>>(clang::interp::InterpState&, clang::interp::CodePtr, clang::OffsetOfExpr const*)
|
inline bool OffsetOf(InterpState &S, CodePtr OpPC, const OffsetOfExpr *E) {
llvm::SmallVector<int64_t> ArrayIndices;
for (size_t I = 0; I != E->getNumExpressions(); ++I)
ArrayIndices.emplace_back(S.Stk.pop<int64_t>());
int64_t Result;
if (!InterpretOffsetOf(S, OpPC, E, ArrayIndices, Result))
return false;
S.Stk.push<T>(T::from(Result));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x600000000, %rax # imm = 0x600000000
movq %rax, -0x8(%rcx)
cmpl $0x0, 0x24(%rdx)
je 0x15f704
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movq 0xb0(%rbx), %rbp
movl $0x8, %esi
movq %rbp, %rdi
callq 0x1c63e0
movq (%rax), %r12
movl $0x8, %esi
movq %rbp, %rdi
callq 0x1c6414
movq %r12, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x18637c
incq %r15
movl 0x24(%r14), %eax
cmpq %rax, %r15
jne 0x15f6c2
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %r8d
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1adee9
movl %eax, %ebp
testb %al, %al
je 0x15f740
movq 0xb0(%rbx), %rdi
movb 0x8(%rsp), %bl
movl $0x8, %esi
callq 0x1c636c
movb %bl, (%rax)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x15f754
callq 0x3c3a0
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::SetParam<(clang::interp::PrimType)13, clang::interp::FunctionPointer>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int)
|
bool SetParam(InterpState &S, CodePtr OpPC, uint32_t I) {
S.Current->setParam<T>(I, S.Stk.pop<T>());
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq 0xc0(%rdi), %r14
movq 0xb0(%rdi), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x1c63e0
movq (%rax), %r12
movb 0x8(%rax), %bpl
movl $0x10, %esi
movq %r15, %rdi
callq 0x1c6414
movq %rsp, %rdx
movq %r12, (%rdx)
movb %bpl, 0x8(%rdx)
movq %r14, %rdi
movl %ebx, %esi
callq 0x18691e
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
clang::interp::EvalEmitter::emitShlUint32Sint8(clang::interp::SourceInfo const&)
|
bool isActive() const { return CurrentLabel == ActiveLabel; }
|
movl 0x334(%rdi), %ecx
movb $0x1, %al
cmpl 0x338(%rdi), %ecx
jne 0x166634
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, 0x328(%rdi)
leaq 0x180(%rdi), %rbx
movq 0x320(%rdi), %r14
movq 0x230(%rdi), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c6414
leaq 0xb(%rsp), %r12
movb %bpl, (%r12)
movq 0x230(%r15), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
leaq 0xc(%rsp), %rdx
movl %ebp, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x193e8f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Interp/EvalEmitter.h
|
clang::interp::EvalEmitter::emitShrUint32Sint16(clang::interp::SourceInfo const&)
|
bool isActive() const { return CurrentLabel == ActiveLabel; }
|
movl 0x334(%rdi), %ecx
movb $0x1, %al
cmpl 0x338(%rdi), %ecx
jne 0x16b507
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, 0x328(%rdi)
leaq 0x180(%rdi), %rbx
movq 0x320(%rdi), %r14
movq 0x230(%rdi), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c63e0
movzwl (%rax), %ebp
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c6414
leaq 0xa(%rsp), %r12
movw %bp, (%r12)
movq 0x230(%r15), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
leaq 0xc(%rsp), %rdx
movl %ebp, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x1943fe
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/EvalEmitter.h
|
clang::interp::EvalEmitter::emitShrUint32Sint32(clang::interp::SourceInfo const&)
|
bool isActive() const { return CurrentLabel == ActiveLabel; }
|
movl 0x334(%rdi), %ecx
movb $0x1, %al
cmpl 0x338(%rdi), %ecx
jne 0x16b5b3
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, 0x328(%rdi)
leaq 0x180(%rdi), %rbx
movq 0x320(%rdi), %r14
movq 0x230(%rdi), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r12, %rdi
callq 0x1c6414
leaq 0xc(%rsp), %r12
movl %ebp, (%r12)
movq 0x230(%r15), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
leaq 0x8(%rsp), %rdx
movl %ebp, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x194858
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/EvalEmitter.h
|
bool clang::interp::Shr<(clang::interp::PrimType)0, (clang::interp::PrimType)5>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Shr(InterpState &S, CodePtr OpPC) {
using LT = typename PrimConv<NameL>::T;
using RT = typename PrimConv<NameR>::T;
auto RHS = S.Stk.pop<RT>();
auto LHS = S.Stk.pop<LT>();
return DoShift<LT, RT, ShiftDir::Right>(S, OpPC, LHS, RHS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movl %ebp, 0x4(%rsp)
movq 0xb0(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movb %bpl, 0x3(%rsp)
movq %rbx, %rdi
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x16d116
andl $0x7, 0x4(%rsp)
leaq 0x3(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %r8d
callq 0x18806c
movl %eax, %ebp
testb %al, %al
je 0x16d166
movl 0x4(%rsp), %ecx
movzbl 0x3(%rsp), %eax
movl %eax, %edx
shrb $0x7, %dl
shrl %cl, %eax
cmpl $0x8, %ecx
movzbl %dl, %r14d
cmovbl %eax, %r14d
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movb %r14b, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Shr<(clang::interp::PrimType)1, (clang::interp::PrimType)5>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Shr(InterpState &S, CodePtr OpPC) {
using LT = typename PrimConv<NameL>::T;
using RT = typename PrimConv<NameR>::T;
auto RHS = S.Stk.pop<RT>();
auto LHS = S.Stk.pop<LT>();
return DoShift<LT, RT, ShiftDir::Right>(S, OpPC, LHS, RHS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movl %ebp, 0x4(%rsp)
movq 0xb0(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movb %bpl, 0x3(%rsp)
movq %rbx, %rdi
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x16d45d
andl $0x7, 0x4(%rsp)
leaq 0x3(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %r8d
callq 0x18a9dc
movl %eax, %ebp
testb %al, %al
je 0x16d4ad
movl 0x4(%rsp), %ecx
movzbl 0x3(%rsp), %eax
movl %eax, %edx
shrb $0x7, %dl
shrl %cl, %eax
cmpl $0x8, %ecx
movzbl %dl, %r14d
cmovbl %eax, %r14d
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movb %r14b, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Shr<(clang::interp::PrimType)5, (clang::interp::PrimType)7>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Shr(InterpState &S, CodePtr OpPC) {
using LT = typename PrimConv<NameL>::T;
using RT = typename PrimConv<NameR>::T;
auto RHS = S.Stk.pop<RT>();
auto LHS = S.Stk.pop<LT>();
return DoShift<LT, RT, ShiftDir::Right>(S, OpPC, LHS, RHS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movq (%rax), %r12
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq %r12, 0x8(%rsp)
movq 0xb0(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movl %ebp, 0x4(%rsp)
movq %rbx, %rdi
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x16e219
andq $0x1f, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x20, %r8d
callq 0x194f1a
movl %eax, %ebp
testb %al, %al
je 0x16e268
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %r14d
cmpq $0x1f, %rax
movl $0x1f, %ecx
cmovbq %rax, %rcx
shrl %cl, %r14d
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movl %r14d, (%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Shr<(clang::interp::PrimType)7, (clang::interp::PrimType)1>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool Shr(InterpState &S, CodePtr OpPC) {
using LT = typename PrimConv<NameL>::T;
using RT = typename PrimConv<NameR>::T;
auto RHS = S.Stk.pop<RT>();
auto LHS = S.Stk.pop<LT>();
return DoShift<LT, RT, ShiftDir::Right>(S, OpPC, LHS, RHS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movb %bpl, 0x7(%rsp)
movq 0xb0(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movq (%rax), %r12
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq %r12, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x16e636
andb $0x3f, 0x7(%rsp)
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x40, %r8d
callq 0x199166
movl %eax, %ebp
testb %al, %al
je 0x16e682
movzbl 0x7(%rsp), %eax
movq 0x8(%rsp), %r14
cmpb $0x3f, %al
movl $0x3f, %ecx
cmovbl %eax, %ecx
shrq %cl, %r14
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movq %r14, (%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Store<(clang::interp::PrimType)7, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool Store(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.peek<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
Ptr.deref<T>() = Value;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xb0(%rdi), %rbx
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c63e0
movq (%rax), %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c6414
movq 0xb0(%r15), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1b4204
movl %eax, %ebp
testb %al, %al
je 0x16f3eb
cmpl $0x0, 0x28(%rbx)
jne 0x16f3e0
cmpq $0x0, 0x18(%rbx)
je 0x16f3e0
cmpl $0x0, 0x20(%rbx)
je 0x16f3e0
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1313de
movq %r12, (%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::Store<(clang::interp::PrimType)8, clang::interp::IntegralAP<false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool Store(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.peek<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
Ptr.deref<T>() = Value;
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0xb0(%rdi), %r14
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c63e0
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movl $0x0, 0x8(%rax)
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c6414
movq 0xb0(%r15), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1b4204
movl %eax, %ebx
testb %al, %al
je 0x16f493
cmpl $0x0, 0x28(%r14)
jne 0x16f480
cmpq $0x0, 0x18(%r14)
je 0x16f480
cmpl $0x0, 0x20(%r14)
je 0x16f480
movq %r14, %rdi
callq 0x1c76c8
movq %r14, %rdi
callq 0x13146a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x717ba
cmpl $0x41, 0x8(%rsp)
jb 0x16f4a8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x16f4a8
callq 0x3c180
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::StoreBitField<(clang::interp::PrimType)2, clang::interp::Integral<16u, true>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool StoreBitField(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.peek<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
if (const auto *FD = Ptr.getField())
Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
else
Ptr.deref<T>() = Value;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0xb0(%rdi), %rbx
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c63e0
movzwl (%rax), %r12d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c63e0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1b4204
movl %eax, %ebp
testb %al, %al
je 0x16fc9e
cmpl $0x0, 0x28(%rbx)
jne 0x16fc34
cmpq $0x0, 0x18(%rbx)
je 0x16fc34
cmpl $0x0, 0x20(%rbx)
je 0x16fc34
movq %rbx, %rdi
callq 0x1c76c8
movq %rbx, %rdi
callq 0x1a60ec
testq %rax, %rax
je 0x16fc92
movq %rax, %r15
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe112
cmpl $0xf, %eax
ja 0x16fc92
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
movswl %r12w, %esi
notl %edx
leal -0x1(%rax), %ecx
movl $0x10000, %edi # imm = 0x10000
shll %cl, %edi
andl %esi, %edx
sarl $0x10, %edi
andl %esi, %edi
movl $0xffff, %r12d # imm = 0xFFFF
movl %eax, %ecx
shll %cl, %r12d
testl %edi, %edi
cmovel %edi, %r12d
orl %edx, %r12d
movq %rbx, %rdi
callq 0x131126
movw %r12w, (%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::StoreBitFieldPop<(clang::interp::PrimType)4, clang::interp::Integral<32u, true>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool StoreBitFieldPop(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
if (const auto *FD = Ptr.getField())
Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
else
Ptr.deref<T>() = Value;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movl (%rax), %ebp
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1b4204
movl %eax, %ebx
testb %al, %al
je 0x170a18
cmpl $0x0, 0x30(%rsp)
jne 0x1709c0
cmpq $0x0, 0x20(%rsp)
je 0x1709c0
cmpl $0x0, 0x28(%rsp)
je 0x1709c0
leaq 0x8(%rsp), %rdi
callq 0x1c76c8
leaq 0x8(%rsp), %rdi
callq 0x1a60ec
testq %rax, %rax
je 0x170a0c
movq %rax, %r15
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe112
cmpl $0x1f, %eax
ja 0x170a0c
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
movl %edx, %ecx
notl %ecx
decb %al
andl %ebp, %ecx
movzbl %al, %eax
xorl %esi, %esi
btl %eax, %ebp
cmovbl %edx, %esi
orl %ecx, %esi
movl %esi, %ebp
leaq 0x8(%rsp), %rdi
callq 0x13123e
movl %ebp, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::StorePop<(clang::interp::PrimType)1, clang::interp::Integral<8u, false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
bool StorePop(InterpState &S, CodePtr OpPC) {
const T &Value = S.Stk.pop<T>();
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckStore(S, OpPC, Ptr))
return false;
if (Ptr.canBeInitialized())
Ptr.initialize();
Ptr.deref<T>() = Value;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c63e0
movb (%rax), %bpl
movl $0x8, %esi
movq %r15, %rdi
callq 0x1c6414
movq 0xb0(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x130c64
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1b4204
movl %eax, %ebx
testb %al, %al
je 0x1713bb
cmpl $0x0, 0x30(%rsp)
jne 0x1713ae
cmpq $0x0, 0x20(%rsp)
je 0x1713ae
cmpl $0x0, 0x28(%rsp)
je 0x1713ae
leaq 0x8(%rsp), %rdi
callq 0x1c76c8
leaq 0x8(%rsp), %rdi
callq 0x13109a
movb %bpl, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::SubPtr<(clang::interp::PrimType)8, clang::interp::IntegralAP<false>>(clang::interp::InterpState&, clang::interp::CodePtr)
|
inline bool SubPtr(InterpState &S, CodePtr OpPC) {
const Pointer &LHS = S.Stk.pop<Pointer>();
const Pointer &RHS = S.Stk.pop<Pointer>();
if (RHS.isZero()) {
S.Stk.push<T>(T::from(LHS.getIndex()));
return true;
}
if (!Pointer::hasSameBase(LHS, RHS) && S.getLangOpts().CPlusPlus) {
// TODO: Diagnose.
return false;
}
if (LHS.isZero() && RHS.isZero()) {
S.Stk.push<T>();
return true;
}
T A = LHS.isElementPastEnd() ? T::from(LHS.getNumElems())
: T::from(LHS.getIndex());
T B = RHS.isElementPastEnd() ? T::from(RHS.getNumElems())
: T::from(RHS.getIndex());
return AddSubMulHelper<T, T::sub, std::minus>(S, OpPC, A.bitWidth(), A, B);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rdi), %rsi
leaq 0x50(%rsp), %rdi
callq 0x130c64
movq 0xb0(%rbx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x130c64
cmpl $0x0, 0x28(%r15)
je 0x1738f2
movq 0x10(%rsp), %rax
orq 0x30(%rsp), %rax
jmp 0x1738f8
cmpq $0x0, 0x28(%rsp)
sete %al
testb %al, %al
je 0x17395f
movq 0xb0(%rbx), %rbx
leaq 0x50(%rsp), %rdi
callq 0x174cd6
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1863f4
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c636c
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
movq (%r14), %rcx
movq %rcx, (%rax)
movb $0x1, %bl
leaq 0x10(%rsp), %rdi
callq 0x1c6a58
leaq 0x50(%rsp), %rdi
callq 0x1c6a58
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c78f8
testb %al, %al
jne 0x173980
movq %rbx, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0x1739b3
cmpl $0x0, 0x78(%rsp)
je 0x173993
movq 0x50(%rsp), %rax
orq 0x70(%rsp), %rax
jmp 0x173999
cmpq $0x0, 0x68(%rsp)
sete %al
testb %al, %al
je 0x1739f0
cmpl $0x0, 0x38(%rsp)
je 0x1739b7
movq 0x10(%rsp), %rax
orq 0x30(%rsp), %rax
jmp 0x1739bd
xorl %ebx, %ebx
jmp 0x17393c
cmpq $0x0, 0x28(%rsp)
sete %al
testb %al, %al
je 0x1739f0
movq 0xb0(%rbx), %rdi
movl $0x10, %esi
callq 0x1c636c
movl $0x3, 0x8(%rax)
movq $-0x1, (%rax)
movq %rax, %rdi
callq 0x661d4
jmp 0x17393a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, 0x50(%rsp)
jne 0x173a14
leaq 0x50(%rsp), %rdi
callq 0x174c2a
movq %rsp, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x17ae68
jmp 0x173a2b
leaq 0x50(%rsp), %rdi
callq 0x174cd6
movq %rsp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1863f4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, 0x10(%rsp)
jne 0x173a51
leaq 0x10(%rsp), %rdi
callq 0x174c2a
leaq 0x40(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x17ae68
jmp 0x173a6a
leaq 0x10(%rsp), %rdi
callq 0x174cd6
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1863f4
movq %rsp, %rcx
movl 0x8(%rcx), %edx
leaq 0x40(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r8
callq 0x1a6b67
movl %eax, %ebx
cmpl $0x41, 0x8(%r15)
jb 0x173a9b
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x173a9b
callq 0x3c180
cmpl $0x41, 0x8(%rsp)
jb 0x17393c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17393c
callq 0x3c180
jmp 0x17393c
|
/AST/Interp/Interp.h
|
clang::interp::Integral<16u, false>::toDiagnosticString[abi:cxx11](clang::ASTContext const&) const
|
std::string toDiagnosticString(const ASTContext &Ctx) const {
std::string NameStr;
llvm::raw_string_ostream OS(NameStr);
OS << V;
return NameStr;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x8(%rsp), %r15
movl $0x0, 0x8(%r15)
movb %al, 0x28(%r15)
movl $0x1, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0x33d37d(%rip), %rax # 0x4b7a48
addq $0x10, %rax
movq %rax, (%r15)
movq %rdi, 0x30(%r15)
movq %r15, %rdi
callq 0x57780
movzwl (%r14), %esi
movq %r15, %rdi
callq 0x57d6c
movq %r15, %rdi
callq 0x58c66
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Integral.h
|
unsigned short clang::interp::IntegralAP<false>::truncateCast<unsigned short, false>(llvm::APInt const&)
|
static T truncateCast(const APInt &V) {
constexpr unsigned BitSize = sizeof(T) * 8;
if (BitSize >= V.getBitWidth()) {
APInt Extended;
if constexpr (InputSigned)
Extended = V.sext(BitSize);
else
Extended = V.zext(BitSize);
return std::is_signed_v<T> ? Extended.getSExtValue()
: Extended.getZExtValue();
}
return std::is_signed_v<T> ? V.trunc(BitSize).getSExtValue()
: V.trunc(BitSize).getZExtValue();
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
cmpl $0x10, 0x8(%rdi)
ja 0x17ba6f
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x71560
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
movq %rdi, %rbx
cmpl $0x41, %eax
jb 0x17ba67
movq (%rdi), %rbx
cmpl $0x41, %eax
setb %al
jmp 0x17ba90
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x72174
cmpl $0x41, 0x8(%rbx)
setb %al
movq (%rbx), %rdi
cmovaeq %rdi, %rbx
movq (%rbx), %rbx
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x17ba9f
callq 0x3c180
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
|
/AST/Interp/IntegralAP.h
|
clang::interp::Integral<8u, true>::Integral(llvm::APSInt const&)
|
explicit Integral(const APSInt &V)
: V(V.isSigned() ? V.getSExtValue() : V.getZExtValue()) {}
|
movl 0x8(%rsi), %eax
cmpb $0x0, 0xc(%rsi)
je 0x17ce12
cmpl $0x41, %eax
jb 0x17ce0d
movq (%rsi), %rsi
movq (%rsi), %rcx
jmp 0x17ce34
cmpl $0x40, %eax
ja 0x17ce2e
movq (%rsi), %rdx
movl %eax, %ecx
negb %cl
shlq %cl, %rdx
sarq %cl, %rdx
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rdx, %rcx
jmp 0x17ce34
movq (%rsi), %rax
movq (%rax), %rcx
movb %cl, (%rdi)
retq
nop
|
/AST/Interp/Integral.h
|
clang::interp::IntegralAP<false>::comp(clang::interp::IntegralAP<false>, clang::interp::IntegralAP<false>*)
|
static bool comp(IntegralAP A, IntegralAP *R) {
*R = IntegralAP(~A.V);
return false;
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movl 0x8(%rdi), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x17d037
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
jmp 0x17d041
leaq 0x8(%rsp), %rdi
callq 0x70bce
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7089e
movl 0x8(%r14), %ecx
movl %ecx, 0x30(%rsp)
movq (%r14), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x8(%r14)
movl %ecx, 0x20(%rsp)
cmpl $0x40, %ecx
ja 0x17d076
movq %rax, 0x18(%rsp)
jmp 0x17d085
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x70bce
cmpl $0x41, 0x8(%rbx)
jb 0x17d098
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17d098
callq 0x3c180
movq 0x18(%rsp), %rax
movq %rax, (%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rbx)
movl $0x0, 0x20(%rsp)
cmpl $0x41, 0x30(%rsp)
jb 0x17d0c5
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x17d0c5
callq 0x3c180
cmpl $0x41, 0x10(%rsp)
jb 0x17d0db
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17d0db
callq 0x3c180
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/Interp/IntegralAP.h
|
clang::interp::IntegralAP<true>::comp(clang::interp::IntegralAP<true>, clang::interp::IntegralAP<true>*)
|
static bool comp(IntegralAP A, IntegralAP *R) {
*R = IntegralAP(~A.V);
return false;
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movl 0x8(%rdi), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x17d109
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
jmp 0x17d113
leaq 0x8(%rsp), %rdi
callq 0x70bce
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7089e
movl 0x8(%r14), %ecx
movl %ecx, 0x30(%rsp)
movq (%r14), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x8(%r14)
movl %ecx, 0x20(%rsp)
cmpl $0x40, %ecx
ja 0x17d148
movq %rax, 0x18(%rsp)
jmp 0x17d157
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x70bce
cmpl $0x41, 0x8(%rbx)
jb 0x17d16a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17d16a
callq 0x3c180
movq 0x18(%rsp), %rax
movq %rax, (%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rbx)
movl $0x0, 0x20(%rsp)
cmpl $0x41, 0x30(%rsp)
jb 0x17d197
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x17d197
callq 0x3c180
cmpl $0x41, 0x10(%rsp)
jb 0x17d1ad
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17d1ad
callq 0x3c180
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/AST/Interp/IntegralAP.h
|
bool clang::interp::CmpHelperEQ<clang::interp::MemberPointer>(clang::interp::InterpState&, clang::interp::CodePtr, llvm::function_ref<bool (clang::ComparisonCategoryResult)>)
|
inline bool CmpHelperEQ<MemberPointer>(InterpState &S, CodePtr OpPC,
CompareFn Fn) {
const auto &RHS = S.Stk.pop<MemberPointer>();
const auto &LHS = S.Stk.pop<MemberPointer>();
// If either operand is a pointer to a weak function, the comparison is not
// constant.
for (const auto &MP : {LHS, RHS}) {
if (const CXXMethodDecl *MD = MP.getMemberFunction(); MD && MD->isWeak()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.FFDiag(Loc, diag::note_constexpr_mem_pointer_weak_comparison) << MD;
return false;
}
}
// C++11 [expr.eq]p2:
// If both operands are null, they compare equal. Otherwise if only one is
// null, they compare unequal.
if (LHS.isZero() && RHS.isZero()) {
S.Stk.push<Boolean>(Fn(ComparisonCategoryResult::Equal));
return true;
}
if (LHS.isZero() || RHS.isZero()) {
S.Stk.push<Boolean>(Fn(ComparisonCategoryResult::Unordered));
return true;
}
// We cannot compare against virtual declarations at compile time.
for (const auto &MP : {LHS, RHS}) {
if (const CXXMethodDecl *MD = MP.getMemberFunction();
MD && MD->isVirtual()) {
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
}
}
S.Stk.push<Boolean>(Boolean::from(Fn(LHS.compare(RHS))));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbp
movq %rdi, %r15
movq 0xb0(%rdi), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1748c6
movq 0xb0(%r15), %rsi
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x1748c6
leaq 0x98(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c69ec
movl 0x38(%rbx), %eax
movl %eax, 0x38(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x1c69ec
movl 0x38(%r12), %eax
movl %eax, 0x38(%r14)
movq 0x30(%r12), %rax
movq %rax, 0x30(%r14)
movl $0x30, %r13d
xorl %r12d, %r12d
movq 0x98(%rsp,%r13), %r14
testq %r14, %r14
je 0x18196e
movl 0x1c(%r14), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
je 0x181971
xorl %r14d, %r14d
testq %r14, %r14
je 0x181982
movq %r14, %rdi
callq 0xbbfa0
testb %al, %al
jne 0x181995
addq $0x40, %r13
cmpq $0xb0, %r13
sete %r12b
jne 0x181955
jmp 0x1819ce
movq 0xc0(%r15), %rdi
movq %rbp, %rsi
callq 0x1c5e4e
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movl $0x8b4, %edx # imm = 0x8B4
xorl %ecx, %ecx
callq 0x1cdcda
testq %rax, %rax
je 0x1819ce
movq %rax, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x96fba
movl $0x40, %r14d
leaq (%rsp,%r14), %rdi
addq $0x98, %rdi
callq 0x1c6a58
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x1819d4
testb $0x1, %r12b
je 0x181be9
movq %rbp, %r13
movl 0x80(%rsp), %eax
testl %eax, %eax
je 0x181a12
movq 0x58(%rsp), %rcx
orq 0x78(%rsp), %rcx
jmp 0x181a18
cmpq $0x0, 0x70(%rsp)
sete %dl
movq 0x88(%rsp), %rcx
testq %rcx, %rcx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x181a62
cmpl $0x0, 0x40(%rsp)
je 0x181a46
movq 0x18(%rsp), %rdx
orq 0x38(%rsp), %rdx
jmp 0x181a4c
cmpq $0x0, 0x30(%rsp)
sete %dl
testb %dl, %dl
je 0x181a62
cmpq $0x0, 0x48(%rsp)
jne 0x181a62
xorl %eax, %eax
jmp 0x181bc4
testl %eax, %eax
je 0x181a72
movq 0x58(%rsp), %rax
orq 0x78(%rsp), %rax
jmp 0x181a78
cmpq $0x0, 0x70(%rsp)
sete %dl
testq %rcx, %rcx
sete %cl
movb $0x4, %al
testb %cl, %dl
jne 0x181bc4
cmpl $0x0, 0x40(%rsp)
je 0x181a9e
movq 0x18(%rsp), %rcx
orq 0x38(%rsp), %rcx
jmp 0x181aa4
cmpq $0x0, 0x30(%rsp)
sete %cl
testb %cl, %cl
je 0x181ab7
cmpq $0x0, 0x48(%rsp)
je 0x181bc4
leaq 0x98(%rsp), %r14
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
callq 0x1c69ec
movl 0x38(%rbx), %eax
movl %eax, 0x38(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
leaq 0xd8(%rsp), %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c69ec
leaq 0x18(%rsp), %rcx
movl 0x38(%rcx), %eax
movl %eax, 0x38(%rbx)
movq 0x30(%rcx), %rax
movq %rax, 0x30(%rbx)
movl $0x30, %r14d
movq %rsp, %rbx
movq 0x98(%rsp,%r14), %rbp
testq %rbp, %rbp
je 0x181b24
movl 0x1c(%rbp), %eax
andl $0x7c, %eax
cmpl $0x20, %eax
je 0x181b26
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x181b81
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x20(%rax)
testb $0xc, 0x52(%rax)
jne 0x181b47
movq %rax, %rdi
callq 0xc7d6a
testl %eax, %eax
je 0x181b81
movq 0xc0(%r15), %rdi
movq %r13, %rsi
callq 0x1c5e4e
movq %rax, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x890, %edx # imm = 0x890
xorl %ecx, %ecx
callq 0x1cddc2
testq %rax, %rax
je 0x181b81
movq %rax, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x96fba
addq $0x40, %r14
cmpq $0xb0, %r14
jne 0x181b0c
movl $0x40, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x98, %rdi
callq 0x1c6a58
addq $-0x40, %rbx
cmpq $-0x40, %rbx
jne 0x181b97
movq 0x88(%rsp), %rax
cmpq 0x48(%rsp), %rax
setne %al
shlb $0x2, %al
movq 0xb0(%r15), %rbx
movzbl %al, %esi
movq 0x8(%rsp), %rdi
callq *0x10(%rsp)
movl %eax, %ebp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1c636c
movb %bpl, (%rax)
leaq 0x58(%rsp), %rdi
callq 0x1c6a58
leaq 0x18(%rsp), %rdi
callq 0x1c6a58
andb $0x1, %r12b
movl %r12d, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
clang::interp::Integral<8u, false> const& clang::interp::InterpFrame::getParam<clang::interp::Integral<8u, false>>(unsigned int) const
|
const T &getParam(unsigned Offset) const {
auto Pt = Params.find(Offset);
if (Pt == Params.end())
return stackRef<T>(Offset);
return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0xb0, %rdi
movq %rax, %rsi
callq 0x1744d4
movl 0xc0(%rbx), %ecx
shlq $0x4, %rcx
addq 0xb0(%rbx), %rcx
cmpq %rcx, %rax
je 0x18221e
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c6960
movq %rbx, %rdi
callq 0x13109a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c6a58
jmp 0x182235
movl 0x4(%rsp), %eax
movq 0x98(%rbx), %r14
movl 0x90(%rbx), %ecx
subq %rcx, %r14
addq %rax, %r14
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/AST/Interp/InterpFrame.h
|
clang::interp::Integral<32u, false> const& clang::interp::InterpFrame::getParam<clang::interp::Integral<32u, false>>(unsigned int) const
|
const T &getParam(unsigned Offset) const {
auto Pt = Params.find(Offset);
if (Pt == Params.end())
return stackRef<T>(Offset);
return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0xb0, %rdi
movq %rax, %rsi
callq 0x1744d4
movl 0xc0(%rbx), %ecx
shlq $0x4, %rcx
addq 0xb0(%rbx), %rcx
cmpq %rcx, %rax
je 0x182416
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c6960
movq %rbx, %rdi
callq 0x1312c8
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c6a58
jmp 0x18242d
movl 0x4(%rsp), %eax
movq 0x98(%rbx), %r14
movl 0x90(%rbx), %ecx
subq %rcx, %r14
addq %rax, %r14
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/AST/Interp/InterpFrame.h
|
bool clang::interp::IncDecHelper<clang::interp::Integral<32u, true>, (clang::interp::IncDecOp)0, (clang::interp::PushVal)1>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Pointer const&)
|
bool IncDecHelper(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
assert(!Ptr.isDummy());
if constexpr (std::is_same_v<T, Boolean>) {
if (!S.getLangOpts().CPlusPlus14)
return Invalid(S, OpPC);
}
const T &Value = Ptr.deref<T>();
T Result;
if constexpr (DoPush == PushVal::Yes)
S.Stk.push<T>(Value);
if constexpr (Op == IncDecOp::Inc) {
if (!T::increment(Value, &Result)) {
Ptr.deref<T>() = Result;
return true;
}
} else {
if (!T::decrement(Value, &Result)) {
Ptr.deref<T>() = Result;
return true;
}
}
// Something went wrong with the previous operation. Compute the
// result with another bit of precision.
unsigned Bits = Value.bitWidth() + 1;
APSInt APResult;
if constexpr (Op == IncDecOp::Inc)
APResult = ++Value.toAPSInt(Bits);
else
APResult = --Value.toAPSInt(Bits);
// Report undefined behaviour, stopping if required.
const Expr *E = S.Current->getExpr(OpPC);
QualType Type = E->getType();
if (S.checkingForUndefinedBehavior()) {
SmallString<32> Trunc;
APResult.trunc(Result.bitWidth())
.toString(Trunc, 10, Result.isSigned(), /*formatAsCLiteral=*/false,
/*UpperCase=*/true, /*InsertSeparators=*/true);
auto Loc = E->getExprLoc();
S.report(Loc, diag::warn_integer_constant_overflow)
<< Trunc << Type << E->getSourceRange();
return true;
}
S.CCEDiag(E, diag::note_constexpr_overflow) << APResult << Type;
return S.noteUndefinedBehavior();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x13123e
movq %rax, %r12
movq 0xb0(%rbx), %rdi
movl $0x8, %esi
callq 0x1c636c
movl (%r12), %ecx
movl %ecx, (%rax)
movl (%r12), %ebp
incl %ebp
jno 0x183032
leaq 0x10(%rsp), %r15
movl $0x1, 0x8(%r15)
movq $0x0, (%r15)
movb $0x0, 0xc(%r15)
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl $0x21, %edx
callq 0x176dcc
movq %r13, %rdi
callq 0x70e2e
movq %r15, %rdi
movq %r13, %rsi
callq 0x717ba
movb 0xc(%r13), %al
movb %al, 0xc(%r15)
cmpl $0x41, 0x8(%r13)
jb 0x182ede
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x182ede
callq 0x3c180
movq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1c5ea4
movq %rax, %r15
movq 0x8(%rax), %r14
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x183040
leaq 0x68(%rsp), %rbp
movq %rbp, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x20, -0x8(%rbp)
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x20, %edx
callq 0x72174
movb 0xc(%r13), %al
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %r13
movl %ecx, 0x8(%r13)
movq (%r12), %rcx
movq %rcx, (%r13)
movb %al, 0xc(%r13)
movl $0x1, (%rsp)
leaq 0x50(%rsp), %rsi
movq %r13, %rdi
movl $0xa, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x74aea
cmpl $0x41, 0x8(%r13)
jb 0x182f94
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x182f94
callq 0x3c180
movq %r15, %rdi
callq 0xd4508
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x92b, %ecx # imm = 0x92B
callq 0x1cdee6
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x964fa
cmpq $0x0, (%r12)
jne 0x182fdb
movq 0x38(%rsp), %rdi
callq 0x9658c
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rbx
movq (%rbx), %rax
movzbl (%rax), %ecx
movb $0x8, 0x1(%rax,%rcx)
movq (%rbx), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r14, 0x10(%rax,%rcx,8)
movq %r15, %rdi
callq 0x20ebb6
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movb $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe7ed8
movq %rbx, %rdi
callq 0x9646e
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x18302e
callq 0x3c3a0
movb $0x1, %bl
jmp 0x183085
movq %r15, %rdi
callq 0x13123e
movl %ebp, (%rax)
movb $0x1, %bl
jmp 0x18309b
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8d3, %edx # imm = 0x8D3
xorl %ecx, %ecx
callq 0x1cdd9c
leaq 0x50(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
callq 0xeb980
movq (%rax), %rdi
testq %rdi, %rdi
je 0x183079
movq %r14, %rsi
movl $0x8, %edx
callq 0x96fba
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebx
cmpl $0x41, 0x18(%rsp)
jb 0x18309b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18309b
callq 0x3c180
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::IncDecHelper<clang::interp::IntegralAP<true>, (clang::interp::IncDecOp)0, (clang::interp::PushVal)1>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Pointer const&)
|
bool IncDecHelper(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
assert(!Ptr.isDummy());
if constexpr (std::is_same_v<T, Boolean>) {
if (!S.getLangOpts().CPlusPlus14)
return Invalid(S, OpPC);
}
const T &Value = Ptr.deref<T>();
T Result;
if constexpr (DoPush == PushVal::Yes)
S.Stk.push<T>(Value);
if constexpr (Op == IncDecOp::Inc) {
if (!T::increment(Value, &Result)) {
Ptr.deref<T>() = Result;
return true;
}
} else {
if (!T::decrement(Value, &Result)) {
Ptr.deref<T>() = Result;
return true;
}
}
// Something went wrong with the previous operation. Compute the
// result with another bit of precision.
unsigned Bits = Value.bitWidth() + 1;
APSInt APResult;
if constexpr (Op == IncDecOp::Inc)
APResult = ++Value.toAPSInt(Bits);
else
APResult = --Value.toAPSInt(Bits);
// Report undefined behaviour, stopping if required.
const Expr *E = S.Current->getExpr(OpPC);
QualType Type = E->getType();
if (S.checkingForUndefinedBehavior()) {
SmallString<32> Trunc;
APResult.trunc(Result.bitWidth())
.toString(Trunc, 10, Result.isSigned(), /*formatAsCLiteral=*/false,
/*UpperCase=*/true, /*InsertSeparators=*/true);
auto Loc = E->getExprLoc();
S.report(Loc, diag::warn_integer_constant_overflow)
<< Trunc << Type << E->getSourceRange();
return true;
}
S.CCEDiag(E, diag::note_constexpr_overflow) << APResult << Type;
return S.noteUndefinedBehavior();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x13150a
movq %rax, %r15
movl $0x3, 0x28(%rsp)
movq $0x7, 0x20(%rsp)
movq 0xb0(%rbx), %rdi
movq %rax, %rsi
callq 0x17e49c
movl 0x8(%r15), %eax
movl %eax, 0x38(%rsp)
cmpl $0x40, %eax
ja 0x1837fc
movq (%r15), %rax
movq %rax, 0x30(%rsp)
jmp 0x183809
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x70bce
leaq 0x30(%rsp), %r13
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x183ab4
movl %eax, %ebp
cmpl $0x41, 0x8(%r13)
jb 0x183833
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x183833
callq 0x3c180
testb %bpl, %bpl
je 0x183a16
movl 0x8(%r15), %edx
xorl %ebp, %ebp
movl $0x1, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movb %bpl, 0x1c(%rsp)
incl %edx
jne 0x183860
movl 0x8(%r15), %edx
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x72292
movl 0x8(%r12), %eax
leaq 0x40(%rsp), %r15
movl %eax, 0x8(%r15)
movq (%r12), %rax
movq %rax, (%r15)
movb %bpl, 0xc(%r15)
movq %r15, %rdi
callq 0x70e2e
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x717ba
movb 0xc(%r15), %al
movb %al, 0xc(%r12)
cmpl $0x41, 0x8(%r15)
jb 0x1838c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1838c0
callq 0x3c180
movq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1c5ea4
movq %rax, %r15
movq 0x8(%rax), %r14
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x183a2f
leaq 0x88(%rsp), %rbp
movq %rbp, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x20, -0x8(%rbp)
movl 0x28(%rsp), %edx
leaq 0x40(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x72174
movb 0xc(%r13), %al
movl 0x8(%r12), %ecx
leaq 0x60(%rsp), %r13
movl %ecx, 0x8(%r13)
movq (%r12), %rcx
movq %rcx, (%r13)
movb %al, 0xc(%r13)
movl $0x1, (%rsp)
leaq 0x70(%rsp), %rsi
movq %r13, %rdi
movl $0xa, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x74aea
cmpl $0x41, 0x8(%r13)
jb 0x183978
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x183978
callq 0x3c180
movq %r15, %rdi
callq 0xd4508
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x92b, %ecx # imm = 0x92B
callq 0x1cdee6
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rdi
callq 0x964fa
cmpq $0x0, (%r12)
jne 0x1839bf
movq 0x48(%rsp), %rdi
callq 0x9658c
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rbx
movq (%rbx), %rax
movzbl (%rax), %ecx
movb $0x8, 0x1(%rax,%rcx)
movq (%rbx), %rax
movzbl (%rax), %ecx
leal 0x1(%rcx), %edx
movb %dl, (%rax)
movq %r14, 0x10(%rax,%rcx,8)
movq %r15, %rdi
callq 0x20ebb6
leaq 0x60(%rsp), %rsi
movq %rax, (%rsi)
movb $0x1, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe7ed8
movq %rbx, %rdi
callq 0x9646e
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x183a12
callq 0x3c3a0
movb $0x1, %bl
jmp 0x183a74
movq %r12, %rdi
callq 0x13150a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x717ba
movb $0x1, %bl
jmp 0x183a8a
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8d3, %edx # imm = 0x8D3
xorl %ecx, %ecx
callq 0x1cdd9c
leaq 0x70(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
callq 0xeb980
movq (%rax), %rdi
testq %rdi, %rdi
je 0x183a68
movq %r14, %rsi
movl $0x8, %edx
callq 0x96fba
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebx
cmpl $0x41, 0x18(%rsp)
jb 0x183a8a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x183a8a
callq 0x3c180
cmpl $0x41, 0x28(%rsp)
jb 0x183aa0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x183aa0
callq 0x3c180
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::DoShift<clang::interp::IntegralAP<false>, clang::interp::Integral<8u, false>, (clang::interp::ShiftDir)1>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<false>&, clang::interp::Integral<8u, false>&)
|
inline bool DoShift(InterpState &S, CodePtr OpPC, LT &LHS, RT &RHS) {
const unsigned Bits = LHS.bitWidth();
// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (S.getLangOpts().OpenCL)
RT::bitAnd(RHS, RT::from(LHS.bitWidth() - 1, RHS.bitWidth()),
RHS.bitWidth(), &RHS);
if (RHS.isNegative()) {
// During constant-folding, a negative shift is an opposite shift. Such a
// shift is not a constant expression.
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false;
RHS = -RHS;
return DoShift < LT, RT,
Dir == ShiftDir::Left ? ShiftDir::Right
: ShiftDir::Left > (S, OpPC, LHS, RHS);
}
if constexpr (Dir == ShiftDir::Left) {
if (LHS.isNegative() && !S.getLangOpts().CPlusPlus20) {
// C++11 [expr.shift]p2: A signed left shift must have a non-negative
// operand, and must not overflow the corresponding unsigned type.
// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
// E1 x 2^E2 module 2^N.
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_lshift_of_negative) << LHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false;
}
}
if (!CheckShift(S, OpPC, LHS, RHS, Bits))
return false;
// Limit the shift amount to Bits - 1. If this happened,
// it has already been diagnosed by CheckShift() above,
// but we still need to handle it.
typename LT::AsUnsigned R;
if constexpr (Dir == ShiftDir::Left) {
if (RHS > RT::from(Bits - 1, RHS.bitWidth()))
LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(Bits - 1), Bits, &R);
else
LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(RHS, Bits), Bits, &R);
} else {
if (RHS > RT::from(Bits - 1, RHS.bitWidth()))
LT::AsUnsigned::shiftRight(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(Bits - 1), Bits, &R);
else
LT::AsUnsigned::shiftRight(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(RHS, Bits), Bits, &R);
}
S.Stk.push<LT>(LT::from(R));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdx), %r15d
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x19b9e1
movb 0x8(%r13), %al
decb %al
andb %al, (%r12)
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %r15d, %r8d
callq 0x19bc0e
movl %eax, %ebx
testb %al, %al
je 0x19bbfa
movl $0x3, 0x10(%rsp)
movq $0x7, 0x8(%rsp)
leal -0x1(%r15), %ebp
movl 0x8(%r13), %eax
cmpb %bpl, (%r12)
jbe 0x19ba32
movl %eax, 0x30(%rsp)
cmpl $0x40, %eax
ja 0x19ba4d
movq (%r13), %rax
movq %rax, 0x28(%rsp)
jmp 0x19ba5a
movl %eax, 0x20(%rsp)
cmpl $0x40, %eax
ja 0x19bad0
movq (%r13), %rax
movq %rax, 0x18(%rsp)
jmp 0x19badd
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x70bce
leaq 0x58(%rsp), %r12
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x17c5c2
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x17ae68
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x19b5d8
cmpl $0x41, 0x8(%r13)
jb 0x19baa8
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x19baa8
callq 0x3c180
cmpl $0x41, 0x60(%rsp)
jb 0x19babe
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x19babe
callq 0x3c180
cmpl $0x41, 0x30(%rsp)
setb %al
movq 0x28(%rsp), %rdi
jmp 0x19bb53
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x70bce
leaq 0x48(%rsp), %r13
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x17c5c2
movzbl (%r12), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movl %r15d, %edx
callq 0x17c140
leaq 0x8(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x19b5d8
cmpl $0x41, 0x8(%r12)
jb 0x19bb30
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x19bb30
callq 0x3c180
cmpl $0x41, 0x50(%rsp)
jb 0x19bb46
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x19bb46
callq 0x3c180
cmpl $0x41, 0x20(%rsp)
setb %al
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x19bb62
callq 0x3c180
movq 0xb0(%r14), %r14
movl 0x10(%rsp), %eax
movl %eax, 0x40(%rsp)
cmpl $0x40, %eax
ja 0x19bb82
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x19bb91
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x70bce
leaq 0x88(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x17c5c2
movl $0x10, %esi
movq %r14, %rdi
callq 0x1c636c
movl 0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%r15)
cmpl $0x41, 0x8(%r12)
jb 0x19bbe4
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x19bbe4
callq 0x3c180
cmpl $0x41, 0x10(%rsp)
jb 0x19bbfa
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19bbfa
callq 0x3c180
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::DoShift<clang::interp::IntegralAP<false>, clang::interp::IntegralAP<false>, (clang::interp::ShiftDir)0>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<false>&, clang::interp::IntegralAP<false>&)
|
inline bool DoShift(InterpState &S, CodePtr OpPC, LT &LHS, RT &RHS) {
const unsigned Bits = LHS.bitWidth();
// OpenCL 6.3j: shift values are effectively % word size of LHS.
if (S.getLangOpts().OpenCL)
RT::bitAnd(RHS, RT::from(LHS.bitWidth() - 1, RHS.bitWidth()),
RHS.bitWidth(), &RHS);
if (RHS.isNegative()) {
// During constant-folding, a negative shift is an opposite shift. Such a
// shift is not a constant expression.
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false;
RHS = -RHS;
return DoShift < LT, RT,
Dir == ShiftDir::Left ? ShiftDir::Right
: ShiftDir::Left > (S, OpPC, LHS, RHS);
}
if constexpr (Dir == ShiftDir::Left) {
if (LHS.isNegative() && !S.getLangOpts().CPlusPlus20) {
// C++11 [expr.shift]p2: A signed left shift must have a non-negative
// operand, and must not overflow the corresponding unsigned type.
// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
// E1 x 2^E2 module 2^N.
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.CCEDiag(Loc, diag::note_constexpr_lshift_of_negative) << LHS.toAPSInt();
if (!S.noteUndefinedBehavior())
return false;
}
}
if (!CheckShift(S, OpPC, LHS, RHS, Bits))
return false;
// Limit the shift amount to Bits - 1. If this happened,
// it has already been diagnosed by CheckShift() above,
// but we still need to handle it.
typename LT::AsUnsigned R;
if constexpr (Dir == ShiftDir::Left) {
if (RHS > RT::from(Bits - 1, RHS.bitWidth()))
LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(Bits - 1), Bits, &R);
else
LT::AsUnsigned::shiftLeft(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(RHS, Bits), Bits, &R);
} else {
if (RHS > RT::from(Bits - 1, RHS.bitWidth()))
LT::AsUnsigned::shiftRight(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(Bits - 1), Bits, &R);
else
LT::AsUnsigned::shiftRight(LT::AsUnsigned::from(LHS),
LT::AsUnsigned::from(RHS, Bits), Bits, &R);
}
S.Stk.push<LT>(LT::from(R));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movl 0x8(%rdx), %r12d
callq 0x1ce21c
testb $0x40, 0x2f(%rax)
je 0x19e975
movl 0x8(%r14), %eax
movl %eax, 0x68(%rsp)
cmpl $0x40, %eax
ja 0x19e90c
movq (%r14), %rax
movq %rax, 0x60(%rsp)
jmp 0x19e919
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x70bce
movl 0x8(%r15), %esi
decl %esi
movl 0x8(%r14), %edx
leaq 0xc8(%rsp), %rbp
movq %rbp, %rdi
callq 0x17ae68
movl 0x8(%r14), %edx
leaq 0x60(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x17b250
cmpl $0x41, 0x8(%rbp)
jb 0x19e95f
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x19e95f
callq 0x3c180
cmpl $0x41, 0x68(%rsp)
jb 0x19e975
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x19e975
callq 0x3c180
movl 0x8(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $-0x8, %edx
addq (%r14), %rdx
cmpl $0x41, %eax
cmovbq %r14, %rdx
movq (%rdx), %rax
btq %rcx, %rax
jae 0x19ea76
movq 0xc0(%rbx), %rdi
movq %r13, 0x10(%rsp)
movq %r13, %rsi
callq 0x1c5e4e
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
movl $0x8c0, %edx # imm = 0x8C0
xorl %ecx, %ecx
callq 0x1cddc2
leaq 0x58(%rsp), %r12
movq %rax, (%r12)
movl 0x8(%r14), %edx
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x71560
movl 0x8(%rbp), %eax
leaq 0x18(%rsp), %r13
movl %eax, 0x8(%r13)
movq (%rbp), %rax
movq %rax, (%r13)
movb $0x1, 0xc(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0xeb980
cmpl $0x41, 0x8(%r13)
jb 0x19ea1e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19ea1e
callq 0x3c180
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x19ebca
movq %rsp, %rdi
movq %r14, %rsi
callq 0x188d60
cmpl $0x41, 0x8(%r14)
jb 0x19ea4f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19ea4f
callq 0x3c180
movq (%rsp), %rax
movq %rax, (%r14)
movl 0x8(%rsp), %eax
movl %eax, 0x8(%r14)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x19edfb
jmp 0x19ede9
movl 0x8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $-0x8, %edx
addq (%r15), %rdx
cmpl $0x41, %eax
cmovbq %r15, %rdx
movq (%rdx), %rax
btq %rcx, %rax
jae 0x19eb49
movq %rbx, %rdi
callq 0x1ce21c
testb $0x40, 0x1(%rax)
jne 0x19eb49
movq 0xc0(%rbx), %rdi
movq %r13, 0x10(%rsp)
movq %r13, %rsi
callq 0x1c5e4e
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
movl $0x8af, %edx # imm = 0x8AF
xorl %ecx, %ecx
callq 0x1cddc2
leaq 0x58(%rsp), %rcx
movq %rax, (%rcx)
movl 0x8(%r15), %edx
movq %rsp, %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x71560
movl 0x8(%rbp), %eax
leaq 0x18(%rsp), %r13
movl %eax, 0x8(%r13)
movq (%rbp), %rax
movq %rax, (%r13)
movb $0x1, 0xc(%r13)
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
callq 0xeb980
cmpl $0x41, 0x8(%r13)
jb 0x19eb32
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19eb32
callq 0x3c180
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
movq 0x10(%rsp), %r13
je 0x19ebca
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %r12d, %r8d
callq 0x19f261
testb %al, %al
je 0x19ebca
movl $0x3, 0x8(%rsp)
movq $0x7, (%rsp)
leal -0x1(%r12), %esi
movl 0x8(%r14), %edx
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movl %esi, 0x10(%rsp)
callq 0x17ae68
movq %r14, %rdi
movq %rbp, %rsi
callq 0x71422
movl %eax, %r13d
cmpl $0x41, 0x8(%rbp)
jb 0x19ebae
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19ebae
callq 0x3c180
movl 0x8(%r15), %eax
testl %r13d, %r13d
jle 0x19ebd1
movl %eax, 0x50(%rsp)
cmpl $0x40, %eax
ja 0x19ebeb
movq (%r15), %rax
movq %rax, 0x48(%rsp)
jmp 0x19ebf8
xorl %eax, %eax
jmp 0x19ede9
movl %eax, 0x40(%rsp)
cmpl $0x40, %eax
ja 0x19ec7d
movq (%r15), %rax
movq %rax, 0x38(%rsp)
jmp 0x19ec8a
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x70bce
leaq 0x98(%rsp), %r14
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x17c5c2
leaq 0xb8(%rsp), %r15
movq %r15, %rdi
movl 0x10(%rsp), %esi
xorl %edx, %edx
callq 0x17ae68
movq %rsp, %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x19b540
cmpl $0x41, 0x8(%r15)
jb 0x19ec4f
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x19ec4f
callq 0x3c180
cmpl $0x41, 0xa0(%rsp)
jb 0x19ec6b
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x19ec6b
callq 0x3c180
cmpl $0x41, 0x50(%rsp)
setb %al
movq 0x48(%rsp), %rdi
jmp 0x19ed48
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x70bce
leaq 0x80(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x17c5c2
movl 0x8(%r14), %eax
movl %eax, 0x30(%rsp)
cmpl $0x40, %eax
ja 0x19ecb5
movq (%r14), %rax
movq %rax, 0x28(%rsp)
jmp 0x19ecc2
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x70bce
leaq 0xa8(%rsp), %r14
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0x17c5c2
leaq 0x80(%rsp), %rdi
movq %rsp, %rcx
movq %r14, %rsi
movl %r12d, %edx
callq 0x19b540
cmpl $0x41, 0x8(%r14)
jb 0x19ed09
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x19ed09
callq 0x3c180
cmpl $0x41, 0x30(%rsp)
jb 0x19ed1f
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19ed1f
callq 0x3c180
cmpl $0x41, 0x88(%rsp)
jb 0x19ed3b
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x19ed3b
callq 0x3c180
cmpl $0x41, 0x40(%rsp)
setb %al
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x19ed57
callq 0x3c180
movq 0xb0(%rbx), %rbx
movl 0x8(%rsp), %eax
movl %eax, 0x78(%rsp)
cmpl $0x40, %eax
ja 0x19ed76
movq (%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x19ed83
leaq 0x70(%rsp), %rdi
movq %rsp, %rsi
callq 0x70bce
leaq 0x18(%rsp), %r14
leaq 0x70(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x17c5c2
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1c636c
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
movq (%r14), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%r14)
cmpl $0x41, 0x8(%r15)
jb 0x19edd2
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x19edd2
callq 0x3c180
cmpl $0x41, 0x8(%rsp)
jb 0x19ede7
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19ede7
callq 0x3c180
movb $0x1, %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.h
|
bool clang::interp::OffsetHelper<clang::interp::Integral<8u, true>, (clang::interp::ArithOp)1>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Integral<8u, true> const&, clang::interp::Pointer const&)
|
bool OffsetHelper(InterpState &S, CodePtr OpPC, const T &Offset,
const Pointer &Ptr) {
// A zero offset does not change the pointer.
if (Offset.isZero()) {
S.Stk.push<Pointer>(Ptr);
return true;
}
if (!CheckNull(S, OpPC, Ptr, CSK_ArrayIndex)) {
// The CheckNull will have emitted a note already, but we only
// abort in C++, since this is fine in C.
if (S.getLangOpts().CPlusPlus)
return false;
}
// Arrays of unknown bounds cannot have pointers into them.
if (!CheckArray(S, OpPC, Ptr))
return false;
uint64_t MaxIndex = static_cast<uint64_t>(Ptr.getNumElems());
uint64_t Index;
if (Ptr.isOnePastEnd())
Index = MaxIndex;
else
Index = Ptr.getIndex();
bool Invalid = false;
// Helper to report an invalid offset, computed as APSInt.
auto DiagInvalidOffset = [&]() -> void {
const unsigned Bits = Offset.bitWidth();
APSInt APOffset(Offset.toAPSInt().extend(Bits + 2), /*IsUnsigend=*/false);
APSInt APIndex(APInt(Bits + 2, Index, /*IsSigned=*/true),
/*IsUnsigned=*/false);
APSInt NewIndex =
(Op == ArithOp::Add) ? (APIndex + APOffset) : (APIndex - APOffset);
S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
<< NewIndex << /*array*/ static_cast<int>(!Ptr.inArray()) << MaxIndex;
Invalid = true;
};
if (Ptr.isBlockPointer()) {
uint64_t IOffset = static_cast<uint64_t>(Offset);
uint64_t MaxOffset = MaxIndex - Index;
if constexpr (Op == ArithOp::Add) {
// If the new offset would be negative, bail out.
if (Offset.isNegative() && (Offset.isMin() || -IOffset > Index))
DiagInvalidOffset();
// If the new offset would be out of bounds, bail out.
if (Offset.isPositive() && IOffset > MaxOffset)
DiagInvalidOffset();
} else {
// If the new offset would be negative, bail out.
if (Offset.isPositive() && Index < IOffset)
DiagInvalidOffset();
// If the new offset would be out of bounds, bail out.
if (Offset.isNegative() && (Offset.isMin() || -IOffset > MaxOffset))
DiagInvalidOffset();
}
}
if (Invalid && S.getLangOpts().CPlusPlus)
return false;
// Offset is valid - compute it on unsigned.
int64_t WideIndex = static_cast<int64_t>(Index);
int64_t WideOffset = static_cast<int64_t>(Offset);
int64_t Result;
if constexpr (Op == ArithOp::Add)
Result = WideIndex + WideOffset;
else
Result = WideIndex - WideOffset;
// When the pointer is one-past-end, going back to index 0 is the only
// useful thing we can do. Any other index has been diagnosed before and
// we don't get here.
if (Result == 0 && Ptr.isOnePastEnd()) {
S.Stk.push<Pointer>(Ptr.asBlockPointer().Pointee,
Ptr.asBlockPointer().Base);
return true;
}
S.Stk.push<Pointer>(Ptr.atIndex(static_cast<uint64_t>(Result)));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
cmpb $0x0, (%rdx)
je 0x1a7362
movq %rdx, %r15
movq %r14, %rdi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x1b3355
testb %al, %al
jne 0x1a7328
movq %r14, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0x1a746b
movq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1b3029
testb %al, %al
je 0x1a746b
movq %rbx, %rdi
callq 0x174c2a
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x174c60
testb %al, %al
je 0x1a7383
movq 0x8(%rsp), %r12
jmp 0x1a738e
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c636c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c69ec
jmp 0x1a74a9
movq %rbx, %rdi
callq 0x174cd6
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %r12, (%rax)
leaq 0x7(%rsp), %rcx
movb $0x0, (%rcx)
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %r14, 0x30(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
cmpl $0x0, 0x28(%rbx)
jne 0x1a741a
movb (%r15), %al
movsbq %al, %r13
movq 0x8(%rsp), %rbp
testb %r13b, %r13b
setns %al
cmpq %r13, %r12
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1a73fa
leaq 0x20(%rsp), %rdi
callq 0x1a74be
movb (%r15), %al
testb %al, %al
jns 0x1a741a
negb %al
jo 0x1a7410
subq %r12, %rbp
negq %r13
cmpq %r13, %rbp
jae 0x1a741a
leaq 0x20(%rsp), %rdi
callq 0x1a74be
cmpb $0x1, 0x7(%rsp)
jne 0x1a742f
movq %r14, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0x1a746b
movq 0x18(%rsp), %r12
movsbq (%r15), %rax
subq %rax, %r12
jne 0x1a746f
movq %rbx, %rdi
callq 0x174c60
testb %al, %al
je 0x1a746f
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c636c
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %rax, %rdi
callq 0x1c69c0
jmp 0x1a74a9
xorl %eax, %eax
jmp 0x1a74ab
movq 0xb0(%r14), %r14
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x17465e
movl $0x30, %esi
movq %r14, %rdi
callq 0x1c636c
movq %rax, %rdi
movq %r15, %rsi
callq 0x1c6a24
movq %r15, %rdi
callq 0x1c6a58
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Interp/Interp.h
|
bool clang::interp::OffsetHelper<clang::interp::IntegralAP<false>, (clang::interp::ArithOp)1>(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::IntegralAP<false> const&, clang::interp::Pointer const&)
|
bool OffsetHelper(InterpState &S, CodePtr OpPC, const T &Offset,
const Pointer &Ptr) {
// A zero offset does not change the pointer.
if (Offset.isZero()) {
S.Stk.push<Pointer>(Ptr);
return true;
}
if (!CheckNull(S, OpPC, Ptr, CSK_ArrayIndex)) {
// The CheckNull will have emitted a note already, but we only
// abort in C++, since this is fine in C.
if (S.getLangOpts().CPlusPlus)
return false;
}
// Arrays of unknown bounds cannot have pointers into them.
if (!CheckArray(S, OpPC, Ptr))
return false;
uint64_t MaxIndex = static_cast<uint64_t>(Ptr.getNumElems());
uint64_t Index;
if (Ptr.isOnePastEnd())
Index = MaxIndex;
else
Index = Ptr.getIndex();
bool Invalid = false;
// Helper to report an invalid offset, computed as APSInt.
auto DiagInvalidOffset = [&]() -> void {
const unsigned Bits = Offset.bitWidth();
APSInt APOffset(Offset.toAPSInt().extend(Bits + 2), /*IsUnsigend=*/false);
APSInt APIndex(APInt(Bits + 2, Index, /*IsSigned=*/true),
/*IsUnsigned=*/false);
APSInt NewIndex =
(Op == ArithOp::Add) ? (APIndex + APOffset) : (APIndex - APOffset);
S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
<< NewIndex << /*array*/ static_cast<int>(!Ptr.inArray()) << MaxIndex;
Invalid = true;
};
if (Ptr.isBlockPointer()) {
uint64_t IOffset = static_cast<uint64_t>(Offset);
uint64_t MaxOffset = MaxIndex - Index;
if constexpr (Op == ArithOp::Add) {
// If the new offset would be negative, bail out.
if (Offset.isNegative() && (Offset.isMin() || -IOffset > Index))
DiagInvalidOffset();
// If the new offset would be out of bounds, bail out.
if (Offset.isPositive() && IOffset > MaxOffset)
DiagInvalidOffset();
} else {
// If the new offset would be negative, bail out.
if (Offset.isPositive() && Index < IOffset)
DiagInvalidOffset();
// If the new offset would be out of bounds, bail out.
if (Offset.isNegative() && (Offset.isMin() || -IOffset > MaxOffset))
DiagInvalidOffset();
}
}
if (Invalid && S.getLangOpts().CPlusPlus)
return false;
// Offset is valid - compute it on unsigned.
int64_t WideIndex = static_cast<int64_t>(Index);
int64_t WideOffset = static_cast<int64_t>(Offset);
int64_t Result;
if constexpr (Op == ArithOp::Add)
Result = WideIndex + WideOffset;
else
Result = WideIndex - WideOffset;
// When the pointer is one-past-end, going back to index 0 is the only
// useful thing we can do. Any other index has been diagnosed before and
// we don't get here.
if (Result == 0 && Ptr.isOnePastEnd()) {
S.Stk.push<Pointer>(Ptr.asBlockPointer().Pointee,
Ptr.asBlockPointer().Base);
return true;
}
S.Stk.push<Pointer>(Ptr.atIndex(static_cast<uint64_t>(Result)));
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, 0x20(%rsp)
movl 0x8(%rdx), %ebp
cmpl $0x40, %ebp
ja 0x1a8a8a
cmpq $0x0, (%r15)
jmp 0x1a8a94
movq %r15, %rdi
callq 0x71b6c
cmpl %ebp, %eax
sete %al
testb %al, %al
je 0x1a8abe
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c636c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c69ec
movb $0x1, %al
jmp 0x1a8bca
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x1b3355
testb %al, %al
jne 0x1a8ae7
movq %r14, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0x1a8bc8
movq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1b3029
testb %al, %al
je 0x1a8bc8
movq %rbx, %rdi
callq 0x174c2a
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x174c60
testb %al, %al
je 0x1a8b21
movq 0x10(%rsp), %rax
jmp 0x1a8b29
movq %rbx, %rdi
callq 0x174cd6
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
movq %r15, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r14, 0x40(%rsp)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
leaq 0x10(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq %rax, 0x60(%rsp)
cmpl $0x0, 0x28(%rbx)
je 0x1a8c1b
cmpb $0x1, 0xf(%rsp)
jne 0x1a8b85
movq %r14, %rdi
callq 0x1ce21c
testb $0x4, 0x1(%rax)
jne 0x1a8bc8
movq 0x18(%rsp), %r12
movq %r15, %rdi
callq 0x1797ac
subq %rax, %r12
jne 0x1a8bdc
movq %rbx, %rdi
callq 0x174c60
testb %al, %al
je 0x1a8bdc
movq 0xb0(%r14), %rdi
movl $0x30, %esi
callq 0x1c636c
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %rax, %rdi
callq 0x1c69c0
jmp 0x1a8ab7
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb0(%r14), %r14
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x17465e
movl $0x30, %esi
movq %r14, %rdi
callq 0x1c636c
movq %rax, %rdi
movq %r15, %rsi
callq 0x1c6a24
movq %r15, %rdi
callq 0x1c6a58
jmp 0x1a8ab7
movq %r15, %rdi
callq 0x17973c
movq %rax, %r12
movl 0x8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $-0x8, %edx
addq (%r15), %rdx
movq 0x10(%rsp), %rsi
movq %rsi, 0x28(%rsp)
cmpl $0x41, %eax
cmovbq %r15, %rdx
movq 0x18(%rsp), %rbp
movq (%rdx), %rax
btq %rcx, %rax
setae %al
cmpq %r12, %rbp
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1a8c6f
leaq 0x30(%rsp), %rdi
callq 0x1a8cd8
movl 0x8(%r15), %r13d
leal -0x1(%r13), %eax
movl %eax, %ecx
shrl $0x3, %ecx
andl $-0x8, %ecx
addq (%r15), %rcx
cmpl $0x41, %r13d
cmovbq %r15, %rcx
movq (%rcx), %rcx
btq %rax, %rcx
jae 0x1a8b70
cmpl $0x40, %r13d
ja 0x1a8ca3
cmpq $0x0, (%r15)
jmp 0x1a8cae
movq %r15, %rdi
callq 0x71b6c
cmpl %r13d, %eax
sete %al
testb %al, %al
jne 0x1a8cc9
movq 0x28(%rsp), %rax
subq %rbp, %rax
negq %r12
cmpq %r12, %rax
jae 0x1a8b70
leaq 0x30(%rsp), %rdi
callq 0x1a8cd8
jmp 0x1a8b70
|
/AST/Interp/Interp.h
|
clang::interp::RunDestructors(clang::interp::InterpState&, clang::interp::CodePtr, clang::interp::Block const*)
|
bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B) {
assert(B);
const Descriptor *Desc = B->getDescriptor();
if (Desc->isPrimitive() || Desc->isPrimitiveArray())
return true;
assert(Desc->isRecord() || Desc->isCompositeArray());
if (Desc->isCompositeArray()) {
const Descriptor *ElemDesc = Desc->ElemDesc;
assert(ElemDesc->isRecord());
Pointer RP(const_cast<Block *>(B));
for (unsigned I = 0; I != Desc->getNumElems(); ++I) {
if (!runRecordDestructor(S, OpPC, RP.atIndex(I).narrow(), ElemDesc))
return false;
}
return true;
}
assert(Desc->isRecord());
return runRecordDestructor(S, OpPC, Pointer(const_cast<Block *>(B)), Desc);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x20(%rdx), %rbx
movb 0x33(%rbx), %al
movb $0x1, %bpl
testb %al, %al
jne 0x1b4eda
cmpq $0x0, 0x18(%rbx)
je 0x1b4fc2
movq 0x20(%rbx), %r15
testq %r15, %r15
sete %cl
testb %cl, %al
jne 0x1b4fc2
testq %r15, %r15
setne %cl
andb %cl, %al
cmpb $0x1, %al
jne 0x1b4f93
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
callq 0x1c6960
xorl %r12d, %r12d
movl 0xc(%rbx), %ecx
movl $0x0, %eax
cmpl $-0x1, %ecx
je 0x1b4f20
movl %ecx, %eax
xorl %edx, %edx
divl 0x8(%rbx)
cmpl %eax, %r12d
sete %bpl
je 0x1b4f8c
movl %r12d, %edx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x17465e
movq %rbx, %r14
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x175dee
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x1b4fd6
movq %r15, %r13
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rbx
callq 0x1c6a58
leaq 0x48(%rsp), %rdi
callq 0x1c6a58
incl %r12d
testb %r15b, %r15b
movq %r13, %r15
jne 0x1b4f0c
leaq 0x18(%rsp), %rdi
jmp 0x1b4fbd
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1c6960
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b4fd6
movl %eax, %ebp
movq %r14, %rdi
callq 0x1c6a58
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Interp/Interp.cpp
|
clang::interp::Record::Record(clang::RecordDecl const*, llvm::SmallVector<clang::interp::Record::Base, 8u>&&, llvm::SmallVector<clang::interp::Record::Field, 8u>&&, llvm::SmallVector<clang::interp::Record::Base, 2u>&&, unsigned int, unsigned int)
|
Record::Record(const RecordDecl *Decl, BaseList &&SrcBases,
FieldList &&SrcFields, VirtualBaseList &&SrcVirtualBases,
unsigned VirtualSize, unsigned BaseSize)
: Decl(Decl), Bases(std::move(SrcBases)), Fields(std::move(SrcFields)),
BaseSize(BaseSize), VirtualSize(VirtualSize), IsUnion(Decl->isUnion()) {
for (Base &V : SrcVirtualBases)
VirtualBases.push_back({ V.Decl, V.Offset + BaseSize, V.Desc, V.R });
for (Base &B : Bases)
BaseMap[B.Decl] = &B;
for (Field &F : Fields)
FieldMap[F.Decl] = &F;
for (Base &V : VirtualBases)
VirtualBaseMap[V.Decl] = &V;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movabsq $0x800000000, %rbp # imm = 0x800000000
movq %rbp, 0x10(%rdi)
cmpl $0x0, 0x8(%rdx)
je 0x1cc892
leaq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x1ccbc0
movl 0x60(%rsp), %r13d
leaq 0x128(%rbx), %rax
movq %rax, 0x118(%rbx)
movq %rbp, 0x120(%rbx)
cmpl $0x0, 0x8(%r12)
je 0x1cc8c3
leaq 0x118(%rbx), %rdi
movq %r12, %rsi
callq 0x1cccd0
leaq 0x1f8(%rbx), %rax
movq %rax, 0x1e8(%rbx)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x1f0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x238(%rbx)
xorl %eax, %eax
movl %eax, 0x248(%rbx)
movups %xmm0, 0x250(%rbx)
movl %eax, 0x260(%rbx)
movups %xmm0, 0x268(%rbx)
movl %eax, 0x278(%rbx)
movl %r13d, 0x280(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x284(%rbx)
movzwl 0x48(%r15), %eax
andl $0xe000, %eax # imm = 0xE000
cmpl $0x4000, %eax # imm = 0x4000
sete 0x288(%rbx)
movl 0x8(%r14), %r12d
testq %r12, %r12
je 0x1cc9b0
leaq 0x1e8(%rbx), %r15
movq (%r14), %rbp
shlq $0x5, %r12
addq %rbp, %r12
leaq 0x8(%rsp), %r14
movq (%rbp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rbp), %eax
addl %r13d, %eax
movl %eax, 0x10(%rsp)
movups 0x10(%rbp), %xmm0
movups %xmm0, 0x18(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cc6ea
movq 0x1e8(%rbx), %rcx
movl 0x1f0(%rbx), %edx
shlq $0x5, %rdx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
incl 0x1f0(%rbx)
addq $0x20, %rbp
cmpq %r12, %rbp
jne 0x1cc954
movl 0x10(%rbx), %r12d
testq %r12, %r12
je 0x1cc9e1
leaq 0x238(%rbx), %r14
movq 0x8(%rbx), %r15
shlq $0x5, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ccdee
movq %r15, 0x8(%rax)
addq $0x20, %r15
addq $-0x20, %r12
jne 0x1cc9c8
movl 0x120(%rbx), %eax
testq %rax, %rax
je 0x1cca1b
leaq 0x250(%rbx), %r14
movq 0x118(%rbx), %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1cd1be
movq %r15, 0x8(%rax)
addq $0x18, %r15
addq $-0x18, %r12
jne 0x1cca02
movl 0x1f0(%rbx), %r15d
testq %r15, %r15
je 0x1cca52
movq 0x1e8(%rbx), %r14
addq $0x268, %rbx # imm = 0x268
shlq $0x5, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cd58e
movq %r14, 0x8(%rax)
addq $0x20, %r14
addq $-0x20, %r15
jne 0x1cca39
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Interp/Record.cpp
|
clang::interp::Record::getBase(clang::QualType) const
|
const Record::Base *Record::getBase(QualType T) const {
if (auto *RT = T->getAs<RecordType>()) {
const RecordDecl *RD = RT->getDecl();
return BaseMap.lookup(RD);
}
return nullptr;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $-0x10, %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x1ccb64
cmpb $0x2e, 0x10(%rdi)
jne 0x1ccb64
callq 0x226c68
addq $0x238, %rbx # imm = 0x238
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1cce3c
testb %al, %al
je 0x1ccb62
movq (%rsp), %rax
movq 0x8(%rax), %rax
jmp 0x1ccb64
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
|
/AST/Interp/Record.cpp
|
(anonymous namespace)::ItaniumMangleContextImpl::mangleCXXVTable(clang::CXXRecordDecl const*, llvm::raw_ostream&)
|
void ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD,
raw_ostream &Out) {
// <special-name> ::= TV <type> # virtual table
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTV";
Mangler.mangleNameOrStandardSubstitution(RD);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdx, %rax
movq %rsi, %r15
leaq 0x38(%rsp), %rcx
movq %rdi, -0x30(%rcx)
movq %rdx, -0x28(%rcx)
movw $0x0, -0x20(%rcx)
movb $0x0, -0x1e(%rcx)
leaq 0x40(%rsp), %rbx
leaq 0x50(%rsp), %rdx
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rdx)
movups %xmm0, -0x30(%rdx)
movq %rdx, -0x10(%rdx)
movabsq $0x400000000, %rsi # imm = 0x400000000
movq %rsi, -0x8(%rdx)
leaq 0xa0(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq %rsi, -0x8(%rdx)
movq %rcx, 0x40(%rdx)
movq $0x0, 0x48(%rdx)
movq %rbx, -0x68(%rdx)
leaq 0x108(%rsp), %r14
movups %xmm0, -0x18(%r14)
xorl %ecx, %ecx
movl %ecx, -0x8(%r14)
movups %xmm0, (%r14)
movl %ecx, 0x10(%r14)
leaq 0x16af0d(%rip), %rsi # 0x33a4d3
movl $0x4, %edx
movq %rax, %rdi
callq 0x577a6
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1e4444
movq %r14, %rdi
callq 0x1d260c
movq (%r14), %rdi
movl 0x10(%r14), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x56dc8
movq -0x18(%r14), %rdi
movl -0x8(%r14), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x56dc8
movq %rbx, %rdi
callq 0x1e36b8
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
|
/AST/ItaniumMangle.cpp
|
(anonymous namespace)::CXXNameMangler::TemplateArgManglingInfo::isOverloadable()
|
bool isOverloadable() {
// Function templates are generally overloadable. As a special case, a
// member function template of a generic lambda is not overloadable.
if (auto *FTD = dyn_cast_or_null<FunctionTemplateDecl>(ResolvedTemplate)) {
auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
if (!RD || !RD->isGenericLambda())
return true;
}
// All other templates are not overloadable. Partial specializations would
// be, but we never mangle them.
return false;
}
|
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x1df67e
movl 0x1c(%rcx), %edx
andl $0x7f, %edx
xorl %eax, %eax
cmpl $0x44, %edx
cmoveq %rcx, %rax
jmp 0x1df680
xorl %eax, %eax
testq %rax, %rax
je 0x1df6be
movq 0x10(%rax), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0x1df697
movq (%rdi), %rdi
movb $0x1, %al
testq %rdi, %rdi
je 0x1df6bd
movzwl 0x8(%rdi), %ecx
andl $0x7f, %ecx
addl $-0x3b, %ecx
cmpl $-0x3, %ecx
jb 0x1df6bd
pushq %rax
addq $-0x40, %rdi
callq 0xc7180
xorb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
|
/AST/ItaniumMangle.cpp
|
clang::MangleContext::mangleObjCMethodName(clang::ObjCMethodDecl const*, llvm::raw_ostream&, bool, bool)
|
void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
raw_ostream &OS,
bool includePrefixByte,
bool includeCategoryNamespace) {
if (getASTContext().getLangOpts().ObjCRuntime.isGNUFamily()) {
// This is the mangling we've always used on the GNU runtimes, but it
// has obvious collisions in the face of underscores within class
// names, category names, and selectors; maybe we should improve it.
OS << (MD->isClassMethod() ? "_c_" : "_i_")
<< MD->getClassInterface()->getName() << '_';
if (includeCategoryNamespace) {
if (auto category = MD->getCategory())
OS << category->getName();
}
OS << '_';
auto selector = MD->getSelector();
for (unsigned slotIndex = 0,
numArgs = selector.getNumArgs(),
slotEnd = std::max(numArgs, 1U);
slotIndex != slotEnd; ++slotIndex) {
if (auto name = selector.getIdentifierInfoForSlot(slotIndex))
OS << name->getName();
// Replace all the positions that would've been ':' with '_'.
// That's after each slot except that a unary selector doesn't
// end in ':'.
if (numArgs)
OS << '_';
}
return;
}
// \01+[ContainerName(CategoryName) SelectorName]
if (includePrefixByte) {
OS << '\01';
}
OS << (MD->isInstanceMethod() ? '-' : '+') << '[';
if (const auto *CID = MD->getCategory()) {
OS << CID->getClassInterface()->getName();
if (includeCategoryNamespace) {
OS << '(' << *CID << ')';
}
} else if (const auto *CD =
dyn_cast<ObjCContainerDecl>(MD->getDeclContext())) {
OS << CD->getName();
} else {
llvm_unreachable("Unexpected ObjC method decl context");
}
OS << ' ';
MD->getSelector().print(OS);
OS << ']';
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %rax
movq 0x830(%rax), %rax
cmpl $0x4, 0x160(%rax)
jb 0x1e4d4f
movzwl 0x38(%r14), %eax
movzbl 0x3a(%r14), %ecx
shll $0x10, %ecx
orl %eax, %ecx
btl $0x11, %ecx
leaq 0x1559a9(%rip), %rax # 0x33a6b6
leaq 0x1559a6(%rip), %rsi # 0x33a6ba
cmovaeq %rax, %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %r15
movq %r14, %rdi
callq 0xca2c2
movq 0x28(%rax), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0x1e4d75
leaq 0x1aab99(%rip), %rsi # 0x38f8e4
xorl %edx, %edx
jmp 0x1e4d7f
testb %cl, %cl
je 0x1e4df8
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e4deb
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x1, (%rax)
jmp 0x1e4df8
movq 0x10(%rax), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %r15, %rdi
callq 0x577a6
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1e4d9e
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x5f, (%rcx)
jmp 0x1e4dab
movq %rax, %rdi
movl $0x5f, %esi
callq 0x5822c
testb %bpl, %bpl
je 0x1e4f30
movq %r14, %rdi
callq 0xca364
testq %rax, %rax
je 0x1e4f30
movq 0x28(%rax), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0x1e4f1e
leaq 0x1aab00(%rip), %rsi # 0x38f8e4
xorl %edx, %edx
jmp 0x1e4f28
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5822c
movb 0x3a(%r14), %al
andb $0x2, %al
addb $0x2b, %al
movq 0x20(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
jae 0x1e4e19
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movb %al, (%rcx)
movq %rbx, %rax
jmp 0x1e4e24
movzbl %al, %esi
movq %rbx, %rdi
callq 0x5822c
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1e4e3b
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x5b, (%rcx)
jmp 0x1e4e48
movq %rax, %rdi
movl $0x5b, %esi
callq 0x5822c
movq %r14, %rdi
callq 0xca364
testq %rax, %rax
je 0x1e4e7b
movq %rax, %r15
movq 0x58(%rax), %rax
movq 0x28(%rax), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
je 0x1e4ecb
leaq 0x1aaa6d(%rip), %rsi # 0x38f8e4
xorl %edx, %edx
jmp 0x1e4ed5
movq 0x10(%r14), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0x1e4e8e
movq (%rax), %rax
movzwl 0x8(%rax), %ecx
andl $0x7f, %ecx
addl $-0x10, %ecx
leaq -0x30(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
xorl %edx, %edx
cmpl $0x5, %ecx
cmovaeq %rdx, %rsi
movq 0x28(%rsi), %rax
testb $0x7, %al
setne %cl
andq $-0x8, %rax
sete %sil
orb %cl, %sil
je 0x1e4f07
leaq 0x1aaa1b(%rip), %rsi # 0x38f8e4
jmp 0x1e4f11
movq 0x10(%rax), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x577a6
testb %bpl, %bpl
je 0x1e5010
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e4fce
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x28, (%rax)
movq %rbx, %r12
jmp 0x1e4fde
movq 0x10(%rax), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x577a6
jmp 0x1e5010
movq 0x10(%rax), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x577a6
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e4f47
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x5f, (%rax)
jmp 0x1e4f54
movq %rbx, %rdi
movl $0x5f, %esi
callq 0x5822c
movq 0x28(%r14), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x2ecbac
movl %eax, %ebp
cmpl $0x1, %eax
movl %eax, %r12d
adcl $0x0, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2ecc04
testq %rax, %rax
je 0x1e4f99
movq 0x10(%rax), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x577a6
testl %ebp, %ebp
je 0x1e4fc1
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e4fb4
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x5f, (%rax)
jmp 0x1e4fc1
movq %rbx, %rdi
movl $0x5f, %esi
callq 0x5822c
incl %r15d
cmpl %r15d, %r12d
jne 0x1e4f77
jmp 0x1e506c
movq %rbx, %rdi
movl $0x28, %esi
callq 0x5822c
movq %rax, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xbaa18
movq 0x20(%r12), %rax
cmpq 0x18(%r12), %rax
jae 0x1e5003
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r12)
movb $0x29, (%rax)
jmp 0x1e5010
movq %r12, %rdi
movl $0x29, %esi
callq 0x5822c
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e5027
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x1e5034
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
movq 0x28(%r14), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x2ece6a
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1e505f
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x5d, (%rax)
jmp 0x1e506c
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x5822c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Mangle.cpp
|
(anonymous namespace)::MicrosoftCXXNameMangler::mangleType(clang::TemplateTypeParmType const*, clang::Qualifiers, clang::SourceRange)
|
void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T,
Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
"cannot mangle this template type parameter type yet");
Diags.Report(Range.getBegin(), DiagID)
<< Range;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %r14
movq 0x20(%r14), %rdi
leaq 0x1488c5(%rip), %rdx # 0x33b473
movl $0x33, %ecx
movl $0x4, %esi
callq 0x2e98bc
movl %ebx, 0x170(%r14)
movl %eax, 0x174(%r14)
xorl %eax, %eax
movq %rax, 0x158(%r14)
movq 0x150(%r14), %rcx
movb %al, (%rcx)
leaq 0x178(%r14), %rcx
leaq 0x10(%rsp), %r15
movq %rcx, (%r15)
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movw $0x1, 0x18(%r15)
movb %al, 0x178(%r14)
movl $0x0, 0x320(%r14)
addq $0x388, %r14 # imm = 0x388
movq %r14, %rdi
callq 0x964b2
movq %rsp, %rsi
movq %rbx, (%rsi)
movb $0x1, 0x8(%rsi)
movq %r15, %rdi
callq 0xe7ed8
movq %r15, %rdi
callq 0x9646e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/MicrosoftMangle.cpp
|
(anonymous namespace)::MicrosoftCXXNameMangler::mangleType(clang::UnaryTransformType const*, clang::Qualifiers, clang::SourceRange)
|
void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
"cannot mangle this unary transform type yet");
Diags.Report(Range.getBegin(), DiagID)
<< Range;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %r14
movq 0x20(%r14), %rdi
leaq 0x148737(%rip), %rdx # 0x33b4f5
movl $0x2b, %ecx
movl $0x4, %esi
callq 0x2e98bc
movl %ebx, 0x170(%r14)
movl %eax, 0x174(%r14)
xorl %eax, %eax
movq %rax, 0x158(%r14)
movq 0x150(%r14), %rcx
movb %al, (%rcx)
leaq 0x178(%r14), %rcx
leaq 0x10(%rsp), %r15
movq %rcx, (%r15)
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movw $0x1, 0x18(%r15)
movb %al, 0x178(%r14)
movl $0x0, 0x320(%r14)
addq $0x388, %r14 # imm = 0x388
movq %r14, %rdi
callq 0x964b2
movq %rsp, %rsi
movq %rbx, (%rsi)
movb $0x1, 0x8(%rsi)
movq %r15, %rdi
callq 0xe7ed8
movq %r15, %rdi
callq 0x9646e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/AST/MicrosoftMangle.cpp
|
clang::ODRHash::AddTemplateParameterList(clang::TemplateParameterList const*)
|
void ODRHash::AddTemplateParameterList(const TemplateParameterList *TPL) {
assert(TPL && "Expecting non-null pointer.");
ID.AddInteger(TPL->size());
for (auto *ND : TPL->asArray()) {
AddSubDecl(ND);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb0(%rdi), %r15
movl $0x1fffffff, %esi # imm = 0x1FFFFFFF
andl 0xc(%rbx), %esi
movq %r15, %rdi
callq 0x75350
movl 0xc(%rbx), %r13d
testl $0x1fffffff, %r13d # imm = 0x1FFFFFFF
je 0x1f75b7
shll $0x3, %r13d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq 0x10(%rbx,%rbp), %rsi
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %r12, %rdi
callq 0x1f76c4
addq $0x8, %rbp
cmpq %rbp, %r13
jne 0x1f7597
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ODRHash.cpp
|
clang::OpenACCClausePrinter::VisitAttachClause(clang::OpenACCAttachClause const&)
|
void OpenACCClausePrinter::VisitAttachClause(const OpenACCAttachClause &C) {
OS << "attach(";
llvm::interleaveComma(C.getVarList(), OS,
[&](const Expr *E) { printExpr(E); });
OS << ")";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x141cfc(%rip), %rsi # 0x33bc5a
movl $0x7, %edx
callq 0x577a6
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x1fa02c
movq 0x18(%r14), %r13
movq (%rbx), %r14
movq (%r13), %rdi
movq 0x8(%rbx), %rcx
leaq 0x156fc5(%rip), %rbp # 0x350f50
movq %rbp, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2104a0
cmpq $0x1, %r12
je 0x1fa02c
shlq $0x3, %r12
movl $0x8, %r15d
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x1f9fe9
movl $0x2, %edx
movq %r14, %rdi
leaq 0x12b049(%rip), %rsi # 0x32502b
callq 0x582a2
jmp 0x1f9ff3
movw $0x202c, (%rax) # imm = 0x202C
addq $0x2, 0x20(%r14)
movq (%r13,%r15), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %rbp, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2104a0
addq $0x8, %r15
cmpq %r15, %r12
jne 0x1f9fc2
movq (%rbx), %rdi
leaq 0x12b263(%rip), %rsi # 0x325299
movl $0x1, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x577a6
|
/AST/OpenACCClause.cpp
|
llvm::raw_ostream& clang::printOpenACCClauseKind<llvm::raw_ostream>(llvm::raw_ostream&, clang::OpenACCClauseKind)
|
inline StreamTy &printOpenACCClauseKind(StreamTy &Out, OpenACCClauseKind K) {
switch (K) {
case OpenACCClauseKind::Finalize:
return Out << "finalize";
case OpenACCClauseKind::IfPresent:
return Out << "if_present";
case OpenACCClauseKind::Seq:
return Out << "seq";
case OpenACCClauseKind::Independent:
return Out << "independent";
case OpenACCClauseKind::Auto:
return Out << "auto";
case OpenACCClauseKind::Worker:
return Out << "worker";
case OpenACCClauseKind::Vector:
return Out << "vector";
case OpenACCClauseKind::NoHost:
return Out << "nohost";
case OpenACCClauseKind::Default:
return Out << "default";
case OpenACCClauseKind::If:
return Out << "if";
case OpenACCClauseKind::Self:
return Out << "self";
case OpenACCClauseKind::Copy:
return Out << "copy";
case OpenACCClauseKind::PCopy:
return Out << "pcopy";
case OpenACCClauseKind::PresentOrCopy:
return Out << "present_or_copy";
case OpenACCClauseKind::UseDevice:
return Out << "use_device";
case OpenACCClauseKind::Attach:
return Out << "attach";
case OpenACCClauseKind::Delete:
return Out << "delete";
case OpenACCClauseKind::Detach:
return Out << "detach";
case OpenACCClauseKind::Device:
return Out << "device";
case OpenACCClauseKind::DevicePtr:
return Out << "deviceptr";
case OpenACCClauseKind::DeviceResident:
return Out << "device_resident";
case OpenACCClauseKind::FirstPrivate:
return Out << "firstprivate";
case OpenACCClauseKind::Host:
return Out << "host";
case OpenACCClauseKind::Link:
return Out << "link";
case OpenACCClauseKind::NoCreate:
return Out << "no_create";
case OpenACCClauseKind::Present:
return Out << "present";
case OpenACCClauseKind::Private:
return Out << "private";
case OpenACCClauseKind::CopyOut:
return Out << "copyout";
case OpenACCClauseKind::PCopyOut:
return Out << "pcopyout";
case OpenACCClauseKind::PresentOrCopyOut:
return Out << "present_or_copyout";
case OpenACCClauseKind::CopyIn:
return Out << "copyin";
case OpenACCClauseKind::PCopyIn:
return Out << "pcopyin";
case OpenACCClauseKind::PresentOrCopyIn:
return Out << "present_or_copyin";
case OpenACCClauseKind::Create:
return Out << "create";
case OpenACCClauseKind::PCreate:
return Out << "pcreate";
case OpenACCClauseKind::PresentOrCreate:
return Out << "present_or_create";
case OpenACCClauseKind::Reduction:
return Out << "reduction";
case OpenACCClauseKind::Collapse:
return Out << "collapse";
case OpenACCClauseKind::Bind:
return Out << "bind";
case OpenACCClauseKind::VectorLength:
return Out << "vector_length";
case OpenACCClauseKind::NumGangs:
return Out << "num_gangs";
case OpenACCClauseKind::NumWorkers:
return Out << "num_workers";
case OpenACCClauseKind::DeviceNum:
return Out << "device_num";
case OpenACCClauseKind::DefaultAsync:
return Out << "default_async";
case OpenACCClauseKind::DeviceType:
return Out << "device_type";
case OpenACCClauseKind::DType:
return Out << "dtype";
case OpenACCClauseKind::Async:
return Out << "async";
case OpenACCClauseKind::Tile:
return Out << "tile";
case OpenACCClauseKind::Gang:
return Out << "gang";
case OpenACCClauseKind::Wait:
return Out << "wait";
case OpenACCClauseKind::Invalid:
return Out << "<invalid>";
}
llvm_unreachable("Uncovered clause kind");
}
|
movl %esi, %eax
leaq 0x140e43(%rip), %rcx # 0x33bb24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18a792(%rip), %rsi # 0x385483
jmp 0x1faf33
leaq 0x140fa8(%rip), %rsi # 0x33bca5
jmp 0x1faf08
leaq 0x1410a0(%rip), %rsi # 0x33bda9
jmp 0x1faef7
leaq 0x14105c(%rip), %rsi # 0x33bd71
jmp 0x1faf33
leaq 0x145281(%rip), %rsi # 0x33ffa2
jmp 0x1faf55
leaq 0x141032(%rip), %rsi # 0x33bd5f
jmp 0x1faed1
leaq 0x18704a(%rip), %rsi # 0x381d83
jmp 0x1faf08
leaq 0x140ff0(%rip), %rsi # 0x33bd35
jmp 0x1faf66
leaq 0x141006(%rip), %rsi # 0x33bd57
jmp 0x1faf66
leaq 0x133b73(%rip), %rsi # 0x32e8d0
jmp 0x1faec0
leaq 0x14104e(%rip), %rsi # 0x33bdb7
jmp 0x1fae51
leaq 0x140f62(%rip), %rsi # 0x33bcd7
jmp 0x1faf19
leaq 0x19cbf0(%rip), %rsi # 0x397971
jmp 0x1faec0
leaq 0x14103c(%rip), %rsi # 0x33bdc9
jmp 0x1faf55
leaq 0x1a17f2(%rip), %rsi # 0x39c58b
jmp 0x1faf55
leaq 0x1b4a5f(%rip), %rsi # 0x3af804
jmp 0x1faf55
leaq 0x159b76(%rip), %rsi # 0x354927
jmp 0x1faf55
leaq 0x140fcb(%rip), %rsi # 0x33bd88
jmp 0x1faf08
leaq 0x140ef8(%rip), %rsi # 0x33bcc1
jmp 0x1faf77
leaq 0x1ac8c8(%rip), %rsi # 0x3a769d
movl $0x2, %edx
jmp 0x577a6
leaq 0x208c47(%rip), %rsi # 0x403a2d
jmp 0x1faf66
leaq 0x140f25(%rip), %rsi # 0x33bd17
jmp 0x1faf08
leaq 0x12bc41(%rip), %rsi # 0x326a3f
movl $0x3, %edx
jmp 0x577a6
leaq 0x140ed3(%rip), %rsi # 0x33bce2
jmp 0x1faec0
leaq 0x131695(%rip), %rsi # 0x32c4b0
jmp 0x1fae51
leaq 0x12f7c2(%rip), %rsi # 0x32a5e6
jmp 0x1faec0
leaq 0x140e7f(%rip), %rsi # 0x33bcaf
jmp 0x1faf19
leaq 0x140f01(%rip), %rsi # 0x33bd3d
jmp 0x1faf66
leaq 0x140ea1(%rip), %rsi # 0x33bce9
jmp 0x1faec0
leaq 0x140f41(%rip), %rsi # 0x33bd92
movl $0xb, %edx
jmp 0x577a6
leaq 0x140e98(%rip), %rsi # 0x33bcfa
jmp 0x1fae85
leaq 0x140e4f(%rip), %rsi # 0x33bcba
jmp 0x1faec0
leaq 0x140e96(%rip), %rsi # 0x33bd0a
movl $0xc, %edx
jmp 0x577a6
leaq 0x140e42(%rip), %rsi # 0x33bcc7
movl $0xf, %edx
jmp 0x577a6
leaq 0x207510(%rip), %rsi # 0x4023a6
jmp 0x1faec0
leaq 0x158415(%rip), %rsi # 0x3532b4
jmp 0x1faec0
leaq 0x12eed6(%rip), %rsi # 0x329d7e
jmp 0x1faf55
leaq 0x133a26(%rip), %rsi # 0x32e8da
jmp 0x1faf66
leaq 0x140e90(%rip), %rsi # 0x33bd50
movl $0x6, %edx
jmp 0x577a6
leaq 0x140e74(%rip), %rsi # 0x33bd45
movl $0x11, %edx
jmp 0x577a6
leaq 0x140ee1(%rip), %rsi # 0x33bdc3
jmp 0x1faf77
leaq 0x12d827(%rip), %rsi # 0x328715
jmp 0x1faf55
leaq 0x140e83(%rip), %rsi # 0x33bd7a
movl $0xd, %edx
jmp 0x577a6
leaq 0x140de8(%rip), %rsi # 0x33bcf0
movl $0x9, %edx
jmp 0x577a6
leaq 0x140e85(%rip), %rsi # 0x33bd9e
movl $0xa, %edx
jmp 0x577a6
leaq 0x1596ce(%rip), %rsi # 0x3545f8
jmp 0x1faf55
leaq 0x140dee(%rip), %rsi # 0x33bd21
movl $0x8, %edx
jmp 0x577a6
leaq 0x140de6(%rip), %rsi # 0x33bd2a
movl $0x12, %edx
jmp 0x577a6
leaq 0x188fe6(%rip), %rsi # 0x383f3b
movl $0x4, %edx
jmp 0x577a6
leaq 0x1b37ba(%rip), %rsi # 0x3ae720
movl $0x7, %edx
jmp 0x577a6
leaq 0x19fbef(%rip), %rsi # 0x39ab66
movl $0x5, %edx
jmp 0x577a6
|
/clang/Basic/OpenACCKinds.h
|
clang::OMPTraitProperty const* llvm::SmallVectorTemplateCommon<clang::OMPTraitProperty, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::OMPTraitProperty, true>>(llvm::SmallVectorTemplateBase<clang::OMPTraitProperty, true>*, clang::OMPTraitProperty 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 %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x20037e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpq %rbx, %rax
setbe %sil
leaq (%rax,%rcx,8), %rcx
cmpq %rbx, %rcx
seta %bpl
andb %sil, %bpl
movq $-0x1, %r15
cmpb $0x1, %bpl
je 0x2003cd
leaq 0x10(%r14), %rsi
movl $0x18, %ecx
movq %r14, %rdi
callq 0x56f14
testb %bpl, %bpl
je 0x200370
leaq (%r15,%r15,2), %rbx
shlq $0x3, %rbx
addq (%r14), %rbx
jmp 0x200370
movq %rbx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r15
jmp 0x2003aa
|
/llvm/ADT/SmallVector.h
|
clang::ASTContext::getFieldOffset(clang::ValueDecl const*) const
|
uint64_t ASTContext::getFieldOffset(const ValueDecl *VD) const {
uint64_t OffsetInBits;
if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) {
OffsetInBits = ::getFieldOffset(*this, FD);
} else {
const IndirectFieldDecl *IFD = cast<IndirectFieldDecl>(VD);
OffsetInBits = 0;
for (const NamedDecl *ND : IFD->chain())
OffsetInBits += ::getFieldOffset(*this, cast<FieldDecl>(ND));
}
return OffsetInBits;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x205be4
movl 0x1c(%rsi), %eax
andl $0x7f, %eax
addl $-0x31, %eax
cmpl $-0x3, %eax
jb 0x205be4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x205c25
movl 0x40(%rsi), %r15d
testq %r15, %r15
je 0x205c15
movq 0x38(%rsi), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x205c25
addq %rax, %r14
addq $0x8, %r13
cmpq %r13, %r15
jne 0x205bfb
jmp 0x205c18
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/AST/RecordLayoutBuilder.cpp
|
getFieldOffset(clang::ASTContext const&, clang::FieldDecl const*)
|
static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD) {
const ASTRecordLayout &Layout = C.getASTRecordLayout(FD->getParent());
return Layout.getFieldOffset(FD->getFieldIndex());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0x205c3f
movq (%rax), %rax
movzwl 0x8(%rax), %ecx
andl $0x7f, %ecx
addl $-0x37, %ecx
leaq -0x40(%rax), %rdx
testq %rax, %rax
cmoveq %rax, %rdx
xorl %esi, %esi
cmpl $0x4, %ecx
cmovbq %rdx, %rsi
callq 0x203026
movq %rax, %r14
movq %rbx, %rdi
callq 0xbe310
movq 0x30(%r14), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/RecordLayoutBuilder.cpp
|
(anonymous namespace)::EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(clang::CXXRecordDecl const*, clang::CXXRecordDecl const*, clang::CharUnits) const
|
bool
EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,
const CXXRecordDecl *Class,
CharUnits Offset) const {
// We don't have to keep looking past the maximum offset that's known to
// contain an empty class.
if (!AnyEmptySubobjectsBeyondOffset(Offset))
return true;
if (!CanPlaceSubobjectAtOffset(RD, Offset))
return false;
const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
// Traverse all non-virtual bases.
for (const CXXBaseSpecifier &Base : RD->bases()) {
if (Base.isVirtual())
continue;
const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
if (!CanPlaceFieldSubobjectAtOffset(BaseDecl, Class, BaseOffset))
return false;
}
if (RD == Class) {
// This is the most derived class, traverse virtual bases as well.
for (const CXXBaseSpecifier &Base : RD->vbases()) {
const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl();
CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
if (!CanPlaceFieldSubobjectAtOffset(VBaseDecl, Class, VBaseOffset))
return false;
}
}
// Traverse all member variables.
unsigned FieldNo = 0;
for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
I != E; ++I, ++FieldNo) {
if (I->isBitField())
continue;
CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
if (!CanPlaceFieldSubobjectAtOffset(*I, FieldOffset))
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bpl
cmpq %rcx, 0x30(%rdi)
jl 0x2084a5
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, %rdx
callq 0x2084ba
testb %al, %al
je 0x2084a3
movq (%r14), %rdi
movq %r15, %rsi
callq 0x203026
movq %rax, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, %rdi
callq 0x79e56
cmpq %rdx, %rax
je 0x2083a9
movq %rax, %rbp
movq %rdx, %r12
movl $0x3, %eax
testb $0x1, 0xc(%rbp)
jne 0x208393
movq 0x10(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0x208360
callq 0x225b78
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x8c0b0
leaq (%rax,%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2082da
xorb $0x1, %al
movzbl %al, %eax
cmpl $0x3, %eax
je 0x2083a0
testl %eax, %eax
jne 0x2084a3
addq $0x18, %rbp
cmpq %r12, %rbp
jne 0x208339
cmpq %r13, 0x8(%rsp)
je 0x20842d
movq 0x8(%rsp), %rdi
callq 0xbeaf4
testq %rax, %rax
sete %bpl
je 0x2084a5
movq %rax, %r12
xorl %r15d, %r15d
testb $0x1, 0x44(%r12)
jne 0x208404
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rsi
movq (%r14), %rdi
callq 0x8bb36
leaq (%rax,%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x20809e
testb %al, %al
je 0x2084a5
movq 0x8(%r12), %r12
andq $-0x8, %r12
je 0x20841f
movl 0x1c(%r12), %eax
andl $0x7f, %eax
addl $-0x2e, %eax
cmpl $0x3, %eax
jae 0x208404
incl %r15d
testq %r12, %r12
sete %bpl
jne 0x2083cd
jmp 0x2084a5
movq 0x8(%rsp), %rdi
callq 0x79e12
cmpq %rdx, %rax
je 0x2083b0
movq %rax, %r12
movq %rdx, %rbp
movq 0x10(%r12), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rax
testb $0xf, 0x8(%rax)
je 0x208463
callq 0x225b78
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x9393a
leaq (%rax,%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2082da
testb %al, %al
je 0x2084a3
addq $0x18, %r12
cmpq %rbp, %r12
jne 0x208446
jmp 0x2083b0
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/RecordLayoutBuilder.cpp
|
(anonymous namespace)::StmtPrinter::VisitGenericSelectionExpr(clang::GenericSelectionExpr*)
|
void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
OS << "_Generic(";
if (Node->isExprPredicate())
PrintExpr(Node->getControllingExpr());
else
Node->getControllingType()->getType().print(OS, Policy);
for (const GenericSelectionExpr::Association &Assoc : Node->associations()) {
OS << ", ";
QualType T = Assoc.getType();
if (T.isNull())
OS << "default";
else
T.print(OS, Policy);
OS << ": ";
PrintExpr(Assoc.getAssociationExpr());
}
OS << ")";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x8, %rcx
ja 0x214645
leaq 0x12ac9d(%rip), %rsi # 0x33f2d6
movl $0x9, %edx
callq 0x582a2
jmp 0x21465b
movabsq $0x636972656e65475f, %rcx # imm = 0x636972656E65475F
movq %rcx, (%rax)
movb $0x28, 0x8(%rax)
addq $0x9, 0x20(%rdi)
movl 0x10(%r14), %eax
btl $0x1e, %eax
jb 0x214696
andl $0x7fff, %eax # imm = 0x7FFF
movq 0x20(%r14,%rax,8), %rax
movq (%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq (%rbx), %rsi
leaq 0x18(%rbx), %rdx
leaq 0x20(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
xorl %r8d, %r8d
callq 0x22ef24
jmp 0x2146a2
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x21cf56
movl 0x10(%r14), %eax
movl %eax, %r13d
andl $0x7fff, %r13d # imm = 0x7FFF
je 0x2147e7
shrl $0x1e, %eax
andl $0x1, %eax
leaq (%r14,%rax,8), %rcx
addq $0x20, %rcx
movq %rcx, 0x18(%rsp)
addq $0x20, %r14
leal (%rax,%r13), %ecx
leaq (%r14,%rcx,8), %rcx
xorl $0x1, %eax
leaq (%rcx,%rax,8), %r12
leaq 0x18(%rbx), %rax
movq %rax, 0x10(%rsp)
shll $0x3, %r13d
xorl %r14d, %r14d
movq 0x18(%rsp), %rax
movq (%rax,%r14), %r15
movq (%r12,%r14), %rbp
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x214720
movl $0x2, %edx
leaq 0x110912(%rip), %rsi # 0x32502b
callq 0x582a2
jmp 0x21472a
movw $0x202c, (%rax) # imm = 0x202C
addq $0x2, 0x20(%rdi)
testq %rbp, %rbp
je 0x214735
movq (%rbp), %rax
jmp 0x214737
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq (%rbx), %rsi
cmpq $0xf, %rax
ja 0x21476c
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rax
subq %rax, %rcx
cmpq $0x6, %rcx
ja 0x21478c
movl $0x7, %edx
movq %rsi, %rdi
leaq 0x11a175(%rip), %rsi # 0x32e8da
callq 0x582a2
jmp 0x21479e
movw $0x101, 0x40(%rsp) # imm = 0x101
leaq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
xorl %r8d, %r8d
callq 0x22ef24
jmp 0x21479e
movl $0x746c7561, 0x3(%rax) # imm = 0x746C7561
movl $0x61666564, (%rax) # imm = 0x61666564
addq $0x7, 0x20(%rsi)
movq (%rbx), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x2147c5
movl $0x2, %edx
leaq 0x174345(%rip), %rsi # 0x388b03
callq 0x582a2
jmp 0x2147cf
movw $0x203a, (%rax) # imm = 0x203A
addq $0x2, 0x20(%rdi)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21cf56
addq $0x8, %r14
cmpq %r14, %r13
jne 0x2146ec
movq (%rbx), %rdi
movq 0x20(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x2147fd
movb $0x29, (%rax)
incq 0x20(%rdi)
jmp 0x21480e
leaq 0x110a95(%rip), %rsi # 0x325299
movl $0x1, %edx
callq 0x582a2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/StmtPrinter.cpp
|
(anonymous namespace)::StmtPrinter::VisitOMPParallelMaskedTaskLoopSimdDirective(clang::OMPParallelMaskedTaskLoopSimdDirective*)
|
void StmtPrinter::VisitOMPParallelMaskedTaskLoopSimdDirective(
OMPParallelMaskedTaskLoopSimdDirective *Node) {
Indent() << "#pragma omp parallel masked taskloop simd";
PrintOMPExecutableDirective(Node);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ebp
testl %ebp, %ebp
jle 0x21a976
leaq 0x108c27(%rip), %r15 # 0x32356c
movq (%r14), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x21a968
movl $0x2, %edx
movq %r15, %rsi
callq 0x582a2
jmp 0x21a972
movw $0x2020, (%rax) # imm = 0x2020
addq $0x2, 0x20(%rdi)
decl %ebp
jne 0x21a945
movq (%r14), %rdi
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
subq %rax, %rcx
cmpq $0x28, %rcx
ja 0x21a99d
leaq 0x1258b0(%rip), %rsi # 0x340241
movl $0x29, %edx
callq 0x582a2
jmp 0x21a9c2
movups 0x1258b6(%rip), %xmm0 # 0x34025a
movups %xmm0, 0x19(%rax)
movups 0x1258a2(%rip), %xmm0 # 0x340251
movups %xmm0, 0x10(%rax)
movups 0x125887(%rip), %xmm0 # 0x340241
movups %xmm0, (%rax)
addq $0x29, 0x20(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21deb6
nop
|
/AST/StmtPrinter.cpp
|
(anonymous namespace)::StmtProfilerWithPointers::VisitDecl(clang::Decl const*)
|
void VisitDecl(const Decl *D) override {
ID.AddInteger(D ? D->getKind() : 0);
if (Canonical && D) {
if (const NonTypeTemplateParmDecl *NTTP =
dyn_cast<NonTypeTemplateParmDecl>(D)) {
ID.AddInteger(NTTP->getDepth());
ID.AddInteger(NTTP->getIndex());
ID.AddBoolean(NTTP->isParameterPack());
// C++20 [temp.over.link]p6:
// Two template-parameters are equivalent under the following
// conditions: [...] if they declare non-type template parameters,
// they have equivalent types ignoring the use of type-constraints
// for placeholder types
//
// TODO: Why do we need to include the type in the profile? It's not
// part of the mangling.
VisitType(Context.getUnconstrainedType(NTTP->getType()));
return;
}
if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
// The Itanium C++ ABI uses the type, scope depth, and scope
// index of a parameter when mangling expressions that involve
// function parameters, so we will use the parameter's type for
// establishing function parameter identity. That way, our
// definition of "equivalent" (per C++ [temp.over.link]) is at
// least as strong as the definition of "equivalent" used for
// name mangling.
//
// TODO: The Itanium C++ ABI only uses the top-level cv-qualifiers,
// not the entirety of the type.
VisitType(Parm->getType());
ID.AddInteger(Parm->getFunctionScopeDepth());
ID.AddInteger(Parm->getFunctionScopeIndex());
return;
}
if (const TemplateTypeParmDecl *TTP =
dyn_cast<TemplateTypeParmDecl>(D)) {
ID.AddInteger(TTP->getDepth());
ID.AddInteger(TTP->getIndex());
ID.AddBoolean(TTP->isParameterPack());
return;
}
if (const TemplateTemplateParmDecl *TTP =
dyn_cast<TemplateTemplateParmDecl>(D)) {
ID.AddInteger(TTP->getDepth());
ID.AddInteger(TTP->getIndex());
ID.AddBoolean(TTP->isParameterPack());
return;
}
}
ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rsi, %rsi
je 0x21eccf
movl 0x1c(%rbx), %esi
andl $0x7f, %esi
jmp 0x21ecd1
xorl %esi, %esi
callq 0x75350
testq %rbx, %rbx
je 0x21ee45
cmpb $0x0, 0x10(%r14)
je 0x21ee45
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x2c, %eax
jne 0x21ed46
movq 0x8(%r14), %rdi
movl $0xfffff, %esi # imm = 0xFFFFF
andl 0x44(%rbx), %esi
callq 0x75350
movq 0x8(%r14), %rdi
movl 0x44(%rbx), %esi
shrl $0x14, %esi
callq 0x75350
movq 0x8(%r14), %rdi
movzbl 0x50(%rbx), %esi
callq 0x75350
movq 0x18(%r14), %rdi
movq 0x30(%rbx), %rsi
callq 0x898ee
movq (%r14), %rcx
movq 0x20(%rcx), %rcx
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
movl 0x1c(%rbx), %ebp
andl $0x7f, %ebp
xorl %r12d, %r12d
movl $0x0, %r15d
cmpl $0x28, %ebp
cmoveq %rbx, %r15
jne 0x21edc1
movq 0x30(%r15), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq 0x8(%r14), %rdi
movl 0x60(%r15), %eax
movl %eax, %ecx
shrl $0xd, %ecx
andl $0x7f, %ecx
btl $0xc, %eax
cmovael %ecx, %r12d
movl %r12d, %esi
callq 0x75350
movq 0x8(%r14), %r12
movl 0x60(%r15), %esi
shrl $0x14, %esi
movl $0xff, %eax
andl %eax, %esi
cmpl %eax, %esi
jne 0x21edab
movq %r15, %rdi
callq 0xbc614
movl %eax, %esi
movq %r12, %rdi
callq 0x75350
cmpl $0x28, %ebp
jne 0x21edc1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x40, %eax
jne 0x21ee0c
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0xd31f4
movq %r15, %rdi
movl %eax, %esi
callq 0x75350
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0xd36ee
movq %r15, %rdi
movl %eax, %esi
callq 0x75350
movq 0x8(%r14), %r14
movq %rbx, %rdi
callq 0xd314e
movzbl %al, %esi
movq %r14, %rdi
jmp 0x21ee71
movl 0x1c(%rbx), %eax
andl $0x7f, %eax
cmpl $0x41, %eax
jne 0x21ee45
movq 0x8(%r14), %rdi
movl $0xfffff, %esi # imm = 0xFFFFF
andl 0x40(%rbx), %esi
callq 0x75350
movq 0x8(%r14), %rdi
movl 0x40(%rbx), %esi
shrl $0x14, %esi
callq 0x75350
movq 0x8(%r14), %rdi
movl 0x50(%rbx), %esi
shrl %esi
andl $0x1, %esi
jmp 0x21ee71
movq 0x8(%r14), %r14
testq %rbx, %rbx
je 0x21ee5c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rbx
jmp 0x21ee5e
xorl %ebx, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x75350
shrq $0x20, %rbx
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x75350
|
/AST/StmtProfile.cpp
|
(anonymous namespace)::StmtProfiler::VisitCXXDeleteExpr(clang::CXXDeleteExpr const*)
|
void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
VisitExpr(S);
ID.AddBoolean(S->isGlobalDelete());
ID.AddBoolean(S->isArrayForm());
VisitDecl(S->getOperatorDelete());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x220e5c
movq 0x8(%rbx), %rdi
movl (%r14), %esi
shrl $0x12, %esi
andl $0x1, %esi
callq 0x75350
movq 0x8(%rbx), %rdi
movl (%r14), %esi
shrl $0x13, %esi
andl $0x1, %esi
callq 0x75350
movq 0x10(%r14), %rsi
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
|
/AST/StmtProfile.cpp
|
clang::Type::isIntegralType(clang::ASTContext const&) const
|
bool Type::isIntegralType(const ASTContext &Ctx) const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
return BT->getKind() >= BuiltinType::Bool &&
BT->getKind() <= BuiltinType::Int128;
// Complete enum types are integral in C.
if (!Ctx.getLangOpts().CPlusPlus)
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
return ET->getDecl()->isComplete();
return isBitIntType();
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rcx
movb 0x10(%rcx), %dl
cmpb $0xd, %dl
setne %al
testq %rcx, %rcx
sete %dil
orb %al, %dil
jne 0x226d66
movl 0x10(%rcx), %eax
shrl $0x13, %eax
andl $0x1fc, %eax # imm = 0x1FC
addl $0xfffffe54, %eax # imm = 0xFFFFFE54
cmpl $0x14, %eax
setb %al
testb %dil, %dil
je 0x226dbb
movq 0x830(%rsi), %rsi
testb $0x4, 0x1(%rsi)
jne 0x226da9
cmpb $0x2d, %dl
setne %dl
testq %rcx, %rcx
sete %bpl
orb %dl, %bpl
jne 0x226da4
movq 0x18(%rcx), %rdi
callq 0x22a1cf
movq %rax, %rcx
cmpq $0x8, 0x80(%rax)
setae %al
orb 0x4a(%rcx), %al
testb %bpl, %bpl
je 0x226dbb
movq 0x8(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xa, 0x10(%rax)
sete %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/AST/Type.cpp
|
clang::LinkageComputer::computeTypeLinkageInfo(clang::Type const*)
|
LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
switch (T->getTypeClass()) {
#define TYPE(Class,Base)
#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
llvm_unreachable("didn't expect a non-canonical type here");
#define TYPE(Class,Base)
#define DEPENDENT_TYPE(Class,Base) case Type::Class:
#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
// Treat instantiation-dependent types as external.
assert(T->isInstantiationDependentType());
return LinkageInfo::external();
case Type::BitInt:
case Type::Builtin:
return LinkageInfo::external();
case Type::Auto:
case Type::DeducedTemplateSpecialization:
return LinkageInfo::external();
case Type::Record:
case Type::Enum:
return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl());
case Type::Complex:
return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
case Type::Pointer:
return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
case Type::BlockPointer:
return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
case Type::LValueReference:
case Type::RValueReference:
return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
case Type::MemberPointer: {
const auto *MPT = cast<MemberPointerType>(T);
LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
return LV;
}
case Type::ConstantArray:
case Type::IncompleteArray:
case Type::VariableArray:
case Type::ArrayParameter:
return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
case Type::Vector:
case Type::ExtVector:
return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
case Type::ConstantMatrix:
return computeTypeLinkageInfo(
cast<ConstantMatrixType>(T)->getElementType());
case Type::FunctionNoProto:
return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
case Type::FunctionProto: {
const auto *FPT = cast<FunctionProtoType>(T);
LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
for (const auto &ai : FPT->param_types())
LV.merge(computeTypeLinkageInfo(ai));
return LV;
}
case Type::ObjCInterface:
return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl());
case Type::ObjCObject:
return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
case Type::ObjCObjectPointer:
return computeTypeLinkageInfo(
cast<ObjCObjectPointerType>(T)->getPointeeType());
case Type::Atomic:
return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
case Type::Pipe:
return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
}
llvm_unreachable("unhandled type class");
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x10(%rsi), %eax
addl $-0x2, %eax
leaq 0x117789(%rip), %rcx # 0x3420e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x16, 0xf(%rsp)
jmp 0x22a986
movq 0x20(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22a93e
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x77caa
jmp 0x22a973
movq 0x18(%r14), %rdi
callq 0x22a1cf
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x22a9db
movq 0x18(%r14), %rax
jmp 0x22a973
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r14
movq %rax, %rdi
callq 0xc20ee
testq %rax, %rax
cmovneq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb964a
jmp 0x22a982
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x22a93e
leaq 0xf(%rsp), %r15
movb %al, (%r15)
movq 0x20(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22a93e
movzbl %al, %esi
movq %r15, %rdi
callq 0x8953e
jmp 0x22a986
movq 0x18(%r14), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22a93e
movb %al, 0xf(%rsp)
movq 0x10(%r14), %rax
shrq $0x26, %rax
movzwl %ax, %r12d
testq %r12, %r12
je 0x22a986
shll $0x3, %r12d
xorl %r13d, %r13d
leaq 0xf(%rsp), %r15
movq 0x30(%r14,%r13), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22a93e
movzbl %al, %esi
movq %r15, %rdi
callq 0x8953e
addq $0x8, %r13
cmpq %r13, %r12
jne 0x22aa51
jmp 0x22a986
|
/AST/Type.cpp
|
bool clang::Decl::hasAttr<clang::CUDADeviceBuiltinTextureTypeAttr>() const
|
bool hasAttrs() const { return HasAttrs; }
|
testb $0x1, 0x1d(%rdi)
jne 0x22adc1
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x22adef
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x91, 0x20(%rsi)
je 0x22adef
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x22adda
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
retq
|
/clang/AST/DeclBase.h
|
(anonymous namespace)::SimpleTransformVisitor<(anonymous namespace)::StripObjCKindOfTypeVisitor>::VisitParenType(clang::ParenType const*)
|
QualType VisitParenType(const ParenType *T) {
QualType innerType = recurse(T->getInnerType());
if (innerType.isNull())
return {};
if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getParenType(innerType);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x2268fa
cmpq $0x10, %rax
jae 0x22bc5f
xorl %ebx, %ebx
jmp 0x22bc69
cmpq 0x20(%rbx), %rax
jne 0x22bc74
andq $-0x10, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8d216
|
/AST/Type.cpp
|
clang::Qualifiers::print(llvm::raw_ostream&, clang::PrintingPolicy const&, bool) const
|
void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
bool appendSpaceIfNonEmpty) const {
bool addSpace = false;
unsigned quals = getCVRQualifiers();
if (quals) {
AppendTypeQualList(OS, quals, Policy.Restrict);
addSpace = true;
}
if (hasUnaligned()) {
if (addSpace)
OS << ' ';
OS << "__unaligned";
addSpace = true;
}
auto ASStr = getAddrSpaceAsString(getAddressSpace());
if (!ASStr.empty()) {
if (addSpace)
OS << ' ';
addSpace = true;
// Wrap target address space into an attribute syntax
if (isTargetAddressSpace(getAddressSpace()))
OS << "__attribute__((address_space(" << ASStr << ")))";
else
OS << ASStr;
}
if (Qualifiers::GC gc = getObjCGCAttr()) {
if (addSpace)
OS << ' ';
addSpace = true;
if (gc == Qualifiers::Weak)
OS << "__weak";
else
OS << "__strong";
}
if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
if (addSpace)
OS << ' ';
addSpace = true;
}
switch (lifetime) {
case Qualifiers::OCL_None: llvm_unreachable("none but true");
case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
case Qualifiers::OCL_Strong:
if (!Policy.SuppressStrongLifetime)
OS << "__strong";
break;
case Qualifiers::OCL_Weak: OS << "__weak"; break;
case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
}
}
if (appendSpaceIfNonEmpty && addSpace)
OS << ' ';
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rdi), %esi
andl $0x7, %esi
je 0x22e79e
movl (%r14), %edx
shrl $0x19, %edx
andl $0x1, %edx
movq %rbx, %rdi
callq 0x22ec38
movb $0x1, %r13b
jmp 0x22e7a1
xorl %r13d, %r13d
testb $0x8, (%r15)
je 0x22e7e7
testb %r13b, %r13b
je 0x22e7d0
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x22e7c3
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x22e7d0
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
leaq 0x1093f8(%rip), %rsi # 0x337bcf
movl $0xb, %edx
movq %rbx, %rdi
callq 0x577a6
movb $0x1, %r13b
movq (%r15), %rsi
shrq $0x9, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x22e9f4
cmpq $0x0, 0x8(%r12)
je 0x22e88d
testb %r13b, %r13b
je 0x22e830
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x22e823
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x22e830
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
movq (%r15), %rax
shrq $0x9, %rax
cmpl $0x15, %eax
jb 0x22e878
leaq 0x114e5c(%rip), %rsi # 0x34369f
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x582a2
leaq 0x114f39(%rip), %rsi # 0x3437a2
movl $0x3, %edx
movq %rax, %rdi
callq 0x577a6
jmp 0x22e88a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x582a2
movb $0x1, %r13b
movl (%r15), %r12d
shrl $0x4, %r12d
andl $0x3, %r12d
je 0x22e8ee
testb %r13b, %r13b
je 0x22e8c3
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x22e8b6
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x22e8c3
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
cmpl $0x1, %r12d
jne 0x22e8d7
leaq 0x1092f8(%rip), %rsi # 0x337bc8
movl $0x6, %edx
jmp 0x22e8e3
leaq 0x1092fd(%rip), %rsi # 0x337bdb
movl $0x8, %edx
movq %rbx, %rdi
callq 0x577a6
movb $0x1, %r13b
movl (%r15), %r12d
shrl $0x6, %r12d
andl $0x7, %r12d
je 0x22e927
cmpl $0x2, %r12d
jne 0x22e908
testb $0x4, 0x2(%r14)
jne 0x22e92c
movb $0x1, %r15b
testb %r13b, %r13b
je 0x22e93e
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x22e931
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x22e93e
movl %r13d, %r15d
jmp 0x22e99c
movl %r13d, %r15d
jmp 0x22e93e
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
decl %r12d
cmpl $0x3, %r12d
ja 0x22e99c
leaq 0x114522(%rip), %rax # 0x342e70
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xfc19e(%rip), %rsi # 0x32aafc
movl $0x13, %edx
jmp 0x22e994
leaq 0x10925c(%rip), %rsi # 0x337bc8
movl $0x6, %edx
jmp 0x22e994
leaq 0x10926a(%rip), %rsi # 0x337be4
movl $0xf, %edx
jmp 0x22e994
testb $0x4, 0x2(%r14)
jne 0x22e99c
leaq 0x10924c(%rip), %rsi # 0x337bdb
movl $0x8, %edx
movq %rbx, %rdi
callq 0x577a6
testb %bpl, %bpl
je 0x22e9ca
testb %r15b, %r15b
je 0x22e9ca
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x22e9bd
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x20, (%rax)
jmp 0x22e9ca
movq %rbx, %rdi
movl $0x20, %esi
callq 0x5822c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22e9e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3c080
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/TypePrinter.cpp
|
llvm::OwningArrayRef<std::pair<unsigned long, clang::ThunkInfo>>::OwningArrayRef(llvm::ArrayRef<std::pair<unsigned long, clang::ThunkInfo>>)
|
OwningArrayRef(ArrayRef<T> Data)
: MutableArrayRef<T>(new T[Data.size()], Data.size()) {
std::copy(Data.begin(), Data.end(), this->begin());
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rax
shrq $0x3a, %rax
movq %rdx, %r13
shlq $0x6, %r13
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r13, %rdi
callq 0x3c450
movq %rax, %r15
testq %rbx, %rbx
je 0x235f6d
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x3c160
movq %r15, (%r12)
movq %rbx, 0x8(%r12)
testq %rbx, %rbx
jle 0x235fc3
incq %rbx
xorl %eax, %eax
movq (%r14,%rax), %rcx
movq %rcx, (%r15,%rax)
movups 0x8(%r14,%rax), %xmm0
movups 0x18(%r14,%rax), %xmm1
movups 0x28(%r14,%rax), %xmm2
movups %xmm0, 0x8(%r15,%rax)
movups %xmm1, 0x18(%r15,%rax)
movups %xmm2, 0x28(%r15,%rax)
movq 0x38(%r14,%rax), %rcx
movq %rcx, 0x38(%r15,%rax)
decq %rbx
addq $0x40, %rax
cmpq $0x1, %rbx
jg 0x235f80
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/ArrayRef.h
|
clang::ItaniumVTableContext::~ItaniumVTableContext()
|
ItaniumVTableContext::~ItaniumVTableContext() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x283d93(%rip), %rax # 0x4b9e38
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
movl 0x80(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x56dc8
movq 0x58(%rbx), %rdi
movl 0x68(%rbx), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x56dc8
leaq 0x40(%rbx), %rdi
callq 0x248966
movq 0x40(%rbx), %rdi
movl 0x50(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x56dc8
movq 0x28(%rbx), %rdi
movl 0x38(%rbx), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x56dc8
leaq 0x282555(%rip), %rax # 0x4b8670
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x96dc0
movq 0x8(%rbx), %rdi
movl 0x18(%rbx), %eax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
movl $0x8, %edx
popq %rbx
jmp 0x56dc8
nop
|
/AST/VTableBuilder.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.