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 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
