Merge pull request microsoft#3968 from microsoft/merge-hlsl2021-master

Merge hlsl2021 master

Author: pow2clk

include/dxc/HlslIntrinsicOp.h

@@ -123,6 +123,7 @@ import hctdb_instrhelp
   IOP_abs,
   IOP_acos,
   IOP_all,
+  IOP_and,
   IOP_any,
   IOP_asdouble,
   IOP_asfloat,
@@ -185,6 +186,7 @@ import hctdb_instrhelp
   IOP_msad4,
   IOP_mul,
   IOP_normalize,
+  IOP_or,
   IOP_pack_clamp_s8,
   IOP_pack_clamp_u8,
   IOP_pack_s8,
@@ -199,6 +201,7 @@ import hctdb_instrhelp
   IOP_round,
   IOP_rsqrt,
   IOP_saturate,
+  IOP_select,
   IOP_sign,
   IOP_sin,
   IOP_sincos,

include/dxc/Support/HLSLOptions.h

@@ -199,6 +199,12 @@ class DxcOpts {
   unsigned ScanLimit = 0; // OPT_memdep_block_scan_limit
   bool ForceZeroStoreLifetimes = false; // OPT_force_zero_store_lifetimes
   bool EnableLifetimeMarkers = false; // OPT_enable_lifetime_markers
+  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
 
   // Optimization pass enables, disables and selects
   std::map<std::string, bool> DxcOptimizationToggles; // OPT_opt_enable & OPT_opt_disable

include/dxc/Support/HLSLOptions.td

@@ -288,6 +288,12 @@ 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]>,
+  HelpText<"Enable template support for HLSL.">;
+def enable_operator_overloading: Flag<["-", "/"], "enable-operator-overloading">, Group<hlslcomp_Group>, Flags<[CoreOption]>,
+  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]>,
@@ -452,6 +458,9 @@ 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 shtemplate : JoinedOrSeparate<["-", "/"], "shtemplate">, MetaVarName<"<file>">, Group<hlslcomp_Group>,
   HelpText<"Template shader file for merging/matching resources">;

lib/DxcSupport/HLSLOptions.cpp

@@ -475,13 +475,30 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
     opts.EnableFXCCompatMode = true;
   }
 
+  // If the HLSL version is 2021, allow the operator overloading by default.
+  // If the HLSL version is 2016 or 2018, allow the operator overloading only
+  // when -enable-operator-overloading option is enabled.
+  // If the HLSL version is 2015, do not allow the operator overloading.
+  opts.EnableOperatorOverloading =
+      opts.HLSLVersion >= 2021 ||
+      Args.hasFlag(OPT_enable_operator_overloading, OPT_INVALID, false);
+  if (opts.HLSLVersion <= 2015 && opts.EnableOperatorOverloading) {
+    errors << "/enable-operator-overloading is not supported with HLSL Version "
+           << opts.HLSLVersion;
+    return 1;
+  }
+
   // AssemblyCodeHex not supported (Fx)
   // OutputLibrary not supported (Fl)
   opts.AssemblyCode = Args.getLastArgValue(OPT_Fc);
   opts.DebugFile = Args.getLastArgValue(OPT_Fd);
   opts.ImportBindingTable = Args.getLastArgValue(OPT_import_binding_table);
   opts.ExtractPrivateFile = Args.getLastArgValue(OPT_getprivate);
   opts.Enable16BitTypes = Args.hasFlag(OPT_enable_16bit_types, OPT_INVALID, false);
+  opts.EnableTemplates = Args.hasFlag(OPT_enable_templates, OPT_INVALID, false);
+  opts.EnableOperatorOverloading =
+      Args.hasFlag(OPT_enable_operator_overloading, OPT_INVALID, false);
+  opts.StrictUDTCasting = Args.hasFlag(OPT_strict_udt_casting, OPT_INVALID, false);
   opts.OutputObject = Args.getLastArgValue(OPT_Fo);
   opts.OutputHeader = Args.getLastArgValue(OPT_Fh);
   opts.OutputWarningsFile = Args.getLastArgValue(OPT_Fe);
