Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/InterpBuiltin_8cpp_source.html below:

clang: lib/AST/ByteCode/InterpBuiltin.cpp Source File

(

*

:

->arguments()) {

assert(

->getFunction()->getNumParams() > Index);

Offset =

->getFunction()->getParamOffset(Index);

->getParam<

>(Offset);

Offset =

->getFunction()->getParamOffset(Index);

R =

->getParam<

>(Offset).toAPSInt());

(IntWidth == 16)

llvm_unreachable(

);

(LongWidth == 32)

(LongWidth == 16)

llvm_unreachable(

);

std::optional<PrimType>

= S.getContext().classify(QT);

int64_t

= Val.getSExtValue();

uint64_t

= Val.getZExtValue();

<

T>

(std::is_same_v<T, APInt>)

(std::is_same_v<T, APSInt>)

(

(

(

) * 8,

uint64_t

(Val),

std::is_signed_v<T>),

!std::is_signed_v<T>),

ValueT, { Dest.

<

>() = T::from(

(

)); });

std::optional<PrimType> &

) {

llvm_unreachable(

);

= S.Current->getSource(OpPC);

S.CCEDiag(

, diag::note_constexpr_invalid_function)

S.CCEDiag(

, diag::note_invalid_subexpr_in_const_expr);

Depth = S.Current->getDepth();

F && F->isInStdNamespace() && F->getIdentifier() &&

F->getIdentifier()->isStr(

);

(S.inConstantContext() && !S.checkingPotentialConstantExpression() &&

S.getEvalStatus().

&&

(Depth == 1 || (Depth == 2 && isStdCall(Caller->

())))) {

diag::warn_is_constant_evaluated_always_true_constexpr)

diag::warn_is_constant_evaluated_always_true_constexpr)

ID =

->getBuiltinID();

(ID == Builtin::BIstrcmp || ID == Builtin::BIstrncmp)

uint64_t Limit = ~static_cast<uint64_t>(0);

(ID == Builtin::BIstrncmp || ID == Builtin::BI__builtin_strncmp)

(;; ++IndexA, ++IndexB, ++Steps) {

uint8_t CA = PA.

<uint8_t>();

uint8_t CB = PB.

<uint8_t>();

}

(CA < CB) {

(CA == 0 || CB == 0)

ID =

->getBuiltinID();

(ID == Builtin::BIstrlen || ID == Builtin::BIwcslen)

(ID == Builtin::BI__builtin_wcslen || ID == Builtin::BIwcslen) {

assert(ElemSize == AC.getTypeSizeInChars(AC.getWCharType()).getQuantity());

(

I = StrPtr.

();; ++I, ++Len) {

Val = ElemPtr.

<uint8_t>();

Val = ElemPtr.

<uint16_t>();

Val = ElemPtr.

<uint32_t>();

llvm_unreachable(

);

(

I = 0;; ++I) {

(Elem.

<int8_t>() == 0)

Str += Elem.

<

>();

Fill = llvm::APInt(32, 0);

(StringRef(Str).getAsInteger(0, Fill))

llvm::fltSemantics &TargetSemantics =

llvm::APFloat::getSNaN(TargetSemantics,

, &Fill));

llvm::APFloat::getQNaN(TargetSemantics,

, &Fill));

llvm::APFloat::getQNaN(TargetSemantics,

, &Fill));

llvm::APFloat::getSNaN(TargetSemantics,

, &Fill));

llvm::fltSemantics &TargetSemantics =

(LHS.

() || RHS < LHS)

(LHS.

() || RHS > LHS)

IsInf = Arg.

();

Builtin::BI__builtin_isgreater:

Builtin::BI__builtin_isgreaterequal:

Builtin::BI__builtin_isless:

Builtin::BI__builtin_islessequal:

Builtin::BI__builtin_islessgreater: {

Builtin::BI__builtin_isunordered:

llvm_unreachable(

);

FPClassArgT = *S.getContext().classify(

->getArg(1)->getType());

int32_t

((F.

() & FPClassArg).getZExtValue());

APFloat::fcInfinity:

APFloat::fcNormal:

APFloat::fcZero:

ArgT = *S.getContext().classify(

->getArg(0)->getType());

(APInt::getSignedMinValue(Val.getBitWidth()),

))

(Val.isNegative())

ArgT = *S.getContext().classify(

->getArg(0)->getType());

ArgT = *S.getContext().classify(

->getArg(0)->getType());

ArgT = *S.getContext().classify(

->getArg(0)->getType());

(S, Val.getBitWidth() - Val.getSignificantBits(),

->getType());

ArgT = *S.getContext().classify(

->getArg(0)->getType());

assert(

->getNumArgs() == 1);

int32_t ReturnVal =

int32_t

(ResultClass);

NumArgs =

->getNumArgs();

assert(NumArgs == 2 || NumArgs == 3);

ArgT = *S.getContext().classify(

->getArg(0)->getType());

AmountT = *S.getContext().classify(

->getArg(1)->getType());

ValueT = *S.getContext().classify(

->getArg(0)->getType());

ArgT = *S.getContext().classify(

->getArg(0)->getType());

uint64_t N =

.countr_zero();

assert(

->getArg(0)->isLValue());

}

