19#include "llvm/ADT/StringExtras.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/SipHash.h"
28 case Builtin::BIas_const:
29 case Builtin::BIforward:
30 case Builtin::BIforward_like:
32 case Builtin::BImove_if_noexcept:
33 case Builtin::BIaddressof:
34 case Builtin::BI__addressof:
35 case Builtin::BI__builtin_addressof:
36 case Builtin::BI__builtin_launder:
83 int64_t
V = Val.getSExtValue();
87 uint64_t
V = Val.getZExtValue();
94 if constexpr (std::is_same_v<T, APInt>)
96 else if constexpr (std::is_same_v<T, APSInt>)
101 std::is_signed_v<T>),
102 !std::is_signed_v<T>),
119 ValueT, { Dest.
deref<
T>() = T::from(
static_cast<T>(
Value)); });
128 if (
T->isPointerType())
132 if (
const auto *AT =
T->getAsArrayTypeUnsafe())
133 return AT->getElementType();
144 S.
CCEDiag(Loc, diag::note_constexpr_invalid_function)
148 S.
CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
154 "Not a boolean vector");
158 llvm::APSInt
Result(NumElems, 0);
159 for (
unsigned I = 0; I != NumElems; ++I) {
160 if (Val.
elem<
bool>(I))
172 return F && F->isInStdNamespace() && F->getIdentifier() &&
173 F->getIdentifier()->isStr(
"is_constant_evaluated");
184 diag::warn_is_constant_evaluated_always_true_constexpr)
188 diag::warn_is_constant_evaluated_always_true_constexpr)
189 <<
"__builtin_is_constant_evaluated" <<
Call->getSourceRange();
201 assert(
Call->getNumArgs() == 1);
209 uint64_t Limit = ~static_cast<uint64_t>(0);
210 if (ID == Builtin::BIstrncmp || ID == Builtin::BI__builtin_strncmp ||
211 ID == Builtin::BIwcsncmp || ID == Builtin::BI__builtin_wcsncmp)
217 if (ID == Builtin::BIstrcmp || ID == Builtin::BIstrncmp ||
218 ID == Builtin::BIwcscmp || ID == Builtin::BIwcsncmp)
229 if (A.isDummy() || B.
isDummy())
234 bool IsWide = ID == Builtin::BIwcscmp || ID == Builtin::BIwcsncmp ||
235 ID == Builtin::BI__builtin_wcscmp ||
236 ID == Builtin::BI__builtin_wcsncmp;
237 assert(A.getFieldDesc()->isPrimitiveArray());
246 auto returnResult = [&](
int V) ->
bool {
251 unsigned IndexA = A.getIndex();
254 for (;; ++IndexA, ++IndexB, ++Steps) {
270 return returnResult(1);
272 return returnResult(-1);
273 if (CA.isZero() || CB.isZero())
274 return returnResult(0);
279 uint8_t CA = PA.
deref<uint8_t>();
280 uint8_t CB = PB.
deref<uint8_t>();
283 return returnResult(1);
285 return returnResult(-1);
286 if (CA == 0 || CB == 0)
287 return returnResult(0);
290 return returnResult(0);
298 if (ID == Builtin::BIstrlen || ID == Builtin::BIwcslen)
316 if (ID == Builtin::BI__builtin_wcslen || ID == Builtin::BIwcslen) {
322 for (
size_t I = StrPtr.
getIndex();; ++I, ++Len) {
331 Val = ElemPtr.
deref<uint8_t>();
334 Val = ElemPtr.
deref<uint16_t>();
337 Val = ElemPtr.
deref<uint32_t>();
340 llvm_unreachable(
"Unsupported char size");
365 for (
unsigned I = 0;; ++I) {
371 if (Elem.
deref<int8_t>() == 0)
374 Str += Elem.
deref<
char>();
379 Fill = llvm::APInt(32, 0);
380 else if (StringRef(Str).getAsInteger(0, Fill))
383 const llvm::fltSemantics &TargetSemantics =
385 Call->getDirectCallee()->getReturnType());
391 llvm::APFloat::getSNaN(TargetSemantics,
false, &Fill));
394 llvm::APFloat::getQNaN(TargetSemantics,
false, &Fill));
403 llvm::APFloat::getQNaN(TargetSemantics,
false, &Fill));
406 llvm::APFloat::getSNaN(TargetSemantics,
false, &Fill));
416 const llvm::fltSemantics &TargetSemantics =
418 Call->getDirectCallee()->getReturnType());
421 Result.copy(APFloat::getInf(TargetSemantics));
494 bool IsInf = F.isInfinity();
497 pushInteger(S, IsInf ? (F.isNegative() ? -1 : 1) : 0,
Call->getType());
557 case Builtin::BI__builtin_isgreater:
559 case Builtin::BI__builtin_isgreaterequal:
561 case Builtin::BI__builtin_isless:
563 case Builtin::BI__builtin_islessequal:
565 case Builtin::BI__builtin_islessgreater: {
570 case Builtin::BI__builtin_isunordered:
573 llvm_unreachable(
"Unexpected builtin ID: Should be a floating point "
574 "comparison function");
589 int32_t
Result =
static_cast<int32_t
>(
590 (F.
classify() & std::move(FPClassArg)).getZExtValue());
605 for (
unsigned I = 0; I != 5; ++I)
613 case APFloat::fcInfinity:
616 case APFloat::fcNormal:
619 case APFloat::fcZero:
632 if (!In.isNegative())
659 APSInt(APInt::getSignedMinValue(Val.getBitWidth()),
false))
661 if (Val.isNegative())
671 if (
Call->getArg(0)->getType()->isExtVectorBoolType()) {
685 assert(
Call->getNumArgs() == 1);
690 int32_t ReturnVal =
static_cast<int32_t
>(ResultClass);
702 unsigned NumArgs =
Call->getNumArgs();
703 assert(NumArgs == 2 || NumArgs == 3);
719 assert(
Call->getArg(0)->isLValue());
722 "Unsupported pointer type passed to __builtin_addressof()");
730 return Call->getDirectCallee()->isConstexpr();
747 unsigned BuiltinOp) {
756 QualType ResultType =
Call->getArg(2)->getType()->getPointeeType();
761 if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
762 BuiltinOp == Builtin::BI__builtin_sub_overflow ||
763 BuiltinOp == Builtin::BI__builtin_mul_overflow) {
764 bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
766 bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
768 uint64_t LHSSize = LHS.getBitWidth();
769 uint64_t RHSSize = RHS.getBitWidth();
771 uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
777 if (IsSigned && !AllSigned)
780 LHS =
APSInt(LHS.extOrTrunc(MaxBits), !IsSigned);
781 RHS =
APSInt(RHS.extOrTrunc(MaxBits), !IsSigned);
788 llvm_unreachable(
"Invalid value for BuiltinOp");
789 case Builtin::BI__builtin_add_overflow:
790 case Builtin::BI__builtin_sadd_overflow:
791 case Builtin::BI__builtin_saddl_overflow:
792 case Builtin::BI__builtin_saddll_overflow:
793 case Builtin::BI__builtin_uadd_overflow:
794 case Builtin::BI__builtin_uaddl_overflow:
795 case Builtin::BI__builtin_uaddll_overflow:
796 Result = LHS.isSigned() ? LHS.sadd_ov(RHS, Overflow)
797 : LHS.uadd_ov(RHS, Overflow);
799 case Builtin::BI__builtin_sub_overflow:
800 case Builtin::BI__builtin_ssub_overflow:
801 case Builtin::BI__builtin_ssubl_overflow:
802 case Builtin::BI__builtin_ssubll_overflow:
803 case Builtin::BI__builtin_usub_overflow:
804 case Builtin::BI__builtin_usubl_overflow:
805 case Builtin::BI__builtin_usubll_overflow:
806 Result = LHS.isSigned() ? LHS.ssub_ov(RHS, Overflow)
807 : LHS.usub_ov(RHS, Overflow);
809 case Builtin::BI__builtin_mul_overflow:
810 case Builtin::BI__builtin_smul_overflow:
811 case Builtin::BI__builtin_smull_overflow:
812 case Builtin::BI__builtin_smulll_overflow:
813 case Builtin::BI__builtin_umul_overflow:
814 case Builtin::BI__builtin_umull_overflow:
815 case Builtin::BI__builtin_umulll_overflow:
816 Result = LHS.isSigned() ? LHS.smul_ov(RHS, Overflow)
817 : LHS.umul_ov(RHS, Overflow);
823 if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
824 BuiltinOp == Builtin::BI__builtin_sub_overflow ||
825 BuiltinOp == Builtin::BI__builtin_mul_overflow) {
833 if (!APSInt::isSameValue(Temp,
Result))
843 assert(
Call->getDirectCallee()->getReturnType()->isBooleanType());
869 bool FirstOverflowed =
false;
870 bool SecondOverflowed =
false;
873 llvm_unreachable(
"Invalid value for BuiltinOp");
874 case Builtin::BI__builtin_addcb:
875 case Builtin::BI__builtin_addcs:
876 case Builtin::BI__builtin_addc:
877 case Builtin::BI__builtin_addcl:
878 case Builtin::BI__builtin_addcll:
880 LHS.uadd_ov(RHS, FirstOverflowed).uadd_ov(CarryIn, SecondOverflowed);
882 case Builtin::BI__builtin_subcb:
883 case Builtin::BI__builtin_subcs:
884 case Builtin::BI__builtin_subc:
885 case Builtin::BI__builtin_subcl:
886 case Builtin::BI__builtin_subcll:
888 LHS.usub_ov(RHS, FirstOverflowed).usub_ov(CarryIn, SecondOverflowed);
893 CarryOut = (uint64_t)(FirstOverflowed | SecondOverflowed);
895 QualType CarryOutType =
Call->getArg(3)->getType()->getPointeeType();
900 assert(
Call->getType() ==
Call->getArg(0)->getType());
907 unsigned BuiltinOp) {
909 std::optional<APSInt> Fallback;
910 if (BuiltinOp == Builtin::BI__builtin_clzg &&
Call->getNumArgs() == 2)
914 if (
Call->getArg(0)->getType()->isExtVectorBoolType()) {
923 bool ZeroIsUndefined = BuiltinOp != Builtin::BI__lzcnt16 &&
924 BuiltinOp != Builtin::BI__lzcnt &&
925 BuiltinOp != Builtin::BI__lzcnt64;
943 unsigned BuiltinID) {
944 std::optional<APSInt> Fallback;
945 if (BuiltinID == Builtin::BI__builtin_ctzg &&
Call->getNumArgs() == 2)
949 if (
Call->getArg(0)->getType()->isExtVectorBoolType()) {
972 assert(Val.getActiveBits() <= 64);
983 unsigned BuiltinOp) {
984 auto returnBool = [&S](
bool Value) ->
bool {
1003 if (Size.isPowerOfTwo()) {
1005 unsigned InlineWidthBits =
1012 return returnBool(
true);
1015 assert(BuiltinOp != Builtin::BI__c11_atomic_is_lock_free);
1017 return returnBool(
true);
1021 if (
APSInt(
APInt(64, IntVal,
false),
true).isAligned(Size.getAsAlign()))
1022 return returnBool(
true);
1025 const Expr *PtrArg =
Call->getArg(1);
1027 if (
const auto *ICE = dyn_cast<ImplicitCastExpr>(PtrArg)) {
1030 if (ICE->getCastKind() == CK_BitCast)
1031 PtrArg = ICE->getSubExpr();
1039 return returnBool(
true);
1045 if (BuiltinOp == Builtin::BI__atomic_always_lock_free)
1046 return returnBool(
false);
1059 if (Size.isPowerOfTwo()) {
1061 unsigned InlineWidthBits =
1082 Result.initializeAllElements();
1095 unsigned BuiltinOp) {
1098 if (Alignment < 0 || !Alignment.isPowerOf2()) {
1099 S.
FFDiag(
Call, diag::note_constexpr_invalid_alignment) << Alignment;
1103 APSInt MaxValue(APInt::getOneBitSet(SrcWidth, SrcWidth - 1));
1104 if (APSInt::compareValues(Alignment, MaxValue) > 0) {
1105 S.
FFDiag(
Call, diag::note_constexpr_alignment_too_big)
1106 << MaxValue <<
Call->getArg(0)->getType() << Alignment;
1115 APInt AlignMinusOne = Alignment.extOrTrunc(Src.getBitWidth()) - 1;
1116 if (BuiltinOp == Builtin::BI__builtin_align_up) {
1118 APSInt((Src + AlignMinusOne) & ~AlignMinusOne, Src.isUnsigned());
1120 }
else if (BuiltinOp == Builtin::BI__builtin_align_down) {
1121 APSInt AlignedVal =
APSInt(Src & ~AlignMinusOne, Src.isUnsigned());
1129 assert(FirstArgT ==
PT_Ptr);
1134 unsigned PtrOffset = Ptr.
getIndex();
1140 if (BuiltinOp == Builtin::BI__builtin_is_aligned) {
1155 S.
FFDiag(
Call->getArg(0), diag::note_constexpr_alignment_compute)
1160 assert(BuiltinOp == Builtin::BI__builtin_align_down ||
1161 BuiltinOp == Builtin::BI__builtin_align_up);
1176 assert(Alignment.getBitWidth() <= 64 &&
1177 "Cannot handle > 64-bit address-space");
1178 uint64_t Alignment64 = Alignment.getZExtValue();
1181 ? llvm::alignDown(PtrOffset, Alignment64)
1182 : llvm::alignTo(PtrOffset, Alignment64));
1189 S.
FFDiag(
Call->getArg(0), diag::note_constexpr_alignment_adjust) << Alignment;
1197 assert(
Call->getNumArgs() == 2 ||
Call->getNumArgs() == 3);
1199 std::optional<APSInt> ExtraOffset;
1200 if (
Call->getNumArgs() == 3)
1216 if (BaseAlignment < Align) {
1218 diag::note_constexpr_baa_insufficient_alignment)
1219 << 0 << BaseAlignment.
getQuantity() << Align.getQuantity();
1228 if (AVOffset.
alignTo(Align) != AVOffset) {
1231 diag::note_constexpr_baa_insufficient_alignment)
1232 << 1 << AVOffset.
getQuantity() << Align.getQuantity();
1235 diag::note_constexpr_baa_value_insufficient_alignment)
1249 unsigned BuiltinOp) {
1250 if (
Call->getNumArgs() != 4 || !
Call->getArg(0)->getType()->isIntegerType() ||
1251 !
Call->getArg(1)->getType()->isIntegerType() ||
1252 !
Call->getArg(2)->getType()->isIntegerType())
1261 bool IsAdd = BuiltinOp == clang::X86::BI__builtin_ia32_addcarryx_u32 ||
1262 BuiltinOp == clang::X86::BI__builtin_ia32_addcarryx_u64;
1264 unsigned BitWidth = LHS.getBitWidth();
1265 unsigned CarryInBit = CarryIn.ugt(0) ? 1 : 0;
1267 IsAdd ? (LHS.zext(BitWidth + 1) + (RHS.zext(BitWidth + 1) + CarryInBit))
1268 : (LHS.zext(BitWidth + 1) - (RHS.zext(BitWidth + 1) + CarryInBit));
1272 APSInt(ExResult.extractBits(1, BitWidth),
true);
1274 QualType CarryOutType =
Call->getArg(3)->getType()->getPointeeType();
1298 assert(Ptr.getFieldDesc()->isPrimitiveArray());
1302 assert(Ptr.getFieldDesc()->getNumElems() >= 1);
1303 StringRef R(&Ptr.deref<
char>(), Ptr.getFieldDesc()->getNumElems() - 1);
1304 uint64_t
Result = getPointerAuthStableSipHash(R);
1317 if (ElemType.isNull()) {
1319 ? diag::note_constexpr_new_untyped
1320 : diag::note_constexpr_new);
1325 if (ElemType->isIncompleteType() || ElemType->isFunctionType()) {
1326 S.
FFDiag(
Call, diag::note_constexpr_new_not_complete_object_type)
1327 << (ElemType->isIncompleteType() ? 0 : 1) << ElemType;
1334 unsigned NumArgs =
Call->getNumArgs();
1335 assert(NumArgs >= 1);
1338 if (
Call->getArg(NumArgs - 1)->getType()->isNothrowT())
1342 Args = Args.drop_front();
1345 for (
const Expr *Arg : Args)
1351 assert(!ElemSize.
isZero());
1354 APInt NumElems, Remainder;
1356 APInt::udivrem(
Bytes, ElemSizeAP, NumElems, Remainder);
1357 if (Remainder != 0) {
1359 S.
FFDiag(
Call, diag::note_constexpr_operator_new_bad_size)
1365 if (NumElems.getActiveBits() >
1370 S.
FFDiag(Loc, diag::note_constexpr_new_too_large)
1371 << NumElems.getZExtValue();
1378 bool IsArray = NumElems.ugt(1);
1383 Allocator.
allocate(NewCall, *ElemT, NumElems.getZExtValue(),
1420 const Expr *Source =
nullptr;
1421 const Block *BlockToDelete =
nullptr;
1439 S.
CCEDiag(
Call, diag::note_constexpr_deallocate_null);
1444 BlockToDelete = Ptr.
block();
1447 S.
FFDiag(
Call, diag::note_constexpr_delete_not_heap_alloc)
1450 S.
Note(D->getLocation(), diag::note_declared_at);
1453 assert(BlockToDelete);
1457 std::optional<DynamicAllocator::Form> AllocForm =
1460 if (!Allocator.
deallocate(Source, BlockToDelete, S)) {
1463 S.
FFDiag(Loc, diag::note_constexpr_double_delete);
1486 assert(
Call->getType() == ElemType);
1492 unsigned BitWidth =
Result.bitWidth();
1493 for (
unsigned I = 1; I != NumElems; ++I) {
1497 if (ID == Builtin::BI__builtin_reduce_add) {
1499 unsigned OverflowBits = BitWidth + 1;
1501 (PrevResult.toAPSInt(OverflowBits) +
1502 Elem.toAPSInt(OverflowBits)));
1505 }
else if (ID == Builtin::BI__builtin_reduce_mul) {
1507 unsigned OverflowBits = BitWidth * 2;
1509 (PrevResult.toAPSInt(OverflowBits) *
1510 Elem.toAPSInt(OverflowBits)));
1514 }
else if (ID == Builtin::BI__builtin_reduce_and) {
1516 }
else if (ID == Builtin::BI__builtin_reduce_or) {
1518 }
else if (ID == Builtin::BI__builtin_reduce_xor) {
1520 }
else if (ID == Builtin::BI__builtin_reduce_min) {
1523 }
else if (ID == Builtin::BI__builtin_reduce_max) {
1527 llvm_unreachable(
"Unhandled vector reduce builtin");
1539 unsigned BuiltinID) {
1540 assert(
Call->getNumArgs() == 1);
1556 assert(
Call->getArg(0)->getType()->isVectorType());
1568 for (
unsigned I = 0; I != NumElems; ++I) {
1571 Dst.
elem<
T>(I) = T::from(
static_cast<T>(
1589 unsigned BuiltinID) {
1590 assert(
Call->getNumArgs() == 1);
1591 if (
Call->getArg(0)->getType()->isIntegerType()) {
1594 if (BuiltinID == Builtin::BI__builtin_elementwise_popcount) {
1602 assert(
Call->getArg(0)->getType()->isVectorType());
1615 for (
unsigned I = 0; I != NumElems; ++I) {
1617 if (BuiltinID == Builtin::BI__builtin_elementwise_popcount) {
1618 Dst.
elem<
T>(I) = T::from(Arg.
elem<
T>(I).toAPSInt().popcount());
1621 T::from(Arg.
elem<
T>(I).toAPSInt().reverseBits().getZExtValue());
1635 unsigned BuiltinID) {
1636 bool HasZeroArg =
Call->getNumArgs() == 2;
1637 bool IsCTTZ = BuiltinID == Builtin::BI__builtin_elementwise_ctzg;
1638 assert(
Call->getNumArgs() == 1 || HasZeroArg);
1639 if (
Call->getArg(0)->getType()->isIntegerType()) {
1642 std::optional<APSInt> ZeroVal;
1656 diag::note_constexpr_countzeroes_zero)
1661 if (BuiltinID == Builtin::BI__builtin_elementwise_clzg) {
1672 assert(
Call->getArg(1)->getType()->isVectorType() &&
1674 Call->getArg(1)->getType()));
1679 assert(
Call->getArg(0)->getType()->isVectorType());
1692 for (
unsigned I = 0; I != NumElems; ++I) {
1695 if (EltVal.isZero()) {
1702 diag::note_constexpr_countzeroes_zero)
1706 }
else if (IsCTTZ) {
1707 Dst.
atIndex(I).
deref<
T>() = T::from(EltVal.countTrailingZeros());
1709 Dst.
atIndex(I).
deref<
T>() = T::from(EltVal.countLeadingZeros());
1721 assert(
Call->getNumArgs() == 3);
1727 assert(!Size.isSigned() &&
"memcpy and friends take an unsigned size");
1729 if (ID == Builtin::BImemcpy || ID == Builtin::BImemmove)
1733 (ID == Builtin::BI__builtin_memmove || ID == Builtin::BImemmove ||
1734 ID == Builtin::BI__builtin_wmemmove || ID == Builtin::BIwmemmove);
1735 bool WChar = ID == Builtin::BIwmemcpy || ID == Builtin::BIwmemmove ||
1736 ID == Builtin::BI__builtin_wmemcpy ||
1737 ID == Builtin::BI__builtin_wmemmove;
1740 if (Size.isZero()) {
1745 if (SrcPtr.
isZero() || DestPtr.isZero()) {
1748 << Move << WChar << !SrcPtr.
isZero()
1755 std::string DiagVal =
"(void *)";
1758 : std::to_string(DestPtr.getIntegerRepresentation());
1760 << Move << WChar << DestPtr.isIntegralPointer() << DiagVal;
1765 if (DestPtr.isDummy() || SrcPtr.
isDummy())
1768 if (DestPtr.getType()->isIncompleteType()) {
1770 diag::note_constexpr_memcpy_incomplete_type)
1771 << Move << DestPtr.getType();
1776 diag::note_constexpr_memcpy_incomplete_type)
1784 diag::note_constexpr_memcpy_incomplete_type)
1785 << Move << DestElemType;
1789 size_t RemainingDestElems;
1790 if (DestPtr.getFieldDesc()->isArray()) {
1791 RemainingDestElems = DestPtr.isUnknownSizeArray()
1793 : (DestPtr.getNumElems() - DestPtr.getIndex());
1795 RemainingDestElems = 1;
1800 uint64_t WCharSize =
1802 Size *=
APSInt(
APInt(Size.getBitWidth(), WCharSize,
false),
1806 if (Size.urem(DestElemSize) != 0) {
1808 diag::note_constexpr_memcpy_unsupported)
1809 << Move << WChar << 0 << DestElemType << Size << DestElemSize;
1814 size_t RemainingSrcElems;
1820 RemainingSrcElems = 1;
1826 << Move << SrcElemType << DestElemType;
1832 << Move << DestElemType;
1837 size_t RemainingDestBytes = RemainingDestElems * DestElemSize;
1838 size_t RemainingSrcBytes = RemainingSrcElems * SrcElemSize;
1839 if (Size.ugt(RemainingDestBytes) || Size.ugt(RemainingSrcBytes)) {
1840 APInt N = Size.udiv(DestElemSize);
1842 diag::note_constexpr_memcpy_unsupported)
1843 << Move << WChar << (Size.ugt(RemainingSrcBytes) ? 1 : 2)
1844 << DestElemType <<
toString(N, 10,
false);
1861 unsigned N = Size.getZExtValue();
1863 if ((SrcIndex <= DstIndex && (SrcIndex + N) > DstIndex) ||
1864 (DstIndex <= SrcIndex && (DstIndex + N) > SrcIndex)) {
1871 assert(Size.getZExtValue() % DestElemSize == 0);
1882 return T->isCharType() ||
T->isChar8Type();
1888 assert(
Call->getNumArgs() == 3);
1893 if (ID == Builtin::BImemcmp || ID == Builtin::BIbcmp ||
1894 ID == Builtin::BIwmemcmp)
1897 if (Size.isZero()) {
1903 (ID == Builtin::BIwmemcmp || ID == Builtin::BI__builtin_wmemcmp);
1913 diag::note_constexpr_memcmp_unsupported)
1919 if (PtrA.isDummy() || PtrB.
isDummy())
1942 unsigned ElemSize = 1;
1947 size_t ByteSize = Size.getZExtValue() * ElemSize;
1948 size_t CmpSize = std::min(MinBufferSize, ByteSize);
1950 for (
size_t I = 0; I != CmpSize; I += ElemSize) {
1953 T A = *reinterpret_cast<T *>(BufferA.Data.get() + I);
1954 T B = *reinterpret_cast<T *>(BufferB.Data.get() + I);
1956 pushInteger(S, -1, Call->getType());
1965 std::byte A = BufferA.
Data[I];
1966 std::byte B = BufferB.
Data[I];
1981 if (ByteSize <= CmpSize) {
1990 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end)
1991 <<
AK_Read << S.Current->getRange(OpPC);
1999 if (ID == Builtin::BImemchr || ID == Builtin::BIwcschr ||
2000 ID == Builtin::BIstrchr || ID == Builtin::BIwmemchr)
2003 std::optional<APSInt> MaxLength;
2004 if (
Call->getNumArgs() == 3)
2010 if (MaxLength && MaxLength->isZero()) {
2018 diag::note_constexpr_ltor_incomplete_type)
2033 bool IsRawByte = ID == Builtin::BImemchr || ID == Builtin::BI__builtin_memchr;
2038 diag::note_constexpr_memchr_unsupported)
2043 if (ID == Builtin::BIstrchr || ID == Builtin::BI__builtin_strchr) {
2053 uint64_t DesiredVal;
2054 if (ID == Builtin::BIwmemchr || ID == Builtin::BI__builtin_wmemchr ||
2055 ID == Builtin::BIwcschr || ID == Builtin::BI__builtin_wcschr) {
2057 DesiredVal = Desired.getZExtValue();
2063 (ID == Builtin::BIstrchr || ID == Builtin::BI__builtin_strchr ||
2064 ID == Builtin::BIwcschr || ID == Builtin::BI__builtin_wcschr);
2073 (Index + Step) > 0 ? Ptr.
atIndex(Index + Step) : Ptr;
2080 ElemT, {
V =
static_cast<uint64_t
>(ElemPtr.
deref<
T>().toUnsigned()); });
2082 if (
V == DesiredVal) {
2087 if (StopAtZero &&
V == 0)
2091 if (MaxLength && Step == MaxLength->getZExtValue())
2115 return std::nullopt;
2153 uint64_t FieldOffset =
2159 llvm_unreachable(
"Unhandled descriptor type");
2195 auto isFlexibleArrayMember = [&](
const Descriptor *FieldDesc) {
2197 FAMKind StrictFlexArraysLevel =
2200 if (StrictFlexArraysLevel == FAMKind::Default)
2203 unsigned NumElems = FieldDesc->getNumElems();
2204 if (NumElems == 0 && StrictFlexArraysLevel != FAMKind::IncompleteOnly)
2207 if (NumElems == 1 && StrictFlexArraysLevel == FAMKind::OneZeroOrIncomplete)
2217 isFlexibleArrayMember(FieldDesc);
2230 assert(Kind <= 3 &&
"unexpected kind");
2231 bool UseFieldDesc = (Kind & 1u);
2232 bool ReportMinimum = (Kind & 2u);
2235 if (
Call->getArg(0)->HasSideEffects(ASTCtx)) {
2253 if (!UseFieldDesc || DetermineForCompleteObject) {
2255 if (ReportMinimum && !DetermineForCompleteObject)
2278 unsigned ByteOffset;
2294 assert(ByteOffset <= *FullSize);
2295 unsigned Result = *FullSize - ByteOffset;
2310 bool CalledFromStd =
false;
2312 if (Callee && Callee->isInStdNamespace()) {
2314 CalledFromStd = Identifier && Identifier->
isStr(
"is_within_lifetime");
2319 diag::err_invalid_is_within_lifetime)
2320 << (CalledFromStd ?
"std::is_within_lifetime"
2321 :
"__builtin_is_within_lifetime")
2356 assert(
Call->getNumArgs() == 1);
2357 assert(
Call->getType()->isIntegerType());
2360 if (!
Call->getArg(0)->getType()->isVectorType()) {
2374 assert(
Call->getNumArgs() == 2);
2377 if (!
Call->getArg(0)->getType()->isVectorType()) {
2378 assert(!
Call->getArg(1)->getType()->isVectorType());
2386 const auto *VT =
Call->getArg(0)->getType()->castAs<
VectorType>();
2387 assert(VT->getElementType()->isIntegralOrEnumerationType());
2389 unsigned NumElems = VT->getNumElements();
2390 bool DestUnsigned =
Call->getType()->isUnsignedIntegerOrEnumerationType();
2393 if (!
Call->getArg(1)->getType()->isVectorType()) {
2394 assert(
Call->getArg(1)->getType()->isIntegralOrEnumerationType());
2400 for (
unsigned I = 0; I != NumElems; ++I) {
2402 Dst.elem<
T>(I) =
static_cast<T>(
2411 assert(
Call->getArg(0)->getType()->isVectorType() &&
2412 Call->getArg(1)->getType()->isVectorType());
2413 assert(VT->getElementType() ==
2415 assert(VT->getNumElements() ==
2417 assert(VT->getElementType()->isIntegralOrEnumerationType());
2422 for (
unsigned I = 0; I != NumElems; ++I) {
2424 APSInt Elem1 = LHS.elem<
T>(I).toAPSInt();
2426 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(
Fn(Elem1, Elem2), DestUnsigned));
2436 llvm::function_ref<
APInt(
const APSInt &)> PackFn) {
2438 [[maybe_unused]]
const auto *VT1 =
2440 assert(VT0 && VT1 &&
"pack builtin VT0 and VT1 must be VectorType");
2443 "pack builtin VT0 and VT1 ElementType must be same");
2450 unsigned SrcBits = ASTCtx.
getIntWidth(VT0->getElementType());
2451 unsigned LHSVecLen = VT0->getNumElements();
2452 unsigned SrcPerLane = 128 / SrcBits;
2453 unsigned Lanes = LHSVecLen * SrcBits / 128;
2457 bool IsUnsigend =
getElemType(Dst)->isUnsignedIntegerType();
2459 for (
unsigned Lane = 0; Lane != Lanes; ++Lane) {
2460 unsigned BaseSrc = Lane * SrcPerLane;
2461 unsigned BaseDst = Lane * (2 * SrcPerLane);
2463 for (
unsigned I = 0; I != SrcPerLane; ++I) {
2465 APSInt A = LHS.elem<
T>(BaseSrc + I).toAPSInt();
2469 APSInt(PackFn(A), IsUnsigend));
2470 assignInteger(S, Dst.atIndex(BaseDst + SrcPerLane + I), DstT,
2471 APSInt(PackFn(B), IsUnsigend));
2476 Dst.initializeAllElements();
2482 unsigned BuiltinID) {
2483 assert(
Call->getNumArgs() == 2);
2494 assert(!
Call->getArg(1)->getType()->isVectorType());
2498 if (BuiltinID == Builtin::BI__builtin_elementwise_max) {
2499 Result = std::max(LHS, RHS);
2500 }
else if (BuiltinID == Builtin::BI__builtin_elementwise_min) {
2501 Result = std::min(LHS, RHS);
2503 llvm_unreachable(
"Wrong builtin ID");
2511 assert(
Call->getArg(0)->getType()->isVectorType() &&
2512 Call->getArg(1)->getType()->isVectorType());
2513 const auto *VT =
Call->getArg(0)->getType()->castAs<
VectorType>();
2514 assert(VT->getElementType() ==
2516 assert(VT->getNumElements() ==
2518 assert(VT->getElementType()->isIntegralOrEnumerationType());
2524 unsigned NumElems = VT->getNumElements();
2525 for (
unsigned I = 0; I != NumElems; ++I) {
2529 Elem1 = LHS.elem<
T>(I).toAPSInt();
2530 Elem2 = RHS.
elem<
T>(I).toAPSInt();
2534 if (BuiltinID == Builtin::BI__builtin_elementwise_max) {
2536 Call->getType()->isUnsignedIntegerOrEnumerationType());
2537 }
else if (BuiltinID == Builtin::BI__builtin_elementwise_min) {
2539 Call->getType()->isUnsignedIntegerOrEnumerationType());
2541 llvm_unreachable(
"Wrong builtin ID");
2545 { Dst.elem<
T>(I) =
static_cast<T>(
Result); });
2547 Dst.initializeAllElements();
2557 assert(
Call->getArg(0)->getType()->isVectorType() &&
2558 Call->getArg(1)->getType()->isVectorType());
2563 const auto *VT =
Call->getArg(0)->getType()->castAs<
VectorType>();
2565 unsigned NumElems = VT->getNumElements();
2568 bool DestUnsigned =
Call->getType()->isUnsignedIntegerOrEnumerationType();
2570 unsigned DstElem = 0;
2571 for (
unsigned I = 0; I != NumElems; I += 2) {
2574 APSInt LoLHS = LHS.elem<
T>(I).toAPSInt();
2575 APSInt HiLHS = LHS.elem<
T>(I + 1).toAPSInt();
2582 { Dst.elem<
T>(DstElem) =
static_cast<T>(
Result); });
2586 Dst.initializeAllElements();
2593 const auto *VT =
Call->getArg(0)->getType()->castAs<
VectorType>();
2595 bool DestUnsigned =
Call->getType()->isUnsignedIntegerOrEnumerationType();
2600 unsigned NumElts = VT->getNumElements();
2602 unsigned EltsPerLane = 128 / EltBits;
2603 unsigned Lanes = NumElts * EltBits / 128;
2604 unsigned DestIndex = 0;
2606 for (
unsigned Lane = 0; Lane < Lanes; ++Lane) {
2607 unsigned LaneStart = Lane * EltsPerLane;
2608 for (
unsigned I = 0; I < EltsPerLane; I += 2) {
2610 APSInt Elem1 = LHS.elem<
T>(LaneStart + I).toAPSInt();
2611 APSInt Elem2 = LHS.elem<
T>(LaneStart + I + 1).toAPSInt();
2613 Dst.elem<
T>(DestIndex++) =
static_cast<T>(ResL);
2617 for (
unsigned I = 0; I < EltsPerLane; I += 2) {
2619 APSInt Elem1 = RHS.
elem<
T>(LaneStart + I).toAPSInt();
2620 APSInt Elem2 = RHS.
elem<
T>(LaneStart + I + 1).toAPSInt();
2622 Dst.elem<
T>(DestIndex++) =
static_cast<T>(ResR);
2626 Dst.initializeAllElements();
2633 llvm::RoundingMode)>
2640 const auto *VT =
Call->getArg(0)->getType()->castAs<
VectorType>();
2644 unsigned NumLanes = NumElts * EltBits / 128;
2645 unsigned NumElemsPerLane = NumElts / NumLanes;
2646 unsigned HalfElemsPerLane = NumElemsPerLane / 2;
2648 for (
unsigned L = 0; L != NumElts; L += NumElemsPerLane) {
2650 for (
unsigned E = 0; E != HalfElemsPerLane; ++E) {
2651 APFloat Elem1 = LHS.elem<
T>(L + (2 * E) + 0).getAPFloat();
2652 APFloat Elem2 = LHS.elem<
T>(L + (2 * E) + 1).getAPFloat();
2653 Dst.elem<
T>(L + E) =
static_cast<T>(
Fn(Elem1, Elem2, RM));
2655 for (
unsigned E = 0; E != HalfElemsPerLane; ++E) {
2656 APFloat Elem1 = RHS.
elem<
T>(L + (2 * E) + 0).getAPFloat();
2657 APFloat Elem2 = RHS.
elem<
T>(L + (2 * E) + 1).getAPFloat();
2658 Dst.elem<
T>(L + E + HalfElemsPerLane) =
2659 static_cast<T>(
Fn(Elem1, Elem2, RM));
2662 Dst.initializeAllElements();
2669 const APFloat &, llvm::RoundingMode)>
2671 assert(
Call->getNumArgs() == 3);
2708 assert(ElemQT->isRealFloatingType());
2715 for (
unsigned I = 0; I != NumElems; ++I) {
2718 APFloat Y = VY.elem<
T>(I).getAPFloat();
2737 unsigned NumElems = LHS.getNumElems();
2738 PrimType ElemT = LHS.getFieldDesc()->getPrimType();
2741 for (
unsigned I = 0; I != NumElems; ++I) {
2749 Elem = Mask[I] ? LHS.elem<
T>(I).toAPSInt() : RHS.
elem<
T>(I).toAPSInt();
2752 { Dst.
elem<
T>(I) =
static_cast<T>(Elem); });
2767 assert(FalseVec.getNumElems() == TrueVec.
getNumElems());
2768 assert(FalseVec.getNumElems() == Dst.getNumElems());
2769 unsigned NumElems = FalseVec.getNumElems();
2770 PrimType ElemT = FalseVec.getFieldDesc()->getPrimType();
2771 PrimType DstElemT = Dst.getFieldDesc()->getPrimType();
2773 for (
unsigned I = 0; I != NumElems; ++I) {
2774 bool MaskBit = Mask[I % 8];
2780 assert(DstElemT == ElemT);
2783 static_cast<T>(MaskBit ? TrueVec.
elem<
T>(I).toAPSInt()
2784 : FalseVec.elem<
T>(I).toAPSInt());
2788 Dst.initializeAllElements();
2795 assert(
Call->getNumArgs() == 2 &&
"masked forms handled via select*");
2802 assert(NumElems == Dst.getNumElems());
2804 for (
unsigned Idx = 0; Idx != NumElems; ++Idx) {
2805 uint8_t Ctlb =
static_cast<uint8_t
>(Control.
elem<int8_t>(Idx));
2808 Dst.elem<int8_t>(Idx) = 0;
2810 unsigned LaneBase = (Idx / 16) * 16;
2811 unsigned SrcOffset = Ctlb & 0x0F;
2812 unsigned SrcIdx = LaneBase + SrcOffset;
2814 Dst.elem<int8_t>(Idx) = Src.elem<int8_t>(SrcIdx);
2817 Dst.initializeAllElements();
2823 assert(
Call->getNumArgs() == 2 &&
"masked forms handled via select*");
2829 PrimType ElemT = Dst.getFieldDesc()->getPrimType();
2831 unsigned ElemBits =
static_cast<unsigned>(
primSize(ElemT) * 8);
2832 if (ElemBits != 16 && ElemBits != 32)
2835 unsigned LaneElts = 128u / ElemBits;
2836 assert(LaneElts && (NumElems % LaneElts == 0));
2838 uint8_t Ctl =
static_cast<uint8_t
>(ControlImm.getZExtValue());
2840 for (
unsigned Idx = 0; Idx != NumElems; Idx++) {
2841 unsigned LaneBase = (Idx / LaneElts) * LaneElts;
2842 unsigned LaneIdx = Idx % LaneElts;
2843 unsigned SrcIdx = Idx;
2844 unsigned Sel = (Ctl >> (2 * (LaneIdx & 0x3))) & 0x3;
2845 if (ElemBits == 32) {
2846 SrcIdx = LaneBase + Sel;
2848 constexpr unsigned HalfSize = 4;
2849 bool InHigh = LaneIdx >= HalfSize;
2850 if (!IsShufHW && !InHigh) {
2851 SrcIdx = LaneBase + Sel;
2852 }
else if (IsShufHW && InHigh) {
2853 SrcIdx = LaneBase + HalfSize + Sel;
2859 Dst.initializeAllElements();
2865 llvm::function_ref<
bool(
const APInt &A,
const APInt &B)>
Fn) {
2871 unsigned SourceLen = LHS.getNumElems();
2876 APInt AWide(LaneWidth * SourceLen, 0);
2877 APInt BWide(LaneWidth * SourceLen, 0);
2879 for (
unsigned I = 0; I != SourceLen; ++I) {
2885 ALane = LHS.elem<
T>(I).toAPSInt();
2886 BLane = RHS.
elem<
T>(I).toAPSInt();
2890 ALane = LHS.elem<
T>(I).getAPFloat().bitcastToAPInt().isNegative();
2891 BLane = RHS.
elem<
T>(I).getAPFloat().bitcastToAPInt().isNegative();
2895 AWide.insertBits(ALane, I * LaneWidth);
2896 BWide.insertBits(BLane, I * LaneWidth);
2906 assert(
Call->getNumArgs() == 3);
2922 unsigned NumElems = VecT->getNumElements();
2923 bool DestUnsigned =
Call->getType()->isUnsignedIntegerOrEnumerationType();
2932 for (
unsigned I = 0; I != NumElems; ++I) {
2934 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(
2935 Fn(Op0.elem<
T>(I).toAPSInt(), Op1.
elem<
T>(I).toAPSInt(), Op2),
2949 for (
unsigned I = 0; I != NumElems; ++I) {
2952 Val0 = Op0.elem<
T>(I).toAPSInt();
2953 Val1 = Op1.elem<
T>(I).toAPSInt();
2954 Val2 = Op2.
elem<
T>(I).toAPSInt();
2958 { Dst.elem<
T>(I) =
static_cast<T>(
Result); });
2968 assert(
Call->getNumArgs() == 3);
2971 uint64_t Index = ImmAPS.getZExtValue();
2986 assert(SubElements != 0 && BaseElements != 0 &&
2987 (BaseElements % SubElements) == 0);
2989 unsigned NumLanes = BaseElements / SubElements;
2990 unsigned Lane =
static_cast<unsigned>(Index % NumLanes);
2991 unsigned InsertPos = Lane * SubElements;
2996 for (
unsigned I = 0; I != BaseElements; ++I)
2998 for (
unsigned I = 0; I != SubElements; ++I)
2999 Dst.
elem<
T>(InsertPos + I) = SubVec.
elem<
T>(I);
3008 assert(
Call->getNumArgs() == 5);
3024 for (
unsigned I = 0; I != DstLen; ++I) {
3025 APInt ALane = A.elem<
T>(I).toAPSInt();
3026 APInt BLane = B.elem<
T>(I).toAPSInt();
3027 APInt CLane =
C.elem<
T>(I).toAPSInt();
3028 APInt RLane(LaneWidth, 0);
3030 for (
unsigned Bit = 0; Bit != LaneWidth; ++Bit) {
3031 unsigned ABit = ALane[Bit];
3032 unsigned BBit = BLane[Bit];
3033 unsigned CBit = CLane[Bit];
3034 unsigned Idx = (ABit << 2) | (BBit << 1) | (CBit);
3035 RLane.setBitVal(Bit, Imm[Idx]);
3037 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(RLane, DstUnsigned));
3039 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(RLane, DstUnsigned));
3041 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(ALane, DstUnsigned));
3045 Dst.initializeAllElements();
3051 assert(
Call->getNumArgs() == 2);
3060 static_cast<unsigned>(ImmAPS.getZExtValue() & (NumElems - 1));
3078 assert(
Call->getNumArgs() == 3);
3084 if (!
Base.getFieldDesc()->isPrimitiveArray())
3089 unsigned NumElems =
Base.getNumElems();
3091 static_cast<unsigned>(ImmAPS.getZExtValue() & (NumElems - 1));
3095 for (
unsigned I = 0; I != NumElems; ++I)
3097 Dst.
elem<
T>(Index) =
static_cast<T>(ValAPS);
3106 assert(
Call->getNumArgs() == 1);
3111 unsigned NumElems = VecT->getNumElements();
3112 bool DestUnsigned =
Call->getType()->isUnsignedIntegerOrEnumerationType();
3116 for (
unsigned I = 0; I != NumElems; ++I) {
3119 APInt ConflictMask(ElemI.getBitWidth(), 0);
3120 for (
unsigned J = 0; J != I; ++J) {
3122 ConflictMask.setBitVal(J, ElemI == ElemJ);
3124 Dst.elem<
T>(I) =
static_cast<T>(
APSInt(ConflictMask, DestUnsigned));
3132 uint32_t BuiltinID) {
3137 switch (BuiltinID) {
3138 case Builtin::BI__builtin_is_constant_evaluated:
3141 case Builtin::BI__builtin_assume:
3142 case Builtin::BI__assume:
3145 case Builtin::BI__builtin_strcmp:
3146 case Builtin::BIstrcmp:
3147 case Builtin::BI__builtin_strncmp:
3148 case Builtin::BIstrncmp:
3149 case Builtin::BI__builtin_wcsncmp:
3150 case Builtin::BIwcsncmp:
3151 case Builtin::BI__builtin_wcscmp:
3152 case Builtin::BIwcscmp:
3155 case Builtin::BI__builtin_strlen:
3156 case Builtin::BIstrlen:
3157 case Builtin::BI__builtin_wcslen:
3158 case Builtin::BIwcslen:
3161 case Builtin::BI__builtin_nan:
3162 case Builtin::BI__builtin_nanf:
3163 case Builtin::BI__builtin_nanl:
3164 case Builtin::BI__builtin_nanf16:
3165 case Builtin::BI__builtin_nanf128:
3168 case Builtin::BI__builtin_nans:
3169 case Builtin::BI__builtin_nansf:
3170 case Builtin::BI__builtin_nansl:
3171 case Builtin::BI__builtin_nansf16:
3172 case Builtin::BI__builtin_nansf128:
3175 case Builtin::BI__builtin_huge_val:
3176 case Builtin::BI__builtin_huge_valf:
3177 case Builtin::BI__builtin_huge_vall:
3178 case Builtin::BI__builtin_huge_valf16:
3179 case Builtin::BI__builtin_huge_valf128:
3180 case Builtin::BI__builtin_inf:
3181 case Builtin::BI__builtin_inff:
3182 case Builtin::BI__builtin_infl:
3183 case Builtin::BI__builtin_inff16:
3184 case Builtin::BI__builtin_inff128:
3187 case Builtin::BI__builtin_copysign:
3188 case Builtin::BI__builtin_copysignf:
3189 case Builtin::BI__builtin_copysignl:
3190 case Builtin::BI__builtin_copysignf128:
3193 case Builtin::BI__builtin_fmin:
3194 case Builtin::BI__builtin_fminf:
3195 case Builtin::BI__builtin_fminl:
3196 case Builtin::BI__builtin_fminf16:
3197 case Builtin::BI__builtin_fminf128:
3200 case Builtin::BI__builtin_fminimum_num:
3201 case Builtin::BI__builtin_fminimum_numf:
3202 case Builtin::BI__builtin_fminimum_numl:
3203 case Builtin::BI__builtin_fminimum_numf16:
3204 case Builtin::BI__builtin_fminimum_numf128:
3207 case Builtin::BI__builtin_fmax:
3208 case Builtin::BI__builtin_fmaxf:
3209 case Builtin::BI__builtin_fmaxl:
3210 case Builtin::BI__builtin_fmaxf16:
3211 case Builtin::BI__builtin_fmaxf128:
3214 case Builtin::BI__builtin_fmaximum_num:
3215 case Builtin::BI__builtin_fmaximum_numf:
3216 case Builtin::BI__builtin_fmaximum_numl:
3217 case Builtin::BI__builtin_fmaximum_numf16:
3218 case Builtin::BI__builtin_fmaximum_numf128:
3221 case Builtin::BI__builtin_isnan:
3224 case Builtin::BI__builtin_issignaling:
3227 case Builtin::BI__builtin_isinf:
3230 case Builtin::BI__builtin_isinf_sign:
3233 case Builtin::BI__builtin_isfinite:
3236 case Builtin::BI__builtin_isnormal:
3239 case Builtin::BI__builtin_issubnormal:
3242 case Builtin::BI__builtin_iszero:
3245 case Builtin::BI__builtin_signbit:
3246 case Builtin::BI__builtin_signbitf:
3247 case Builtin::BI__builtin_signbitl:
3250 case Builtin::BI__builtin_isgreater:
3251 case Builtin::BI__builtin_isgreaterequal:
3252 case Builtin::BI__builtin_isless:
3253 case Builtin::BI__builtin_islessequal:
3254 case Builtin::BI__builtin_islessgreater:
3255 case Builtin::BI__builtin_isunordered:
3258 case Builtin::BI__builtin_isfpclass:
3261 case Builtin::BI__builtin_fpclassify:
3264 case Builtin::BI__builtin_fabs:
3265 case Builtin::BI__builtin_fabsf:
3266 case Builtin::BI__builtin_fabsl:
3267 case Builtin::BI__builtin_fabsf128:
3270 case Builtin::BI__builtin_abs:
3271 case Builtin::BI__builtin_labs:
3272 case Builtin::BI__builtin_llabs:
3275 case Builtin::BI__builtin_popcount:
3276 case Builtin::BI__builtin_popcountl:
3277 case Builtin::BI__builtin_popcountll:
3278 case Builtin::BI__builtin_popcountg:
3279 case Builtin::BI__popcnt16:
3280 case Builtin::BI__popcnt:
3281 case Builtin::BI__popcnt64:
3284 case Builtin::BI__builtin_parity:
3285 case Builtin::BI__builtin_parityl:
3286 case Builtin::BI__builtin_parityll:
3289 return APInt(Val.getBitWidth(), Val.popcount() % 2);
3291 case Builtin::BI__builtin_clrsb:
3292 case Builtin::BI__builtin_clrsbl:
3293 case Builtin::BI__builtin_clrsbll:
3296 return APInt(Val.getBitWidth(),
3297 Val.getBitWidth() - Val.getSignificantBits());
3299 case Builtin::BI__builtin_bitreverse8:
3300 case Builtin::BI__builtin_bitreverse16:
3301 case Builtin::BI__builtin_bitreverse32:
3302 case Builtin::BI__builtin_bitreverse64:
3304 S, OpPC,
Call, [](
const APSInt &Val) {
return Val.reverseBits(); });
3306 case Builtin::BI__builtin_classify_type:
3309 case Builtin::BI__builtin_expect:
3310 case Builtin::BI__builtin_expect_with_probability:
3313 case Builtin::BI__builtin_rotateleft8:
3314 case Builtin::BI__builtin_rotateleft16:
3315 case Builtin::BI__builtin_rotateleft32:
3316 case Builtin::BI__builtin_rotateleft64:
3317 case Builtin::BI_rotl8:
3318 case Builtin::BI_rotl16:
3319 case Builtin::BI_rotl:
3320 case Builtin::BI_lrotl:
3321 case Builtin::BI_rotl64:
3324 return Value.rotl(Amount);
3327 case Builtin::BI__builtin_rotateright8:
3328 case Builtin::BI__builtin_rotateright16:
3329 case Builtin::BI__builtin_rotateright32:
3330 case Builtin::BI__builtin_rotateright64:
3331 case Builtin::BI_rotr8:
3332 case Builtin::BI_rotr16:
3333 case Builtin::BI_rotr:
3334 case Builtin::BI_lrotr:
3335 case Builtin::BI_rotr64:
3338 return Value.rotr(Amount);
3341 case Builtin::BI__builtin_ffs:
3342 case Builtin::BI__builtin_ffsl:
3343 case Builtin::BI__builtin_ffsll:
3346 return APInt(Val.getBitWidth(),
3347 Val.isZero() ? 0u : Val.countTrailingZeros() + 1u);
3350 case Builtin::BIaddressof:
3351 case Builtin::BI__addressof:
3352 case Builtin::BI__builtin_addressof:
3356 case Builtin::BIas_const:
3357 case Builtin::BIforward:
3358 case Builtin::BIforward_like:
3359 case Builtin::BImove:
3360 case Builtin::BImove_if_noexcept:
3364 case Builtin::BI__builtin_eh_return_data_regno:
3367 case Builtin::BI__builtin_launder:
3371 case Builtin::BI__builtin_add_overflow:
3372 case Builtin::BI__builtin_sub_overflow:
3373 case Builtin::BI__builtin_mul_overflow:
3374 case Builtin::BI__builtin_sadd_overflow:
3375 case Builtin::BI__builtin_uadd_overflow:
3376 case Builtin::BI__builtin_uaddl_overflow:
3377 case Builtin::BI__builtin_uaddll_overflow:
3378 case Builtin::BI__builtin_usub_overflow:
3379 case Builtin::BI__builtin_usubl_overflow:
3380 case Builtin::BI__builtin_usubll_overflow:
3381 case Builtin::BI__builtin_umul_overflow:
3382 case Builtin::BI__builtin_umull_overflow:
3383 case Builtin::BI__builtin_umulll_overflow:
3384 case Builtin::BI__builtin_saddl_overflow:
3385 case Builtin::BI__builtin_saddll_overflow:
3386 case Builtin::BI__builtin_ssub_overflow:
3387 case Builtin::BI__builtin_ssubl_overflow:
3388 case Builtin::BI__builtin_ssubll_overflow:
3389 case Builtin::BI__builtin_smul_overflow:
3390 case Builtin::BI__builtin_smull_overflow:
3391 case Builtin::BI__builtin_smulll_overflow:
3394 case Builtin::BI__builtin_addcb:
3395 case Builtin::BI__builtin_addcs:
3396 case Builtin::BI__builtin_addc:
3397 case Builtin::BI__builtin_addcl:
3398 case Builtin::BI__builtin_addcll:
3399 case Builtin::BI__builtin_subcb:
3400 case Builtin::BI__builtin_subcs:
3401 case Builtin::BI__builtin_subc:
3402 case Builtin::BI__builtin_subcl:
3403 case Builtin::BI__builtin_subcll:
3406 case Builtin::BI__builtin_clz:
3407 case Builtin::BI__builtin_clzl:
3408 case Builtin::BI__builtin_clzll:
3409 case Builtin::BI__builtin_clzs:
3410 case Builtin::BI__builtin_clzg:
3411 case Builtin::BI__lzcnt16:
3412 case Builtin::BI__lzcnt:
3413 case Builtin::BI__lzcnt64:
3416 case Builtin::BI__builtin_ctz:
3417 case Builtin::BI__builtin_ctzl:
3418 case Builtin::BI__builtin_ctzll:
3419 case Builtin::BI__builtin_ctzs:
3420 case Builtin::BI__builtin_ctzg:
3423 case Builtin::BI__builtin_elementwise_clzg:
3424 case Builtin::BI__builtin_elementwise_ctzg:
3428 case Builtin::BI__builtin_bswap16:
3429 case Builtin::BI__builtin_bswap32:
3430 case Builtin::BI__builtin_bswap64:
3433 case Builtin::BI__atomic_always_lock_free:
3434 case Builtin::BI__atomic_is_lock_free:
3437 case Builtin::BI__c11_atomic_is_lock_free:
3440 case Builtin::BI__builtin_complex:
3443 case Builtin::BI__builtin_is_aligned:
3444 case Builtin::BI__builtin_align_up:
3445 case Builtin::BI__builtin_align_down:
3448 case Builtin::BI__builtin_assume_aligned:
3451 case clang::X86::BI__builtin_ia32_bextr_u32:
3452 case clang::X86::BI__builtin_ia32_bextr_u64:
3453 case clang::X86::BI__builtin_ia32_bextri_u32:
3454 case clang::X86::BI__builtin_ia32_bextri_u64:
3457 unsigned BitWidth = Val.getBitWidth();
3458 uint64_t Shift = Idx.extractBitsAsZExtValue(8, 0);
3459 uint64_t Length = Idx.extractBitsAsZExtValue(8, 8);
3460 if (Length > BitWidth) {
3465 if (Length == 0 || Shift >= BitWidth)
3466 return APInt(BitWidth, 0);
3468 uint64_t
Result = Val.getZExtValue() >> Shift;
3469 Result &= llvm::maskTrailingOnes<uint64_t>(Length);
3473 case clang::X86::BI__builtin_ia32_bzhi_si:
3474 case clang::X86::BI__builtin_ia32_bzhi_di:
3477 unsigned BitWidth = Val.getBitWidth();
3478 uint64_t Index = Idx.extractBitsAsZExtValue(8, 0);
3481 if (Index < BitWidth)
3482 Result.clearHighBits(BitWidth - Index);
3487 case clang::X86::BI__builtin_ia32_lzcnt_u16:
3488 case clang::X86::BI__builtin_ia32_lzcnt_u32:
3489 case clang::X86::BI__builtin_ia32_lzcnt_u64:
3492 return APInt(Src.getBitWidth(), Src.countLeadingZeros());
3495 case clang::X86::BI__builtin_ia32_tzcnt_u16:
3496 case clang::X86::BI__builtin_ia32_tzcnt_u32:
3497 case clang::X86::BI__builtin_ia32_tzcnt_u64:
3500 return APInt(Src.getBitWidth(), Src.countTrailingZeros());
3503 case clang::X86::BI__builtin_ia32_pdep_si:
3504 case clang::X86::BI__builtin_ia32_pdep_di:
3507 unsigned BitWidth = Val.getBitWidth();
3510 for (
unsigned I = 0, P = 0; I != BitWidth; ++I) {
3512 Result.setBitVal(I, Val[P++]);
3518 case clang::X86::BI__builtin_ia32_pext_si:
3519 case clang::X86::BI__builtin_ia32_pext_di:
3522 unsigned BitWidth = Val.getBitWidth();
3525 for (
unsigned I = 0, P = 0; I != BitWidth; ++I) {
3527 Result.setBitVal(P++, Val[I]);
3533 case clang::X86::BI__builtin_ia32_addcarryx_u32:
3534 case clang::X86::BI__builtin_ia32_addcarryx_u64:
3535 case clang::X86::BI__builtin_ia32_subborrow_u32:
3536 case clang::X86::BI__builtin_ia32_subborrow_u64:
3540 case Builtin::BI__builtin_os_log_format_buffer_size:
3543 case Builtin::BI__builtin_ptrauth_string_discriminator:
3546 case Builtin::BI__noop:
3550 case Builtin::BI__builtin_operator_new:
3553 case Builtin::BI__builtin_operator_delete:
3556 case Builtin::BI__arithmetic_fence:
3559 case Builtin::BI__builtin_reduce_add:
3560 case Builtin::BI__builtin_reduce_mul:
3561 case Builtin::BI__builtin_reduce_and:
3562 case Builtin::BI__builtin_reduce_or:
3563 case Builtin::BI__builtin_reduce_xor:
3564 case Builtin::BI__builtin_reduce_min:
3565 case Builtin::BI__builtin_reduce_max:
3568 case Builtin::BI__builtin_elementwise_popcount:
3569 case Builtin::BI__builtin_elementwise_bitreverse:
3573 case Builtin::BI__builtin_elementwise_abs:
3576 case Builtin::BI__builtin_memcpy:
3577 case Builtin::BImemcpy:
3578 case Builtin::BI__builtin_wmemcpy:
3579 case Builtin::BIwmemcpy:
3580 case Builtin::BI__builtin_memmove:
3581 case Builtin::BImemmove:
3582 case Builtin::BI__builtin_wmemmove:
3583 case Builtin::BIwmemmove:
3586 case Builtin::BI__builtin_memcmp:
3587 case Builtin::BImemcmp:
3588 case Builtin::BI__builtin_bcmp:
3589 case Builtin::BIbcmp:
3590 case Builtin::BI__builtin_wmemcmp:
3591 case Builtin::BIwmemcmp:
3594 case Builtin::BImemchr:
3595 case Builtin::BI__builtin_memchr:
3596 case Builtin::BIstrchr:
3597 case Builtin::BI__builtin_strchr:
3598 case Builtin::BIwmemchr:
3599 case Builtin::BI__builtin_wmemchr:
3600 case Builtin::BIwcschr:
3601 case Builtin::BI__builtin_wcschr:
3602 case Builtin::BI__builtin_char_memchr:
3605 case Builtin::BI__builtin_object_size:
3606 case Builtin::BI__builtin_dynamic_object_size:
3609 case Builtin::BI__builtin_is_within_lifetime:
3612 case Builtin::BI__builtin_elementwise_add_sat:
3615 return LHS.isSigned() ? LHS.sadd_sat(RHS) : LHS.uadd_sat(RHS);
3618 case Builtin::BI__builtin_elementwise_sub_sat:
3621 return LHS.isSigned() ? LHS.ssub_sat(RHS) : LHS.usub_sat(RHS);
3624 case clang::X86::BI__builtin_ia32_pavgb128:
3625 case clang::X86::BI__builtin_ia32_pavgw128:
3626 case clang::X86::BI__builtin_ia32_pavgb256:
3627 case clang::X86::BI__builtin_ia32_pavgw256:
3628 case clang::X86::BI__builtin_ia32_pavgb512:
3629 case clang::X86::BI__builtin_ia32_pavgw512:
3631 llvm::APIntOps::avgCeilU);
3633 case clang::X86::BI__builtin_ia32_pmaddubsw128:
3634 case clang::X86::BI__builtin_ia32_pmaddubsw256:
3635 case clang::X86::BI__builtin_ia32_pmaddubsw512:
3640 unsigned BitWidth = 2 * LoLHS.getBitWidth();
3641 return (LoLHS.zext(BitWidth) * LoRHS.sext(BitWidth))
3642 .sadd_sat((HiLHS.zext(BitWidth) * HiRHS.sext(BitWidth)));
3645 case clang::X86::BI__builtin_ia32_pmaddwd128:
3646 case clang::X86::BI__builtin_ia32_pmaddwd256:
3647 case clang::X86::BI__builtin_ia32_pmaddwd512:
3652 unsigned BitWidth = 2 * LoLHS.getBitWidth();
3653 return (LoLHS.sext(BitWidth) * LoRHS.sext(BitWidth)) +
3654 (HiLHS.sext(BitWidth) * HiRHS.sext(BitWidth));
3657 case clang::X86::BI__builtin_ia32_pmulhuw128:
3658 case clang::X86::BI__builtin_ia32_pmulhuw256:
3659 case clang::X86::BI__builtin_ia32_pmulhuw512:
3661 llvm::APIntOps::mulhu);
3663 case clang::X86::BI__builtin_ia32_pmulhw128:
3664 case clang::X86::BI__builtin_ia32_pmulhw256:
3665 case clang::X86::BI__builtin_ia32_pmulhw512:
3667 llvm::APIntOps::mulhs);
3669 case clang::X86::BI__builtin_ia32_psllv2di:
3670 case clang::X86::BI__builtin_ia32_psllv4di:
3671 case clang::X86::BI__builtin_ia32_psllv4si:
3672 case clang::X86::BI__builtin_ia32_psllv8di:
3673 case clang::X86::BI__builtin_ia32_psllv8hi:
3674 case clang::X86::BI__builtin_ia32_psllv8si:
3675 case clang::X86::BI__builtin_ia32_psllv16hi:
3676 case clang::X86::BI__builtin_ia32_psllv16si:
3677 case clang::X86::BI__builtin_ia32_psllv32hi:
3678 case clang::X86::BI__builtin_ia32_psllwi128:
3679 case clang::X86::BI__builtin_ia32_psllwi256:
3680 case clang::X86::BI__builtin_ia32_psllwi512:
3681 case clang::X86::BI__builtin_ia32_pslldi128:
3682 case clang::X86::BI__builtin_ia32_pslldi256:
3683 case clang::X86::BI__builtin_ia32_pslldi512:
3684 case clang::X86::BI__builtin_ia32_psllqi128:
3685 case clang::X86::BI__builtin_ia32_psllqi256:
3686 case clang::X86::BI__builtin_ia32_psllqi512:
3689 if (RHS.uge(LHS.getBitWidth())) {
3690 return APInt::getZero(LHS.getBitWidth());
3692 return LHS.shl(RHS.getZExtValue());
3695 case clang::X86::BI__builtin_ia32_psrav4si:
3696 case clang::X86::BI__builtin_ia32_psrav8di:
3697 case clang::X86::BI__builtin_ia32_psrav8hi:
3698 case clang::X86::BI__builtin_ia32_psrav8si:
3699 case clang::X86::BI__builtin_ia32_psrav16hi:
3700 case clang::X86::BI__builtin_ia32_psrav16si:
3701 case clang::X86::BI__builtin_ia32_psrav32hi:
3702 case clang::X86::BI__builtin_ia32_psravq128:
3703 case clang::X86::BI__builtin_ia32_psravq256:
3704 case clang::X86::BI__builtin_ia32_psrawi128:
3705 case clang::X86::BI__builtin_ia32_psrawi256:
3706 case clang::X86::BI__builtin_ia32_psrawi512:
3707 case clang::X86::BI__builtin_ia32_psradi128:
3708 case clang::X86::BI__builtin_ia32_psradi256:
3709 case clang::X86::BI__builtin_ia32_psradi512:
3710 case clang::X86::BI__builtin_ia32_psraqi128:
3711 case clang::X86::BI__builtin_ia32_psraqi256:
3712 case clang::X86::BI__builtin_ia32_psraqi512:
3715 if (RHS.uge(LHS.getBitWidth())) {
3716 return LHS.ashr(LHS.getBitWidth() - 1);
3718 return LHS.ashr(RHS.getZExtValue());
3721 case clang::X86::BI__builtin_ia32_psrlv2di:
3722 case clang::X86::BI__builtin_ia32_psrlv4di:
3723 case clang::X86::BI__builtin_ia32_psrlv4si:
3724 case clang::X86::BI__builtin_ia32_psrlv8di:
3725 case clang::X86::BI__builtin_ia32_psrlv8hi:
3726 case clang::X86::BI__builtin_ia32_psrlv8si:
3727 case clang::X86::BI__builtin_ia32_psrlv16hi:
3728 case clang::X86::BI__builtin_ia32_psrlv16si:
3729 case clang::X86::BI__builtin_ia32_psrlv32hi:
3730 case clang::X86::BI__builtin_ia32_psrlwi128:
3731 case clang::X86::BI__builtin_ia32_psrlwi256:
3732 case clang::X86::BI__builtin_ia32_psrlwi512:
3733 case clang::X86::BI__builtin_ia32_psrldi128:
3734 case clang::X86::BI__builtin_ia32_psrldi256:
3735 case clang::X86::BI__builtin_ia32_psrldi512:
3736 case clang::X86::BI__builtin_ia32_psrlqi128:
3737 case clang::X86::BI__builtin_ia32_psrlqi256:
3738 case clang::X86::BI__builtin_ia32_psrlqi512:
3741 if (RHS.uge(LHS.getBitWidth())) {
3742 return APInt::getZero(LHS.getBitWidth());
3744 return LHS.lshr(RHS.getZExtValue());
3746 case clang::X86::BI__builtin_ia32_packsswb128:
3747 case clang::X86::BI__builtin_ia32_packsswb256:
3748 case clang::X86::BI__builtin_ia32_packsswb512:
3749 case clang::X86::BI__builtin_ia32_packssdw128:
3750 case clang::X86::BI__builtin_ia32_packssdw256:
3751 case clang::X86::BI__builtin_ia32_packssdw512:
3753 return APInt(Src).truncSSat(Src.getBitWidth() / 2);
3755 case clang::X86::BI__builtin_ia32_packusdw128:
3756 case clang::X86::BI__builtin_ia32_packusdw256:
3757 case clang::X86::BI__builtin_ia32_packusdw512:
3758 case clang::X86::BI__builtin_ia32_packuswb128:
3759 case clang::X86::BI__builtin_ia32_packuswb256:
3760 case clang::X86::BI__builtin_ia32_packuswb512:
3762 unsigned DstBits = Src.getBitWidth() / 2;
3763 if (Src.isNegative())
3764 return APInt::getZero(DstBits);
3765 if (Src.isIntN(DstBits))
3766 return APInt(Src).trunc(DstBits);
3767 return APInt::getAllOnes(DstBits);
3770 case clang::X86::BI__builtin_ia32_vprotbi:
3771 case clang::X86::BI__builtin_ia32_vprotdi:
3772 case clang::X86::BI__builtin_ia32_vprotqi:
3773 case clang::X86::BI__builtin_ia32_vprotwi:
3774 case clang::X86::BI__builtin_ia32_prold128:
3775 case clang::X86::BI__builtin_ia32_prold256:
3776 case clang::X86::BI__builtin_ia32_prold512:
3777 case clang::X86::BI__builtin_ia32_prolq128:
3778 case clang::X86::BI__builtin_ia32_prolq256:
3779 case clang::X86::BI__builtin_ia32_prolq512:
3782 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS.rotl(RHS); });
3784 case clang::X86::BI__builtin_ia32_prord128:
3785 case clang::X86::BI__builtin_ia32_prord256:
3786 case clang::X86::BI__builtin_ia32_prord512:
3787 case clang::X86::BI__builtin_ia32_prorq128:
3788 case clang::X86::BI__builtin_ia32_prorq256:
3789 case clang::X86::BI__builtin_ia32_prorq512:
3792 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS.rotr(RHS); });
3794 case Builtin::BI__builtin_elementwise_max:
3795 case Builtin::BI__builtin_elementwise_min:
3798 case clang::X86::BI__builtin_ia32_phaddw128:
3799 case clang::X86::BI__builtin_ia32_phaddw256:
3800 case clang::X86::BI__builtin_ia32_phaddd128:
3801 case clang::X86::BI__builtin_ia32_phaddd256:
3804 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS + RHS; });
3805 case clang::X86::BI__builtin_ia32_phaddsw128:
3806 case clang::X86::BI__builtin_ia32_phaddsw256:
3809 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS.sadd_sat(RHS); });
3810 case clang::X86::BI__builtin_ia32_phsubw128:
3811 case clang::X86::BI__builtin_ia32_phsubw256:
3812 case clang::X86::BI__builtin_ia32_phsubd128:
3813 case clang::X86::BI__builtin_ia32_phsubd256:
3816 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS - RHS; });
3817 case clang::X86::BI__builtin_ia32_phsubsw128:
3818 case clang::X86::BI__builtin_ia32_phsubsw256:
3821 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS.ssub_sat(RHS); });
3822 case clang::X86::BI__builtin_ia32_haddpd:
3823 case clang::X86::BI__builtin_ia32_haddps:
3824 case clang::X86::BI__builtin_ia32_haddpd256:
3825 case clang::X86::BI__builtin_ia32_haddps256:
3828 [](
const APFloat &LHS,
const APFloat &RHS, llvm::RoundingMode RM) {
3833 case clang::X86::BI__builtin_ia32_hsubpd:
3834 case clang::X86::BI__builtin_ia32_hsubps:
3835 case clang::X86::BI__builtin_ia32_hsubpd256:
3836 case clang::X86::BI__builtin_ia32_hsubps256:
3839 [](
const APFloat &LHS,
const APFloat &RHS, llvm::RoundingMode RM) {
3841 F.subtract(RHS, RM);
3845 case clang::X86::BI__builtin_ia32_pmuldq128:
3846 case clang::X86::BI__builtin_ia32_pmuldq256:
3847 case clang::X86::BI__builtin_ia32_pmuldq512:
3852 return llvm::APIntOps::mulsExtended(LoLHS, LoRHS);
3855 case clang::X86::BI__builtin_ia32_pmuludq128:
3856 case clang::X86::BI__builtin_ia32_pmuludq256:
3857 case clang::X86::BI__builtin_ia32_pmuludq512:
3862 return llvm::APIntOps::muluExtended(LoLHS, LoRHS);
3865 case Builtin::BI__builtin_elementwise_fma:
3869 llvm::RoundingMode RM) {
3871 F.fusedMultiplyAdd(Y, Z, RM);
3875 case X86::BI__builtin_ia32_vpmadd52luq128:
3876 case X86::BI__builtin_ia32_vpmadd52luq256:
3877 case X86::BI__builtin_ia32_vpmadd52luq512:
3880 return A + (B.trunc(52) *
C.trunc(52)).zext(64);
3882 case X86::BI__builtin_ia32_vpmadd52huq128:
3883 case X86::BI__builtin_ia32_vpmadd52huq256:
3884 case X86::BI__builtin_ia32_vpmadd52huq512:
3887 return A + llvm::APIntOps::mulhu(B.trunc(52),
C.trunc(52)).zext(64);
3890 case X86::BI__builtin_ia32_vpshldd128:
3891 case X86::BI__builtin_ia32_vpshldd256:
3892 case X86::BI__builtin_ia32_vpshldd512:
3893 case X86::BI__builtin_ia32_vpshldq128:
3894 case X86::BI__builtin_ia32_vpshldq256:
3895 case X86::BI__builtin_ia32_vpshldq512:
3896 case X86::BI__builtin_ia32_vpshldw128:
3897 case X86::BI__builtin_ia32_vpshldw256:
3898 case X86::BI__builtin_ia32_vpshldw512:
3902 return llvm::APIntOps::fshl(Hi, Lo, Amt);
3905 case X86::BI__builtin_ia32_vpshrdd128:
3906 case X86::BI__builtin_ia32_vpshrdd256:
3907 case X86::BI__builtin_ia32_vpshrdd512:
3908 case X86::BI__builtin_ia32_vpshrdq128:
3909 case X86::BI__builtin_ia32_vpshrdq256:
3910 case X86::BI__builtin_ia32_vpshrdq512:
3911 case X86::BI__builtin_ia32_vpshrdw128:
3912 case X86::BI__builtin_ia32_vpshrdw256:
3913 case X86::BI__builtin_ia32_vpshrdw512:
3918 return llvm::APIntOps::fshr(Hi, Lo, Amt);
3920 case X86::BI__builtin_ia32_vpconflictsi_128:
3921 case X86::BI__builtin_ia32_vpconflictsi_256:
3922 case X86::BI__builtin_ia32_vpconflictsi_512:
3923 case X86::BI__builtin_ia32_vpconflictdi_128:
3924 case X86::BI__builtin_ia32_vpconflictdi_256:
3925 case X86::BI__builtin_ia32_vpconflictdi_512:
3927 case clang::X86::BI__builtin_ia32_blendpd:
3928 case clang::X86::BI__builtin_ia32_blendpd256:
3929 case clang::X86::BI__builtin_ia32_blendps:
3930 case clang::X86::BI__builtin_ia32_blendps256:
3931 case clang::X86::BI__builtin_ia32_pblendw128:
3932 case clang::X86::BI__builtin_ia32_pblendw256:
3933 case clang::X86::BI__builtin_ia32_pblendd128:
3934 case clang::X86::BI__builtin_ia32_pblendd256:
3937 case clang::X86::BI__builtin_ia32_blendvpd:
3938 case clang::X86::BI__builtin_ia32_blendvpd256:
3939 case clang::X86::BI__builtin_ia32_blendvps:
3940 case clang::X86::BI__builtin_ia32_blendvps256:
3944 llvm::RoundingMode) {
return C.isNegative() ?
T : F; });
3946 case clang::X86::BI__builtin_ia32_pblendvb128:
3947 case clang::X86::BI__builtin_ia32_pblendvb256:
3950 return ((
APInt)
C).isNegative() ?
T : F;
3952 case X86::BI__builtin_ia32_ptestz128:
3953 case X86::BI__builtin_ia32_ptestz256:
3954 case X86::BI__builtin_ia32_vtestzps:
3955 case X86::BI__builtin_ia32_vtestzps256:
3956 case X86::BI__builtin_ia32_vtestzpd:
3957 case X86::BI__builtin_ia32_vtestzpd256:
3960 [](
const APInt &A,
const APInt &B) {
return (A & B) == 0; });
3961 case X86::BI__builtin_ia32_ptestc128:
3962 case X86::BI__builtin_ia32_ptestc256:
3963 case X86::BI__builtin_ia32_vtestcps:
3964 case X86::BI__builtin_ia32_vtestcps256:
3965 case X86::BI__builtin_ia32_vtestcpd:
3966 case X86::BI__builtin_ia32_vtestcpd256:
3969 [](
const APInt &A,
const APInt &B) {
return (~A & B) == 0; });
3970 case X86::BI__builtin_ia32_ptestnzc128:
3971 case X86::BI__builtin_ia32_ptestnzc256:
3972 case X86::BI__builtin_ia32_vtestnzcps:
3973 case X86::BI__builtin_ia32_vtestnzcps256:
3974 case X86::BI__builtin_ia32_vtestnzcpd:
3975 case X86::BI__builtin_ia32_vtestnzcpd256:
3978 return ((A & B) != 0) && ((~A & B) != 0);
3980 case X86::BI__builtin_ia32_selectb_128:
3981 case X86::BI__builtin_ia32_selectb_256:
3982 case X86::BI__builtin_ia32_selectb_512:
3983 case X86::BI__builtin_ia32_selectw_128:
3984 case X86::BI__builtin_ia32_selectw_256:
3985 case X86::BI__builtin_ia32_selectw_512:
3986 case X86::BI__builtin_ia32_selectd_128:
3987 case X86::BI__builtin_ia32_selectd_256:
3988 case X86::BI__builtin_ia32_selectd_512:
3989 case X86::BI__builtin_ia32_selectq_128:
3990 case X86::BI__builtin_ia32_selectq_256:
3991 case X86::BI__builtin_ia32_selectq_512:
3992 case X86::BI__builtin_ia32_selectph_128:
3993 case X86::BI__builtin_ia32_selectph_256:
3994 case X86::BI__builtin_ia32_selectph_512:
3995 case X86::BI__builtin_ia32_selectpbf_128:
3996 case X86::BI__builtin_ia32_selectpbf_256:
3997 case X86::BI__builtin_ia32_selectpbf_512:
3998 case X86::BI__builtin_ia32_selectps_128:
3999 case X86::BI__builtin_ia32_selectps_256:
4000 case X86::BI__builtin_ia32_selectps_512:
4001 case X86::BI__builtin_ia32_selectpd_128:
4002 case X86::BI__builtin_ia32_selectpd_256:
4003 case X86::BI__builtin_ia32_selectpd_512:
4006 case X86::BI__builtin_ia32_pshufb128:
4007 case X86::BI__builtin_ia32_pshufb256:
4008 case X86::BI__builtin_ia32_pshufb512:
4011 case X86::BI__builtin_ia32_pshuflw:
4012 case X86::BI__builtin_ia32_pshuflw256:
4013 case X86::BI__builtin_ia32_pshuflw512:
4016 case X86::BI__builtin_ia32_pshufhw:
4017 case X86::BI__builtin_ia32_pshufhw256:
4018 case X86::BI__builtin_ia32_pshufhw512:
4021 case X86::BI__builtin_ia32_pshufd:
4022 case X86::BI__builtin_ia32_pshufd256:
4023 case X86::BI__builtin_ia32_pshufd512:
4026 case X86::BI__builtin_ia32_kandqi:
4027 case X86::BI__builtin_ia32_kandhi:
4028 case X86::BI__builtin_ia32_kandsi:
4029 case X86::BI__builtin_ia32_kanddi:
4032 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS & RHS; });
4034 case X86::BI__builtin_ia32_kandnqi:
4035 case X86::BI__builtin_ia32_kandnhi:
4036 case X86::BI__builtin_ia32_kandnsi:
4037 case X86::BI__builtin_ia32_kandndi:
4040 [](
const APSInt &LHS,
const APSInt &RHS) {
return ~LHS & RHS; });
4042 case X86::BI__builtin_ia32_korqi:
4043 case X86::BI__builtin_ia32_korhi:
4044 case X86::BI__builtin_ia32_korsi:
4045 case X86::BI__builtin_ia32_kordi:
4048 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS | RHS; });
4050 case X86::BI__builtin_ia32_kxnorqi:
4051 case X86::BI__builtin_ia32_kxnorhi:
4052 case X86::BI__builtin_ia32_kxnorsi:
4053 case X86::BI__builtin_ia32_kxnordi:
4056 [](
const APSInt &LHS,
const APSInt &RHS) {
return ~(LHS ^ RHS); });
4058 case X86::BI__builtin_ia32_kxorqi:
4059 case X86::BI__builtin_ia32_kxorhi:
4060 case X86::BI__builtin_ia32_kxorsi:
4061 case X86::BI__builtin_ia32_kxordi:
4064 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS ^ RHS; });
4066 case X86::BI__builtin_ia32_knotqi:
4067 case X86::BI__builtin_ia32_knothi:
4068 case X86::BI__builtin_ia32_knotsi:
4069 case X86::BI__builtin_ia32_knotdi:
4071 S, OpPC,
Call, [](
const APSInt &Src) {
return ~Src; });
4073 case X86::BI__builtin_ia32_kaddqi:
4074 case X86::BI__builtin_ia32_kaddhi:
4075 case X86::BI__builtin_ia32_kaddsi:
4076 case X86::BI__builtin_ia32_kadddi:
4079 [](
const APSInt &LHS,
const APSInt &RHS) {
return LHS + RHS; });
4081 case X86::BI__builtin_ia32_pternlogd128_mask:
4082 case X86::BI__builtin_ia32_pternlogd256_mask:
4083 case X86::BI__builtin_ia32_pternlogd512_mask:
4084 case X86::BI__builtin_ia32_pternlogq128_mask:
4085 case X86::BI__builtin_ia32_pternlogq256_mask:
4086 case X86::BI__builtin_ia32_pternlogq512_mask:
4088 case X86::BI__builtin_ia32_pternlogd128_maskz:
4089 case X86::BI__builtin_ia32_pternlogd256_maskz:
4090 case X86::BI__builtin_ia32_pternlogd512_maskz:
4091 case X86::BI__builtin_ia32_pternlogq128_maskz:
4092 case X86::BI__builtin_ia32_pternlogq256_maskz:
4093 case X86::BI__builtin_ia32_pternlogq512_maskz:
4095 case Builtin::BI__builtin_elementwise_fshl:
4097 llvm::APIntOps::fshl);
4098 case Builtin::BI__builtin_elementwise_fshr:
4100 llvm::APIntOps::fshr);
4102 case X86::BI__builtin_ia32_insertf32x4_256:
4103 case X86::BI__builtin_ia32_inserti32x4_256:
4104 case X86::BI__builtin_ia32_insertf64x2_256:
4105 case X86::BI__builtin_ia32_inserti64x2_256:
4106 case X86::BI__builtin_ia32_insertf32x4:
4107 case X86::BI__builtin_ia32_inserti32x4:
4108 case X86::BI__builtin_ia32_insertf64x2_512:
4109 case X86::BI__builtin_ia32_inserti64x2_512:
4110 case X86::BI__builtin_ia32_insertf32x8:
4111 case X86::BI__builtin_ia32_inserti32x8:
4112 case X86::BI__builtin_ia32_insertf64x4:
4113 case X86::BI__builtin_ia32_inserti64x4:
4114 case X86::BI__builtin_ia32_vinsertf128_ps256:
4115 case X86::BI__builtin_ia32_vinsertf128_pd256:
4116 case X86::BI__builtin_ia32_vinsertf128_si256:
4117 case X86::BI__builtin_ia32_insert128i256:
4120 case X86::BI__builtin_ia32_vec_ext_v4hi:
4121 case X86::BI__builtin_ia32_vec_ext_v16qi:
4122 case X86::BI__builtin_ia32_vec_ext_v8hi:
4123 case X86::BI__builtin_ia32_vec_ext_v4si:
4124 case X86::BI__builtin_ia32_vec_ext_v2di:
4125 case X86::BI__builtin_ia32_vec_ext_v32qi:
4126 case X86::BI__builtin_ia32_vec_ext_v16hi:
4127 case X86::BI__builtin_ia32_vec_ext_v8si:
4128 case X86::BI__builtin_ia32_vec_ext_v4di:
4129 case X86::BI__builtin_ia32_vec_ext_v4sf:
4132 case X86::BI__builtin_ia32_vec_set_v4hi:
4133 case X86::BI__builtin_ia32_vec_set_v16qi:
4134 case X86::BI__builtin_ia32_vec_set_v8hi:
4135 case X86::BI__builtin_ia32_vec_set_v4si:
4136 case X86::BI__builtin_ia32_vec_set_v2di:
4137 case X86::BI__builtin_ia32_vec_set_v32qi:
4138 case X86::BI__builtin_ia32_vec_set_v16hi:
4139 case X86::BI__builtin_ia32_vec_set_v8si:
4140 case X86::BI__builtin_ia32_vec_set_v4di:
4145 diag::note_invalid_subexpr_in_const_expr)
4151 llvm_unreachable(
"Unhandled builtin ID");
4160 unsigned ArrayIndex = 0;
4162 for (
unsigned I = 0; I != N; ++I) {
4168 if (!RD || RD->isInvalidDecl())
4172 assert(FieldIndex < RL.
getFieldCount() &&
"offsetof field in wrong type");
4181 int64_t Index = ArrayIndices[ArrayIndex];
4187 Result += Index * ElementSize;
4198 if (!RD || RD->isInvalidDecl())
4203 CurrentType = BaseSpec->
getType();
4213 llvm_unreachable(
"Dependent OffsetOfExpr?");
4217 IntResult =
Result.getQuantity();
4234 FieldPtr.
deref<
T>() = T::from(IntValue.getSExtValue()));
4244 Dest.deref<T>().~T();
4245 new (&Dest.deref<T>()) T();
4252 for (
const Record::Field &F : R->
fields()) {
4260 for (
unsigned I = 0, N = Desc->
getNumElems(); I != N; ++I) {
4262 Dest.deref<T>().~T();
4263 new (&Dest.deref<T>()) T();
4270 for (
unsigned I = 0, N = Desc->
getNumElems(); I != N; ++I) {
4278static bool copyComposite(InterpState &S, CodePtr OpPC,
const Pointer &Src,
4279 Pointer &Dest,
bool Activate);
4285 auto copyField = [&](
const Record::Field &F,
bool Activate) ->
bool {
4304 for (
const Record::Field &F : R->
fields()) {
4309 if (!copyField(F,
true))
4323 for (
const Record::Base &B : R->
bases()) {
4346 for (
unsigned I = 0, N = DestDesc->
getNumElems(); I != N; ++I) {
4359 for (
unsigned I = 0, N = DestDesc->
getNumElems(); I != N; ++I) {
Defines enum values for all the target-independent builtin functions.
GCCTypeClass
Values returned by __builtin_classify_type, chosen to match the values produced by GCC's builtin.
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.
static bool isOneByteCharacterType(QualType T)
static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal)
Attempts to detect a user writing into a piece of memory that's impossible to figure out the size of ...
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
#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.
static QualType getPointeeType(const MemRegion *R)
Enumerates target-specific builtins in their own namespaces within namespace clang.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
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
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
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)...
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.
CanQualType getCanonicalTagType(const TagDecl *TD) const
static bool hasSameUnqualifiedType(QualType T1, QualType T2)
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
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.
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - 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 the identifier name for the specified builtin inside single quotes for a diagnostic,...
bool isConstantEvaluated(unsigned ID) const
Return true if this function can be constant evaluated by Clang frontend.
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]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
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...
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...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Represents a function declaration or definition.
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.
StrictFlexArraysLevelKind
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
const OffsetOfNode & getComponent(unsigned Idx) const
TypeSourceInfo * getTypeSourceInfo() const
unsigned getNumComponents() const
Helper class for OffsetOfExpr.
FieldDecl * getField() const
For a field offsetof node, returns the field.
@ 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.
Kind getKind() const
Determine what kind of offsetof node this is.
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
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...
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
virtual int getEHDataRegisterNumber(unsigned RegNo) const
Return the register number that __builtin_eh_return_regno would return with the specified argument.
virtual bool isNan2008() const
Returns true if NaN encoding is IEEE 754-2008.
QualType getType() const
Return the type wrapped by this type source info.
bool isBooleanType() const
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 ...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isVectorType() const
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
Represents a GCC generic vector type.
unsigned getNumElements() const
QualType getElementType() 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.
const LangOptions & getLangOpts() const
Returns the language options.
OptPrimType classify(QualType T) const
Classifies a type.
unsigned getEvalID() const
Manages dynamic memory allocations done during bytecode interpretation.
bool deallocate(const Expr *Source, const Block *BlockToDelete, InterpState &S)
Deallocate the given source+block combination.
std::optional< Form > getAllocationForm(const Expr *Source) const
Checks whether the allocation done at the given source is an array allocation.
Block * allocate(const Descriptor *D, unsigned EvalID, Form AllocForm)
Allocate ONE element of the given descriptor.
If a Floating is constructed from Memory, it DOES NOT OWN THAT MEMORY.
void copy(const APFloat &F)
llvm::FPClassTest classify() const
ComparisonCategoryResult compare(const Floating &RHS) const
APFloat::fltCategory getCategory() const
APFloat getAPFloat() const
Base class for stack frames, shared between VM and walker.
virtual const FunctionDecl * getCallee() const =0
Returns the called function's declaration.
If an IntegralAP is constructed from Memory, it DOES NOT OWN THAT MEMORY.
Frame storing local variables.
const Expr * getExpr(CodePtr PC) const
InterpFrame * Caller
The frame of the previous function.
SourceInfo getSource(CodePtr PC) const
Map a location to a source.
CodePtr getRetPC() const
Returns the return address of the frame.
SourceLocation getLocation(CodePtr PC) const
SourceRange getRange(CodePtr PC) const
unsigned getDepth() const
const FunctionDecl * getCallee() const override
Returns the caller.
Stack frame storing temporaries and parameters.
T pop()
Returns the value from the top of the stack and removes it.
void push(Tys &&...Args)
Constructs a value in place on the top of the stack.
void discard()
Discards the top value from the stack.
T & peek() const
Returns a reference to the value on the top of the stack.
Expr::EvalStatus & getEvalStatus() const override
Context & getContext() const
DynamicAllocator & getAllocator()
Context & Ctx
Interpreter Context.
Floating allocFloat(const llvm::fltSemantics &Sem)
llvm::SmallVector< const Block * > InitializingBlocks
List of blocks we're currently running either constructors or destructors for.
ASTContext & getASTContext() const override
InterpStack & Stk
Temporary stack.
const VarDecl * EvaluatingDecl
Declaration we're initializing/evaluting, if any.
InterpFrame * Current
The current frame.
T allocAP(unsigned BitWidth)
const LangOptions & getLangOpts() const
StdAllocatorCaller getStdAllocatorCaller(StringRef Name) const
bool inConstantContext() const
Program & P
Reference to the module containing all bytecode.
PrimType value_or(PrimType PT) const
A pointer to a memory block, live or dead.
Pointer narrow() const
Restricts the scope of an array element pointer.
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.
Pointer getArray() const
Returns the parent array.
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 isArrayElement() const
Checks if the pointer points to an array.
void initializeAllElements() const
Initialize all elements of a primitive array at once.
bool isLive() const
Checks if the pointer is live.
bool inArray() const
Checks if the innermost field is an array.
T & elem(unsigned I) const
Dereferences the element at index I.
Pointer getBase() const
Returns a pointer to the object of which this pointer is a field.
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.
bool isRoot() const
Pointer points directly to a block.
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.
bool isOnePastEnd() const
Checks if the index is one past end.
uint64_t getIntegerRepresentation() const
const FieldDecl * getField() const
Returns the field information.
Pointer expand() const
Expands a pointer to the containing array, undoing narrowing.
bool isBlockPointer() const
const Block * block() const
const Descriptor * getFieldDesc() const
Accessors for information about the innermost field.
bool isVirtualBaseClass() const
bool isBaseClass() const
Checks if a structure is a base class.
size_t elemSize() const
Returns the element size of the innermost field.
bool canBeInitialized() const
If this pointer has an InlineDescriptor we can use to initialize.
Lifetime getLifetime() const
void initialize() const
Initializes a field.
bool isField() const
Checks if the item is a field in an object.
const Record * getRecord() const
Returns the record descriptor of a class.
Descriptor * createDescriptor(const DeclTy &D, PrimType T, const Type *SourceTy=nullptr, Descriptor::MetadataSize MDSize=std::nullopt, bool IsConst=false, bool IsTemporary=false, bool IsMutable=false, bool IsVolatile=false)
Creates a descriptor for a primitive type.
Structure/Class descriptor.
const RecordDecl * getDecl() const
Returns the underlying declaration.
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.
OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId)
Add a note to a prior diagnostic.
DiagnosticBuilder report(SourceLocation Loc, diag::kind DiagId)
Directly reports a diagnostic message.
OptionalDiagnostic FFDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation could not be folded (FF => FoldFailure)
OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation does not produce a C++11 core constant expression.
bool checkingPotentialConstantExpression() const
Are we checking whether the expression is a potential constant expression?
Defines the clang::TargetInfo interface.
bool computeOSLogBufferLayout(clang::ASTContext &Ctx, const clang::CallExpr *E, OSLogBufferLayout &layout)
static bool isNoopBuiltin(unsigned ID)
static bool interp__builtin_is_within_lifetime(InterpState &S, CodePtr OpPC, const CallExpr *Call)
static void assignInteger(InterpState &S, const Pointer &Dest, PrimType ValueT, const APSInt &Value)
bool readPointerToBuffer(const Context &Ctx, const Pointer &FromPtr, BitcastBuffer &Buffer, bool ReturnOnUninit)
static Floating abs(InterpState &S, const Floating &In)
static bool interp__builtin_fmax(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, bool IsNumBuiltin)
static bool interp__builtin_elementwise_maxmin(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned BuiltinID)
static bool interp__builtin_bswap(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_elementwise_triop(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APInt(const APSInt &, const APSInt &, const APSInt &)> Fn)
static bool interp__builtin_assume(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
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_isnan(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
Defined as __builtin_isnan(...), to accommodate the fact that it can take a float,...
static llvm::RoundingMode getRoundingMode(FPOptions FPO)
static bool interp__builtin_elementwise_countzeroes(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinID)
Can be called with an integer or vector as the first and only parameter.
static bool interp__builtin_ia32_pshufb(InterpState &S, CodePtr OpPC, const CallExpr *Call)
bool Call(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
static bool interp__builtin_classify_type(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_fmin(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, bool IsNumBuiltin)
static bool interp__builtin_blend(InterpState &S, CodePtr OpPC, const CallExpr *Call)
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}...
static bool interp__builtin_operator_delete(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_fabs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame)
static bool interp__builtin_ia32_vpconflict(InterpState &S, CodePtr OpPC, const CallExpr *Call)
static bool interp__builtin_memcmp(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned ID)
static bool interp__builtin_atomic_lock_free(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinOp)
bool __atomic_always_lock_free(size_t, void const volatile*) bool __atomic_is_lock_free(size_t,...
static llvm::APSInt convertBoolVectorToInt(const Pointer &Val)
static bool interp__builtin_move(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_clz(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinOp)
bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a pointer points to a mutable field.
static bool interp__builtin_is_aligned_up_down(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinOp)
__builtin_is_aligned() __builtin_align_up() __builtin_align_down() The first parameter is either an i...
static bool Activate(InterpState &S, CodePtr OpPC)
static bool interp__builtin_ia32_addcarry_subborrow(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinOp)
(CarryIn, LHS, RHS, Result)
static bool isOneByteCharacterType(QualType T)
Determine if T is a character type for which we guarantee that sizeof(T) == 1.
static unsigned computePointerOffset(const ASTContext &ASTCtx, const Pointer &Ptr)
Compute the byte offset of Ptr in the full declaration.
static bool interp__builtin_strcmp(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned ID)
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_overflowop(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned BuiltinOp)
static bool interp__builtin_inf(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_vec_ext(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
static bool interp__builtin_ia32_test_op(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< bool(const APInt &A, const APInt &B)> Fn)
static bool interp__builtin_isinf(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, bool CheckSign, const CallExpr *Call)
static bool interp__builtin_os_log_format_buffer_size(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
bool InterpretOffsetOf(InterpState &S, CodePtr OpPC, const OffsetOfExpr *E, ArrayRef< int64_t > ArrayIndices, int64_t &Result)
Interpret an offsetof operation.
static bool interp__builtin_x86_insert_subvector(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a pointer is in range.
static bool pointsToLastObject(const Pointer &Ptr)
Does Ptr point to the last subobject?
static bool interp__builtin_select(InterpState &S, CodePtr OpPC, const CallExpr *Call)
AVX512 predicated move: "Result = Mask[] ? LHS[] : RHS[]".
static void discard(InterpStack &Stk, PrimType T)
bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a pointer is live and accessible.
static bool interp__builtin_fpclassify(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
Five int values followed by one floating value.
static bool interp__builtin_abs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp_floating_comparison(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
static bool handleOverflow(InterpState &S, CodePtr OpPC, const T &SrcValue)
static bool copyComposite(InterpState &S, CodePtr OpPC, const Pointer &Src, Pointer &Dest, bool Activate)
static bool copyRecord(InterpState &S, CodePtr OpPC, const Pointer &Src, Pointer &Dest, bool Activate=false)
static bool interp__builtin_c11_atomic_is_lock_free(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
bool __c11_atomic_is_lock_free(size_t)
static void zeroAll(Pointer &Dest)
static bool interp__builtin_elementwise_int_binop(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APInt(const APSInt &, const APSInt &)> Fn)
static bool interp__builtin_issubnormal(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_arithmetic_fence(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
PrimType
Enumeration of the primitive types of the VM.
static bool interp__builtin_isfinite(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, uint32_t BuiltinID)
Interpret a builtin function.
static bool interp__builtin_expect(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_vec_set(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
static bool interp__builtin_complex(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
__builtin_complex(Float A, float B);
static bool interp__builtin_ia32_pshuf(InterpState &S, CodePtr OpPC, const CallExpr *Call, bool IsShufHW)
bool CheckDummy(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK)
Checks if a pointer is a dummy pointer.
static bool interp__builtin_assume_aligned(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
__builtin_assume_aligned(Ptr, Alignment[, ExtraOffset])
static bool interp__builtin_ptrauth_string_discriminator(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_memchr(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
static bool interp__builtin_ia32_pmul(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APInt(const APSInt &, const APSInt &, const APSInt &, const APSInt &)> Fn)
static bool interp__builtin_x86_pack(InterpState &S, CodePtr, const CallExpr *E, llvm::function_ref< APInt(const APSInt &)> PackFn)
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_operator_new(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_strlen(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned ID)
bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if the array is offsetable.
static bool interp__builtin_elementwise_abs(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinID)
static bool interp__builtin_copysign(InterpState &S, CodePtr OpPC, const InterpFrame *Frame)
static bool interp__builtin_iszero(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_elementwise_popcount(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinID)
Can be called with an integer or vector as the first and only parameter.
static bool interp__builtin_addressof(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_signbit(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
bool Error(InterpState &S, CodePtr OpPC)
Do nothing and just abort execution.
static bool interp__builtin_vector_reduce(InterpState &S, CodePtr OpPC, const CallExpr *Call, unsigned ID)
static bool interp__builtin_memcpy(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned ID)
static bool interp_builtin_horizontal_fp_binop(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APFloat(const APFloat &, const APFloat &, llvm::RoundingMode)> Fn)
static bool interp__builtin_elementwise_triop_fp(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APFloat(const APFloat &, const APFloat &, const APFloat &, llvm::RoundingMode)> Fn)
size_t primSize(PrimType Type)
Returns the size of a primitive type in bytes.
static bool interp__builtin_popcount(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_object_size(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_carryop(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinOp)
Three integral values followed by a pointer (lhs, rhs, carry, carryOut).
bool CheckArraySize(InterpState &S, CodePtr OpPC, uint64_t NumElems)
static bool interp__builtin_ctz(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, unsigned BuiltinID)
static bool interp__builtin_is_constant_evaluated(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static APSInt popToAPSInt(InterpStack &Stk, PrimType T)
static std::optional< unsigned > computeFullDescSize(const ASTContext &ASTCtx, const Descriptor *Desc)
static bool interp__builtin_isfpclass(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
First parameter to __builtin_isfpclass is the floating value, the second one is an integral value.
static bool interp__builtin_issignaling(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp__builtin_nan(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call, bool Signaling)
bool DoMemcpy(InterpState &S, CodePtr OpPC, const Pointer &Src, Pointer &Dest)
Copy the contents of Src into Dest.
static bool interp__builtin_elementwise_int_unaryop(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APInt(const APSInt &)> Fn)
constexpr bool isIntegralType(PrimType T)
static bool interp__builtin_eh_return_data_regno(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static bool interp_builtin_horizontal_int_binop(InterpState &S, CodePtr OpPC, const CallExpr *Call, llvm::function_ref< APInt(const APSInt &, const APSInt &)> Fn)
static void diagnoseNonConstexprBuiltin(InterpState &S, CodePtr OpPC, unsigned ID)
static QualType getElemType(const Pointer &P)
static bool interp__builtin_ia32_pternlog(InterpState &S, CodePtr OpPC, const CallExpr *Call, bool MaskZ)
static bool interp__builtin_isnormal(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call)
static void swapBytes(std::byte *M, size_t N)
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
U cast(CodeGen::Address addr)
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
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
bool isCompositeArray() const
Checks if the descriptor is of an array of composites.
const ValueDecl * asValueDecl() const
static constexpr unsigned MaxArrayElemBytes
Maximum number of bytes to be used for array elements.
const Decl * asDecl() const
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.
const VarDecl * asVarDecl() const
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.
Mapping from primitive types to their representation.