github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code.
:warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff origin/main HEAD --extensions cpp,h,c --
clang/lib/AST/ByteCode/InterpBuiltin.cpp clang/lib/AST/ExprConstant.cpp
clang/lib/Headers/mmintrin.h clang/test/CodeGen/X86/avx2-builtins.c
clang/test/CodeGen/X86/avx512bw-builtins.c
clang/test/CodeGen/X86/avx512f-builtins.c
clang/test/CodeGen/X86/avx512vl-builtins.c
clang/test/CodeGen/X86/avx512vlbw-builtins.c
clang/test/CodeGen/X86/mmx-builtins.c clang/test/CodeGen/X86/sse2-builtins.c
``````````
:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/clang/lib/AST/ByteCode/InterpBuiltin.cpp
b/clang/lib/AST/ByteCode/InterpBuiltin.cpp
index 1156626a3..e3b9acac6 100644
--- a/clang/lib/AST/ByteCode/InterpBuiltin.cpp
+++ b/clang/lib/AST/ByteCode/InterpBuiltin.cpp
@@ -3179,7 +3179,6 @@ static bool
interp__builtin_x86_insert_subvector(InterpState &S, CodePtr OpPC,
return true;
}
-
bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call,
uint32_t BuiltinID) {
if (!S.getASTContext().BuiltinInfo.isConstantEvaluated(BuiltinID))
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 3fee70212..a5e9bd69d 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -11868,292 +11868,318 @@ bool VectorExprEvaluator::VisitCallExpr(const
CallExpr *E) {
return Success(APValue(ResultElements.data(), ResultElements.size()), E);
}
-case X86::BI__builtin_ia32_pshufw: {
- APValue Src;
- APSInt Imm;
- if (!EvaluateAsRValue(Info, E->getArg(0), Src)) return false;
- if (!EvaluateInteger(E->getArg(1), Imm, Info)) return false;
+ case X86::BI__builtin_ia32_pshufw: {
+ APValue Src;
+ APSInt Imm;
+ if (!EvaluateAsRValue(Info, E->getArg(0), Src))
+ return false;
+ if (!EvaluateInteger(E->getArg(1), Imm, Info))
+ return false;
- unsigned N = Src.getVectorLength();
- SmallVector<APValue, 4> ResultElements;
- ResultElements.reserve(N);
+ unsigned N = Src.getVectorLength();
+ SmallVector<APValue, 4> ResultElements;
+ ResultElements.reserve(N);
- uint8_t C = static_cast<uint8_t>(Imm.getZExtValue());
- for (unsigned i = 0; i != N; ++i) {
- unsigned sel = (C >> (2 * i)) & 0x3;
- ResultElements.push_back(Src.getVectorElt(sel));
+ uint8_t C = static_cast<uint8_t>(Imm.getZExtValue());
+ for (unsigned i = 0; i != N; ++i) {
+ unsigned sel = (C >> (2 * i)) & 0x3;
+ ResultElements.push_back(Src.getVectorElt(sel));
+ }
+ return Success(APValue(ResultElements.data(), ResultElements.size()), E);
}
- return Success(APValue(ResultElements.data(), ResultElements.size()), E);
-}
-case clang::X86::BI__builtin_ia32_pshuflw:
-case clang::X86::BI__builtin_ia32_pshuflw256:
-case clang::X86::BI__builtin_ia32_pshuflw512:
-case clang::X86::BI__builtin_ia32_pshuflw128_mask:
-case clang::X86::BI__builtin_ia32_pshuflw256_mask:
-case clang::X86::BI__builtin_ia32_pshuflw512_mask:
-case clang::X86::BI__builtin_ia32_pshuflw128_maskz:
-case clang::X86::BI__builtin_ia32_pshuflw256_maskz:
-case clang::X86::BI__builtin_ia32_pshuflw512_maskz: {
- const unsigned BID = E->getBuiltinCallee();
-
- const bool IsMask =
- BID == clang::X86::BI__builtin_ia32_pshuflw128_mask ||
- BID == clang::X86::BI__builtin_ia32_pshuflw256_mask ||
- BID == clang::X86::BI__builtin_ia32_pshuflw512_mask;
-
- const bool IsMaskZ =
- BID == clang::X86::BI__builtin_ia32_pshuflw128_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshuflw256_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshuflw512_maskz;
-
- const unsigned AIdx = 0, ImmIdx = 1;
- const unsigned SrcIdx = 2;
- const unsigned KIdx = IsMaskZ ? 2 : 3;
-
- APValue AVal, SrcVal;
- APSInt Imm, K;
- if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal)) return false;
- if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info)) return false;
-
- const APSInt *KPtr = nullptr;
- const APValue *PassThru = nullptr;
- bool ZeroInactive = false;
-
- if (IsMask) {
- if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal)) return false;
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = &SrcVal; ZeroInactive = false;
- } else if (IsMaskZ) {
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = nullptr; ZeroInactive = true;
- }
-
- const auto *VT = E->getType()->getAs<VectorType>();
- if (!VT) return false;
- const unsigned NumElts = VT->getNumElements();
-
- const unsigned ElemBits = 16;
- const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
- const unsigned Half = 4;
- const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
- const bool DestUnsigned =
- VT->getElementType()->isUnsignedIntegerOrEnumerationType();
-
- auto MakeZero = [&]() -> APValue {
- return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
- };
+ case clang::X86::BI__builtin_ia32_pshuflw:
+ case clang::X86::BI__builtin_ia32_pshuflw256:
+ case clang::X86::BI__builtin_ia32_pshuflw512:
+ case clang::X86::BI__builtin_ia32_pshuflw128_mask:
+ case clang::X86::BI__builtin_ia32_pshuflw256_mask:
+ case clang::X86::BI__builtin_ia32_pshuflw512_mask:
+ case clang::X86::BI__builtin_ia32_pshuflw128_maskz:
+ case clang::X86::BI__builtin_ia32_pshuflw256_maskz:
+ case clang::X86::BI__builtin_ia32_pshuflw512_maskz: {
+ const unsigned BID = E->getBuiltinCallee();
- SmallVector<APValue, 32> ResultElements;
- ResultElements.reserve(NumElts);
+ const bool IsMask = BID == clang::X86::BI__builtin_ia32_pshuflw128_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshuflw256_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshuflw512_mask;
- for (unsigned i = 0; i < NumElts; ++i) {
- const unsigned laneBase = (i / LaneElems) * LaneElems;
- const unsigned inLane = i % LaneElems;
+ const bool IsMaskZ = BID == clang::X86::BI__builtin_ia32_pshuflw128_maskz
||
+ BID == clang::X86::BI__builtin_ia32_pshuflw256_maskz
||
+ BID == clang::X86::BI__builtin_ia32_pshuflw512_maskz;
- APValue Chosen;
- if (inLane < Half) {
- const unsigned pos = inLane;
- const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
- const unsigned srcIdx = laneBase + sel;
- Chosen = AVal.getVectorElt(srcIdx);
- } else {
- Chosen = AVal.getVectorElt(i);
+ const unsigned AIdx = 0, ImmIdx = 1;
+ const unsigned SrcIdx = 2;
+ const unsigned KIdx = IsMaskZ ? 2 : 3;
+
+ APValue AVal, SrcVal;
+ APSInt Imm, K;
+ if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info))
+ return false;
+
+ const APSInt *KPtr = nullptr;
+ const APValue *PassThru = nullptr;
+ bool ZeroInactive = false;
+
+ if (IsMask) {
+ if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = &SrcVal;
+ ZeroInactive = false;
+ } else if (IsMaskZ) {
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = nullptr;
+ ZeroInactive = true;
}
- if (KPtr) {
- const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
- if (Keep) {
- ResultElements.push_back(Chosen);
- } else if (ZeroInactive) {
- ResultElements.push_back(MakeZero());
+ const auto *VT = E->getType()->getAs<VectorType>();
+ if (!VT)
+ return false;
+ const unsigned NumElts = VT->getNumElements();
+
+ const unsigned ElemBits = 16;
+ const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
+ const unsigned Half = 4;
+ const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
+ const bool DestUnsigned =
+ VT->getElementType()->isUnsignedIntegerOrEnumerationType();
+
+ auto MakeZero = [&]() -> APValue {
+ return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
+ };
+
+ SmallVector<APValue, 32> ResultElements;
+ ResultElements.reserve(NumElts);
+
+ for (unsigned i = 0; i < NumElts; ++i) {
+ const unsigned laneBase = (i / LaneElems) * LaneElems;
+ const unsigned inLane = i % LaneElems;
+
+ APValue Chosen;
+ if (inLane < Half) {
+ const unsigned pos = inLane;
+ const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
+ const unsigned srcIdx = laneBase + sel;
+ Chosen = AVal.getVectorElt(srcIdx);
} else {
- const APValue &PT = PassThru ? PassThru->getVectorElt(i)
- : AVal.getVectorElt(i);
- ResultElements.push_back(PT);
+ Chosen = AVal.getVectorElt(i);
+ }
+
+ if (KPtr) {
+ const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
+ if (Keep) {
+ ResultElements.push_back(Chosen);
+ } else if (ZeroInactive) {
+ ResultElements.push_back(MakeZero());
+ } else {
+ const APValue &PT =
+ PassThru ? PassThru->getVectorElt(i) : AVal.getVectorElt(i);
+ ResultElements.push_back(PT);
+ }
+ } else {
+ ResultElements.push_back(Chosen);
}
- } else {
- ResultElements.push_back(Chosen);
}
+ return Success(APValue(ResultElements.data(), ResultElements.size()), E);
}
- return Success(APValue(ResultElements.data(), ResultElements.size()), E);
-}
-case clang::X86::BI__builtin_ia32_pshufhw:
-case clang::X86::BI__builtin_ia32_pshufhw256:
-case clang::X86::BI__builtin_ia32_pshufhw512:
-case clang::X86::BI__builtin_ia32_pshufhw128_mask:
-case clang::X86::BI__builtin_ia32_pshufhw256_mask:
-case clang::X86::BI__builtin_ia32_pshufhw512_mask:
-case clang::X86::BI__builtin_ia32_pshufhw128_maskz:
-case clang::X86::BI__builtin_ia32_pshufhw256_maskz:
-case clang::X86::BI__builtin_ia32_pshufhw512_maskz: {
- const unsigned BID = E->getBuiltinCallee();
-
- const bool IsMask =
- BID == clang::X86::BI__builtin_ia32_pshufhw128_mask ||
- BID == clang::X86::BI__builtin_ia32_pshufhw256_mask ||
- BID == clang::X86::BI__builtin_ia32_pshufhw512_mask;
-
- const bool IsMaskZ =
- BID == clang::X86::BI__builtin_ia32_pshufhw128_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshufhw256_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshufhw512_maskz;
-
- const unsigned AIdx = 0, ImmIdx = 1;
- const unsigned SrcIdx = 2;
- const unsigned KIdx = IsMaskZ ? 2 : 3;
-
- APValue AVal, SrcVal;
- APSInt Imm, K;
- if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal)) return false;
- if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info)) return false;
-
- const APSInt *KPtr = nullptr;
- const APValue *PassThru = nullptr;
- bool ZeroInactive = false;
- if (IsMask) {
- if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal)) return false;
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = &SrcVal; ZeroInactive = false;
- } else if (IsMaskZ) {
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = nullptr; ZeroInactive = true;
- }
-
- const auto *VT = E->getType()->getAs<VectorType>();
- if (!VT) return false;
- const unsigned NumElts = VT->getNumElements();
- const unsigned ElemBits = 16;
- const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
- const unsigned Half = 4;
- const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
- const bool DestUnsigned =
- VT->getElementType()->isUnsignedIntegerOrEnumerationType();
-
- auto MakeZero = [&]() -> APValue {
- return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
- };
+ case clang::X86::BI__builtin_ia32_pshufhw:
+ case clang::X86::BI__builtin_ia32_pshufhw256:
+ case clang::X86::BI__builtin_ia32_pshufhw512:
+ case clang::X86::BI__builtin_ia32_pshufhw128_mask:
+ case clang::X86::BI__builtin_ia32_pshufhw256_mask:
+ case clang::X86::BI__builtin_ia32_pshufhw512_mask:
+ case clang::X86::BI__builtin_ia32_pshufhw128_maskz:
+ case clang::X86::BI__builtin_ia32_pshufhw256_maskz:
+ case clang::X86::BI__builtin_ia32_pshufhw512_maskz: {
+ const unsigned BID = E->getBuiltinCallee();
- SmallVector<APValue, 32> Out;
- Out.reserve(NumElts);
+ const bool IsMask = BID == clang::X86::BI__builtin_ia32_pshufhw128_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshufhw256_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshufhw512_mask;
- for (unsigned i = 0; i < NumElts; ++i) {
- const unsigned laneBase = (i / LaneElems) * LaneElems;
- const unsigned inLane = i % LaneElems;
+ const bool IsMaskZ = BID == clang::X86::BI__builtin_ia32_pshufhw128_maskz
||
+ BID == clang::X86::BI__builtin_ia32_pshufhw256_maskz
||
+ BID == clang::X86::BI__builtin_ia32_pshufhw512_maskz;
- APValue Chosen;
- if (inLane >= Half) {
- const unsigned pos = inLane - Half;
- const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
- const unsigned srcIdx = laneBase + Half + sel;
- Chosen = AVal.getVectorElt(srcIdx);
- } else {
- Chosen = AVal.getVectorElt(i);
+ const unsigned AIdx = 0, ImmIdx = 1;
+ const unsigned SrcIdx = 2;
+ const unsigned KIdx = IsMaskZ ? 2 : 3;
+
+ APValue AVal, SrcVal;
+ APSInt Imm, K;
+ if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info))
+ return false;
+
+ const APSInt *KPtr = nullptr;
+ const APValue *PassThru = nullptr;
+ bool ZeroInactive = false;
+ if (IsMask) {
+ if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = &SrcVal;
+ ZeroInactive = false;
+ } else if (IsMaskZ) {
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = nullptr;
+ ZeroInactive = true;
}
- if (KPtr) {
- const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
- if (Keep) {
- Out.push_back(Chosen);
- } else if (ZeroInactive) {
- Out.push_back(MakeZero());
+ const auto *VT = E->getType()->getAs<VectorType>();
+ if (!VT)
+ return false;
+ const unsigned NumElts = VT->getNumElements();
+ const unsigned ElemBits = 16;
+ const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
+ const unsigned Half = 4;
+ const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
+ const bool DestUnsigned =
+ VT->getElementType()->isUnsignedIntegerOrEnumerationType();
+
+ auto MakeZero = [&]() -> APValue {
+ return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
+ };
+
+ SmallVector<APValue, 32> Out;
+ Out.reserve(NumElts);
+
+ for (unsigned i = 0; i < NumElts; ++i) {
+ const unsigned laneBase = (i / LaneElems) * LaneElems;
+ const unsigned inLane = i % LaneElems;
+
+ APValue Chosen;
+ if (inLane >= Half) {
+ const unsigned pos = inLane - Half;
+ const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
+ const unsigned srcIdx = laneBase + Half + sel;
+ Chosen = AVal.getVectorElt(srcIdx);
} else {
- const APValue &PT = PassThru ? PassThru->getVectorElt(i)
- : AVal.getVectorElt(i);
- Out.push_back(PT);
+ Chosen = AVal.getVectorElt(i);
}
- } else {
- Out.push_back(Chosen);
- }
- }
- return Success(APValue(Out.data(), Out.size()), E);
-}
-
-case clang::X86::BI__builtin_ia32_pshufd:
-case clang::X86::BI__builtin_ia32_pshufd256:
-case clang::X86::BI__builtin_ia32_pshufd512:
-case clang::X86::BI__builtin_ia32_pshufd128_mask:
-case clang::X86::BI__builtin_ia32_pshufd256_mask:
-case clang::X86::BI__builtin_ia32_pshufd512_mask:
-case clang::X86::BI__builtin_ia32_pshufd128_maskz:
-case clang::X86::BI__builtin_ia32_pshufd256_maskz:
-case clang::X86::BI__builtin_ia32_pshufd512_maskz: {
- const unsigned BID = E->getBuiltinCallee();
-
- const bool IsMask =
- BID == clang::X86::BI__builtin_ia32_pshufd512_mask ||
- BID == clang::X86::BI__builtin_ia32_pshufd128_mask ||
- BID == clang::X86::BI__builtin_ia32_pshufd256_mask;
-
- const bool IsMaskZ =
- BID == clang::X86::BI__builtin_ia32_pshufd512_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshufd128_maskz ||
- BID == clang::X86::BI__builtin_ia32_pshufd256_maskz;
-
- const unsigned AIdx = 0, ImmIdx = 1;
- const unsigned SrcIdx = 2;
- const unsigned KIdx = IsMaskZ ? 2 : 3;
-
- APValue AVal, SrcVal;
- APSInt Imm, K;
- if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal)) return false;
- if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info)) return false;
-
- const APSInt *KPtr = nullptr;
- const APValue *PassThru = nullptr;
- bool ZeroInactive = false;
- if (IsMask) {
- if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal)) return false;
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = &SrcVal; ZeroInactive = false;
- } else if (IsMaskZ) {
- if (!EvaluateInteger(E->getArg(KIdx), K, Info)) return false;
- KPtr = &K; PassThru = nullptr; ZeroInactive = true;
- }
-
- const auto *VT = E->getType()->getAs<VectorType>();
- if (!VT) return false;
- const unsigned NumElts = VT->getNumElements();
- const unsigned ElemBits = 32;
- const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
- const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
- const bool DestUnsigned =
- VT->getElementType()->isUnsignedIntegerOrEnumerationType();
-
- auto MakeZero = [&]() -> APValue {
- return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
- };
- SmallVector<APValue, 32> Out;
- Out.reserve(NumElts);
+ if (KPtr) {
+ const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
+ if (Keep) {
+ Out.push_back(Chosen);
+ } else if (ZeroInactive) {
+ Out.push_back(MakeZero());
+ } else {
+ const APValue &PT =
+ PassThru ? PassThru->getVectorElt(i) : AVal.getVectorElt(i);
+ Out.push_back(PT);
+ }
+ } else {
+ Out.push_back(Chosen);
+ }
+ }
+ return Success(APValue(Out.data(), Out.size()), E);
+ }
- for (unsigned i = 0; i < NumElts; ++i) {
- const unsigned laneBase = (i / LaneElems) * LaneElems;
- const unsigned inLane = i % LaneElems;
+ case clang::X86::BI__builtin_ia32_pshufd:
+ case clang::X86::BI__builtin_ia32_pshufd256:
+ case clang::X86::BI__builtin_ia32_pshufd512:
+ case clang::X86::BI__builtin_ia32_pshufd128_mask:
+ case clang::X86::BI__builtin_ia32_pshufd256_mask:
+ case clang::X86::BI__builtin_ia32_pshufd512_mask:
+ case clang::X86::BI__builtin_ia32_pshufd128_maskz:
+ case clang::X86::BI__builtin_ia32_pshufd256_maskz:
+ case clang::X86::BI__builtin_ia32_pshufd512_maskz: {
+ const unsigned BID = E->getBuiltinCallee();
- const unsigned pos = inLane & 3;
- const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
- const unsigned srcIdx = laneBase + sel;
- APValue Chosen = AVal.getVectorElt(srcIdx);
+ const bool IsMask = BID == clang::X86::BI__builtin_ia32_pshufd512_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshufd128_mask ||
+ BID == clang::X86::BI__builtin_ia32_pshufd256_mask;
- if (KPtr) {
- const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
- if (Keep) {
- Out.push_back(Chosen);
- } else if (ZeroInactive) {
- Out.push_back(MakeZero());
+ const bool IsMaskZ = BID == clang::X86::BI__builtin_ia32_pshufd512_maskz ||
+ BID == clang::X86::BI__builtin_ia32_pshufd128_maskz ||
+ BID == clang::X86::BI__builtin_ia32_pshufd256_maskz;
+
+ const unsigned AIdx = 0, ImmIdx = 1;
+ const unsigned SrcIdx = 2;
+ const unsigned KIdx = IsMaskZ ? 2 : 3;
+
+ APValue AVal, SrcVal;
+ APSInt Imm, K;
+ if (!EvaluateAsRValue(Info, E->getArg(AIdx), AVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(ImmIdx), Imm, Info))
+ return false;
+
+ const APSInt *KPtr = nullptr;
+ const APValue *PassThru = nullptr;
+ bool ZeroInactive = false;
+ if (IsMask) {
+ if (!EvaluateAsRValue(Info, E->getArg(SrcIdx), SrcVal))
+ return false;
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = &SrcVal;
+ ZeroInactive = false;
+ } else if (IsMaskZ) {
+ if (!EvaluateInteger(E->getArg(KIdx), K, Info))
+ return false;
+ KPtr = &K;
+ PassThru = nullptr;
+ ZeroInactive = true;
+ }
+
+ const auto *VT = E->getType()->getAs<VectorType>();
+ if (!VT)
+ return false;
+ const unsigned NumElts = VT->getNumElements();
+ const unsigned ElemBits = 32;
+ const unsigned LaneElems = std::min(NumElts, 128u / ElemBits);
+ const uint8_t Ctl = static_cast<uint8_t>(Imm.getZExtValue());
+ const bool DestUnsigned =
+ VT->getElementType()->isUnsignedIntegerOrEnumerationType();
+
+ auto MakeZero = [&]() -> APValue {
+ return APValue(APSInt(APInt(ElemBits, 0), DestUnsigned));
+ };
+
+ SmallVector<APValue, 32> Out;
+ Out.reserve(NumElts);
+
+ for (unsigned i = 0; i < NumElts; ++i) {
+ const unsigned laneBase = (i / LaneElems) * LaneElems;
+ const unsigned inLane = i % LaneElems;
+
+ const unsigned pos = inLane & 3;
+ const unsigned sel = (Ctl >> (2 * pos)) & 0x3;
+ const unsigned srcIdx = laneBase + sel;
+ APValue Chosen = AVal.getVectorElt(srcIdx);
+
+ if (KPtr) {
+ const bool Keep = (i < KPtr->getBitWidth()) ? (*KPtr)[i] : false;
+ if (Keep) {
+ Out.push_back(Chosen);
+ } else if (ZeroInactive) {
+ Out.push_back(MakeZero());
+ } else {
+ const APValue &PT =
+ PassThru ? PassThru->getVectorElt(i) : AVal.getVectorElt(i);
+ Out.push_back(PT);
+ }
} else {
- const APValue &PT = PassThru ? PassThru->getVectorElt(i)
- : AVal.getVectorElt(i);
- Out.push_back(PT);
+ Out.push_back(Chosen);
}
- } else {
- Out.push_back(Chosen);
}
+ return Success(APValue(Out.data(), Out.size()), E);
}
- return Success(APValue(Out.data(), Out.size()), E);
-}
case clang::X86::BI__builtin_ia32_vprotbi:
case clang::X86::BI__builtin_ia32_vprotdi:
@@ -12477,7 +12503,6 @@ case clang::X86::BI__builtin_ia32_pshufd512_maskz: {
return Success(APValue(ResultElements.data(), ResultElements.size()), E);
}
-
case X86::BI__builtin_ia32_insertf32x4_256:
case X86::BI__builtin_ia32_inserti32x4_256:
case X86::BI__builtin_ia32_insertf64x2_256:
diff --git a/clang/lib/Headers/mmintrin.h b/clang/lib/Headers/mmintrin.h
index 039f8c5ca..371a8c5ac 100644
--- a/clang/lib/Headers/mmintrin.h
+++ b/clang/lib/Headers/mmintrin.h
@@ -43,7 +43,7 @@ typedef char __v16qi __attribute__((__vector_size__(16)));
__attribute__((__always_inline__, __nodebug__, __target__("sse2"),
\
__min_vector_width__(128)))
-#define __DEFAULT_FN_ATTRS_MMX \
+#define __DEFAULT_FN_ATTRS_MMX
\
__attribute__((__always_inline__, __nodebug__, __target__("mmx")))
#if defined(__cplusplus) && (__cplusplus >= 201103L)
@@ -51,7 +51,7 @@ typedef char __v16qi __attribute__((__vector_size__(16)));
#define __DEFAULT_FN_ATTRS_MMX_CONSTEXPR __DEFAULT_FN_ATTRS_MMX constexpr
#else
#define __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR __DEFAULT_FN_ATTRS_SSE2
-#define __DEFAULT_FN_ATTRS_MMX_CONSTEXPR __DEFAULT_FN_ATTRS_MMX
+#define __DEFAULT_FN_ATTRS_MMX_CONSTEXPR __DEFAULT_FN_ATTRS_MMX
#endif
#define __trunc64(x)
\
@@ -192,7 +192,6 @@ _mm_packs_pi32(__m64 __m1, __m64 __m2) {
(__v4si)__builtin_shufflevector(__m1, __m2, 0, 1), (__v4si){}));
}
-
/// Converts, with saturation, 16-bit signed integers from both 64-bit integer
/// vector parameters of [4 x i16] into 8-bit unsigned integer values, and
/// constructs a 64-bit integer vector of [8 x i8] as the result.
``````````
</details>
https://github.com/llvm/llvm-project/pull/161094
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