(PtrT ==

) {

assert(

&&

);

(ArgT,

&Arg = S.Stk.peek<

>(); S.Stk.push<

>(Arg););

->getDecl()->isConstexpr();

ArgT = *S.getContext().classify(

->getArg(0)->getType());

BuiltinOp =

->getBuiltinID();

RHST = *S.getContext().classify(

->getArg(1)->getType());

LHST = *S.getContext().classify(

->getArg(0)->getType());

ResultType =

->getArg(2)->getType()->getPointeeType();

ResultT = *S.getContext().classify(ResultType);

(BuiltinOp == Builtin::BI__builtin_add_overflow ||

BuiltinOp == Builtin::BI__builtin_sub_overflow ||

BuiltinOp == Builtin::BI__builtin_mul_overflow) {

IsSigned = LHS.isSigned() || RHS.isSigned() ||

AllSigned = LHS.isSigned() && RHS.isSigned() &&

uint64_t LHSSize = LHS.getBitWidth();

uint64_t RHSSize = RHS.getBitWidth();

uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);

(IsSigned && !AllSigned)

LHS =

(LHS.extOrTrunc(MaxBits), !IsSigned);

RHS =

(RHS.extOrTrunc(MaxBits), !IsSigned);

llvm_unreachable(

);

Builtin::BI__builtin_add_overflow:

Builtin::BI__builtin_sadd_overflow:

Builtin::BI__builtin_saddl_overflow:

Builtin::BI__builtin_saddll_overflow:

Builtin::BI__builtin_uadd_overflow:

Builtin::BI__builtin_uaddl_overflow:

Builtin::BI__builtin_uaddll_overflow:

= LHS.isSigned() ? LHS.sadd_ov(RHS, Overflow)

: LHS.uadd_ov(RHS, Overflow);

Builtin::BI__builtin_sub_overflow:

Builtin::BI__builtin_ssub_overflow:

Builtin::BI__builtin_ssubl_overflow:

Builtin::BI__builtin_ssubll_overflow:

Builtin::BI__builtin_usub_overflow:

Builtin::BI__builtin_usubl_overflow:

Builtin::BI__builtin_usubll_overflow:

= LHS.isSigned() ? LHS.ssub_ov(RHS, Overflow)

: LHS.usub_ov(RHS, Overflow);

Builtin::BI__builtin_mul_overflow:

Builtin::BI__builtin_smul_overflow:

Builtin::BI__builtin_smull_overflow:

Builtin::BI__builtin_smulll_overflow:

Builtin::BI__builtin_umul_overflow:

Builtin::BI__builtin_umull_overflow:

Builtin::BI__builtin_umulll_overflow:

= LHS.isSigned() ? LHS.smul_ov(RHS, Overflow)

: LHS.umul_ov(RHS, Overflow);

(BuiltinOp == Builtin::BI__builtin_add_overflow ||

BuiltinOp == Builtin::BI__builtin_sub_overflow ||

BuiltinOp == Builtin::BI__builtin_mul_overflow) {

(!APSInt::isSameValue(Temp,

))

assert(

->getDecl()->getReturnType()->isBooleanType());

S.Stk.push<

>(Overflow);

BuiltinOp =

->getBuiltinID();

LHST = *S.getContext().classify(

->getArg(0)->getType());

RHST = *S.getContext().classify(

->getArg(1)->getType());

CarryT = *S.getContext().classify(

->getArg(2)->getType());

FirstOverflowed =

;

SecondOverflowed =

;

llvm_unreachable(

);

Builtin::BI__builtin_addcb:

Builtin::BI__builtin_addcs:

Builtin::BI__builtin_addc:

Builtin::BI__builtin_addcl:

Builtin::BI__builtin_addcll:

LHS.uadd_ov(RHS, FirstOverflowed).uadd_ov(CarryIn, SecondOverflowed);

Builtin::BI__builtin_subcb:

Builtin::BI__builtin_subcs:

Builtin::BI__builtin_subc:

Builtin::BI__builtin_subcl:

Builtin::BI__builtin_subcll:

LHS.usub_ov(RHS, FirstOverflowed).usub_ov(CarryIn, SecondOverflowed);

CarryOut = (uint64_t)(FirstOverflowed | SecondOverflowed);

CarryOutType =

->getArg(3)->getType()->getPointeeType();

CarryOutT = *S.getContext().classify(CarryOutType);

assert(

->getType() ==

->getArg(0)->getType());

BuiltinOp =

->getBuiltinID();

ValT = *S.getContext().classify(

->getArg(0));

ZeroIsUndefined = BuiltinOp != Builtin::BI__lzcnt16 &&

BuiltinOp != Builtin::BI__lzcnt &&

BuiltinOp != Builtin::BI__lzcnt64;

(

->getBuiltinID() == Builtin::BI__builtin_clzg &&

->getNumArgs() == 2) {

FallbackT = *S.getContext().classify(

->getArg(1));

ValT = *S.getContext().classify(

->getArg(0));

(

->getBuiltinID() == Builtin::BI__builtin_ctzg &&

->getNumArgs() == 2) {

FallbackT = *S.getContext().classify(

->getArg(1));

ReturnT = *S.getContext().classify(

->getType());

ValT = *S.getContext().classify(

->getArg(0));

assert(Val.getActiveBits() <= 64);

{ S.Stk.push<

>(T::from(Val.byteSwap().getZExtValue())); });

BuiltinOp =

->getBuiltinID();

ValT = *S.getContext().classify(

->getArg(0));

SizeValOffset = 0;

(BuiltinOp != Builtin::BI__c11_atomic_is_lock_free)

returnBool = [&S](

) ->

{

(Size.isPowerOfTwo()) {

InlineWidthBits =

(BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||

returnBool(

);

assert(BuiltinOp != Builtin::BI__c11_atomic_is_lock_free);

returnBool(

);

(

(

(64, IntVal,

),

).isAligned(Size.getAsAlign()))

returnBool(

);

*PtrArg =

->getArg(1);

(

*ICE = dyn_cast<ImplicitCastExpr>(PtrArg)) {

(ICE->getCastKind() == CK_BitCast)

PtrArg = ICE->getSubExpr();

returnBool(

);

(BuiltinOp == Builtin::BI__atomic_always_lock_free)

returnBool(

);

.atIndex(0).initialize();

.atIndex(1).initialize();

BuiltinOp =

->getBuiltinID();

AlignmentT = *S.Ctx.classify(

->getArg(1));

(Alignment < 0 || !Alignment.isPowerOf2()) {

S.FFDiag(

, diag::note_constexpr_invalid_alignment) << Alignment;

MaxValue(APInt::getOneBitSet(SrcWidth, SrcWidth - 1));

(APSInt::compareValues(Alignment, MaxValue) > 0) {

S.FFDiag(

, diag::note_constexpr_alignment_too_big)

<< MaxValue <<

->getArg(0)->getType() << Alignment;

FirstArgT = *S.Ctx.classify(

->getArg(0));

Align = Alignment.extOrTrunc(Src.getBitWidth());

(BuiltinOp == Builtin::BI__builtin_align_up) {

((Src + (Align - 1)) & ~(Align - 1), Src.isUnsigned());

}

(BuiltinOp == Builtin::BI__builtin_align_down) {

AlignedVal =

(Src & ~(Align - 1), Src.isUnsigned());

assert(*S.Ctx.classify(

->getType()) ==

);

S.Stk.push<

>((Src & (Align - 1)) == 0);

assert(FirstArgT ==

);

(BuiltinOp == Builtin::BI__builtin_is_aligned) {

S.Stk.push<

>(

);

S.Stk.push<

>(

);

S.FFDiag(

->getArg(0), diag::note_constexpr_alignment_compute)

assert(BuiltinOp == Builtin::BI__builtin_align_down ||

BuiltinOp == Builtin::BI__builtin_align_up);

assert(Alignment.getBitWidth() <= 64 &&

);

uint64_t Alignment64 = Alignment.getZExtValue();

? llvm::alignDown(PtrOffset, Alignment64)

: llvm::alignTo(PtrOffset, Alignment64));

S.FFDiag(

->getArg(0), diag::note_constexpr_alignment_adjust) << Alignment;

assert(

->getNumArgs() == 2 ||

->getNumArgs() == 3);

std::optional<PrimType> PtrT = S.Ctx.classify(

->getArg(0));

std::optional<APSInt> ExtraOffset;

(

->getNumArgs() == 2) {

AlignmentT = *S.Ctx.classify(

->getArg(1));

ExtraOffsetT = *S.Ctx.classify(

->getArg(2));

(BaseAlignment < Align) {

S.CCEDiag(

->getArg(0),

diag::note_constexpr_baa_insufficient_alignment)

(AVOffset.

(Align) != AVOffset) {

S.CCEDiag(

->getArg(0),

diag::note_constexpr_baa_insufficient_alignment)

S.CCEDiag(

->getArg(0),

diag::note_constexpr_baa_value_insufficient_alignment)

(

->getNumArgs() != 2 || !

->getArg(0)->getType()->isIntegerType() ||

!

->getArg(1)->getType()->isIntegerType())

BitWidth = Val.getBitWidth();

uint64_t Shift = Index.extractBitsAsZExtValue(8, 0);

uint64_t Length = Index.extractBitsAsZExtValue(8, 8);

Length = Length > BitWidth ? BitWidth : Length;

(Length == 0 || Shift >= BitWidth) {

uint64_t

= Val.getZExtValue() >> Shift;

&= llvm::maskTrailingOnes<uint64_t>(Length);

(

->getNumArgs() != 2 || !

->getArg(0)->getType()->isIntegerType() ||

!

->getArg(1)->getType()->isIntegerType() ||

BitWidth = Val.getBitWidth();

uint64_t Index = Idx.extractBitsAsZExtValue(8, 0);

(Index < BitWidth)

Val.clearHighBits(BitWidth - Index);

!

->getArg(0)->getType()->isIntegerType())

(S, Val.countLeadingZeros(), CallType);

!

->getArg(0)->getType()->isIntegerType())

(S, Val.countTrailingZeros(), CallType);

(

->getNumArgs() != 2 || !

->getArg(0)->getType()->isIntegerType() ||

!

->getArg(1)->getType()->isIntegerType())

BitWidth = Val.getBitWidth();

(

I = 0,

= 0; I != BitWidth; ++I) {

.setBitVal(I, Val[

++]);

(

->getNumArgs() != 2 || !

->getArg(0)->getType()->isIntegerType() ||

!

->getArg(1)->getType()->isIntegerType())

BitWidth = Val.getBitWidth();

(

I = 0,

= 0; I != BitWidth; ++I) {

.setBitVal(

++, Val[I]);

(

->getNumArgs() != 4 || !

->getArg(0)->getType()->isIntegerType() ||

!

->getArg(1)->getType()->isIntegerType() ||

!

->getArg(2)->getType()->isIntegerType())

BuiltinOp =

->getBuiltinID();

IsAdd = BuiltinOp == clang::X86::BI__builtin_ia32_addcarryx_u32 ||

BuiltinOp == clang::X86::BI__builtin_ia32_addcarryx_u64;

BitWidth = LHS.getBitWidth();

CarryInBit = CarryIn.ugt(0) ? 1 : 0;

IsAdd ? (LHS.zext(BitWidth + 1) + (RHS.zext(BitWidth + 1) + CarryInBit))

: (LHS.zext(BitWidth + 1) - (RHS.zext(BitWidth + 1) + CarryInBit));

(ExResult.extractBits(1, BitWidth),

);

CarryOutType =

->getArg(3)->getType()->getPointeeType();

CarryOutT = *S.getContext().classify(CarryOutType);

&Ptr = S.Stk.peek<

>();

assert(Ptr.getFieldDesc()->isPrimitiveArray());

StringRef R(&Ptr.deref<

>(), Ptr.getFieldDesc()->getNumElems() - 1);

uint64_t

= getPointerAuthStableSipHash(R);

*Arg =

->getArg(0);

returnInt = [&S,

](

) ->

{

PrevDiags = S.getEvalStatus().

;

S.getEvalStatus().

=

;

Res =

.interpretExpr(Arg,

Arg->

());

S.getEvalStatus().

= PrevDiags;

(Res.isInvalid()) {

returnInt(

);

&LV = Res.toAPValue();

(

.isNull()) {

returnInt(

);

}

(

*

=

.dyn_cast<

*>()) {

(!isa<StringLiteral>(

))

returnInt(

);

returnInt(

);

returnInt(

);

returnInt(

);

returnInt(

);

*NewCall =

;

*MD = dyn_cast_if_present<CXXMethodDecl>(

->getDecl());

(!FnII || !FnII->

(

))

dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent());

(CTSD->isInStdNamespace() && ClassII && ClassII->

(

) &&

ElemType = TAL[0].getAsType();

NewCall = cast<CallExpr>(F->Caller->getExpr(F->getRetPC()));

(ElemType.

()) {

? diag::note_constexpr_new_untyped

: diag::note_constexpr_new);

S.FFDiag(

, diag::note_constexpr_new_not_complete_object_type)

assert(!ElemSize.

());

NumElems, Remainder;

APInt::udivrem(

, ElemSizeAP, NumElems, Remainder);

(Remainder != 0) {

S.FFDiag(

, diag::note_constexpr_operator_new_bad_size)

<<

<<

(ElemSizeAP,

) << ElemType;

(NumElems.getActiveBits() >

S.FFDiag(

, diag::note_constexpr_new_too_large)

<< NumElems.getZExtValue();

std::optional<PrimType> ElemT = S.getContext().classify(ElemType);

(NumElems.ule(1)) {

*B = Allocator.allocate(Desc, S.getContext().getEvalID(),

assert(NumElems.ugt(1));

Allocator.allocate(NewCall, *ElemT, NumElems.getZExtValue(),

*Desc = S.P.createDescriptor(

,

,

,

(NumElems.ule(1)) {

*B = Allocator.allocate(Desc, S.getContext().getEvalID(),

Allocator.allocate(Desc, NumElems.getZExtValue(), S.Ctx.getEvalID(),

*Source =

;

*BlockToDelete =

;

S.CCEDiag(

, diag::note_constexpr_deallocate_null);

BlockToDelete = Ptr.

();

assert(BlockToDelete);

std::optional<DynamicAllocator::Form> AllocForm =

Allocator.getAllocationForm(Source);

(!Allocator.deallocate(Source, BlockToDelete, S)) {

S.FFDiag(

, diag::note_constexpr_double_delete);

ID =

->getBuiltinID();

assert(

->getType() == ElemType);

ElemT = *S.getContext().classify(ElemType);

BitWidth =

.bitWidth();

(

I = 1; I != NumElems; ++I) {

Elem = Arg.

(I).deref<T>();

(ID == Builtin::BI__builtin_reduce_add) {

OverflowBits = BitWidth + 1;

(PrevResult.toAPSInt(OverflowBits) +

Elem.toAPSInt(OverflowBits)));

}

(ID == Builtin::BI__builtin_reduce_mul) {

OverflowBits = BitWidth * 2;

(PrevResult.toAPSInt(OverflowBits) *

Elem.toAPSInt(OverflowBits)));

}

(ID == Builtin::BI__builtin_reduce_and) {

}

(ID == Builtin::BI__builtin_reduce_or) {

}

(ID == Builtin::BI__builtin_reduce_xor) {

llvm_unreachable(

);

assert(

->getNumArgs() == 1);

(

->getArg(0)->getType()->isIntegerType()) {

ArgT = *S.getContext().classify(

->getArg(0)->getType());

assert(

->getArg(0)->getType()->isVectorType());

ElemT = *S.getContext().classify(ElemType);

(

I = 0; I != NumElems; ++I) {

T::from(Arg.

(I).

<

>().toAPSInt().popcount());

assert(

->getNumArgs() == 3);

ID =

->getBuiltinID();

assert(!Size.isSigned() &&

);

(ID == Builtin::BImemcpy || ID == Builtin::BImemmove)

Move = (ID == Builtin::BI__builtin_memmove || ID == Builtin::BImemmove);

(Size.isZero()) {

S.Stk.push<

>(DestPtr);

S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_memcpy_null)

<<

Move <<

<< !SrcPtr.

()

RemainingDestElems;

DestElemType = DestPtr.

();

RemainingDestElems = 1;

(Size.urem(DestElemSize) != 0) {

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_memcpy_unsupported)

<< Move <<

<< 0 << DestElemType << Size

RemainingSrcElems;

SrcElemType = SrcPtr.

();

RemainingSrcElems = 1;

S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_memcpy_type_pun)

<< Move << SrcElemType << DestElemType;

RemainingDestBytes = RemainingDestElems * DestElemSize;

RemainingSrcBytes = RemainingSrcElems * SrcElemSize;

(Size.ugt(RemainingDestBytes) || Size.ugt(RemainingSrcBytes)) {

N = Size.udiv(DestElemSize);

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_memcpy_unsupported)

<< Move <<

<< (Size.ugt(RemainingSrcBytes) ? 1 : 2)

<< DestElemType <<

(N, 10,

);

N = Size.getZExtValue();

((SrcIndex <= DstIndex && (SrcIndex + N) > DstIndex) ||

(DstIndex <= SrcIndex && (DstIndex + N) > SrcIndex)) {

S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_memcpy_overlap)

assert(Size.getZExtValue() % DestElemSize == 0);

S.Stk.push<

>(DestPtr);

assert(

->getNumArgs() == 3);

ID =

->getBuiltinID();

(ID == Builtin::BImemcmp || ID == Builtin::BIbcmp ||

ID == Builtin::BIwmemcmp)

(Size.isZero()) {

(ID == Builtin::BIwmemcmp || ID == Builtin::BI__builtin_wmemcmp);

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_memcmp_unsupported)

ElemSize = 1;

ByteSize = Size.getZExtValue() * ElemSize;

CmpSize = std::min(MinBufferSize, ByteSize);

(

I = 0; I != CmpSize; I += ElemSize) {

T A = *reinterpret_cast<T *>(BufferA.Data.get() + I);

T B = *reinterpret_cast<T *>(BufferB.Data.get() + I);

pushInteger(S, -1, Call->getType());

std::byte A = BufferA.

[I];

std::byte B = BufferB.

[I];

(ByteSize <= CmpSize) {

S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end)

<<

<< S.Current->getRange(OpPC);

std::optional<PrimType> ReturnT = S.getContext().classify(

);

(BuiltinID) {

Builtin::BI__builtin_is_constant_evaluated:

Builtin::BI__builtin_assume:

Builtin::BI__assume:

Builtin::BI__builtin_strcmp:

Builtin::BIstrcmp:

Builtin::BI__builtin_strncmp:

Builtin::BIstrncmp:

Builtin::BI__builtin_strlen:

Builtin::BIstrlen:

Builtin::BI__builtin_wcslen:

Builtin::BIwcslen:

Builtin::BI__builtin_nan:

Builtin::BI__builtin_nanf:

Builtin::BI__builtin_nanl:

Builtin::BI__builtin_nanf16:

Builtin::BI__builtin_nanf128:

Builtin::BI__builtin_nans:

Builtin::BI__builtin_nansf:

Builtin::BI__builtin_nansl:

Builtin::BI__builtin_nansf16:

Builtin::BI__builtin_nansf128:

Builtin::BI__builtin_huge_val:

Builtin::BI__builtin_huge_valf:

Builtin::BI__builtin_huge_vall:

Builtin::BI__builtin_huge_valf16:

Builtin::BI__builtin_huge_valf128:

Builtin::BI__builtin_inf:

Builtin::BI__builtin_inff:

Builtin::BI__builtin_infl:

Builtin::BI__builtin_inff16:

Builtin::BI__builtin_inff128:

Builtin::BI__builtin_copysign:

Builtin::BI__builtin_copysignf:

Builtin::BI__builtin_copysignl:

Builtin::BI__builtin_copysignf128:

Builtin::BI__builtin_fmin:

Builtin::BI__builtin_fminf:

Builtin::BI__builtin_fminl:

Builtin::BI__builtin_fminf16:

Builtin::BI__builtin_fminf128:

Builtin::BI__builtin_fminimum_num:

Builtin::BI__builtin_fminimum_numf:

Builtin::BI__builtin_fminimum_numl:

Builtin::BI__builtin_fminimum_numf16:

Builtin::BI__builtin_fminimum_numf128:

Builtin::BI__builtin_fmax:

Builtin::BI__builtin_fmaxf:

Builtin::BI__builtin_fmaxl:

Builtin::BI__builtin_fmaxf16:

Builtin::BI__builtin_fmaxf128:

Builtin::BI__builtin_fmaximum_num:

Builtin::BI__builtin_fmaximum_numf:

Builtin::BI__builtin_fmaximum_numl:

Builtin::BI__builtin_fmaximum_numf16:

Builtin::BI__builtin_fmaximum_numf128:

Builtin::BI__builtin_isnan:

Builtin::BI__builtin_issignaling:

Builtin::BI__builtin_isinf:

Builtin::BI__builtin_isinf_sign:

Builtin::BI__builtin_isfinite:

Builtin::BI__builtin_isnormal:

Builtin::BI__builtin_issubnormal:

Builtin::BI__builtin_iszero:

Builtin::BI__builtin_signbit:

Builtin::BI__builtin_signbitf:

Builtin::BI__builtin_signbitl:

Builtin::BI__builtin_isgreater:

Builtin::BI__builtin_isgreaterequal:

Builtin::BI__builtin_isless:

Builtin::BI__builtin_islessequal:

Builtin::BI__builtin_islessgreater:

Builtin::BI__builtin_isunordered:

Builtin::BI__builtin_isfpclass:

Builtin::BI__builtin_fpclassify:

Builtin::BI__builtin_fabs:

Builtin::BI__builtin_fabsf:

Builtin::BI__builtin_fabsl:

Builtin::BI__builtin_fabsf128:

Builtin::BI__builtin_abs:

Builtin::BI__builtin_labs:

Builtin::BI__builtin_llabs:

Builtin::BI__builtin_popcount:

Builtin::BI__builtin_popcountl:

Builtin::BI__builtin_popcountll:

Builtin::BI__builtin_popcountg:

Builtin::BI__popcnt16:

Builtin::BI__popcnt:

Builtin::BI__popcnt64:

Builtin::BI__builtin_parity:

Builtin::BI__builtin_parityl:

Builtin::BI__builtin_parityll:

Builtin::BI__builtin_clrsb:

Builtin::BI__builtin_clrsbl:

Builtin::BI__builtin_clrsbll:

Builtin::BI__builtin_bitreverse8:

Builtin::BI__builtin_bitreverse16:

Builtin::BI__builtin_bitreverse32:

Builtin::BI__builtin_bitreverse64:

Builtin::BI__builtin_classify_type:

Builtin::BI__builtin_expect:

Builtin::BI__builtin_expect_with_probability:

Builtin::BI__builtin_rotateleft8:

Builtin::BI__builtin_rotateleft16:

Builtin::BI__builtin_rotateleft32:

Builtin::BI__builtin_rotateleft64:

Builtin::BI_rotl8:

Builtin::BI_rotl16:

Builtin::BI_rotl:

Builtin::BI_lrotl:

Builtin::BI_rotl64:

Builtin::BI__builtin_rotateright8:

Builtin::BI__builtin_rotateright16:

Builtin::BI__builtin_rotateright32:

Builtin::BI__builtin_rotateright64:

Builtin::BI_rotr8:

Builtin::BI_rotr16:

Builtin::BI_rotr:

Builtin::BI_lrotr:

Builtin::BI_rotr64:

Builtin::BI__builtin_ffs:

Builtin::BI__builtin_ffsl:

Builtin::BI__builtin_ffsll:

Builtin::BIaddressof:

Builtin::BI__addressof:

Builtin::BI__builtin_addressof:

Builtin::BIas_const:

Builtin::BIforward:

Builtin::BIforward_like:

Builtin::BImove:

Builtin::BImove_if_noexcept:

Builtin::BI__builtin_eh_return_data_regno:

Builtin::BI__builtin_launder:

Builtin::BI__builtin_add_overflow:

Builtin::BI__builtin_sub_overflow:

Builtin::BI__builtin_mul_overflow:

Builtin::BI__builtin_sadd_overflow:

Builtin::BI__builtin_uadd_overflow:

Builtin::BI__builtin_uaddl_overflow:

Builtin::BI__builtin_uaddll_overflow:

Builtin::BI__builtin_usub_overflow:

Builtin::BI__builtin_usubl_overflow:

Builtin::BI__builtin_usubll_overflow:

Builtin::BI__builtin_umul_overflow:

Builtin::BI__builtin_umull_overflow:

Builtin::BI__builtin_umulll_overflow:

Builtin::BI__builtin_saddl_overflow:

Builtin::BI__builtin_saddll_overflow:

Builtin::BI__builtin_ssub_overflow:

Builtin::BI__builtin_ssubl_overflow:

Builtin::BI__builtin_ssubll_overflow:

Builtin::BI__builtin_smul_overflow:

Builtin::BI__builtin_smull_overflow:

Builtin::BI__builtin_smulll_overflow:

Builtin::BI__builtin_addcb:

Builtin::BI__builtin_addcs:

Builtin::BI__builtin_addc:

Builtin::BI__builtin_addcl:

Builtin::BI__builtin_addcll:

Builtin::BI__builtin_subcb:

Builtin::BI__builtin_subcs:

Builtin::BI__builtin_subc:

Builtin::BI__builtin_subcl:

Builtin::BI__builtin_subcll:

Builtin::BI__builtin_clz:

Builtin::BI__builtin_clzl:

Builtin::BI__builtin_clzll:

Builtin::BI__builtin_clzs:

Builtin::BI__builtin_clzg:

Builtin::BI__lzcnt16:

Builtin::BI__lzcnt:

Builtin::BI__lzcnt64:

Builtin::BI__builtin_ctz:

Builtin::BI__builtin_ctzl:

Builtin::BI__builtin_ctzll:

Builtin::BI__builtin_ctzs:

Builtin::BI__builtin_ctzg:

Builtin::BI__builtin_bswap16:

Builtin::BI__builtin_bswap32:

Builtin::BI__builtin_bswap64:

Builtin::BI__atomic_always_lock_free:

Builtin::BI__atomic_is_lock_free:

Builtin::BI__c11_atomic_is_lock_free:

Builtin::BI__builtin_complex:

Builtin::BI__builtin_is_aligned:

Builtin::BI__builtin_align_up:

Builtin::BI__builtin_align_down:

Builtin::BI__builtin_assume_aligned:

clang::X86::BI__builtin_ia32_bextr_u32:

clang::X86::BI__builtin_ia32_bextr_u64:

clang::X86::BI__builtin_ia32_bextri_u32:

clang::X86::BI__builtin_ia32_bextri_u64:

clang::X86::BI__builtin_ia32_bzhi_si:

clang::X86::BI__builtin_ia32_bzhi_di:

clang::X86::BI__builtin_ia32_lzcnt_u16:

clang::X86::BI__builtin_ia32_lzcnt_u32:

clang::X86::BI__builtin_ia32_lzcnt_u64:

clang::X86::BI__builtin_ia32_tzcnt_u16:

clang::X86::BI__builtin_ia32_tzcnt_u32:

clang::X86::BI__builtin_ia32_tzcnt_u64:

clang::X86::BI__builtin_ia32_pdep_si:

clang::X86::BI__builtin_ia32_pdep_di:

clang::X86::BI__builtin_ia32_pext_si:

clang::X86::BI__builtin_ia32_pext_di:

clang::X86::BI__builtin_ia32_addcarryx_u32:

clang::X86::BI__builtin_ia32_addcarryx_u64:

clang::X86::BI__builtin_ia32_subborrow_u32:

clang::X86::BI__builtin_ia32_subborrow_u64:

Builtin::BI__builtin_os_log_format_buffer_size:

Builtin::BI__builtin_ptrauth_string_discriminator:

Builtin::BI__builtin_constant_p:

Builtin::BI__noop:

Builtin::BI__builtin_operator_new:

Builtin::BI__builtin_operator_delete:

Builtin::BI__arithmetic_fence:

Builtin::BI__builtin_reduce_add:

Builtin::BI__builtin_reduce_mul:

Builtin::BI__builtin_reduce_and:

Builtin::BI__builtin_reduce_or:

Builtin::BI__builtin_reduce_xor:

Builtin::BI__builtin_elementwise_popcount:

Builtin::BI__builtin_memcpy:

Builtin::BImemcpy:

Builtin::BI__builtin_memmove:

Builtin::BImemmove:

Builtin::BI__builtin_memcmp:

Builtin::BImemcmp:

Builtin::BI__builtin_bcmp:

Builtin::BIbcmp:

Builtin::BI__builtin_wmemcmp:

Builtin::BIwmemcmp:

S.FFDiag(S.Current->getLocation(OpPC),

diag::note_invalid_subexpr_in_const_expr)

<< S.Current->getRange(OpPC);

int64_t &IntResult) {

N =

->getNumComponents();

ArrayIndex = 0;

(

I = 0; I != N; ++I) {

(

.getKind()) {

assert(FieldIndex < RL.

() &&

);

int64_t Index = ArrayIndices[ArrayIndex];

+= Index * ElementSize;

CurrentType = BaseSpec->

();

llvm_unreachable(

);

IntResult =

.getQuantity();

FieldPtr.

<

>() = T::from(IntValue.getSExtValue()));

copyComposite(InterpState &S, CodePtr OpPC,

&Src,

&Dest,

Activate);

&Dest,

Activate =

) {

copyField = [&](

Record::Field &F,

Activate) ->

{

(std::optional<PrimType> FT = S.Ctx.classify(F.Decl->getType())) {

(

Record::Field &F : R->

()) {

(!copyField(F,

))

(!copyField(F, Activate))

(

Record::Base &B : R->

()) {

(!copyRecord(S, OpPC, Src.

(B.Offset), DestBase, Activate))

&Dest,

Activate =

) {

(

I = 0, N = DestDesc->

(); I != N; ++I) {

copyRecord(S, OpPC, Src, Dest, Activate);

Defines enum values for all the target-independent builtin functions.

CharUnits GetAlignOfExpr(const ASTContext &Ctx, const Expr *E, UnaryExprOrTypeTrait ExprKind)

GCCTypeClass EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts)

EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way as GCC.

#define INT_TYPE_SWITCH_NO_BOOL(Expr, B)

#define INT_TYPE_SWITCH(Expr, B)

#define TYPE_SWITCH(Expr, B)

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Enumerates target-specific builtins in their own namespaces within namespace clang.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

const LValueBase getLValueBase() const

CharUnits & getLValueOffset()

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

unsigned getIntWidth(QualType T) const

const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const

Return the APFloat 'semantics' for the specified scalar floating point type.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

Get or compute information about the layout of the specified record (struct/union/class) D,...

Builtin::Context & BuiltinInfo

CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const

Return a conservative estimate of the alignment of the specified decl D.

QualType getWCharType() const

Return the unique wchar_t type available in C++ (and available as __wchar_t as a Microsoft extension)...

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...

unsigned getFieldCount() const

getFieldCount - Get the number of fields in the layout.

uint64_t getFieldOffset(unsigned FieldNo) const

getFieldOffset - Get the offset of the given field index, in bits.

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

getBaseClassOffset - Get the offset, in chars, for the given base class.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

std::string getQuotedName(unsigned ID) const

Return a quoted name for the specified builtin for use in diagnostics.

Represents a base class of a C++ class.

bool isVirtual() const

Determines whether the base class is a virtual base class (or not).

QualType getType() const

Retrieves the type of the base class.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

CharUnits - This is an opaque type for sizes expressed in character units.

CharUnits alignmentAtOffset(CharUnits offset) const

Given that this is a non-zero alignment value, what is the alignment at the given offset?

bool isZero() const

isZero - Test whether the quantity equals zero.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits One()

One - Construct a CharUnits quantity of one.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

CharUnits alignTo(const CharUnits &Align) const

alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...

static unsigned getMaxSizeBits(const ASTContext &Context)

Determine the maximum number of active bits that an array's size can require, which limits the maximu...

bool isInvalidDecl() const

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Represents a member of a struct/union/class.

unsigned getFieldIndex() const

Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...

Represents a function declaration or definition.

QualType getReturnType() const

One of these records is kept for each identifier that is lexed.

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...

Helper class for OffsetOfExpr.

@ Array

An index into an array.

@ Identifier

A field in a dependent type, known only by its name.

@ Base

An implicit indirection through a C++ base class, when the field found is in a base class.

PointerType - C99 6.7.5.1 - Pointer Declarators.

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

Represents a struct/union/class.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

ASTContext & getASTContext() const

const LangOptions & getLangOpts() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

Exposes information about the current target.

unsigned getMaxAtomicInlineWidth() const

Return the maximum width lock-free atomic operation which can be inlined given the supported features...

unsigned getIntWidth() const

getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...

virtual int getEHDataRegisterNumber(unsigned RegNo) const

Return the register number that __builtin_eh_return_regno would return with the specified argument.

unsigned getLongWidth() const

getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...

virtual bool isNan2008() const

Returns true if NaN encoding is IEEE 754-2008.

A template argument list.

unsigned size() const

Retrieve the number of template arguments in this template argument list.

@ Type

The template argument is a type.

Symbolic representation of typeid(T) for some type T.

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool isUnsignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...

bool isPointerType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isAnyComplexType() const

bool isIncompleteType(NamedDecl **Def=nullptr) const

Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...

bool isFunctionType() const

bool isFloatingType() const

const T * getAs() const

Member-template getAs<specific type>'.

bool isNullPtrType() const

A memory block, either on the stack or in the heap.

const Descriptor * getDescriptor() const

Returns the block's descriptor.

Wrapper around boolean types.

static Boolean from(T Value)

Pointer into the code segment.

Compilation context for expressions.

Manages dynamic memory allocations done during bytecode interpretation.

const APFloat & getAPFloat() const

llvm::FPClassTest classify() const

ComparisonCategoryResult compare(const Floating &RHS) const

static Floating getInf(const llvm::fltSemantics &Sem)

static Floating abs(const Floating &F)

APFloat::fltCategory getCategory() const

Base class for stack frames, shared between VM and walker.

const FunctionDecl * getDecl() const

Returns the original FunctionDecl.

unsigned getBuiltinID() const

Frame storing local variables.

const Expr * getExpr(CodePtr PC) const

InterpFrame * Caller

The frame of the previous function.

CodePtr getRetPC() const

Returns the return address of the frame.

const FunctionDecl * getCallee() const override

Returns the caller.

Stack frame storing temporaries and parameters.

void clear()

Clears the stack without calling any destructors.

T & peek() const

Returns a reference to the value on the top of the stack.

A pointer to a memory block, live or dead.

bool isInitialized() const

Checks if an object was initialized.

Pointer atIndex(uint64_t Idx) const

Offsets a pointer inside an array.

bool isDummy() const

Checks if the pointer points to a dummy value.

int64_t getIndex() const

Returns the index into an array.

bool isActive() const

Checks if the object is active.

Pointer atField(unsigned Off) const

Creates a pointer to a field.

T & deref() const

Dereferences the pointer, if it's live.

unsigned getNumElems() const

Returns the number of elements.

bool isUnknownSizeArray() const

Checks if the structure is an array of unknown size.

void activate() const

Activats a field.

bool isIntegralPointer() const

QualType getType() const

Returns the type of the innermost field.

bool isLive() const

Checks if the pointer is live.

uint64_t getByteOffset() const

Returns the byte offset from the start.

std::string toDiagnosticString(const ASTContext &Ctx) const

Converts the pointer to a string usable in diagnostics.

bool isZero() const

Checks if the pointer is null.

const Descriptor * getDeclDesc() const

Accessor for information about the declaration site.

static bool pointToSameBlock(const Pointer &A, const Pointer &B)

Checks if both given pointers point to the same block.

APValue toAPValue(const ASTContext &ASTCtx) const

Converts the pointer to an APValue.

uint64_t getIntegerRepresentation() const

bool isBlockPointer() const

const Block * block() const

const Descriptor * getFieldDesc() const

Accessors for information about the innermost field.

size_t elemSize() const

Returns the element size of the innermost field.

void initialize() const

Initializes a field.

const Record * getRecord() const

Returns the record descriptor of a class.

Structure/Class descriptor.

bool isUnion() const

Checks if the record is a union.

const Field * getField(const FieldDecl *FD) const

Returns a field.

llvm::iterator_range< const_base_iter > bases() const

unsigned getNumFields() const

llvm::iterator_range< const_field_iter > fields() const

Describes the statement/declaration an opcode was generated from.

Defines the clang::TargetInfo interface.

bool computeOSLogBufferLayout(clang::ASTContext &Ctx, const clang::CallExpr *E, OSLogBufferLayout &layout)

static bool interp__builtin_atomic_lock_free(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

bool __atomic_always_lock_free(size_t, void const volatile*) bool __atomic_is_lock_free(size_t,...

bool readPointerToBuffer(const Context &Ctx, const Pointer &FromPtr, BitcastBuffer &Buffer, bool ReturnOnUninit)

static APSInt peekToAPSInt(InterpStack &Stk, PrimType T, size_t Offset=0)

Peek an integer value from the stack into an APSInt.

static bool interp__builtin_classify_type(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static PrimType getLongPrimType(const InterpState &S)

static bool interp__builtin_assume_aligned(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

__builtin_assume_aligned(Ptr, Alignment[, ExtraOffset])

bool CheckNewDeleteForms(InterpState &S, CodePtr OpPC, DynamicAllocator::Form AllocForm, DynamicAllocator::Form DeleteForm, const Descriptor *D, const Expr *NewExpr)

Diagnose mismatched new[]/delete or new/delete[] pairs.

static bool interp__builtin_operator_delete(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp_floating_comparison(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

bool InterpretOffsetOf(InterpState &S, CodePtr OpPC, const OffsetOfExpr *E, llvm::ArrayRef< int64_t > ArrayIndices, int64_t &Result)

Interpret an offsetof operation.

static bool interp__builtin_nan(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, bool Signaling)

bool SetThreeWayComparisonField(InterpState &S, CodePtr OpPC, const Pointer &Ptr, const APSInt &IntValue)

Sets the given integral value to the pointer, which is of a std::{weak,partial,strong}_ordering type.

static bool interp__builtin_ptrauth_string_discriminator(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool retPrimValue(InterpState &S, CodePtr OpPC, std::optional< PrimType > &T)

static bool interp__builtin_fabs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func)

static bool interp__builtin_memcpy(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_operator_new(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_carryop(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

Three integral values followed by a pointer (lhs, rhs, carry, carryOut).

static bool interp__builtin_signbit(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

static bool interp__builtin_arithmetic_fence(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_inf(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F)

static bool interp__builtin_ia32_bzhi(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static unsigned callArgSize(const InterpState &S, const CallExpr *C)

static bool interp__builtin_isnormal(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

static bool interp__builtin_vector_reduce(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_os_log_format_buffer_size(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_clz(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_is_aligned_up_down(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

__builtin_is_aligned() __builtin_align_up() __builtin_align_down() The first parameter is either an i...

static bool interp__builtin_clrsb(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_constant_p(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_eh_return_data_regno(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

bool RetVoid(InterpState &S, CodePtr &PC)

static bool isOneByteCharacterType(QualType T)

Determine if T is a character type for which we guarantee that sizeof(T) == 1.

static bool interp__builtin_popcount(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a value can be loaded from a block.

static bool interp__builtin_abs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static T getParam(const InterpFrame *Frame, unsigned Index)

static bool interp__builtin_ia32_lzcnt(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_strcmp(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

constexpr size_t align(size_t Size)

Aligns a size to the pointer alignment.

bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is in range.

bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is live and accessible.

static bool interp__builtin_ia32_pext(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_overflowop(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_elementwise_popcount(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

Can be called with an integer or vector as the first and only parameter.

static bool handleOverflow(InterpState &S, CodePtr OpPC, const T &SrcValue)

PrimType

Enumeration of the primitive types of the VM.

static bool interp__builtin_isfinite(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

static bool copyComposite(InterpState &S, CodePtr OpPC, const Pointer &Src, Pointer &Dest, bool Activate)

static bool interp__builtin_issubnormal(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

static bool interp__builtin_isinf(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, bool CheckSign, const CallExpr *Call)

static bool interp__builtin_move(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_fmax(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, bool IsNumBuiltin)

static APSInt getAPSIntParam(const InterpFrame *Frame, unsigned Index)

static bool noopPointer(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

Just takes the first Argument to the call and puts it on the stack.

static void pushInteger(InterpState &S, const APSInt &Val, QualType QT)

Pushes Val on the stack as the type given by QT.

static bool interp__builtin_issignaling(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if the array is offsetable.

static bool interp__builtin_complex(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

__builtin_complex(Float A, float B);

static bool interp__builtin_ia32_tzcnt(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_parity(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

bool CheckDummy(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is a dummy pointer.

static bool interp__builtin_ctz(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_iszero(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

static bool interp__builtin_ia32_pdep(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static PrimType getIntPrimType(const InterpState &S)

size_t primSize(PrimType Type)

Returns the size of a primitive type in bytes.

static void assignInteger(Pointer &Dest, PrimType ValueT, const APSInt &Value)

static bool interp__builtin_strlen(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_expect(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F, const CallExpr *Call, uint32_t BuiltinID)

Interpret a builtin function.

static bool interp__builtin_is_constant_evaluated(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)

static bool interp__builtin_memcmp(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_fpclassify(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

Five int values followed by one floating value.

static bool interp__builtin_ia32_bextr(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_fmin(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, bool IsNumBuiltin)

static bool interp__builtin_isnan(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F, const CallExpr *Call)

Defined as __builtin_isnan(...), to accommodate the fact that it can take a float,...

bool DoMemcpy(InterpState &S, CodePtr OpPC, const Pointer &Src, Pointer &Dest)

Copy the contents of Src into Dest.

static bool interp__builtin_rotate(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call, bool Right)

rotateleft(value, amount)

constexpr bool isIntegralType(PrimType T)

static bool interp__builtin_ffs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_copysign(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *F)

static bool interp__builtin_isfpclass(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

First parameter to __builtin_isfpclass is the floating value, the second one is an integral value.

static void diagnoseNonConstexprBuiltin(InterpState &S, CodePtr OpPC, unsigned ID)

static bool interp__builtin_addressof(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_bitreverse(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static bool interp__builtin_ia32_addcarry_subborrow(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

static void swapBytes(std::byte *M, size_t N)

static bool interp__builtin_bswap(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const Function *Func, const CallExpr *Call)

The JSON file list parser is used to communicate input to InstallAPI.

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

ComparisonCategoryResult

An enumeration representing the possible results of a three-way comparison.

@ Result

The result type of a method or function.

const FunctionProtoType * T

Track what bits have been initialized to known values and which ones have indeterminate value.

std::unique_ptr< std::byte[]> Data

size_t getQuantity() const

Describes a memory block created by an allocation site.

unsigned getNumElems() const

Returns the number of elements stored in the block.

bool isPrimitive() const

Checks if the descriptor is of a primitive.

QualType getElemQualType() const

const ValueDecl * asValueDecl() const

static constexpr unsigned MaxArrayElemBytes

Maximum number of bytes to be used for array elements.

static constexpr MetadataSize InlineDescMD

unsigned getElemSize() const

returns the size of an element when the structure is viewed as an array.

bool isPrimitiveArray() const

Checks if the descriptor is of an array of primitives.

PrimType getPrimType() const

bool isRecord() const

Checks if the descriptor is of a record.

const Record *const ElemRecord

Pointer to the record, if block contains records.

const Expr * asExpr() const

bool isArray() const

Checks if the descriptor is of an array.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4