Remove HLSL 2021 per-feature flags (#4716)

* [NFC] Transform all test cases to use `-HV 2021`

This just updates test cases to use `-HV 2021` instead of the
per-feature options.

* Remove HLSL 2021 per-feature flags

This change removes the HLSL 2021 per-feature enabling flags. Now that
HLSL 2021 is feature complete we're removing the ability to opt into
individual features. Any code relying on a single feature of HLSL 2021
should now adopt HLSL 2021 completely.

Co-authored-by: Greg Roth <[email protected]>

Author: llvm-beanz

include/dxc/Support/HLSLOptions.h

@@ -206,14 +206,6 @@ class DxcOpts {
   bool ForceZeroStoreLifetimes = false; // OPT_force_zero_store_lifetimes
   bool EnableLifetimeMarkers = false; // OPT_enable_lifetime_markers
   bool ForceDisableLocTracking = false; // OPT_fdisable_loc_tracking
-  bool EnableTemplates = false; // OPT_enable_templates
-  bool EnableOperatorOverloading = false; // OPT_enable_operator_overloading
-  bool StrictUDTCasting = false; // OPT_strict_udt_casting
-
-  // Experimental option to enable short-circuiting operators
-  bool EnableShortCircuit = false; // OPT_enable_short_circuit
-
-  bool EnableBitfields = false; // OPT_enable_bitfields
 
   // Optimization pass enables, disables and selects
   std::map<std::string, bool> DxcOptimizationToggles; // OPT_opt_enable & OPT_opt_disable

include/dxc/Support/HLSLOptions.td

@@ -302,12 +302,6 @@ def enable_lifetime_markers : Flag<["-", "/"], "enable-lifetime-markers">, Group
   HelpText<"Enable generation of lifetime markers">;
 def disable_lifetime_markers : Flag<["-", "/"], "disable-lifetime-markers">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
   HelpText<"Disable generation of lifetime markers where they would be otherwise (6.6+)">;
-def enable_templates: Flag<["-", "/"], "enable-templates">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
-  HelpText<"Enable template support for HLSL.">;
-def enable_operator_overloading: Flag<["-", "/"], "enable-operator-overloading">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
-  HelpText<"Enable operator overloading support for HLSL.">;
-def strict_udt_casting: Flag<["-", "/"], "strict-udt-casting">, Group<hlslcomp_Group>, Flags<[CoreOption, HelpHidden]>,
-  HelpText<"Require explicit casts between different structure types with compatible layouts.">;
 def enable_payload_qualifiers : Flag<["-", "/"], "enable-payload-qualifiers">, Group<hlslcomp_Group>, Flags<[CoreOption, RewriteOption, DriverOption]>,
   HelpText<"Enables support for payload access qualifiers for raytracing payloads in SM 6.6.">;
 def disable_payload_qualifiers : Flag<["-", "/"], "disable-payload-qualifiers">, Group<hlslcomp_Group>, Flags<[CoreOption, RewriteOption, DriverOption]>,
@@ -483,12 +477,6 @@ def Qstrip_reflect_from_dxil : Flag<["-", "/"], "Qstrip_reflect_from_dxil">,
   Flags<[CoreOption, HelpHidden]>, Group<hlslutil_Group>,
   HelpText<"Strip reflection data from shader bytecode  (must be used with /Fo <file>)">;
 
-def enable_short_circuit : Flag<["-", "/"], "enable-short-circuit">, Flags<[CoreOption, HelpHidden]>, Group<hlslcomp_Group>,
-  HelpText<"Operators '&&', '||', and '?:' will short circuit, only accepting scalar inputs.  Use and(), or(), and select() intrinsics in place of non-short-circuiting vector operators.">;
-
-def enable_bitfields : Flag<["-", "/"], "enable-bitfields">, Flags<[CoreOption, HelpHidden]>, Group<hlslcomp_Group>,
-  HelpText<"Enables bitfields on struct members">;
-
 /*
 def shtemplate : JoinedOrSeparate<["-", "/"], "shtemplate">, MetaVarName<"<file>">, Group<hlslcomp_Group>,
   HelpText<"Template shader file for merging/matching resources">;

lib/DxcSupport/HLSLOptions.cpp

@@ -520,55 +520,6 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
     opts.EnableFXCCompatMode = true;
   }
 
-  // If the HLSL version is 2021, allow the 2021 features by default.
-  // If the HLSL version is 2016 or 2018, allow them only
-  // when the individual option is enabled.
-  // If the HLSL version is 2015, dissallow these features
-  if (opts.HLSLVersion >= hlsl::LangStd::v2021) {
-    // Enable operator overloading in structs
-    opts.EnableOperatorOverloading = true;
-    // Enable template support
-    opts.EnableTemplates = true;
-    // Determine overload matching based on UDT names, not just types
-    opts.StrictUDTCasting = true;
-    // Experimental option to enable short-circuiting operators
-    opts.EnableShortCircuit = true;
-    // Enable bitfield support
-    opts.EnableBitfields = true;
-
-  } else {
-    opts.EnableOperatorOverloading = Args.hasFlag(OPT_enable_operator_overloading, OPT_INVALID, false);
-    opts.EnableTemplates = Args.hasFlag(OPT_enable_templates, OPT_INVALID, false);
-    opts.StrictUDTCasting = Args.hasFlag(OPT_strict_udt_casting, OPT_INVALID, false);
-    opts.EnableShortCircuit = Args.hasFlag(OPT_enable_short_circuit, OPT_INVALID, false);
-    opts.EnableBitfields = Args.hasFlag(OPT_enable_bitfields, OPT_INVALID, false);
-
-    if (opts.HLSLVersion <= hlsl::LangStd::v2015) {
-
-      if (opts.EnableOperatorOverloading)
-        errors << "/enable-operator-overloading is not supported with HLSL "
-                  "Version "
-               << (unsigned long)opts.HLSLVersion;
-      if (opts.EnableTemplates)
-        errors << "/enable-templates is not supported with HLSL Version "
-               << (unsigned long)opts.HLSLVersion;
-
-      if (opts.StrictUDTCasting)
-        errors << "/enable-udt-casting is not supported with HLSL Version "
-               << (unsigned long)opts.HLSLVersion;
-
-      if (opts.EnableShortCircuit)
-        errors << "/enable-short-circuit is not supported with HLSL Version "
-               << (unsigned long)opts.HLSLVersion;
-
-      if (opts.EnableBitfields)
-        errors << "/enable-bitfields is not supported with HLSL Version "
-               << (unsigned long)opts.HLSLVersion;
-
-      return 1;
-    }
-  }
-
   // AssemblyCodeHex not supported (Fx)
   // OutputLibrary not supported (Fl)
   opts.AssemblyCode = Args.getLastArgValue(OPT_Fc);

tools/clang/include/clang/Basic/LangOptions.h

@@ -159,12 +159,7 @@ class LangOptions : public LangOptionsBase {
   bool UseMinPrecision = true; // use min precision, not native precision.
   bool EnableDX9CompatMode = false;
   bool EnableFXCCompatMode = false;
-  bool EnableTemplates = false;
-  bool EnableOperatorOverloading = false;
-  bool StrictUDTCasting = false;
   bool EnablePayloadAccessQualifiers = false;
-  bool EnableShortCircuit = false;
-  bool EnableBitfields = false;
   // HLSL Change Ends
 
   bool SPIRV = false;  // SPIRV Change

tools/clang/include/clang/Driver/Options.td

@@ -680,14 +680,6 @@ def hlsl_version : Separate<["-", "/"], "HV">, Group<f_Group>, Flags<[DriverOpti
   HelpText<"HLSL version (2015, 2016, 2017, 2018, 2021). Default is 2018">; // HLSL Change - mimic the HLSLOptions.td flag
 def enable_16bit_types: Flag<["-", "/"], "enable-16bit-types">, Flags<[CoreOption, DriverOption, HelpHidden]>,
   HelpText<"Enable 16bit types and disable min precision types.">; // HLSL Change - mimic the HLSLOptions.td flag
-def enable_templates: Flag<["-", "/"], "enable-templates">, Flags<[CoreOption, DriverOption, HelpHidden]>,
-  HelpText<"Enable template support for HLSL.">; // HLSL Change
-def enable_operator_overloading: Flag<["-", "/"], "enable-operator-overloading">, Flags<[CoreOption, DriverOption, HelpHidden]>,
-  HelpText<"Enable operator overloading support for HLSL.">; // HLSL Change
-def strict_udt_casting: Flag<["-", "/"], "strict-udt-casting">, Flags<[CoreOption, DriverOption, HelpHidden]>,
-  HelpText<"Require explicit casts between different structure types with compatible layouts.">; // HLSL Change
-def enable_bitfields : Flag<["-", "/"], "enable-bitfields">, Flags<[CoreOption, DriverOption, HelpHidden]>,
-  HelpText<"Enables bitfields on struct members">; // HLSL Change
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,

tools/clang/lib/AST/ExprConstant.cpp

@@ -9412,7 +9412,8 @@ static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
 bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
                                  SourceLocation *Loc) const {
   // HLSL Change - if templates are enabled we need to act like C++11 here
-  if (Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().EnableTemplates)
+  if (Ctx.getLangOpts().CPlusPlus11 ||
+      Ctx.getLangOpts().HLSLVersion >= hlsl::LangStd::v2021)
     return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
 
   ICEDiag D = CheckICE(this, Ctx);
@@ -9426,7 +9427,8 @@ bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
 bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
                                  SourceLocation *Loc, bool isEvaluated) const {
   // HLSL Change - if templates are enabled we need to act like C++11 here
-  if (Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().EnableTemplates)
+  if (Ctx.getLangOpts().CPlusPlus11 ||
+      Ctx.getLangOpts().HLSLVersion >= hlsl::LangStd::v2021)
     return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc);
 
   if (!isIntegerConstantExpr(Ctx, Loc))

tools/clang/lib/CodeGen/CGExprScalar.cpp

@@ -3422,7 +3422,8 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
     // 0 && RHS: If it is safe, just elide the RHS, and return 0/false.
     if (!CGF.ContainsLabel(E->getRHS())) {
       // HLSL Change Begins.
-      if (CGF.getLangOpts().HLSL && !CGF.getLangOpts().EnableShortCircuit) {
+      if (CGF.getLangOpts().HLSL &&
+          CGF.getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
         // HLSL does not short circuit by default.
         Visit(E->getRHS());
       }
@@ -3432,7 +3433,8 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
   }
 
   // HLSL Change Begins.
-  if (CGF.getLangOpts().HLSL && !CGF.getLangOpts().EnableShortCircuit) {
+  if (CGF.getLangOpts().HLSL &&
+      CGF.getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
     // HLSL does not short circuit by default.
     Value *LHS = Visit(E->getLHS());
     Value *RHS = Visit(E->getRHS());
@@ -3527,7 +3529,8 @@ Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
     // 1 || RHS: If it is safe, just elide the RHS, and return 1/true.
     if (!CGF.ContainsLabel(E->getRHS())) {
       // HLSL Change Begins.
-      if (CGF.getLangOpts().HLSL && !CGF.getLangOpts().EnableShortCircuit) {
+      if (CGF.getLangOpts().HLSL &&
+          CGF.getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
         // HLSL does not short circuit by default.
         Visit(E->getRHS());
       }
@@ -3537,7 +3540,8 @@ Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
   }
 
   // HLSL Change Begins.
-  if (CGF.getLangOpts().HLSL && !CGF.getLangOpts().EnableShortCircuit) {
+  if (CGF.getLangOpts().HLSL &&
+      CGF.getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
     // HLSL does not short circuit by default.
     Value *LHS = Visit(E->getLHS());
     Value *RHS = Visit(E->getRHS());
@@ -3702,7 +3706,8 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
     return tmp5;
   }
   // HLSL Change Starts
-  if (CGF.getLangOpts().HLSL && !CGF.getLangOpts().EnableShortCircuit) {
+  if (CGF.getLangOpts().HLSL &&
+      CGF.getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
     // HLSL does not short circuit by default before HLSL 2021
     if (hlsl::IsHLSLVecType(E->getType()) || E->getType()->isArithmeticType()) {
       llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
@@ -3754,7 +3759,8 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
 
   // HLSL Change Begins
   llvm::Instruction *ResultAlloca = nullptr;
-  if (CGF.getLangOpts().HLSL && CGF.getLangOpts().EnableShortCircuit &&
+  if (CGF.getLangOpts().HLSL &&
+      CGF.getLangOpts().HLSLVersion >= hlsl::LangStd::v2021 &&
       hlsl::IsHLSLMatType(E->getType())) {
     llvm::Type *MatTy = CGF.ConvertTypeForMem(E->getType());
     ResultAlloca = CGF.CreateTempAlloca(MatTy);

tools/clang/lib/CodeGen/CodeGenFunction.cpp

@@ -1088,7 +1088,8 @@ void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
       }
 
       // HLSL Change Begins.
-      if (getLangOpts().HLSL && !getLangOpts().EnableShortCircuit) {
+      if (getLangOpts().HLSL &&
+          getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
         // HLSL does not short circuit by default.
         // Emit the code with the fully general case.
         llvm::Value *CondV;
@@ -1148,7 +1149,8 @@ void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
       }
 
       // HLSL Change Begins.
-      if (getLangOpts().HLSL && !getLangOpts().EnableShortCircuit) {
+      if (getLangOpts().HLSL &&
+          getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
         // HLSL does not short circuit by default.
         // Emit the code with the fully general case.
         llvm::Value *CondV;

tools/clang/lib/Frontend/CompilerInvocation.cpp

@@ -1737,39 +1737,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
   // TODO: should we tie low precision to HLSL2018 only?
   Opts.UseMinPrecision = !Args.hasArg(options::OPT_enable_16bit_types);
 
-  // If the HLSL version is 2021, allow the 2021 features by default.
-  // If the HLSL version is 2016 or 2018, allow them only
-  // when the individual option is enabled.
-  // If the HLSL version is 2015, dissallow these features
-  if (Opts.HLSLVersion >= hlsl::LangStd::v2021) {
-    // Enable operator overloading in structs
-    Opts.EnableOperatorOverloading = true;
-    // Enable template support
-    Opts.EnableTemplates = true;
-    // Determine overload matching based on UDT names, not just types
-    Opts.StrictUDTCasting = true;
-    // Experimental option to enable short-circuiting operators
-    Opts.EnableShortCircuit = true;
-    // Enable bitfield support
-    Opts.EnableBitfields = true;
-
-  } else {
-    Opts.EnableOperatorOverloading = Args.hasArg(OPT_enable_operator_overloading);
-    Opts.EnableTemplates = Args.hasArg(OPT_enable_templates);
-    Opts.StrictUDTCasting = Args.hasArg(OPT_strict_udt_casting);
-    Opts.EnableBitfields = Args.hasArg(OPT_enable_bitfields);
-
-    if (Opts.HLSLVersion <= hlsl::LangStd::v2015) {
-      if (Opts.EnableOperatorOverloading)
-        Diags.Report(diag::err_hlsl_invalid_drv_for_feature) << "/enable-operator-overloading" << ver;
-      if (Opts.EnableTemplates)
-        Diags.Report(diag::err_hlsl_invalid_drv_for_feature) << "/enable-templates" << ver;
-      if (Opts.StrictUDTCasting)
-        Diags.Report(diag::err_hlsl_invalid_drv_for_feature) << "/enable-udt-casting" << ver;
-      if (Opts.EnableBitfields)
-        Diags.Report(diag::err_hlsl_invalid_drv_for_feature) << "/enable-bitfields" << ver;
-    }
-  }
 #endif // #ifdef MS_SUPPORT_VARIABLE_LANGOPTS
 }
 

tools/clang/lib/Parse/ParseDecl.cpp

@@ -2005,7 +2005,8 @@ Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context,
   switch (Tok.getKind()) {
   case tok::kw_template:
     // HLSL Change Starts
-    if (getLangOpts().HLSL && !getLangOpts().EnableTemplates) {
+    if (getLangOpts().HLSL &&
+        getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
       Diag(Tok, diag::err_hlsl_reserved_keyword) << Tok.getName();
       SkipMalformedDecl();
       return DeclGroupPtrTy();
@@ -4169,7 +4170,10 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
 
     // C++ typename-specifier:
     case tok::kw_typename:
-      if (getLangOpts().HLSL && !getLangOpts().EnableTemplates) { goto HLSLReservedKeyword; } // HLSL Change - reserved for HLSL
+      if (getLangOpts().HLSL &&
+          getLangOpts().HLSLVersion < hlsl::LangStd::v2021) {
+        goto HLSLReservedKeyword;
+      } // HLSL Change - reserved for HLSL
       if (TryAnnotateTypeOrScopeToken()) {
         DS.SetTypeSpecError();
         goto DoneWithDeclSpec;