[clang] Revert "[HLSL] Vector Usual Arithmetic Conversions" (PR #110191)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Sep 26 17:35:00 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Chris B (llvm-beanz)
<details>
<summary>Changes</summary>
Reverts llvm/llvm-project#<!-- -->108659
---
Patch is 38.05 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/110191.diff
7 Files Affected:
- (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (-3)
- (modified) clang/include/clang/Driver/Options.td (+1-1)
- (modified) clang/include/clang/Sema/Sema.h (+1-2)
- (modified) clang/include/clang/Sema/SemaHLSL.h (-5)
- (modified) clang/lib/Sema/SemaExpr.cpp (+2-16)
- (modified) clang/lib/Sema/SemaHLSL.cpp (-188)
- (removed) clang/test/SemaHLSL/Language/UsualArithmeticConversions.hlsl (-379)
``````````diff
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 9e8f152852fd1e..f3d5d4c56606cc 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -12395,9 +12395,6 @@ def err_hlsl_operator_unsupported : Error<
def err_hlsl_param_qualifier_mismatch :
Error<"conflicting parameter qualifier %0 on parameter %1">;
-def err_hlsl_vector_compound_assignment_truncation : Error<
- "left hand operand of type %0 to compound assignment cannot be truncated "
- "when used with right hand operand of type %1">;
def warn_hlsl_impcast_vector_truncation : Warning<
"implicit conversion truncates vector: %0 to %1">, InGroup<Conversion>;
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 1dc2ff18170abf..932cf13edab53d 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -2978,7 +2978,7 @@ def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Grou
"LangOptions::LaxVectorConversionKind::Integer",
"LangOptions::LaxVectorConversionKind::All"]>,
MarshallingInfoEnum<LangOpts<"LaxVectorConversions">,
- !strconcat("(", open_cl.KeyPath, " || ", hlsl.KeyPath, ")") #
+ open_cl.KeyPath #
" ? LangOptions::LaxVectorConversionKind::None" #
" : LangOptions::LaxVectorConversionKind::All">;
def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>,
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index a9ce3681338d46..e1c3a99cfa167e 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -7423,8 +7423,7 @@ class Sema final : public SemaBase {
SourceLocation Loc,
BinaryOperatorKind Opc);
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
- SourceLocation Loc,
- BinaryOperatorKind Opc);
+ SourceLocation Loc);
/// Context in which we're performing a usual arithmetic conversion.
enum ArithConvKind {
diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h
index fa957abc9791af..311cd58bbcac2c 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -63,11 +63,6 @@ class SemaHLSL : public SemaBase {
std::initializer_list<llvm::Triple::EnvironmentType> AllowedStages);
void DiagnoseAvailabilityViolations(TranslationUnitDecl *TU);
- QualType handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS,
- QualType LHSType, QualType RHSType,
- bool IsCompAssign);
- void emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS, BinaryOperatorKind Opc);
-
void handleNumThreadsAttr(Decl *D, const ParsedAttr &AL);
void handleWaveSizeAttr(Decl *D, const ParsedAttr &AL);
void handleSV_DispatchThreadIDAttr(Decl *D, const ParsedAttr &AL);
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index e072fb65b81328..66df9c969256a2 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -10133,10 +10133,6 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
const VectorType *RHSVecType = RHSType->getAs<VectorType>();
assert(LHSVecType || RHSVecType);
- if (getLangOpts().HLSL)
- return HLSL().handleVectorBinOpConversion(LHS, RHS, LHSType, RHSType,
- IsCompAssign);
-
// AltiVec-style "vector bool op vector bool" combinations are allowed
// for some operators but not others.
if (!AllowBothBool && LHSVecType &&
@@ -12867,8 +12863,7 @@ static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS,
}
QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
- SourceLocation Loc,
- BinaryOperatorKind Opc) {
+ SourceLocation Loc) {
// Ensure that either both operands are of the same vector type, or
// one operand is of a vector type and the other is of its element type.
QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
@@ -12888,15 +12883,6 @@ QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
if (!getLangOpts().CPlusPlus &&
!(isa<ExtVectorType>(vType->getAs<VectorType>())))
return InvalidLogicalVectorOperands(Loc, LHS, RHS);
- // Beginning with HLSL 2021, HLSL disallows logical operators on vector
- // operands and instead requires the use of the `and`, `or`, `any`, `all`, and
- // `select` functions.
- if (getLangOpts().HLSL &&
- getLangOpts().getHLSLVersion() >= LangOptionsBase::HLSL_2021) {
- (void)InvalidOperands(Loc, LHS, RHS);
- HLSL().emitLogicalOperatorFixIt(LHS.get(), RHS.get(), Opc);
- return QualType();
- }
return GetSignedVectorType(LHS.get()->getType());
}
@@ -13068,7 +13054,7 @@ inline QualType Sema::CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS,
// Check vector operands differently.
if (LHS.get()->getType()->isVectorType() ||
RHS.get()->getType()->isVectorType())
- return CheckVectorLogicalOperands(LHS, RHS, Loc, Opc);
+ return CheckVectorLogicalOperands(LHS, RHS, Loc);
bool EnumConstantInBoolContext = false;
for (const ExprResult &HS : {LHS, RHS}) {
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index f17b606a8f262a..1d8ccdda45573f 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -401,194 +401,6 @@ void SemaHLSL::DiagnoseAttrStageMismatch(
<< (AllowedStages.size() != 1) << join(StageStrings, ", ");
}
-template <CastKind Kind>
-static void castVector(Sema &S, ExprResult &E, QualType &Ty, unsigned Sz) {
- if (const auto *VTy = Ty->getAs<VectorType>())
- Ty = VTy->getElementType();
- Ty = S.getASTContext().getExtVectorType(Ty, Sz);
- E = S.ImpCastExprToType(E.get(), Ty, Kind);
-}
-
-template <CastKind Kind>
-static QualType castElement(Sema &S, ExprResult &E, QualType Ty) {
- E = S.ImpCastExprToType(E.get(), Ty, Kind);
- return Ty;
-}
-
-static QualType handleFloatVectorBinOpConversion(
- Sema &SemaRef, ExprResult &LHS, ExprResult &RHS, QualType LHSType,
- QualType RHSType, QualType LElTy, QualType RElTy, bool IsCompAssign) {
- bool LHSFloat = LElTy->isRealFloatingType();
- bool RHSFloat = RElTy->isRealFloatingType();
-
- if (LHSFloat && RHSFloat) {
- if (IsCompAssign ||
- SemaRef.getASTContext().getFloatingTypeOrder(LElTy, RElTy) > 0)
- return castElement<CK_FloatingCast>(SemaRef, RHS, LHSType);
-
- return castElement<CK_FloatingCast>(SemaRef, LHS, RHSType);
- }
-
- if (LHSFloat)
- return castElement<CK_IntegralToFloating>(SemaRef, RHS, LHSType);
-
- assert(RHSFloat);
- if (IsCompAssign)
- return castElement<clang::CK_FloatingToIntegral>(SemaRef, RHS, LHSType);
-
- return castElement<CK_IntegralToFloating>(SemaRef, LHS, RHSType);
-}
-
-static QualType handleIntegerVectorBinOpConversion(
- Sema &SemaRef, ExprResult &LHS, ExprResult &RHS, QualType LHSType,
- QualType RHSType, QualType LElTy, QualType RElTy, bool IsCompAssign) {
-
- int IntOrder = SemaRef.Context.getIntegerTypeOrder(LElTy, RElTy);
- bool LHSSigned = LElTy->hasSignedIntegerRepresentation();
- bool RHSSigned = RElTy->hasSignedIntegerRepresentation();
- auto &Ctx = SemaRef.getASTContext();
-
- // If both types have the same signedness, use the higher ranked type.
- if (LHSSigned == RHSSigned) {
- if (IsCompAssign || IntOrder >= 0)
- return castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);
-
- return castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);
- }
-
- // If the unsigned type has greater than or equal rank of the signed type, use
- // the unsigned type.
- if (IntOrder != (LHSSigned ? 1 : -1)) {
- if (IsCompAssign || RHSSigned)
- return castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);
- return castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);
- }
-
- // At this point the signed type has higher rank than the unsigned type, which
- // means it will be the same size or bigger. If the signed type is bigger, it
- // can represent all the values of the unsigned type, so select it.
- if (Ctx.getIntWidth(LElTy) != Ctx.getIntWidth(RElTy)) {
- if (IsCompAssign || LHSSigned)
- return castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);
- return castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);
- }
-
- // This is a bit of an odd duck case in HLSL. It shouldn't happen, but can due
- // to C/C++ leaking through. The place this happens today is long vs long
- // long. When arguments are vector<unsigned long, N> and vector<long long, N>,
- // the long long has higher rank than long even though they are the same size.
-
- // If this is a compound assignment cast the right hand side to the left hand
- // side's type.
- if (IsCompAssign)
- return castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);
-
- // If this isn't a compound assignment we convert to unsigned long long.
- QualType ElTy = Ctx.getCorrespondingUnsignedType(LHSSigned ? LElTy : RElTy);
- QualType NewTy = Ctx.getExtVectorType(
- ElTy, RHSType->castAs<VectorType>()->getNumElements());
- (void)castElement<CK_IntegralCast>(SemaRef, RHS, NewTy);
-
- return castElement<CK_IntegralCast>(SemaRef, LHS, NewTy);
-}
-
-static CastKind getScalarCastKind(ASTContext &Ctx, QualType DestTy,
- QualType SrcTy) {
- if (DestTy->isRealFloatingType() && SrcTy->isRealFloatingType())
- return CK_FloatingCast;
- if (DestTy->isIntegralType(Ctx) && SrcTy->isIntegralType(Ctx))
- return CK_IntegralCast;
- if (DestTy->isRealFloatingType())
- return CK_IntegralToFloating;
- assert(SrcTy->isRealFloatingType() && DestTy->isIntegralType(Ctx));
- return CK_FloatingToIntegral;
-}
-
-QualType SemaHLSL::handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS,
- QualType LHSType,
- QualType RHSType,
- bool IsCompAssign) {
- const auto *LVecTy = LHSType->getAs<VectorType>();
- const auto *RVecTy = RHSType->getAs<VectorType>();
- auto &Ctx = getASTContext();
-
- // If the LHS is not a vector and this is a compound assignment, we truncate
- // the argument to a scalar then convert it to the LHS's type.
- if (!LVecTy && IsCompAssign) {
- QualType RElTy = RHSType->castAs<VectorType>()->getElementType();
- RHS = SemaRef.ImpCastExprToType(RHS.get(), RElTy, CK_HLSLVectorTruncation);
- RHSType = RHS.get()->getType();
- if (Ctx.hasSameUnqualifiedType(LHSType, RHSType))
- return LHSType;
- RHS = SemaRef.ImpCastExprToType(RHS.get(), LHSType,
- getScalarCastKind(Ctx, LHSType, RHSType));
- return LHSType;
- }
-
- unsigned EndSz = std::numeric_limits<unsigned>::max();
- unsigned LSz = 0;
- if (LVecTy)
- LSz = EndSz = LVecTy->getNumElements();
- if (RVecTy)
- EndSz = std::min(RVecTy->getNumElements(), EndSz);
- assert(EndSz != std::numeric_limits<unsigned>::max() &&
- "one of the above should have had a value");
-
- // In a compound assignment, the left operand does not change type, the right
- // operand is converted to the type of the left operand.
- if (IsCompAssign && LSz != EndSz) {
- Diag(LHS.get()->getBeginLoc(),
- diag::err_hlsl_vector_compound_assignment_truncation)
- << LHSType << RHSType;
- return QualType();
- }
-
- if (RVecTy && RVecTy->getNumElements() > EndSz)
- castVector<CK_HLSLVectorTruncation>(SemaRef, RHS, RHSType, EndSz);
- if (!IsCompAssign && LVecTy && LVecTy->getNumElements() > EndSz)
- castVector<CK_HLSLVectorTruncation>(SemaRef, LHS, LHSType, EndSz);
-
- if (!RVecTy)
- castVector<CK_VectorSplat>(SemaRef, RHS, RHSType, EndSz);
- if (!IsCompAssign && !LVecTy)
- castVector<CK_VectorSplat>(SemaRef, LHS, LHSType, EndSz);
-
- // If we're at the same type after resizing we can stop here.
- if (Ctx.hasSameUnqualifiedType(LHSType, RHSType))
- return Ctx.getCommonSugaredType(LHSType, RHSType);
-
- QualType LElTy = LHSType->castAs<VectorType>()->getElementType();
- QualType RElTy = RHSType->castAs<VectorType>()->getElementType();
-
- // Handle conversion for floating point vectors.
- if (LElTy->isRealFloatingType() || RElTy->isRealFloatingType())
- return handleFloatVectorBinOpConversion(SemaRef, LHS, RHS, LHSType, RHSType,
- LElTy, RElTy, IsCompAssign);
-
- assert(LElTy->isIntegralType(Ctx) && RElTy->isIntegralType(Ctx) &&
- "HLSL Vectors can only contain integer or floating point types");
- return handleIntegerVectorBinOpConversion(SemaRef, LHS, RHS, LHSType, RHSType,
- LElTy, RElTy, IsCompAssign);
-}
-
-void SemaHLSL::emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS,
- BinaryOperatorKind Opc) {
- assert((Opc == BO_LOr || Opc == BO_LAnd) &&
- "Called with non-logical operator");
- llvm::SmallVector<char, 256> Buff;
- llvm::raw_svector_ostream OS(Buff);
- PrintingPolicy PP(SemaRef.getLangOpts());
- StringRef NewFnName = Opc == BO_LOr ? "or" : "and";
- OS << NewFnName << "(";
- LHS->printPretty(OS, nullptr, PP);
- OS << ", ";
- RHS->printPretty(OS, nullptr, PP);
- OS << ")";
- SourceRange FullRange = SourceRange(LHS->getBeginLoc(), RHS->getEndLoc());
- SemaRef.Diag(LHS->getBeginLoc(), diag::note_function_suggestion)
- << NewFnName << FixItHint::CreateReplacement(FullRange, OS.str());
-}
-
void SemaHLSL::handleNumThreadsAttr(Decl *D, const ParsedAttr &AL) {
llvm::VersionTuple SMVersion =
getASTContext().getTargetInfo().getTriple().getOSVersion();
diff --git a/clang/test/SemaHLSL/Language/UsualArithmeticConversions.hlsl b/clang/test/SemaHLSL/Language/UsualArithmeticConversions.hlsl
deleted file mode 100644
index 6138169e299fd7..00000000000000
--- a/clang/test/SemaHLSL/Language/UsualArithmeticConversions.hlsl
+++ /dev/null
@@ -1,379 +0,0 @@
-// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -finclude-default-header -fnative-half-type %s -DERRORS -Wconversion -Wdouble-promotion -verify
-// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -std=hlsl2018 -finclude-default-header -fnative-half-type %s -DERRORS -Wconversion -Wdouble-promotion -verify
-// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -finclude-default-header -fnative-half-type %s -ast-dump | FileCheck %s
-
-//----------------------------------------------------------------------------//
-// Case 1: float4 * int4 and inverse.
-//
-// In both cases here the int is converted to a float and the computation
-// produces a float value.
-//----------------------------------------------------------------------------//
-
-// CHECK-LABEL: FunctionDecl {{.*}} used f4f4i4 'float4 (float4, int4)'
-// CHECK: BinaryOperator {{.*}} 'float4':'vector<float, 4>' '*'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float4':'vector<float, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'float4':'vector<float, 4>' lvalue ParmVar {{.*}} 'A' 'float4':'vector<float, 4>'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float4':'vector<float, 4>' <IntegralToFloating>
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int4':'vector<int, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'int4':'vector<int, 4>' lvalue ParmVar {{.*}} 'B' 'int4':'vector<int, 4>'
-export float4 f4f4i4(float4 A, int4 B) {
- return A * B; // expected-warning{{implicit conversion from 'int4' (aka 'vector<int, 4>') to 'float4' (aka 'vector<float, 4>') may lose precision}}
-}
-
-// CHECK-LABEL: FunctionDecl {{.*}} used f4i4f4 'float4 (float4, int4)'
-// CHECK: BinaryOperator {{.*}} 'float4':'vector<float, 4>' '*'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float4':'vector<float, 4>' <IntegralToFloating>
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int4':'vector<int, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'int4':'vector<int, 4>' lvalue ParmVar {{.*}} 'B' 'int4':'vector<int, 4>'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float4':'vector<float, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'float4':'vector<float, 4>' lvalue ParmVar {{.*}} 'A' 'float4':'vector<float, 4>'
-export float4 f4i4f4(float4 A, int4 B) {
- return B * A; // expected-warning{{implicit conversion from 'int4' (aka 'vector<int, 4>') to 'float4' (aka 'vector<float, 4>') may lose precision}}
-}
-
-//----------------------------------------------------------------------------//
-// Case 2: float4 * int2 and inverse.
-//
-// In both cases the float vector is trunctated to a float2 and the integer
-// vector is converted to a float2.
-//----------------------------------------------------------------------------//
-
-// CHECK-LABEL: FunctionDecl {{.*}} used f2f4i2 'float2 (float4, int2)'
-// CHECK: BinaryOperator {{.*}} 'vector<float, 2>' '*'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<float, 2>' <HLSLVectorTruncation>
-// CHECK-NEXT: ImplicitCastExpr {{.*}}'float4':'vector<float, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'float4':'vector<float, 4>' lvalue ParmVar {{.*}} 'A' 'float4':'vector<float, 4>'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<float, 2>' <IntegralToFloating>
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int2':'vector<int, 2>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'int2':'vector<int, 2>' lvalue ParmVar {{.*}} 'B' 'int2':'vector<int, 2>'
-export float2 f2f4i2(float4 A, int2 B) {
- // expected-warning@#f2f4i2 {{implicit conversion from 'int2' (aka 'vector<int, 2>') to 'vector<float, 2>' (vector of 2 'float' values) may lose precision}}
- // expected-warning@#f2f4i2 {{implicit conversion truncates vector: 'float4' (aka 'vector<float, 4>') to 'vector<float, 2>' (vector of 2 'float' values)}}
- return A * B; // #f2f4i2
-}
-
-// CHECK-LABEL: FunctionDecl {{.*}} used f2i2f4 'float2 (float4, int2)'
-// CHECK: BinaryOperator {{.*}} 'vector<float, 2>' '*'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<float, 2>' <IntegralToFloating>
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int2':'vector<int, 2>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'int2':'vector<int, 2>' lvalue ParmVar {{.*}} 'B' 'int2':'vector<int, 2>'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<float, 2>' <HLSLVectorTruncation>
-// CHECK-NEXT: ImplicitCastExpr {{.*}}'float4':'vector<float, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr {{.*}} 'float4':'vector<float, 4>' lvalue ParmVar {{.*}} 'A' 'float4':'vector<float, 4>'
-export float2 f2i2f4(float4 A, int2 B) {
- // expected-warning@#f2i2f4 {{implicit conversion from 'int2' (aka 'vector<int, 2>') to 'vector<float, 2>' (vector of 2 'float' values) may lose precision}}
- // expected-warning@#f2i2f4 {{implicit conversion truncates vector: 'float4' (aka 'vector<float, 4>') to 'vector<float, 2>' (vector of 2 'float' values)}}
- return B * A; // #f2i2f4
-}
-
-//----------------------------------------------------------------------------//
-// Case 3: Integers of mismatched sign, equivalent size, but the unsigned type
-// has lower conversion rank.
-//
-// This is the odd-ball case for HLSL that isn't really in spec, but we should
-// handle gracefully. The lower-ranked unsigned type is converted to the
-// equivalent unsigned type of higher rank, and the signed type is also
-// converted to that unsigned type (meaning `unsigned long` becomes `unsinged
-// long long`, and `long long` becomes `unsigned long long`).
-//----------------------------------------------------------------------------//
-
-// CHECK-LABEL: FunctionDecl {{.*}} used wierdo 'int4 (vector<unsigned long, 4>, vector<long long, 4>)'
-// CHECK: BinaryOperator {{.*}} 'vector<unsigned long long, 4>' '*'
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<unsigned long long, 4>' <IntegralCast>
-// CHECK-NEXT: ImplicitCastExpr {{.*}} 'vector<unsigned long, 4>' <LValueToRValue>
-// CHECK-NEXT: DeclRefExpr{{.*}} 'vector<unsigned lon...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/110191
More information about the cfe-commits
mailing list