name string | code string | asm string | file string |
|---|---|---|---|
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 wo... | 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,... | /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
... | /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 (!HandleMemberPointerAcc... | 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... | /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);... | 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, 0x... | /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 %r... | /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 d... | 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 ... | /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(... | /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(),
... | 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)
mova... | /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()) {
... | 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 0x10b3... | /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), %r... | /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 Stm... | 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
mov... | /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... | 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... | /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
... | /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 initi... | 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... | /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
... | /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.
... | 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
... | /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 ... | /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 ... | 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
tes... | /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 0x... | /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(ge... | 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... | 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... | /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(getInteg... | 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(%rs... | /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
mo... | /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)
... | 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... | /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, ... | /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, ... | /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 %... | /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, ... | /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);
... | 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, 0x... | /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
... | /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),... | /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();... | 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), ... | /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();... | 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), %r... | /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 ... | /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
... | /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
cal... | /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
mov... | /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.ac... | 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... | /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), ... | /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), ... | /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), ... | /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.a... | 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(%r... | /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.a... | 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)... | /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 fal... | 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(%rs... | /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... | /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
m... | /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
m... | /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
m... | /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 (%ra... | /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 (%ra... | /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 0... | /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 0... | /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, %r... | /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... | /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->getBit... | 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,... | /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->getB... | 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
mov... | /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
mov... | /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: Diagnos... | 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, 0x2... | /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, ... | /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... | 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 $... | /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
mov... | /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(%r... | /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(%r... | /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 ... | 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
c... | /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
c... | /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
c... | /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<... | 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(%r... | /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<... | 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)
cm... | /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 (R... | 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 %... | /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 (R... | 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,... | /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... | 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... | /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... | 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
... | /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 *ElemD... | 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 0x1b4f... | /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), IsU... | 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(%rd... | /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 ... | /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 %x... | /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());
... | 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 ... | /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.isGNUFam... | 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... | /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"... | 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), %... | /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... | 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), %... | /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
s... | /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... | /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::Indepen... | 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 0x1faf3... | /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::Take... | 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
... | /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 ... | 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
mov... | /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
call... | /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
// contai... | 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(... | /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()) {
... | 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 $0x63697... | /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
call... | /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.Ad... | 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... | /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 %... | /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 ... | 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 # i... | /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 DEPE... | 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 (... | /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... | /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... | /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 (ad... | 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, %r1... | /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... | /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(%rb... | /AST/VTableBuilder.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.