@@ -695,6 +712,10 @@ int ReadDxcOpts(const OptTable *optionTable, unsigned flagsToInclude,
                               !Args.hasFlag(OPT_disable_lifetime_markers, OPT_INVALID, false);
   opts.EnablePayloadQualifiers = Args.hasFlag(OPT_enable_payload_qualifiers, OPT_INVALID,
                                             DXIL::CompareVersions(Major, Minor, 6, 7) >= 0); 
+
+  // Experimental option to enable short-circuiting operators
+  opts.EnableShortCircuit = Args.hasFlag(OPT_enable_short_circuit, OPT_INVALID, false);
+
   if (DXIL::CompareVersions(Major, Minor, 6, 8) < 0) {
      opts.EnablePayloadQualifiers &= !Args.hasFlag(OPT_disable_payload_qualifiers, OPT_INVALID, false);
   }

lib/HLSL/HLOperationLower.cpp

@@ -5338,6 +5338,72 @@ Value *TranslateGetHandleFromHeap(CallInst *CI, IntrinsicOp IOP,
 }
 }
 
+// Translate and/or/select intrinsics
+namespace {
+Value *TranslateAnd(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                     HLOperationLowerHelper &helper,  HLObjectOperationLowerHelper *pObjHelper, bool &Translated) {
+  Value *x = CI->getArgOperand(HLOperandIndex::kBinaryOpSrc0Idx);
+  Value *y = CI->getArgOperand(HLOperandIndex::kBinaryOpSrc1Idx);
+  Type *Ty = CI->getType();
+  Type *EltTy = Ty->getScalarType();
+  IRBuilder<> Builder(CI);
+
+  if (Ty != EltTy) {
+    Value *Result = UndefValue::get(Ty);
+    for (unsigned i = 0; i < Ty->getVectorNumElements(); i++) {
+      Value *EltX = Builder.CreateExtractElement(x, i);
+      Value *EltY = Builder.CreateExtractElement(y, i);
+      Value *tmp = Builder.CreateAnd(EltX, EltY);
+      Result = Builder.CreateInsertElement(Result, tmp, i);
+    }
+    return Result;
+  }
+  return Builder.CreateAnd(x, y);
+}
+Value *TranslateOr(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                     HLOperationLowerHelper &helper,  HLObjectOperationLowerHelper *pObjHelper, bool &Translated) {
+  Value *x = CI->getArgOperand(HLOperandIndex::kBinaryOpSrc0Idx);
+  Value *y = CI->getArgOperand(HLOperandIndex::kBinaryOpSrc1Idx);
+  Type *Ty = CI->getType();
+  Type *EltTy = Ty->getScalarType();
+  IRBuilder<> Builder(CI);
+
+  if (Ty != EltTy) {
+    Value *Result = UndefValue::get(Ty);
+    for (unsigned i = 0; i < Ty->getVectorNumElements(); i++) {
+      Value *EltX = Builder.CreateExtractElement(x, i);
+      Value *EltY = Builder.CreateExtractElement(y, i);
+      Value *tmp = Builder.CreateOr(EltX, EltY);
+      Result = Builder.CreateInsertElement(Result, tmp, i);
+    }
+    return Result;
+  }
+  return Builder.CreateOr(x, y);
+}
+Value *TranslateSelect(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
+                     HLOperationLowerHelper &helper,  HLObjectOperationLowerHelper *pObjHelper, bool &Translated) {
+  Value *cond = CI->getArgOperand(HLOperandIndex::kTrinaryOpSrc0Idx);
+  Value *t = CI->getArgOperand(HLOperandIndex::kTrinaryOpSrc1Idx);
+  Value *f = CI->getArgOperand(HLOperandIndex::kTrinaryOpSrc2Idx);
+  Type *Ty = CI->getType();
+  Type *EltTy = Ty->getScalarType();
+  IRBuilder<> Builder(CI);
+
+  if (Ty != EltTy) {
+    Value *Result = UndefValue::get(Ty);
+    for (unsigned i = 0; i < Ty->getVectorNumElements(); i++) {
+      Value *EltCond = Builder.CreateExtractElement(cond, i);
+      Value *EltTrue = Builder.CreateExtractElement(t, i);
+      Value *EltFalse = Builder.CreateExtractElement(f, i);
+      Value *tmp = Builder.CreateSelect(EltCond, EltTrue, EltFalse);
+      Result = Builder.CreateInsertElement(Result, tmp, i);
+    }
+    return Result;
+  }
+  return Builder.CreateSelect(cond, t, f);
+}
+}
+
 // Lower table.
 namespace {
 
@@ -5475,6 +5541,7 @@ IntrinsicLower gLowerTable[] = {
     {IntrinsicOp::IOP_abs, TranslateAbs, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_acos, TrivialUnaryOperation, DXIL::OpCode::Acos},
     {IntrinsicOp::IOP_all, TranslateAll, DXIL::OpCode::NumOpCodes},
+    {IntrinsicOp::IOP_and, TranslateAnd, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_any, TranslateAny, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_asdouble, TranslateAsDouble, DXIL::OpCode::MakeDouble},
     {IntrinsicOp::IOP_asfloat, TranslateBitcast, DXIL::OpCode::NumOpCodes},
@@ -5537,6 +5604,7 @@ IntrinsicLower gLowerTable[] = {
     {IntrinsicOp::IOP_msad4, TranslateMSad4, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_mul, TranslateMul, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_normalize, TranslateNormalize, DXIL::OpCode::NumOpCodes},
+    {IntrinsicOp::IOP_or, TranslateOr, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_pack_clamp_s8, TranslatePack, DXIL::OpCode::Pack4x8 },
     {IntrinsicOp::IOP_pack_clamp_u8, TranslatePack, DXIL::OpCode::Pack4x8 },
     {IntrinsicOp::IOP_pack_s8, TranslatePack, DXIL::OpCode::Pack4x8 },
@@ -5551,6 +5619,7 @@ IntrinsicLower gLowerTable[] = {
     {IntrinsicOp::IOP_round, TrivialUnaryOperation, DXIL::OpCode::Round_ne},
     {IntrinsicOp::IOP_rsqrt, TrivialUnaryOperation, DXIL::OpCode::Rsqrt},
     {IntrinsicOp::IOP_saturate, TrivialUnaryOperation, DXIL::OpCode::Saturate},
+    {IntrinsicOp::IOP_select, TranslateSelect, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_sign, TranslateSign, DXIL::OpCode::NumOpCodes},
     {IntrinsicOp::IOP_sin, TrivialUnaryOperation, DXIL::OpCode::Sin},
     {IntrinsicOp::IOP_sincos, EmptyLower, DXIL::OpCode::NumOpCodes},

tools/clang/include/clang/Basic/DiagnosticCommonKinds.td

@@ -66,6 +66,9 @@ def warn_method_param_declaration : Warning<"redeclaration of method parameter %
 def err_invalid_storage_class_in_func_decl : Error<
   "invalid storage class specifier in function declarator">;
 def err_expected_namespace_name : Error<"expected namespace name">;
+// HLSL Change Starts
+def err_hlsl_variadic_templates : Error<"variadic templates are not supported in HLSL">;
+// HLSL Change Ends
 def ext_variadic_templates : ExtWarn<
   "variadic templates are a C++11 extension">, InGroup<CXX11>;
 def warn_cxx98_compat_variadic_templates :

tools/clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -192,4 +192,8 @@ def warn_target_unsupported_nan2008 : Warning<
 def warn_target_unsupported_nanlegacy : Warning<
   "ignoring '-mnan=legacy' option because the '%0' architecture does not support it">,
   InGroup<UnsupportedNan>;
+
+// HLSL Change Starts
+def err_hlsl_invalid_drv_for_operator_overloading : Error<"/enable-operator-overloading is not supported with HLSL Version '%0'">;
+// HLSL Change Ends
 }

tools/clang/include/clang/Basic/DiagnosticGroups.td

@@ -797,4 +797,5 @@ def HLSLPayloadAccessQualifer: DiagGroup<"payload-access-qualifier", [
      HLSLPayloadAccessQualiferPerf,
      HLSLPayloadAccessQualiferCall
   ]>;
+def HLSLSemanticIdentifierCollision : DiagGroup<"semantic-identifier-collision">;
 // HLSL Change Ends

tools/clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1022,6 +1022,9 @@ def warn_hlsl_effect_state_block : Warning <
 def warn_hlsl_effect_technique : Warning <
   "effect technique ignored - effect syntax is deprecated">,
   InGroup< HLSLEffectsSyntax >;
+def warn_hlsl_semantic_identifier_collision : Warning <
+  "'%0' interpreted as semantic; previous definition(s) ignored">,
+  InGroup< HLSLSemanticIdentifierCollision >;
 def err_hlsl_enum : Error<
   "enum is unsupported in HLSL before 2017">;
 

tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -7481,6 +7481,8 @@ def err_hlsl_matrix_member_too_many_positions: Error<
   "more than four positions are referenced in '%0'">;
 def err_hlsl_matrix_member_zero_in_one_based: Error<
   "the digit '0' is used in '%0', but the syntax is for one-based rows and columns">;
+def err_hlsl_overloading_new_delete_operator: Error<
+  "overloading %0 is not allowed">;
 def err_hlsl_vector_member_bad_format: Error<
   "invalid format for vector swizzle '%0'">;
 def err_hlsl_vector_member_empty: Error<
@@ -7746,6 +7748,10 @@ def err_hlsl_load_from_mesh_out_arrays: Error<
    "output arrays of a mesh shader can not be read from">;
 def err_hlsl_out_indices_array_incorrect_access: Error<
    "a vector in out indices array must be accessed as a whole">;
+def err_hlsl_logical_binop_scalar : Error<
+   "operands for short-circuiting logical binary operator must be scalar">;
+def err_hlsl_ternary_scalar : Error<
+   "condition for short-circuiting ternary operator must be scalar">;
 // HLSL Change Ends
 
 // SPIRV Change Starts

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

@@ -149,16 +149,20 @@ class LangOptions : public LangOptionsBase {
 #endif
 
   // HLSL Change Starts
-  unsigned HLSLVersion; 
+  unsigned HLSLVersion = 2018;
   std::string HLSLEntryFunction;
   std::string HLSLProfile;
-  unsigned RootSigMajor;
-  unsigned RootSigMinor;
-  bool IsHLSLLibrary;
-  bool UseMinPrecision; // use min precision, not native precision.
-  bool EnableDX9CompatMode;
-  bool EnableFXCCompatMode;
-  bool EnablePayloadAccessQualifiers;
+  unsigned RootSigMajor = 1;
+  unsigned RootSigMinor = 1;
+  bool IsHLSLLibrary = false;
+  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;
   // HLSL Change Ends
 
   bool SPIRV = false;  // SPIRV Change

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

@@ -680,6 +680,12 @@ def hlsl_version : Separate<["-", "/"], "HV">, Group<f_Group>, Flags<[DriverOpti
   HelpText<"HLSL version (2015, 2016, 2017)">; // 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.">;
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,

tools/clang/include/clang/SPIRV/AstTypeProbe.h

@@ -18,6 +18,13 @@
 namespace clang {
 namespace spirv {
 
+/// Returns a string name for the function if |fn| is not an overloaded
+/// operator. Otherwise, returns the name of the operator. If
+/// |addClassNameWithOperator| is true, adds the name of RecordType that
+/// defines the overloaded operator in front of the operator name.
+std::string getFunctionOrOperatorName(const FunctionDecl *fn,
+                                      bool addClassNameWithOperator);
+
 /// Returns a string name for the given type.
 std::string getAstTypeName(QualType type);
 
@@ -114,6 +121,10 @@ bool isConstantTextureBuffer(QualType);
 /// * SubpassInput(MS)
 bool isResourceType(QualType);
 
+/// \brief Returns true if the given type is a user-defined struct or class
+/// type (not HLSL built-in type).
+bool isUserDefinedRecordType(const ASTContext &, QualType);
+
 /// Returns true if the given type is or contains a 16-bit type.
 /// The caller must also specify whether 16-bit types have been enabled via
 /// command line options.
@@ -240,6 +251,12 @@ bool isRWTexture(QualType);
 /// \brief Returns true if the given type is an HLSL sampler type.
 bool isSampler(QualType);
 
+/// \brief Returns true if the given type is InputPatch.
+bool isInputPatch(QualType type);
+
+/// \brief Returns true if the given type is OutputPatch.
+bool isOutputPatch(QualType type);
+
 /// \brief Returns true if the given type is SubpassInput.
 bool isSubpassInput(QualType);
 

tools/clang/include/clang/Sema/Sema.h

@@ -5507,7 +5507,8 @@ class Sema {
 
   void LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS,
                           QualType ObjectType, bool EnteringContext,
-                          bool &MemberOfUnknownSpecialization);
+                          bool &MemberOfUnknownSpecialization,
+                          bool NextIsLess = false); // HLSL Change - additional special case flag
 
   TemplateNameKind isTemplateName(Scope *S,
                                   CXXScopeSpec &SS,
@@ -5516,7 +5517,8 @@ class Sema {
                                   ParsedType ObjectType,
                                   bool EnteringContext,
                                   TemplateTy &Template,
-                                  bool &MemberOfUnknownSpecialization);
+                                  bool &MemberOfUnknownSpecialization,
+                                  bool NextIsLess = false); // HLSL Change - additional special case flag
 
   bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
                                    SourceLocation IILoc,

tools/clang/lib/CodeGen/CGDebugInfo.cpp

@@ -465,9 +465,6 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::OCLSampler:
   case BuiltinType::OCLEvent:
     llvm_unreachable("No ObjC or OpenCL support");
-  case BuiltinType::LitInt:
-  case BuiltinType::LitFloat:
-    llvm_unreachable("Unsupported HLSL types");
 #endif // HLSL Change - no ObjC or OpenCL support
 
   case BuiltinType::UChar:
@@ -503,6 +500,7 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::Long:
   case BuiltinType::WChar_S:
   case BuiltinType::LongLong:
+  case BuiltinType::LitInt:
     Encoding = llvm::dwarf::DW_ATE_signed;
     break;
   case BuiltinType::Bool:
@@ -517,6 +515,7 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
   case BuiltinType::Double:
+  case BuiltinType::LitFloat:
     Encoding = llvm::dwarf::DW_ATE_float;
     break;
   }

tools/clang/lib/CodeGen/CGExpr.cpp

@@ -3075,9 +3075,8 @@ LValue CodeGenFunction::EmitLValueForField(LValue base,
     const CGBitFieldInfo &Info = RL.getBitFieldInfo(field);
     llvm::Value *Addr = base.getAddress();
     unsigned Idx = RL.getLLVMFieldNo(field);
-    if (Idx != 0)
-      // For structs, we GEP to the field that the record layout suggests.
-      Addr = Builder.CreateStructGEP(nullptr, Addr, Idx, field->getName());
+    // For structs, we GEP to the field that the record layout suggests.
+    Addr = Builder.CreateStructGEP(nullptr, Addr, Idx, field->getName());
     // Get the access type.
     llvm::Type *PtrTy = llvm::Type::getIntNPtrTy(
       getLLVMContext(), Info.StorageSize,