Add builtin types for min precision and half (#1492)

tools/clang/include/clang/AST/ASTContext.h

@@ -838,8 +838,11 @@ public:
   CanQualType OCLImage2dTy, OCLImage2dArrayTy;
   CanQualType OCLImage3dTy;
   CanQualType OCLSamplerTy, OCLEventTy;
-  CanQualType Min12IntTy, Min10FloatTy; // HLSL Change - HLSL-specific types
-  CanQualType LitIntTy, LitFloatTy; // HLSL Change - HLSL-specific types
+  // HLSL Changes begin
+  CanQualType Min12IntTy, Min10FloatTy;
+  CanQualType LitIntTy, LitFloatTy;
+  CanQualType HalfFloatTy, Min16FloatTy, Min16IntTy, Min16UIntTy;
+  // HLSL Changes end
 
   // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
   mutable QualType AutoDeductTy;     // Deduction against 'auto'.

tools/clang/include/clang/AST/BuiltinTypes.def

@@ -81,6 +81,9 @@ UNSIGNED_TYPE(Char32, Char32Ty)
 // 'unsigned short'
 UNSIGNED_TYPE(UShort, UnsignedShortTy)
 
+// HLSL Change - 'min16uint' in HLSL
+UNSIGNED_TYPE(Min16UInt, Min16UIntTy)
+
 // 'unsigned int'
 UNSIGNED_TYPE(UInt, UnsignedIntTy)
 
@@ -122,6 +125,9 @@ SIGNED_TYPE(Int128, Int128Ty)
 // HLSL Change - 'min12int' in HLSL
 SIGNED_TYPE(Min12Int, Min12IntTy)
 
+// HLSL Change - 'min16int' in HLSL
+SIGNED_TYPE(Min16Int, Min16IntTy)
+
 // HLSL Change - literal int in HLSL
 SIGNED_TYPE(LitInt, LitIntTy)
 
@@ -142,6 +148,12 @@ FLOATING_TYPE(LongDouble, LongDoubleTy)
 // HLSL Change - 'min10float' in HLSL
 FLOATING_TYPE(Min10Float, Min10FloatTy)
 
+// HLSL Change - 'min16float' in HLSL
+FLOATING_TYPE(Min16Float, Min16FloatTy)
+
+ // HLSL Change - 'halffloat' in HLSL
+FLOATING_TYPE(HalfFloat, HalfFloatTy)
+
 // HLSL Change - literal float in HLSL
 FLOATING_TYPE(LitFloat, LitFloatTy)
 

tools/clang/include/clang/Basic/Specifiers.h

@@ -46,9 +46,15 @@ namespace clang {
     TST_char32,       // C++11 char32_t
     TST_int,
     TST_int128,
-    TST_min10float,   // HLSL Change - HLSL type
-    TST_min12int,     // HLSL Change - HLSL type
+    // HLSL Changes begin
+    TST_min16float,
+    TST_min16int,
+    TST_min16uint,
+    TST_min10float,
+    TST_min12int,
+    // HLSL Changes end
     TST_half,         // OpenCL half, ARM NEON __fp16
+    TST_halffloat, // HLSL Change
     TST_float,
     TST_double,
     TST_bool,         // _Bool

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

@@ -290,6 +290,10 @@ public:
   static const TST TST_int = clang::TST_int;
   static const TST TST_int128 = clang::TST_int128;
   // HLSL Change Starts
+  static const TST TST_halffloat = clang::TST_halffloat;
+  static const TST TST_min16float = clang::TST_min16float;
+  static const TST TST_min16int = clang::TST_min16int;
+  static const TST TST_min16uint = clang::TST_min16uint;
   static const TST TST_min10float = clang::TST_min10float;
   static const TST TST_min12int = clang::TST_min12int;
   // HLSL Change Ends

tools/clang/lib/AST/ASTContext.cpp

@@ -57,7 +57,7 @@ unsigned ASTContext::NumImplicitDestructors;
 unsigned ASTContext::NumImplicitDestructorsDeclared;
 
 enum FloatingRank {
-  LitFloatRank, Min10FloatRank, HalfRank, FloatRank, DoubleRank, LongDoubleRank // HLSL Change - adds LitFloatRank and Min10FloatRank
+  LitFloatRank, Min10FloatRank, Min16FloatRank, HalfRank, HalfFloatRank, FloatRank, DoubleRank, LongDoubleRank // HLSL Change - adds LitFloatRank, Min10FloatRank, HalfFloat, and Min16FloatRank
 };
 
 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
@@ -1095,7 +1095,11 @@ void ASTContext::InitBuiltinTypes(const TargetInfo &Target) {
   // HLSL Change Starts
   if (LangOpts.HLSL) {
     InitBuiltinType(Min12IntTy, BuiltinType::Min12Int);
+    InitBuiltinType(Min16IntTy, BuiltinType::Min16Int);
+    InitBuiltinType(Min16UIntTy, BuiltinType::Min16UInt);
+    InitBuiltinType(Min16FloatTy, BuiltinType::Min16Float);
     InitBuiltinType(Min10FloatTy, BuiltinType::Min10Float);
+    InitBuiltinType(HalfFloatTy, BuiltinType::HalfFloat);
     InitBuiltinType(LitIntTy, BuiltinType::LitInt);
     InitBuiltinType(LitFloatTy, BuiltinType::LitFloat);
     hlsl::InitializeASTContextForHLSL(*this); // Previously in constructor, guarded by !DelayInitialization
@@ -1318,8 +1322,10 @@ const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   default: llvm_unreachable("Not a floating point type!");
   // HLSL Change Starts
   case BuiltinType::Min10Float:
+  case BuiltinType::Min16Float:
   // HLSL Change Ends
   case BuiltinType::Half:       return Target->getHalfFormat();
+  case BuiltinType::HalfFloat: // HLSL Change
   case BuiltinType::Float:      return Target->getFloatFormat();
   case BuiltinType::Double:     return Target->getDoubleFormat();
   case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
@@ -1608,6 +1614,7 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
       Width = Target->getChar32Width();
       Align = Target->getChar32Align();
       break;
+    case BuiltinType::Min16UInt: // HLSL Change
     case BuiltinType::UShort:
     case BuiltinType::Short:
       Width = Target->getShortWidth();
@@ -1637,6 +1644,7 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
       Width = Target->getHalfWidth();
       Align = Target->getHalfAlign();
       break;
+    case BuiltinType::HalfFloat: // HLSL Change
     case BuiltinType::Float:
       Width = Target->getFloatWidth();
       Align = Target->getFloatAlign();
@@ -1647,10 +1655,12 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
       break;
     // HLSL Change Starts
     case BuiltinType::Min10Float:
+    case BuiltinType::Min16Float:
       Width = 16;
       Align = 16;
       break;
     case BuiltinType::Min12Int:
+    case BuiltinType::Min16Int:
       Width = 16;
       Align = 16;
       break;
@@ -4600,8 +4610,12 @@ static FloatingRank getFloatingRank(QualType T) {
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
-  case BuiltinType::Min10Float: return Min10FloatRank; // HLSL Change
-  case BuiltinType::LitFloat:   return LitFloatRank; // HLSL Change
+  // HLSL Changes begin
+  case BuiltinType::Min10Float: return Min10FloatRank;
+  case BuiltinType::Min16Float: return Min16FloatRank;
+  case BuiltinType::HalfFloat: return HalfFloatRank;
+  case BuiltinType::LitFloat:   return LitFloatRank;
+  // HLSL Changes end
   }
 }
 
@@ -4614,12 +4628,17 @@ QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
     switch (EltRank) {
-    case HalfRank: llvm_unreachable("Complex half is not supported");
     case FloatRank:      return FloatComplexTy;
     case DoubleRank:     return DoubleComplexTy;
     case LongDoubleRank: return LongDoubleComplexTy;
-    case LitFloatRank:   llvm_unreachable("Complex LitFloat is not supported");  // HLSL Change
-    case Min10FloatRank: llvm_unreachable("Complex Min10Float is not supported"); // HLSL Change
+    // HLSL Changes begin
+    case HalfRank:
+    case LitFloatRank:
+    case Min10FloatRank:
+    case Min16FloatRank:
+    case HalfFloatRank:
+      llvm_unreachable("Complex type is not supported in HLSL.");
+    // HLSL Changes end
     }
   }
 
@@ -5462,6 +5481,10 @@ static char getObjCEncodingForPrimitiveKind(const ASTContext *C,
     // HLSL Change Start
     case BuiltinType::Min12Int:
     case BuiltinType::Min10Float:
+    case BuiltinType::Min16Float:
+    case BuiltinType::Min16Int:
+    case BuiltinType::Min16UInt:
+    case BuiltinType::HalfFloat:
     case BuiltinType::LitInt:
     case BuiltinType::LitFloat:
       llvm_unreachable("@encoding HLSL primitive type");

tools/clang/lib/AST/ItaniumMangle.cpp

@@ -2044,6 +2044,10 @@ void CXXNameMangler::mangleType(const BuiltinType *T) {
   case BuiltinType::LitInt: Out << "lit_int"; break;
   case BuiltinType::LitFloat: Out << "lit_float"; break;
   case BuiltinType::Min10Float: Out << "min10_float"; break;
+  case BuiltinType::Min16Float: Out << "min16_float"; break;
+  case BuiltinType::Min16Int: Out << "min16_int"; break;
+  case BuiltinType::Min16UInt: Out << "min16_uint"; break;
+  case BuiltinType::HalfFloat: Out << "half_float"; break;
     // HLSL Change ends
   }
 }

tools/clang/lib/AST/MicrosoftMangle.cpp

@@ -1597,6 +1597,18 @@ void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
   case BuiltinType::Min10Float:
     Out << "$min10f@";
     break;
+  case BuiltinType::Min16Float:
+    Out << "$min16f@";
+    break;
+  case BuiltinType::Min16Int:
+    Out << "$min16i@";
+    break;
+  case BuiltinType::Min16UInt:
+    Out << "$min16ui@";
+    break;
+  case BuiltinType::HalfFloat:
+    Out << "$halff@";
+    break;
   case BuiltinType::Min12Int:
     Out << "$min12i@";
     break;

tools/clang/lib/AST/StmtPrinter.cpp

@@ -1131,7 +1131,9 @@ void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
   case BuiltinType::Char_S:
   case BuiltinType::Char_U:    OS << "i8"; break;
   case BuiltinType::UChar:     OS << "Ui8"; break;
+  case BuiltinType::Min16Int: // HLSL Change
   case BuiltinType::Short:     OS << "i16"; break;
+  case BuiltinType::Min16UInt: // HLSL Change
   case BuiltinType::UShort:    OS << "Ui16"; break;
   case BuiltinType::LitInt:    break; // HLSL Change
   case BuiltinType::Int:       break; // no suffix.
@@ -1164,6 +1166,8 @@ static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
     default: llvm_unreachable("Unexpected type for float literal!");
     case BuiltinType::LitFloat:   break; // HLSL Change -- no suffix
     case BuiltinType::Min10Float: break; // no suffix, as this is a literal and 'F' would pollute expression
+    case BuiltinType::HalfFloat:
+    case BuiltinType::Min16Float:
     case BuiltinType::Half:       OS << 'H'; break; // HLSL Change -- added suffix
     case BuiltinType::Double:     OS << 'L'; break; // HLSL Change -- added suffix
     case BuiltinType::Float:      OS << 'F'; break;

tools/clang/lib/AST/Type.cpp

@@ -2492,7 +2492,10 @@ StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case ULong:             return "unsigned long";
   case ULongLong:         return "unsigned long long";
   case UInt128:           return "unsigned __int128";
-  case Half:              return Policy.Half ? "half" : "__fp16";
+  // HLSL Changes begin
+  case HalfFloat:
+  case Half:              return /*Policy.Half*/ true ? "half" : "__fp16";
+  // HLSL Changes end
   case Float:             return "float";
   case Double:            return "double";
   case LongDouble:        return "long double";
@@ -2521,6 +2524,9 @@ StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case OCLEvent:          return "event_t";
   // HLSL Change Starts
   case Min10Float:        return "min10float";
+  case Min16Float:        return "min16float";
+  case Min16Int:          return "min16int";
+  case Min16UInt:         return "min16uint";
   case Min12Int:          return "min12int";
   case LitFloat:          return "literal float";
   case LitInt:            return "literal int";

tools/clang/lib/AST/TypeLoc.cpp

@@ -321,7 +321,11 @@ TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::Double:
   case BuiltinType::LongDouble:
   // HLSL Change Starts
+  case BuiltinType::HalfFloat:
   case BuiltinType::Min10Float:
+  case BuiltinType::Min16Float:
+  case BuiltinType::Min16Int:
+  case BuiltinType::Min16UInt:
   case BuiltinType::Min12Int:
   case BuiltinType::LitFloat:
   case BuiltinType::LitInt:

tools/clang/lib/CodeGen/CGDebugInfo.cpp

@@ -462,9 +462,7 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::OCLSampler:
   case BuiltinType::OCLEvent:
     llvm_unreachable("No ObjC or OpenCL support");
-  case BuiltinType::Min12Int:
   case BuiltinType::LitInt:
-  case BuiltinType::Min10Float:
   case BuiltinType::LitFloat:
     llvm_unreachable("Unsupported HLSL types");
 #endif // HLSL Change - no ObjC or OpenCL support
@@ -482,6 +480,7 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
     Encoding = llvm::dwarf::DW_ATE_UTF;
     break;
   case BuiltinType::UShort:
+  case BuiltinType::Min16UInt: // HLSL Change
   case BuiltinType::UInt:
   case BuiltinType::UInt128:
   case BuiltinType::ULong:
@@ -489,6 +488,10 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::ULongLong:
     Encoding = llvm::dwarf::DW_ATE_unsigned;
     break;
+  // HLSL Changes begin
+  case BuiltinType::Min12Int:
+  case BuiltinType::Min16Int:
+  // HLSL Changed end
   case BuiltinType::Short:
   case BuiltinType::Int:
   case BuiltinType::Int128:
@@ -500,6 +503,11 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   case BuiltinType::Bool:
     Encoding = llvm::dwarf::DW_ATE_boolean;
     break;
+  // HLSL Changes begin
+  case BuiltinType::Min10Float:
+  case BuiltinType::Min16Float:
+  case BuiltinType::HalfFloat:
+  // HLSL Changes end
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:

tools/clang/lib/CodeGen/CGHLSLMS.cpp

@@ -664,6 +664,7 @@ static CompType::Kind BuiltinTyToCompTy(const BuiltinType *BTy, bool bSNorm,
   case BuiltinType::UInt:
     kind = CompType::Kind::U32;
     break;
+  case BuiltinType::Min16UInt: // HLSL Change
   case BuiltinType::UShort:
     kind = CompType::Kind::U16;
     break;
@@ -673,14 +674,20 @@ static CompType::Kind BuiltinTyToCompTy(const BuiltinType *BTy, bool bSNorm,
   case BuiltinType::Int:
     kind = CompType::Kind::I32;
     break;
+  // HLSL Changes begin
   case BuiltinType::Min12Int:
+  case BuiltinType::Min16Int:
+  // HLSL Changes end
   case BuiltinType::Short:
     kind = CompType::Kind::I16;
     break;
   case BuiltinType::LongLong:
     kind = CompType::Kind::I64;
     break;
+  // HLSL Changes begin
   case BuiltinType::Min10Float:
+  case BuiltinType::Min16Float:
+  // HLSL Changes end
   case BuiltinType::Half:
     if (bSNorm)
       kind = CompType::Kind::SNormF16;
@@ -689,6 +696,7 @@ static CompType::Kind BuiltinTyToCompTy(const BuiltinType *BTy, bool bSNorm,
     else
       kind = CompType::Kind::F16;
     break;
+  case BuiltinType::HalfFloat: // HLSL Change
   case BuiltinType::Float:
     if (bSNorm)
       kind = CompType::Kind::SNormF32;
@@ -1887,10 +1895,14 @@ hlsl::CompType CGMSHLSLRuntime::GetCompType(const BuiltinType *BT) {
   case BuiltinType::Double:
     ElementType = hlsl::CompType::getF64();
     break;
+  case BuiltinType::HalfFloat: // HLSL Change
   case BuiltinType::Float:
     ElementType = hlsl::CompType::getF32();
     break;
+  // HLSL Changes begin
   case BuiltinType::Min10Float:
+  case BuiltinType::Min16Float:
+  // HLSL Changes end
   case BuiltinType::Half:
     ElementType = hlsl::CompType::getF16();
     break;
@@ -1900,7 +1912,10 @@ hlsl::CompType CGMSHLSLRuntime::GetCompType(const BuiltinType *BT) {
   case BuiltinType::LongLong:
     ElementType = hlsl::CompType::getI64();
     break;
+  // HLSL Changes begin
   case BuiltinType::Min12Int:
+  case BuiltinType::Min16Int:
+  // HLSL Changes end
   case BuiltinType::Short:
     ElementType = hlsl::CompType::getI16();
     break;
@@ -1910,6 +1925,7 @@ hlsl::CompType CGMSHLSLRuntime::GetCompType(const BuiltinType *BT) {
   case BuiltinType::ULongLong:
     ElementType = hlsl::CompType::getU64();
     break;
+  case BuiltinType::Min16UInt: // HLSL Change
   case BuiltinType::UShort:
     ElementType = hlsl::CompType::getU16();
     break;

tools/clang/lib/CodeGen/CodeGenTypes.cpp

@@ -405,6 +405,8 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
     case BuiltinType::WChar_U:
     // HLSL Change Starts
     case BuiltinType::Min12Int:
+    case BuiltinType::Min16Int:
+    case BuiltinType::Min16UInt:
     case BuiltinType::LitInt:
     // HLSL Change Ends
     case BuiltinType::Char16:
@@ -414,6 +416,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
       break;
     // HLSL Change Starts
     case BuiltinType::Min10Float:
+    case BuiltinType::Min16Float:
 // OACR error 6287
 #pragma prefast(disable: __WARNING_REDUNDANTTEST, "language options are constants, by design")
     // HLSL Change Ends
@@ -425,6 +428,7 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
                                Context.getLangOpts().HalfArgsAndReturns);
       break;
     case BuiltinType::LitFloat: // HLSL Change
+    case BuiltinType::HalfFloat: // HLSL Change
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

@@ -2369,8 +2369,12 @@ static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
     case BuiltinType::ObjCSel:
       llvm_unreachable("FIXME: Objective-C types are unsupported!");
     case BuiltinType::Min12Int:
+    case BuiltinType::Min16Int:
+    case BuiltinType::Min16UInt:
     case BuiltinType::LitInt:
     case BuiltinType::Min10Float:
+    case BuiltinType::Min16Float:
+    case BuiltinType::HalfFloat:
     case BuiltinType::LitFloat:
       llvm_unreachable("FIXME: HLSL types are unsupported!");
       break;

tools/clang/lib/Index/USRGeneration.cpp

@@ -566,6 +566,7 @@ void USRGenerator::VisitType(QualType T) {
           c = 'q'; break;
         case BuiltinType::Char32:
           c = 'w'; break;
+        case BuiltinType::Min16UInt: // HLSL Change
         case BuiltinType::UShort:
           c = 's'; break;
         case BuiltinType::UInt:
@@ -584,6 +585,7 @@ void USRGenerator::VisitType(QualType T) {
         case BuiltinType::WChar_S:
         case BuiltinType::WChar_U:
           c = 'W'; break;
+        case BuiltinType::Min16Int: // HLSL Change
         case BuiltinType::Short:
           c = 'S'; break;
         case BuiltinType::Int:
@@ -594,6 +596,7 @@ void USRGenerator::VisitType(QualType T) {
           c = 'K'; break;
         case BuiltinType::Int128:
           c = 'J'; break;
+        case BuiltinType::HalfFloat: // HLSL Change
         case BuiltinType::Half:
           c = 'h'; break;
         case BuiltinType::Float:
@@ -604,6 +607,7 @@ void USRGenerator::VisitType(QualType T) {
           c = 'D'; break;
         // HLSL Change Starts
         case BuiltinType::Min10Float:
+        case BuiltinType::Min16Float:
           c = 'r'; break;
         case BuiltinType::Min12Int:
           c = 'R'; break;

tools/clang/lib/SPIRV/SPIRVEmitter.cpp

@@ -2503,6 +2503,8 @@ uint32_t SPIRVEmitter::processFlatConversion(const QualType type,
         case BuiltinType::Int:
         case BuiltinType::Short:
         case BuiltinType::Min12Int:
+        case BuiltinType::Min16Int:
+        case BuiltinType::Min16UInt:
         case BuiltinType::UShort:
         case BuiltinType::UInt:
         case BuiltinType::Long:
@@ -2514,7 +2516,9 @@ uint32_t SPIRVEmitter::processFlatConversion(const QualType type,
         case BuiltinType::Double:
         case BuiltinType::Float:
         case BuiltinType::Half:
+        case BuiltinType::HalfFloat:
         case BuiltinType::Min10Float:
+        case BuiltinType::Min16Float:
           return castToFloat(initId, initType, ty, srcLoc);
         default:
           emitError("flat conversion of type %0 unimplemented", srcLoc)

tools/clang/lib/SPIRV/TypeTranslator.cpp

@@ -82,13 +82,10 @@ bool TypeTranslator::isRelaxedPrecisionType(QualType type,
     if (isScalarType(type, &ty))
       if (const auto *builtinType = ty->getAs<BuiltinType>())
         switch (builtinType->getKind()) {
-        // TODO: Figure out why 'min16float' and 'half' share an enum.
-        // 'half' should not get RelaxedPrecision decoration, but due to the
-        // shared enum, we currently do so.
-        case BuiltinType::Half:
-        case BuiltinType::Short:
-        case BuiltinType::UShort:
         case BuiltinType::Min12Int:
+        case BuiltinType::Min16Int:
+        case BuiltinType::Min16UInt:
+        case BuiltinType::Min16Float:
         case BuiltinType::Min10Float: {
           // If '-enable-16bit-types' options is enabled, these types are
           // translated to real 16-bit type, and therefore are not
@@ -438,13 +435,24 @@ uint32_t TypeTranslator::getElementSpirvBitwidth(QualType type) {
     case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
       return 64;
-    // min16int (short), ushort, min12int, half, and min10float are treated as
-    // 16-bit if '-enable-16bit-types' option is enabled. They are treated as
-    // 32-bit otherwise.
+    // Half builtin type is always 16-bit. The HLSL 'half' keyword is translated
+    // to 'Half' enum if -enable-16bit-types is true.
+    // int16_t and uint16_t map to Short and UShort
+    case BuiltinType::Half:
     case BuiltinType::Short:
     case BuiltinType::UShort:
+      return 16;
+    // HalfFloat builtin type is just an alias for Float builtin type and is
+    // always 32-bit. The HLSL 'half' keyword is translated to 'HalfFloat' enum
+    // if -enable-16bit-types is false.
+    case BuiltinType::HalfFloat:
+      return 32;
+    // The following types are treated as 16-bit if '-enable-16bit-types' option
+    // is enabled. They are treated as 32-bit otherwise.
     case BuiltinType::Min12Int:
-    case BuiltinType::Half:
+    case BuiltinType::Min16Int:
+    case BuiltinType::Min16UInt:
+    case BuiltinType::Min16Float:
     case BuiltinType::Min10Float: {
       return spirvOptions.enable16BitTypes ? 16 : 32;
     }
@@ -511,14 +519,18 @@ uint32_t TypeTranslator::translateType(QualType type, LayoutRule rule) {
         case BuiltinType::Int:
         case BuiltinType::UInt:
         case BuiltinType::Short:
-        case BuiltinType::Min12Int:
         case BuiltinType::UShort:
+        case BuiltinType::Min12Int:
+        case BuiltinType::Min16Int:
+        case BuiltinType::Min16UInt:
         case BuiltinType::LongLong:
         case BuiltinType::ULongLong:
         // All the floats
-        case BuiltinType::Float:
         case BuiltinType::Double:
+        case BuiltinType::Float:
         case BuiltinType::Half:
+        case BuiltinType::HalfFloat:
+        case BuiltinType::Min16Float:
         case BuiltinType::Min10Float: {
           const auto bitwidth = getElementSpirvBitwidth(ty);
           return getTypeWithCustomBitwidth(ty, bitwidth);
@@ -778,13 +790,19 @@ bool TypeTranslator::isOrContains16BitType(QualType type) {
     if (isScalarType(type, &ty)) {
       if (const auto *builtinType = ty->getAs<BuiltinType>()) {
         switch (builtinType->getKind()) {
+        case BuiltinType::Min12Int:
+        case BuiltinType::Min16Int:
+        case BuiltinType::Min16UInt:
+        case BuiltinType::Min10Float:
+        case BuiltinType::Min16Float:
+          return spirvOptions.enable16BitTypes;
+        // the 'Half' enum always represents 16-bit and 'HalfFloat' always
+        // represents 32-bit floats.
+        // int16_t and uint16_t map to Short and UShort
         case BuiltinType::Short:
         case BuiltinType::UShort:
-        case BuiltinType::Min12Int:
         case BuiltinType::Half:
-        case BuiltinType::Min10Float: {
-          return spirvOptions.enable16BitTypes;
-        }
+          return true;
         default:
           return false;
         }
@@ -1802,16 +1820,25 @@ TypeTranslator::getAlignmentAndSize(QualType type, LayoutRule rule,
         case BuiltinType::LongLong:
         case BuiltinType::ULongLong:
           return {8, 8};
-        case BuiltinType::Short:
-        case BuiltinType::UShort:
         case BuiltinType::Min12Int:
-        case BuiltinType::Half:
+        case BuiltinType::Min16Int:
+        case BuiltinType::Min16UInt:
+        case BuiltinType::Min16Float:
         case BuiltinType::Min10Float: {
           if (spirvOptions.enable16BitTypes)
             return {2, 2};
           else
             return {4, 4};
         }
+        // the 'Half' enum always represents 16-bit floats.
+        // int16_t and uint16_t map to Short and UShort.
+        case BuiltinType::Short:
+        case BuiltinType::UShort:
+        case BuiltinType::Half:
+          return {2, 2};
+        // 'HalfFloat' always represents 32-bit floats.
+        case BuiltinType::HalfFloat:
+          return {4, 4};
         default:
           emitError("alignment and size calculation for type %0 unimplemented")
               << type;
@@ -1990,9 +2017,16 @@ std::string TypeTranslator::getName(QualType type) {
         case BuiltinType::UShort:
           return "ushort";
         case BuiltinType::Half:
+        case BuiltinType::HalfFloat:
           return "half";
         case BuiltinType::Min12Int:
           return "min12int";
+        case BuiltinType::Min16Int:
+          return "min16int";
+        case BuiltinType::Min16UInt:
+          return "min16uint";
+        case BuiltinType::Min16Float:
+          return "min16float";
         case BuiltinType::Min10Float:
           return "min10float";
         default:

tools/clang/lib/Sema/DeclSpec.cpp

@@ -310,6 +310,10 @@ bool Declarator::isDeclarationOfFunction() const {
     case TST_void:
     case TST_wchar:
     // HLSL Change Starts
+    case TST_halffloat:
+    case TST_min16float:
+    case TST_min16int:
+    case TST_min16uint:
     case TST_min10float:
     case TST_min12int:
     // HLSL Change Ends
@@ -459,8 +463,12 @@ const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_int:         return "int";
   case DeclSpec::TST_int128:      return "__int128";
   // HLSL Change Starts
+  case DeclSpec::TST_min16float:  return "min16float";
+  case DeclSpec::TST_min16int:    return "min16int";
+  case DeclSpec::TST_min16uint:   return "min16uint";
   case DeclSpec::TST_min10float:  return "min10float";
   case DeclSpec::TST_min12int:    return "min12int";
+  case DeclSpec::TST_halffloat:
     // HLSL Change Ends
   case DeclSpec::TST_half:        return "half";
   case DeclSpec::TST_float:       return "float";

tools/clang/lib/Sema/SemaHLSL.cpp

@@ -263,6 +263,7 @@ enum ArBasicKind {
 
 #define GET_BPROP_PRIM_KIND(_Props) \
     ((_Props) & (BPROP_BOOLEAN | BPROP_INTEGER | BPROP_FLOATING))
+
 #define GET_BPROP_PRIM_KIND_SU(_Props) \
     ((_Props) & (BPROP_BOOLEAN | BPROP_INTEGER | BPROP_FLOATING | BPROP_UNSIGNED))
 
@@ -278,9 +279,11 @@ enum ArBasicKind {
 #define IS_BPROP_SINT(_Props) \
     (((_Props) & (BPROP_INTEGER | BPROP_UNSIGNED | BPROP_BOOLEAN)) == \
      BPROP_INTEGER)
+
 #define IS_BPROP_UINT(_Props) \
     (((_Props) & (BPROP_INTEGER | BPROP_UNSIGNED | BPROP_BOOLEAN)) == \
      (BPROP_INTEGER | BPROP_UNSIGNED))
+
 #define IS_BPROP_AINT(_Props) \
     (((_Props) & (BPROP_INTEGER | BPROP_BOOLEAN)) == BPROP_INTEGER)
 
@@ -1749,173 +1752,140 @@ inline void AssignOpt(T value, _Out_opt_ T* ptr)
   }
 }
 
-static bool CombineBasicTypes(
-  ArBasicKind LeftKind,
-  ArBasicKind RightKind,
-  _Out_ ArBasicKind* pOutKind,
-  _Out_opt_ CastKind* leftCastKind = nullptr,
-  _Out_opt_ CastKind* rightCastKind = nullptr)
-{
-  AssignOpt(CastKind::CK_NoOp, leftCastKind);
-  AssignOpt(CastKind::CK_NoOp, rightCastKind);
-
-  if ((LeftKind < 0 || LeftKind >= AR_BASIC_COUNT) ||
-      (RightKind < 0 || RightKind >= AR_BASIC_COUNT)) {
-    return false;
-  }
-
-  if (LeftKind == RightKind) {
-    *pOutKind = LeftKind;
-    return true;
-  }
-
-  UINT uLeftProps = GetBasicKindProps(LeftKind);
-  UINT uRightProps = GetBasicKindProps(RightKind);
-
-  UINT uBits = GET_BPROP_BITS(uLeftProps) > GET_BPROP_BITS(uRightProps) ?
-    GET_BPROP_BITS(uLeftProps) : GET_BPROP_BITS(uRightProps);
-  UINT uBothFlags = uLeftProps & uRightProps;
-  UINT uEitherFlags = uLeftProps | uRightProps;
-
-  if ((BPROP_BOOLEAN & uBothFlags) != 0)
-  {
-    *pOutKind = AR_BASIC_BOOL;
-    return true;
-  }
-
-  if ((BPROP_LITERAL & uBothFlags) != 0)
-  {
-    if ((BPROP_INTEGER & uBothFlags) != 0)
-    {
-      *pOutKind = AR_BASIC_LITERAL_INT;
-    }
-    else
-    {
-      *pOutKind = AR_BASIC_LITERAL_FLOAT;
-    }
-    return true;
-  }
-
-  if ((BPROP_UNSIGNED & uBothFlags) != 0)
-  {
-    switch (uBits)
-    {
-    case BPROP_BITS8:  *pOutKind = AR_BASIC_UINT8;  break;
-    case BPROP_BITS16: (uEitherFlags & BPROP_MIN_PRECISION) ?
-      *pOutKind = AR_BASIC_MIN16UINT : *pOutKind = AR_BASIC_UINT16; break;
-    case BPROP_BITS32: *pOutKind = AR_BASIC_UINT32; break;
-    case BPROP_BITS64: *pOutKind = AR_BASIC_UINT64; break;
-    default: DXASSERT_NOMSG(false);   break;
-    }
-    AssignOpt(CK_IntegralCast, leftCastKind);
-    AssignOpt(CK_IntegralCast, rightCastKind);
-    return true;
-  }
-
-  if ((BPROP_INTEGER & uBothFlags) != 0)
-  {
-    if ((BPROP_UNSIGNED & uEitherFlags) != 0)
-    {
-      switch (uBits)
-      {
-      case BPROP_BITS8:  *pOutKind = AR_BASIC_UINT8;     break;
-      case BPROP_BITS16: (uEitherFlags & BPROP_MIN_PRECISION) ?
-        *pOutKind = AR_BASIC_MIN16UINT : *pOutKind = AR_BASIC_UINT16; break;
-      case BPROP_BITS32: *pOutKind = AR_BASIC_UINT32;    break;
-      case BPROP_BITS64: *pOutKind = AR_BASIC_UINT64;    break;
-      default: DXASSERT_NOMSG(false);   break;
-      }
-    }
-    else
-    {
-      switch (uBits)
-      {
-      case BPROP_BITS0:  *pOutKind = AR_BASIC_LITERAL_INT; break;
-      case BPROP_BITS8:  *pOutKind = AR_BASIC_INT8;        break;
-      case BPROP_BITS12: *pOutKind = AR_BASIC_MIN12INT;    break;
-      case BPROP_BITS16: (uEitherFlags & BPROP_MIN_PRECISION) ?
-        *pOutKind = AR_BASIC_MIN16INT : *pOutKind = AR_BASIC_INT16; break;
-      case BPROP_BITS32: *pOutKind = AR_BASIC_INT32;       break;
-      case BPROP_BITS64: *pOutKind = AR_BASIC_INT64;       break;
-      default: DXASSERT_NOMSG(false);  break;
-      }
-    }
-    AssignOpt(CK_IntegralCast, leftCastKind);
-    AssignOpt(CK_IntegralCast, rightCastKind);
-    return true;
-  }
-
-  // At least one side is floating-point. Assume both are and fix later
-  // in this function.
-  DXASSERT_NOMSG((BPROP_FLOATING & uEitherFlags) != 0);
-  AssignOpt(CK_FloatingCast, leftCastKind);
-  AssignOpt(CK_FloatingCast, rightCastKind);
-
-  if ((BPROP_FLOATING & uBothFlags) == 0)
-  {
-    // One side is floating-point and one isn't,
-    // convert to the floating-point type.
-    if ((BPROP_FLOATING & uLeftProps) != 0)
-    {
-      uBits = GET_BPROP_BITS(uLeftProps);
-      AssignOpt(CK_IntegralToFloating, rightCastKind);
-    }
-    else
-    {
-      DXASSERT_NOMSG((BPROP_FLOATING & uRightProps) != 0);
-      uBits = GET_BPROP_BITS(uRightProps);
-      AssignOpt(CK_IntegralToFloating, leftCastKind);
-    }
-
-    if (uBits == 0)
-    {
-      // We have a literal plus a non-literal so drop
-      // any literalness.
-      uBits = BPROP_BITS32;
-    }
-  }
-
-  switch (uBits)
-  {
-  case BPROP_BITS10:
-    *pOutKind = AR_BASIC_MIN10FLOAT;
-    break;
-  case BPROP_BITS16:
-    if ((uEitherFlags & BPROP_MIN_PRECISION) != 0)
-    {
-      *pOutKind = AR_BASIC_MIN16FLOAT;
-    }
-    else
-    {
-      *pOutKind = AR_BASIC_FLOAT16;
-    }
-    break;
-  case BPROP_BITS32:
-    if ((uEitherFlags & BPROP_LITERAL) != 0 &&
-      (uEitherFlags & BPROP_PARTIAL_PRECISION) != 0)
-    {
-      *pOutKind = AR_BASIC_FLOAT32_PARTIAL_PRECISION;
-    }
-    else if ((uBothFlags & BPROP_PARTIAL_PRECISION) != 0)
-    {
-      *pOutKind = AR_BASIC_FLOAT32_PARTIAL_PRECISION;
-    }
-    else
-    {
-      *pOutKind = AR_BASIC_FLOAT32;
-    }
-    break;
-  case BPROP_BITS64:
-    *pOutKind = AR_BASIC_FLOAT64;
-    break;
-  default:
-    DXASSERT(false, "unexpected bit count");
-    *pOutKind = AR_BASIC_FLOAT32;
-    break;
-  }
-
-  return true;
-}
+static bool CombineBasicTypes(ArBasicKind LeftKind,
+                              ArBasicKind RightKind,
+                              _Out_ ArBasicKind* pOutKind)
+{
+  if ((LeftKind < 0 || LeftKind >= AR_BASIC_COUNT) ||
+    (RightKind < 0 || RightKind >= AR_BASIC_COUNT)) {
+    return false;
+  }
+
+  if (LeftKind == RightKind) {
+    *pOutKind = LeftKind;
+    return true;
+  }
+
+  UINT uLeftProps = GetBasicKindProps(LeftKind);
+  UINT uRightProps = GetBasicKindProps(RightKind);
+  UINT uBits = GET_BPROP_BITS(uLeftProps) > GET_BPROP_BITS(uRightProps) ?
+               GET_BPROP_BITS(uLeftProps) : GET_BPROP_BITS(uRightProps);
+  UINT uBothFlags = uLeftProps & uRightProps;
+  UINT uEitherFlags = uLeftProps | uRightProps;
+
+  // Notes: all numeric types have either BPROP_FLOATING or BPROP_INTEGER (even bool)
+  //        unsigned only applies to non-literal ints, not bool or enum
+  //        literals, bool, and enum are all BPROP_BITS0
+  if (uBothFlags & BPROP_BOOLEAN) {
+    *pOutKind = AR_BASIC_BOOL;
+    return true;
+  }
+
+  bool bFloatResult = 0 != (uEitherFlags & BPROP_FLOATING);
+  if (uBothFlags & BPROP_LITERAL) {
+    *pOutKind = bFloatResult ? AR_BASIC_LITERAL_FLOAT : AR_BASIC_LITERAL_INT;
+    return true;
+  }
+
+  // Starting approximation of result properties:
+  // - float if either are float, otherwise int (see Notes above)
+  // - min/partial precision if both have same flag
+  // - if not float, add unsigned if either is unsigned
+  UINT uResultFlags =
+    (uBothFlags & (BPROP_INTEGER | BPROP_MIN_PRECISION | BPROP_PARTIAL_PRECISION)) |
+    (uEitherFlags & BPROP_FLOATING) |
+    (!bFloatResult ? (uEitherFlags & BPROP_UNSIGNED) : 0);
+
+  // If one is literal/bool/enum, use min/partial precision from the other
+  if (uEitherFlags & (BPROP_LITERAL | BPROP_BOOLEAN | BPROP_ENUM)) {
+    uResultFlags |= uEitherFlags & (BPROP_MIN_PRECISION | BPROP_PARTIAL_PRECISION);
+  }
+
+  // Now if we have partial precision, we know the result must be half
+  if (uResultFlags & BPROP_PARTIAL_PRECISION) {
+    *pOutKind = AR_BASIC_FLOAT32_PARTIAL_PRECISION;
+    return true;
+  }
+
+  // uBits are already initialized to max of either side, so now:
+  // if only one is float, get result props from float side
+  //  min16float + int -> min16float
+  //  also take min precision from that side
+  if (bFloatResult && 0 == (uBothFlags & BPROP_FLOATING)) {
+    uResultFlags = (uLeftProps & BPROP_FLOATING) ? uLeftProps : uRightProps;
+    uBits = GET_BPROP_BITS(uResultFlags);
+    uResultFlags &= ~BPROP_LITERAL;
+  }
+
+  bool bMinPrecisionResult = uResultFlags & BPROP_MIN_PRECISION;
+
+  // if uBits is 0 here, upgrade to 32-bits
+  // this happens if bool, literal or enum on both sides,
+  // or if float came from literal side
+  if (uBits == BPROP_BITS0)
+    uBits = BPROP_BITS32;
+
+  DXASSERT(uBits != BPROP_BITS0, "CombineBasicTypes: uBits should not be zero at this point");
+  DXASSERT(uBits != BPROP_BITS8, "CombineBasicTypes: 8-bit types not supported at this time");
+
+  if (bMinPrecisionResult) {
+    DXASSERT(uBits < BPROP_BITS32, "CombineBasicTypes: min-precision result must be less than 32-bits");
+  } else {
+    DXASSERT(uBits > BPROP_BITS12, "CombineBasicTypes: 10 or 12 bit result must be min precision");
+  }
+  if (bFloatResult) {
+    DXASSERT(uBits != BPROP_BITS12, "CombineBasicTypes: 12-bit result must be int");
+  } else {
+    DXASSERT(uBits != BPROP_BITS10, "CombineBasicTypes: 10-bit result must be float");
+  }
+  if (uBits == BPROP_BITS12) {
+    DXASSERT(!(uResultFlags & BPROP_UNSIGNED), "CombineBasicTypes: 12-bit result must not be unsigned");
+  }
+
+  if (bFloatResult) {
+    switch (uBits) {
+    case BPROP_BITS10:
+      *pOutKind = AR_BASIC_MIN10FLOAT;
+      break;
+    case BPROP_BITS16:
+      *pOutKind = bMinPrecisionResult ? AR_BASIC_MIN16FLOAT : AR_BASIC_FLOAT16;
+      break;
+    case BPROP_BITS32:
+      *pOutKind = AR_BASIC_FLOAT32;
+      break;
+    case BPROP_BITS64:
+      *pOutKind = AR_BASIC_FLOAT64;
+      break;
+    default:
+      DXASSERT(false, "Unexpected bit count for float result");
+      break;
+    }
+  } else {
+    // int or unsigned int
+    switch (uBits) {
+    case BPROP_BITS12:
+      *pOutKind = AR_BASIC_MIN12INT;
+      break;
+    case BPROP_BITS16:
+      if (uResultFlags & BPROP_UNSIGNED)
+        *pOutKind = bMinPrecisionResult ? AR_BASIC_MIN16UINT : AR_BASIC_UINT16;
+      else
+        *pOutKind = bMinPrecisionResult ? AR_BASIC_MIN16INT : AR_BASIC_INT16;
+      break;
+    case BPROP_BITS32:
+      *pOutKind = (uResultFlags & BPROP_UNSIGNED) ? AR_BASIC_UINT32 : AR_BASIC_INT32;
+      break;
+    case BPROP_BITS64:
+      *pOutKind = (uResultFlags & BPROP_UNSIGNED) ? AR_BASIC_UINT64 : AR_BASIC_INT64;
+      break;
+    default:
+      DXASSERT(false, "Unexpected bit count for int result");
+      break;
+    }
+  }
+
+  return true;
+}
 
 class UsedIntrinsicStore : public std::set<UsedIntrinsic>
 {
@@ -3378,16 +3348,20 @@ public:
       case BuiltinType::Bool: return AR_BASIC_BOOL;
       case BuiltinType::Double: return AR_BASIC_FLOAT64;
       case BuiltinType::Float: return AR_BASIC_FLOAT32;
-      case BuiltinType::Half: return m_context->getLangOpts().UseMinPrecision ? AR_BASIC_MIN16FLOAT : AR_BASIC_FLOAT16;
+      case BuiltinType::Half: return AR_BASIC_FLOAT16;
+      case BuiltinType::HalfFloat: return AR_BASIC_FLOAT32_PARTIAL_PRECISION;
       case BuiltinType::Int: return AR_BASIC_INT32;
       case BuiltinType::UInt: return AR_BASIC_UINT32;
-      case BuiltinType::Short: return m_context->getLangOpts().UseMinPrecision ? AR_BASIC_MIN16INT : AR_BASIC_INT16;
-      case BuiltinType::UShort: return m_context->getLangOpts().UseMinPrecision ? AR_BASIC_MIN16UINT : AR_BASIC_UINT16;
+      case BuiltinType::Short: return AR_BASIC_INT16;
+      case BuiltinType::UShort: return AR_BASIC_UINT16;
       case BuiltinType::Long: return AR_BASIC_INT32;
       case BuiltinType::ULong: return AR_BASIC_UINT32;
       case BuiltinType::LongLong: return AR_BASIC_INT64;
       case BuiltinType::ULongLong: return AR_BASIC_UINT64;
       case BuiltinType::Min12Int: return AR_BASIC_MIN12INT;
+      case BuiltinType::Min16Float: return AR_BASIC_MIN16FLOAT;
+      case BuiltinType::Min16Int: return AR_BASIC_MIN16INT;
+      case BuiltinType::Min16UInt: return AR_BASIC_MIN16UINT;
       case BuiltinType::Min10Float: return AR_BASIC_MIN10FLOAT;
       case BuiltinType::LitFloat: return AR_BASIC_LITERAL_FLOAT;
       case BuiltinType::LitInt: return AR_BASIC_LITERAL_INT;
@@ -3454,7 +3428,7 @@ public:
     switch (kind) {
     case AR_BASIC_BOOL:           return HLSLScalarType_bool;
     case AR_BASIC_LITERAL_FLOAT:  return HLSLScalarType_float_lit;
-    case AR_BASIC_FLOAT16:        return HLSLScalarType_float_min16;
+    case AR_BASIC_FLOAT16:        return HLSLScalarType_half;
     case AR_BASIC_FLOAT32_PARTIAL_PRECISION:
                                   return HLSLScalarType_float;
     case AR_BASIC_FLOAT32:        return HLSLScalarType_float;
@@ -3488,7 +3462,7 @@ public:
     case AR_BASIC_BOOL:           return m_context->BoolTy;
     case AR_BASIC_LITERAL_FLOAT:  return m_context->LitFloatTy;
     case AR_BASIC_FLOAT16:        return m_context->HalfTy;
-    case AR_BASIC_FLOAT32_PARTIAL_PRECISION: return m_context->FloatTy;
+    case AR_BASIC_FLOAT32_PARTIAL_PRECISION: return m_context->HalfFloatTy;
     case AR_BASIC_FLOAT32:        return m_context->FloatTy;
     case AR_BASIC_FLOAT64:        return m_context->DoubleTy;
     case AR_BASIC_LITERAL_INT:    return m_context->LitIntTy;
@@ -4518,14 +4492,14 @@ void HLSLExternalSource::AddBaseTypes()
   m_baseTypes[HLSLScalarType_int] = m_context->IntTy;
   m_baseTypes[HLSLScalarType_uint] = m_context->UnsignedIntTy;
   m_baseTypes[HLSLScalarType_dword] = m_context->UnsignedIntTy;
-  m_baseTypes[HLSLScalarType_half] = m_context->getLangOpts().UseMinPrecision ? m_context->FloatTy : m_context->HalfTy;
+  m_baseTypes[HLSLScalarType_half] = m_context->getLangOpts().UseMinPrecision ? m_context->HalfFloatTy : m_context->HalfTy;
   m_baseTypes[HLSLScalarType_float] = m_context->FloatTy;
   m_baseTypes[HLSLScalarType_double] = m_context->DoubleTy;
-  m_baseTypes[HLSLScalarType_float_min10] = m_context->HalfTy;
-  m_baseTypes[HLSLScalarType_float_min16] = m_context->HalfTy;
-  m_baseTypes[HLSLScalarType_int_min12] = m_context->ShortTy;
-  m_baseTypes[HLSLScalarType_int_min16] = m_context->ShortTy;
-  m_baseTypes[HLSLScalarType_uint_min16] = m_context->UnsignedShortTy;
+  m_baseTypes[HLSLScalarType_float_min10] = m_context->Min10FloatTy;
+  m_baseTypes[HLSLScalarType_float_min16] = m_context->Min16FloatTy;
+  m_baseTypes[HLSLScalarType_int_min12] = m_context->Min12IntTy;
+  m_baseTypes[HLSLScalarType_int_min16] = m_context->Min16IntTy;
+  m_baseTypes[HLSLScalarType_uint_min16] = m_context->Min16UIntTy;
   m_baseTypes[HLSLScalarType_float_lit] = m_context->LitFloatTy;
   m_baseTypes[HLSLScalarType_int_lit] = m_context->LitIntTy;
   m_baseTypes[HLSLScalarType_int16] = m_context->ShortTy;
@@ -8062,7 +8036,7 @@ void HLSLExternalSource::CheckBinOpForHLSL(
     if (BinaryOperatorKindIsLogical(Opc)) {
       resultElementKind = AR_BASIC_BOOL;
     } else if (!BinaryOperatorKindIsBitwiseShift(Opc) && leftElementKind != rightElementKind) {
-      if (!CombineBasicTypes(leftElementKind, rightElementKind, &resultElementKind, nullptr, nullptr)) {
+      if (!CombineBasicTypes(leftElementKind, rightElementKind, &resultElementKind)) {
         m_sema->Diag(OpLoc, diag::err_hlsl_type_mismatch);
         return;
       }
@@ -8325,7 +8299,7 @@ clang::QualType HLSLExternalSource::CheckVectorConditional(
   ArBasicKind resultElementKind = leftElementKind;
   // Combine LHS and RHS element types for computation.
   if (leftElementKind != rightElementKind) {
-    if (!CombineBasicTypes(leftElementKind, rightElementKind, &resultElementKind, nullptr, nullptr)) {
+    if (!CombineBasicTypes(leftElementKind, rightElementKind, &resultElementKind)) {
       m_sema->Diag(QuestionLoc, diag::err_hlsl_conditional_result_comptype_mismatch);
       return QualType();
     }

tools/clang/lib/Sema/SemaOverload.cpp

@@ -1919,15 +1919,18 @@ bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
         return true;
 
       // HLSL Change Starts
+      // TODO: Update this for new builtin types min16float, min16int, min16uint.
       if (getLangOpts().HLSL) {
         if (FromBuiltin->getKind() == BuiltinType::LitFloat &&
             (ToBuiltin->getKind() == BuiltinType::Min10Float ||
+              ToBuiltin->getKind() == BuiltinType::HalfFloat ||
              ToBuiltin->getKind() == BuiltinType::Float ||
              ToBuiltin->getKind() == BuiltinType::Half ||
              ToBuiltin->getKind() == BuiltinType::Double))
           return true;
         if (FromBuiltin->getKind() == BuiltinType::Min10Float &&
             (ToBuiltin->getKind() == BuiltinType::Float ||
+             ToBuiltin->getKind() == BuiltinType::HalfFloat ||
              ToBuiltin->getKind() == BuiltinType::Half ||
              ToBuiltin->getKind() == BuiltinType::Double))
           return true;

tools/clang/lib/Sema/SemaTemplateVariadic.cpp

@@ -725,6 +725,7 @@ bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   case TST_int:
   case TST_int128:
   case TST_half:
+  case TST_halffloat: // HLSL Change
   case TST_float:
   case TST_double:
   case TST_bool:
@@ -741,6 +742,9 @@ bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   case TST_unknown_anytype:
   case TST_error:
   // HLSL Change Start
+  case TST_min16float:
+  case TST_min16int:
+  case TST_min16uint:
   case TST_min10float:
   case TST_min12int:
   // HLSL Change End

tools/clang/lib/Sema/SemaType.cpp

@@ -1334,6 +1334,10 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
   case DeclSpec::TST_half: Result = Context.HalfTy; break;
   case DeclSpec::TST_float: Result = Context.FloatTy; break;
     // HLSL Change Starts
+  case DeclSpec::TST_halffloat: Result = Context.HalfFloatTy; break;
+  case DeclSpec::TST_min16float: Result = Context.Min16FloatTy; break;
+  case DeclSpec::TST_min16int: Result = Context.Min16IntTy; break;
+  case DeclSpec::TST_min16uint: Result = Context.Min16UIntTy; break;
   case DeclSpec::TST_min10float: Result = Context.Min10FloatTy; break;
   case DeclSpec::TST_min12int: Result = Context.Min12IntTy; break;
     // HLSL Change Ends

tools/clang/test/CodeGenHLSL/quick-test/function_overload_floats.hlsl

@@ -0,0 +1,21 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+}} = call half @dx.op.loadInput.f16(i32 4, i32 3, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call half @dx.op.loadInput.f16(i32 4, i32 2, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)
+// CHECK: entry
+
+float4 foo(float v0, float v1, float v2, float v3) { return float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+half4 foo(half v0, half v1, half v2, half v3) { return half4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min16float4 foo(min16float v0, min16float v1, min16float v2, min16float v3) { return min16float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min10float4 foo(min10float v0, min10float v1, min10float v2, min10float v3) { return min10float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+
+[RootSignature("")]
+float4 main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vf, vf, vf, vf) + foo(vh, vh, vh, vh) + foo(vm16, vm16, vm16, vm16) + foo(vm10, vm10, vm10, vm10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_floats_16bitflag.hlsl

@@ -0,0 +1,21 @@
+// RUN: %dxc -enable-16bit-types /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+}} = call half @dx.op.loadInput.f16(i32 4, i32 3, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call half @dx.op.loadInput.f16(i32 4, i32 2, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call half @dx.op.loadInput.f16(i32 4, i32 1, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)
+// CHECK: entry
+
+float4 foo(float v0, float v1, float v2, float v3) { return float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+half4 foo(half v0, half v1, half v2, half v3) { return half4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min16float4 foo(min16float v0, min16float v1, min16float v2, min16float v3) { return min16float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min10float4 foo(min10float v0, min10float v1, min10float v2, min10float v3) { return min10float4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+
+[RootSignature("")]
+float4 main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vf, vf, vf, vf) + foo(vh, vh, vh, vh) + foo(vm16, vm16, vm16, vm16) + foo(vm10, vm10, vm10, vm10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_ints.hlsl

@@ -0,0 +1,23 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+}} = call i16 @dx.op.loadInput.i16(i32 4, i32 4, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call i16 @dx.op.loadInput.i16(i32 4, i32 3, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call i16 @dx.op.loadInput.i16(i32 4, i32 2, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call i32 @dx.op.loadInput.i32(i32 4, i32 1, i32 0, i8 0, i32 undef)
+// CHECK: %{{[a-z0-9]+}} = call i32 @dx.op.loadInput.i32(i32 4, i32 0, i32 0, i8 0, i32 undef)
+// CHECK: entry
+
+int4 foo(int v0, int v1, int v2, int v3) { return int4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+uint4 foo(uint v0, uint v1, uint v2, uint v3) { return uint4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min16int4 foo(min16int v0, min16int v1, min16int v2, min16int v3) { return min16int4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min12int4 foo(min12int v0, min12int v1, min12int v2, min12int v3) { return min12int4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+min16uint4 foo(min16uint v0, min16uint v1, min16uint v2, min16uint v3) { return min16uint4(v0, v0 * v1, v0 * v1 * v2, v0 * v1 * v2 * v3); }
+
+float4 main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vi, vi, vi, vi) + foo(vui, vui, vui, vui) + foo(vm16i, vm16i, vm16i, vm16i) + foo(vm12i, vm12i, vm12i, vm12i) + foo(vm16ui, vm16ui, vm16ui, vm16ui);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_float.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = frem fast float %{{[a-z0-9]+.*[a-z0-9]*}}, 1.000000e+01
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fdiv fast float %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vf, vf % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_float_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = frem fast float %{{[a-z0-9]+.*[a-z0-9]*}}, 1.000000e+01
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fdiv fast float %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+  : A, half vh
+  : B, min16float vm16
+  : C, min10float vm10
+  : D) : SV_Target{
+    return foo(vf, vf % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_half.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fmul fast float %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+  : A, half vh
+  : B, min16float vm16
+  : C, min10float vm10
+  : D) : SV_Target{
+    return foo(vh, vh % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_half_16bitflag.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fmul fast half %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+  : A, half vh
+  : B, min16float vm16
+  : C, min10float vm10
+  : D) : SV_Target{
+    return foo(vh, vh % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_int.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = sdiv i32 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vi, vi % 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_int_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = sdiv i32 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vi, vi % 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min10float.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fsub fast half %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vm10, vm10 % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min10float_16bitflag.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fsub fast half %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vm10, vm10 % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min12int.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = sub nsw i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm12i, vm12i >> 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min12int_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = sub nsw i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm12i, vm12i >> 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16float.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fadd fast half %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vm16, vm16 % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16float_16bitflag.hlsl

@@ -0,0 +1,18 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = fadd fast half %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+float foo(float v0, float v1) { return v0 / v1; }
+half foo(half v0, half v1) { return v0 * v1; }
+min16float foo(min16float v0, min16float v1) { return v0 + v1; }
+min10float foo(min10float v0, min10float v1) { return v0 - v1; }
+
+[RootSignature("")]
+float main(float vf
+                                : A, half vh
+                                : B, min16float vm16
+                                : C, min10float vm10
+                                : D) : SV_Target {
+  return foo(vm16, vm16 % 10.0);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16int.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = add nsw i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm16i, vm16i >> 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16int_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = add nsw i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm16i, vm16i >> 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16uint.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = shl i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm16ui, vm16ui % 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_min16uint_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = shl i16 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vm16ui, vm16ui % 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_uint.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = mul i32 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vui, vui % 10);
+}

tools/clang/test/CodeGenHLSL/quick-test/function_overload_selection_uint_16bitflag.hlsl

@@ -0,0 +1,19 @@
+// RUN: %dxc /Tps_6_2 -enable-16bit-types /Emain > %s | FileCheck %s
+// CHECK: define void @main()
+// CHECK: %{{[a-z0-9]+.*[a-z0-9]*}} = mul i32 %{{[a-z0-9]+.*[a-z0-9]*}}, %{{[a-z0-9]+.*[a-z0-9]*}}
+// CHECK: entry
+
+int foo(int v0, int v1) { return v0 / v1; }
+uint foo(uint v0, uint v1) { return v0 * v1; }
+min16int foo(min16int v0, min16int v1) { return v0 + v1; }
+min12int foo(min12int v0, min12int v1) { return v0 - v1; }
+min16uint foo(min16uint v0, min16uint v1) { return v0 << v1; }
+
+int main(int vi
+            : A, uint vui
+            : B, min16int vm16i
+            : C, min12int vm12i
+            : D, min16uint vm16ui
+            : E) : SV_Target {
+  return foo(vui, vui % 10);
+}

tools/clang/test/HLSL/functions.hlsl

@@ -220,15 +220,15 @@ void fn_uint_oload3(inout uint u) { }
 void fn_uint_oload3(out uint u) { }
 
 // function redefinitions
-void fn_redef(min10float x) {}      /* expected-note {{previous definition is here}} expected-warning {{min10float is promoted to min16float}} */
-void fn_redef(min16float x) {}      /* expected-error {{redefinition of 'fn_redef'}} */
+void fn_redef(min10float x) {}      /* expected-warning {{min10float is promoted to min16float}} */
+void fn_redef(min16float x) {}      /* */
 
 
-void fn_redef2(min12int x) {}       /* expected-note {{previous definition is here}} expected-warning {{min12int is promoted to min16int}} */
-void fn_redef2(min16int x) {}       /* expected-error {{redefinition of 'fn_redef2'}} */
+void fn_redef2(min12int x) {}       /* expected-warning {{min12int is promoted to min16int}} */
+void fn_redef2(min16int x) {}       /* */
 
-void fn_redef3(half x) {}           /* expected-note {{previous definition is here}} */
-void fn_redef3(float x) {}          /* expected-error {{redefinition of 'fn_redef3'}} */
+void fn_redef3(half x) {}           /* */
+void fn_redef3(float x) {}          /* */
 
 typedef min16int My16Int;
 void fn_redef4(min16int x) {}       /* expected-note {{previous definition is here}} */

tools/clang/test/HLSL/implicit-casts.hlsl

@@ -321,7 +321,7 @@ float4 test(): SV_Target {
   VERIFY_TYPES(float4x4, i4x4 * f);
   VERIFY_TYPES(float4x4, f * i4x4);
   VERIFY_TYPES(bool, b = i4);                   /* expected-warning {{implicit truncation of vector type}} fxc-warning {{X3206: implicit truncation of vector type}} */
-  
+
   VERIFY_TYPES(float4x4, overload1(i4x4 * f));
   VERIFY_TYPES(float4x4, overload1(i4x4 * 1.5F));
   VERIFY_TYPES(float4x4, overload1(i4x4 * 1.5));
@@ -335,10 +335,10 @@ float4 test(): SV_Target {
   VERIFY_TYPES(int4x4, overload2(f, i4x4));
 
   VERIFY_TYPES(uint64_t4x4, overload2(u644x4, d));
-  VERIFY_TYPES(uint64_t4x4, overload2(d, u644x4)); 
+  VERIFY_TYPES(uint64_t4x4, overload2(d, u644x4));
   VERIFY_TYPES(int64_t4x4, overload2(i644x4, d));
-  VERIFY_TYPES(int64_t4x4, overload2(d, i644x4)); 
-  
+  VERIFY_TYPES(int64_t4x4, overload2(d, i644x4));
+
   // ambiguous:
   //VERIFY_TYPES(float4, overload2(f4, i4));
 
@@ -359,7 +359,7 @@ float4 test(): SV_Target {
       `-ImplicitCastExpr <col:8> 'int' <LValueToRValue>
         `-DeclRefExpr <col:8> 'int' lvalue Var 'i' 'int'
   */
-  
+
   u64 = d;
   /*verify-ast
     BinaryOperator <col:3, col:9> 'uint64_t':'unsigned long long' '='
@@ -1016,4 +1016,4 @@ bool1 stresstest() {
 float4 main() : SV_Target
 {
   return test();
-}
+}

tools/clang/test/HLSL/intrinsic-examples.hlsl

@@ -45,13 +45,13 @@ float4 RWByteAddressBufferMain(uint2 a : A, uint2 b : B) : SV_Target
   r += uav1.Load2<float>(16);                               /* expected-error {{Explicit template arguments on intrinsic Load2 are not supported.}} */
   r += uav1.Load3<int>(20);                                 /* expected-error {{Explicit template arguments on intrinsic Load3 are not supported.}} */
   r += uav1.Load4<int16_t>(24);                             /* expected-error {{Explicit template arguments on intrinsic Load4 are not supported.}} */
-  r += uav1.Load<half3x4>(24);                              /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} expected-error {{cannot convert from 'matrix<__fp16, 3, 4>' to 'float4'}} */
+  r += uav1.Load<half3x4>(24);                              /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} expected-error {{cannot convert from 'matrix<half, 3, 4>' to 'float4'}} */
   r += uav1.Load<float, float3>(16, status);                /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} */
   r += uav1.Load<double3>(16, status);                      /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} expected-error {{cannot convert from 'vector<double, 3>' to 'float4'}} */
   r += uav1.Load2<float>(16, status);                       /* expected-error {{Explicit template arguments on intrinsic Load2 are not supported.}} */
   r += uav1.Load3<int>(20, status);                         /* expected-error {{Explicit template arguments on intrinsic Load3 are not supported.}} */
   r += uav1.Load4<int16_t>(24, status);                     /* expected-error {{Explicit template arguments on intrinsic Load4 are not supported.}} */
-  r += uav1.Load<half3x4>(24, status);                      /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} expected-error {{cannot convert from 'matrix<__fp16, 3, 4>' to 'float4'}} */
+  r += uav1.Load<half3x4>(24, status);                      /* expected-error {{Explicit template arguments on intrinsic Load requires HLSL version 2018 or above.}} expected-error {{cannot convert from 'matrix<half, 3, 4>' to 'float4'}} */
   // valid template argument
   uav1.Store(0, r);
   uav1.Store(0, r.x);

tools/clang/test/HLSL/matrix-syntax-exact-precision.hlsl

@@ -72,8 +72,8 @@ void matrix_unsigned() {
    unsigned bool3x4 boolMatirx;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned half4x1 halfMatrix;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned double1x2 doubleMatrix;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min12int2x3 min12intMatrix;                       /* expected-warning {{min12int is promoted to int16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min16float3x4 min16floatMatrix;                   /* expected-error {{'half' cannot be signed or unsigned}} expected-warning {{min16float is promoted to float16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2x3 min12intMatrix;                       /* expected-error {{'min12int' cannot be signed or unsigned}} expected-warning {{min12int is promoted to int16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min16float3x4 min16floatMatrix;                   /* expected-error {{'min16float' cannot be signed or unsigned}} expected-warning {{min16float is promoted to float16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
 
    unsigned int16_t2x3 uint16_tMatrix1;                       /* fxc-error {{X3000: syntax error: unexpected token 'int16_t2x3'}} */
    unsigned int32_t4x2 uint32_tMatrix1;                       /* fxc-error {{X3000: syntax error: unexpected token 'int32_t4x2'}} */

tools/clang/test/HLSL/matrix-syntax.hlsl

@@ -67,12 +67,12 @@ void matrix_unsigned() {
    unsigned min16uint4x1 min16uintMatrix;
    unsigned uint64_t2x2 int64uintMatrix;
    unsigned dword3x2 dwordvector; /* fxc-error {{X3000: unrecognized identifier 'dword3x1'}} */
-   
+
    unsigned float2x3 floatMatrix; /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned bool3x4 boolvector;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned half4x1 halfvector;   /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned half4x1 halfvector;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned double1x2 doublevector;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min12int2x3 min12intvector;                       /* expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2x3 min12intvector;                       /* expected-error {{'min12int' cannot be signed or unsigned}} expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned min16float3x4 min16floatvector;                   /* expected-error {{'min16float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
 
 }
@@ -157,4 +157,4 @@ void main() {
     myConstMatrix[0][0] = 3;                                /* expected-error {{cannot assign to variable 'myConstMatrix' with const-qualified type 'const matrix<float, 4, 4>'}} fxc-error {{X3025: l-value specifies const object}} */
     myConstMatrix[3] = float4(1,2,3,4);                     /* expected-error {{cannot assign to variable 'myConstMatrix' with const-qualified type 'const matrix<float, 4, 4>'}} fxc-error {{X3025: l-value specifies const object}} */
 
-}
+}

tools/clang/test/HLSL/scalar-assignments-exact-precision.hlsl

@@ -130,14 +130,14 @@ min10float left96; bool right96; left96 = right96;  // expected-warning {{min10f
 min10float left97; int right97; left97 = right97; // expected-warning {{conversion from larger type 'int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min10float left98; uint right98; left98 = right98; // expected-warning {{conversion from larger type 'uint' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min10float left99; dword right99; left99 = right99; // expected-warning {{conversion from larger type 'dword' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min10float left100; half right100; left100 = right100; // expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left100; half right100; left100 = right100; // expected-warning {{conversion from larger type 'half' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min10float left101; float right101; left101 = right101; // expected-warning {{conversion from larger type 'float' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min10float left102; double right102; left102 = right102; // expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min10float left103; min16float right103; left103 = right103; // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left103; min16float right103; left103 = right103; // expected-warning {{conversion from larger type 'min16float' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min10float left104; min10float right104; left104 = right104;  // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} //
-min10float left105; min16int right105; left105 = right105; // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min10float left106; min12int right106; left106 = right106; // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min10float left107; min16uint right107; left107 = right107; // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left105; min16int right105; left105 = right105; // expected-warning {{conversion from larger type 'min16int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left106; min12int right106; left106 = right106; // expected-warning {{conversion from larger type 'min12int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left107; min16uint right107; left107 = right107; // expected-warning {{conversion from larger type 'min16uint' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to float16_t}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min16int left108; bool right108; left108 = right108;        /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 min16int left109; int right109; left109 = right109; // expected-warning {{conversion from larger type 'int' to smaller type 'min16int', possible loss of data}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16int left110; uint right110; left110 = right110; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16int', possible loss of data}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
@@ -154,14 +154,14 @@ min12int left120; bool right120; left120 = right120;  // expected-warning {{min1
 min12int left121; int right121; left121 = right121; // expected-warning {{conversion from larger type 'int' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left122; uint right122; left122 = right122; // expected-warning {{conversion from larger type 'uint' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left123; dword right123; left123 = right123; // expected-warning {{conversion from larger type 'dword' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min12int left124; half right124; left124 = right124; // expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left124; half right124; left124 = right124; // expected-warning {{conversion from larger type 'half' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left125; float right125; left125 = right125; // expected-warning {{conversion from larger type 'float' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left126; double right126; left126 = right126; // expected-warning {{conversion from larger type 'double' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
-min12int left127; min16float right127; left127 = right127; // expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left127; min16float right127; left127 = right127; // expected-warning {{conversion from larger type 'min16float' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16float is promoted to float16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left128; min10float right128; left128 = right128;  // expected-warning {{min10float is promoted to float16_t}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} //
-min12int left129; min16int right129; left129 = right129; // expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left129; min16int right129; left129 = right129; // expected-warning {{conversion from larger type 'min16int' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16int is promoted to int16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min12int left130; min12int right130; left130 = right130;  // expected-warning {{min12int is promoted to int16_t}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} //
-min12int left131; min16uint right131; left131 = right131; // expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left131; min16uint right131; left131 = right131; // expected-warning {{conversion from larger type 'min16uint' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to int16_t}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
 min16uint left132; bool right132; left132 = right132;     /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 min16uint left133; int right133; left133 = right133; // expected-warning {{conversion from larger type 'int' to smaller type 'min16uint', possible loss of data}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16uint left134; uint right134; left134 = right134; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16uint', possible loss of data}} expected-warning {{min16uint is promoted to uint16_t}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}

tools/clang/test/HLSL/scalar-assignments.hlsl

@@ -127,17 +127,17 @@ min16float left93; min16int right93; left93 = right93;
 min16float left94; min12int right94; left94 = right94;  // expected-warning {{min12int is promoted to min16int}}
 min16float left95; min16uint right95; left95 = right95;
 min10float left96; bool right96; left96 = right96;  // expected-warning {{min10float is promoted to min16float}}
-min10float left97; int right97; left97 = right97; // expected-warning {{conversion from larger type 'int' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min10float is promoted to min16float}}
-min10float left98; uint right98; left98 = right98; // expected-warning {{conversion from larger type 'uint' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min10float is promoted to min16float}}
-min10float left99; dword right99; left99 = right99; // expected-warning {{conversion from larger type 'dword' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left100; half right100; left100 = right100; // expected-warning {{conversion from larger type 'half' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left101; float right101; left101 = right101; // expected-warning {{conversion from larger type 'float' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left102; double right102; left102 = right102; // expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} // expected-warning {{min10float is promoted to min16float}}
-min10float left103; min16float right103; left103 = right103; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
-min10float left104; min10float right104; left104 = right104;  // expected-warning {{min10float is promoted to min16float}} // expected-warning {{min10float is promoted to min16float}}
-min10float left105; min16int right105; left105 = right105; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
-min10float left106; min12int right106; left106 = right106; // expected-warning {{min10float is promoted to min16float}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
-min10float left107; min16uint right107; left107 = right107; // expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left97; int right97; left97 = right97; // expected-warning {{conversion from larger type 'int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left98; uint right98; left98 = right98; // expected-warning {{conversion from larger type 'uint' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left99; dword right99; left99 = right99; // expected-warning {{conversion from larger type 'dword' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left100; half right100; left100 = right100; // expected-warning {{conversion from larger type 'half' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left101; float right101; left101 = right101; // expected-warning {{conversion from larger type 'float' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left102; double right102; left102 = right102; // expected-warning {{conversion from larger type 'double' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min10float left103; min16float right103; left103 = right103; // expected-warning {{conversion from larger type 'min16float' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left104; min10float right104; left104 = right104;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+min10float left105; min16int right105; left105 = right105; // expected-warning {{conversion from larger type 'min16int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left106; min12int right106; left106 = right106; // expected-warning {{conversion from larger type 'min12int' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min10float left107; min16uint right107; left107 = right107; // expected-warning {{conversion from larger type 'min16uint' to smaller type 'min10float', possible loss of data}} expected-warning {{min10float is promoted to min16float}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16int left108; bool right108; left108 = right108;
 min16int left109; int right109; left109 = right109; // expected-warning {{conversion from larger type 'int' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16int left110; uint right110; left110 = right110; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
@@ -151,17 +151,17 @@ min16int left117; min16int right117; left117 = right117;
 min16int left118; min12int right118; left118 = right118;  // expected-warning {{min12int is promoted to min16int}}
 min16int left119; min16uint right119; left119 = right119;
 min12int left120; bool right120; left120 = right120;  // expected-warning {{min12int is promoted to min16int}}
-min12int left121; int right121; left121 = right121; // expected-warning {{conversion from larger type 'int' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left122; uint right122; left122 = right122; // expected-warning {{conversion from larger type 'uint' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left123; dword right123; left123 = right123; // expected-warning {{conversion from larger type 'dword' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left124; half right124; left124 = right124; // expected-warning {{conversion from larger type 'half' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left125; float right125; left125 = right125; // expected-warning {{conversion from larger type 'float' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left126; double right126; left126 = right126; // expected-warning {{conversion from larger type 'double' to smaller type 'min12int', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left127; min16float right127; left127 = right127; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  
-min12int left128; min10float right128; left128 = right128;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left129; min16int right129; left129 = right129; // expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}  
-min12int left130; min12int right130; left130 = right130;  // expected-warning {{min12int is promoted to min16int}}  // expected-warning {{min12int is promoted to min16int}}
-min12int left131; min16uint right131; left131 = right131; // expected-warning {{min12int is promoted to min16int}}  fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} 
+min12int left121; int right121; left121 = right121; // expected-warning {{conversion from larger type 'int' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left122; uint right122; left122 = right122; // expected-warning {{conversion from larger type 'uint' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left123; dword right123; left123 = right123; // expected-warning {{conversion from larger type 'dword' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left124; half right124; left124 = right124; // expected-warning {{conversion from larger type 'half' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left125; float right125; left125 = right125; // expected-warning {{conversion from larger type 'float' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left126; double right126; left126 = right126; // expected-warning {{conversion from larger type 'double' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} //
+min12int left127; min16float right127; left127 = right127; // expected-warning {{conversion from larger type 'min16float' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min12int left128; min10float right128; left128 = right128;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min12int is promoted to min16int}} //
+min12int left129; min16int right129; left129 = right129; // expected-warning {{conversion from larger type 'min16int' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+min12int left130; min12int right130; left130 = right130;  // expected-warning {{min12int is promoted to min16int}} expected-warning {{min12int is promoted to min16int}} //
+min12int left131; min16uint right131; left131 = right131; // expected-warning {{conversion from larger type 'min16uint' to smaller type 'min12int', possible loss of data}} expected-warning {{min12int is promoted to min16int}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16uint left132; bool right132; left132 = right132;
 min16uint left133; int right133; left133 = right133; // expected-warning {{conversion from larger type 'int' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
 min16uint left134; uint right134; left134 = right134; // expected-warning {{conversion from larger type 'uint' to smaller type 'min16uint', possible loss of data}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
@@ -294,8 +294,8 @@ unorm min16float left1095; unorm min10float right1095; left1095 = right1095;  //
 // min10float left1099; unorm double right1099; left1099 = right1099;
 // min10float left1100; snorm min16float right1100; left1100 = right1100;
 // min10float left1101; unorm min16float right1101; left1101 = right1101;
- min10float left1102; snorm min10float right1102; left1102 = right1102;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
- min10float left1103; unorm min10float right1103; left1103 = right1103;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
+ min10float left1102; snorm min10float right1102; left1102 = right1102;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+ min10float left1103; unorm min10float right1103; left1103 = right1103;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
 // snorm min10float left1104;  float right1104; left1104 = right1104;
 // snorm min10float left1105; snorm float right1105; left1105 = right1105;
 // snorm min10float left1106; unorm float right1106; left1106 = right1106;
@@ -305,9 +305,9 @@ unorm min16float left1095; unorm min10float right1095; left1095 = right1095;  //
 // snorm min10float left1110;  min16float right1110; left1110 = right1110;
 // snorm min10float left1111; snorm min16float right1111; left1111 = right1111;
 // snorm min10float left1112; unorm min16float right1112; left1112 = right1112;
-snorm min10float left1113;  min10float right1113; left1113 = right1113;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
-snorm min10float left1114; snorm min10float right1114; left1114 = right1114;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
-snorm min10float left1115; unorm min10float right1115; left1115 = right1115;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
+snorm min10float left1113;  min10float right1113; left1113 = right1113;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+snorm min10float left1114; snorm min10float right1114; left1114 = right1114;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+snorm min10float left1115; unorm min10float right1115; left1115 = right1115;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
 // unorm min10float left1116;  float right1116; left1116 = right1116;
 // unorm min10float left1117; snorm float right1117; left1117 = right1117;
 // unorm min10float left1118; unorm float right1118; left1118 = right1118;
@@ -317,8 +317,8 @@ snorm min10float left1115; unorm min10float right1115; left1115 = right1115;  //
 // unorm min10float left1122;  min16float right1122; left1122 = right1122;
 // unorm min10float left1123; snorm min16float right1123; left1123 = right1123;
 // unorm min10float left1124; unorm min16float right1124; left1124 = right1124;
-unorm min10float left1125;  min10float right1125; left1125 = right1125;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
-unorm min10float left1126; snorm min10float right1126; left1126 = right1126;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
-unorm min10float left1127; unorm min10float right1127; left1127 = right1127;  // expected-warning {{min10float is promoted to min16float}}  // expected-warning {{min10float is promoted to min16float}}
+unorm min10float left1125;  min10float right1125; left1125 = right1125;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+unorm min10float left1126; snorm min10float right1126; left1126 = right1126;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
+unorm min10float left1127; unorm min10float right1127; left1127 = right1127;  // expected-warning {{min10float is promoted to min16float}} expected-warning {{min10float is promoted to min16float}} //
 
 }

tools/clang/test/HLSL/scalar-operators-assign-exact-precision.hlsl

@@ -1463,7 +1463,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats /= uint64_ts)>::v
 _Static_assert(std::is_same<min10float, __decltype(min10floats /= float16_ts)>::value, "");
 _Static_assert(std::is_same<min10float, __decltype(min10floats /= float32_ts)>::value, "");
 _Static_assert(std::is_same<min10float, __decltype(min10floats /= float64_ts)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints /= bools)>::value, "");
+_Static_assert(std::is_same<min16int, __decltype(min16ints /= bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= ints)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= uints)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= halfs)>::value, "");
@@ -1471,9 +1471,9 @@ _Static_assert(std::is_same<min16int, __decltype(min16ints /= floats)>::value, "
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= doubles)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= min16floats)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= min10floats)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints /= min16ints)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints /= min12ints)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints /= min16uints)>::value, "");
+_Static_assert(std::is_same<min16int, __decltype(min16ints /= min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints /= min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints /= min16uints)>::value, "");   
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= int16_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= int32_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= int64_ts)>::value, "");
@@ -1483,7 +1483,7 @@ _Static_assert(std::is_same<min16int, __decltype(min16ints /= uint64_ts)>::value
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= float16_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= float32_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints /= float64_ts)>::value, "");
-_Static_assert(std::is_same<min12int, __decltype(min12ints /= bools)>::value, "");
+_Static_assert(std::is_same<min12int, __decltype(min12ints /= bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= ints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= uints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= halfs)>::value, "");
@@ -1491,8 +1491,8 @@ _Static_assert(std::is_same<min12int, __decltype(min12ints /= floats)>::value, "
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= doubles)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= min16floats)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= min10floats)>::value, "");
-_Static_assert(std::is_same<min12int, __decltype(min12ints /= min16ints)>::value, "");
-_Static_assert(std::is_same<min12int, __decltype(min12ints /= min12ints)>::value, "");
+_Static_assert(std::is_same<min12int, __decltype(min12ints /= min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints /= min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= min16uints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= int16_ts)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints /= int32_ts)>::value, "");
@@ -1511,7 +1511,7 @@ _Static_assert(std::is_same<min16uint, __decltype(min16uints /= floats)>::value,
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= doubles)>::value, "");
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= min16floats)>::value, "");
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= min10floats)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(min16uints /= min16ints)>::value, "");
+_Static_assert(std::is_same<min16uint, __decltype(min16uints /= min16ints)>::value, "");  
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= min12ints)>::value, "");
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= min16uints)>::value, "");
 _Static_assert(std::is_same<min16uint, __decltype(min16uints /= int16_ts)>::value, "");
@@ -1863,7 +1863,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats %= uint64_ts)>::v
 _Static_assert(std::is_same<min10float, __decltype(min10floats %= float16_ts)>::value, "");
 _Static_assert(std::is_same<min10float, __decltype(min10floats %= float32_ts)>::value, "");
 (min10floats %= float64_ts);     /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<min16int, __decltype(min16ints %= bools)>::value, "");
+_Static_assert(std::is_same<min16int, __decltype(min16ints %= bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= ints)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= uints)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= halfs)>::value, "");
@@ -1871,8 +1871,8 @@ _Static_assert(std::is_same<min16int, __decltype(min16ints %= floats)>::value, "
 (min16ints %= doubles);          /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} */
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= min16floats)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= min10floats)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints %= min16ints)>::value, "");
-_Static_assert(std::is_same<min16int, __decltype(min16ints %= min12ints)>::value, "");
+_Static_assert(std::is_same<min16int, __decltype(min16ints %= min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints %= min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= min16uints)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= int16_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= int32_ts)>::value, "");
@@ -1883,7 +1883,7 @@ _Static_assert(std::is_same<min16int, __decltype(min16ints %= uint64_ts)>::value
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= float16_ts)>::value, "");
 _Static_assert(std::is_same<min16int, __decltype(min16ints %= float32_ts)>::value, "");
 (min16ints %= float64_ts);       /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<min12int, __decltype(min12ints %= bools)>::value, "");
+_Static_assert(std::is_same<min12int, __decltype(min12ints %= bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= ints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= uints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= halfs)>::value, "");
@@ -1891,8 +1891,8 @@ _Static_assert(std::is_same<min12int, __decltype(min12ints %= floats)>::value, "
 (min12ints %= doubles);          /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}} */
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16floats)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= min10floats)>::value, "");
-_Static_assert(std::is_same<min12int, __decltype(min12ints %= min16ints)>::value, "");
-_Static_assert(std::is_same<min12int, __decltype(min12ints %= min12ints)>::value, "");
+_Static_assert(std::is_same<min12int, __decltype(min12ints %= min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints %= min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} */
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16uints)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= int16_ts)>::value, "");
 _Static_assert(std::is_same<min12int, __decltype(min12ints %= int32_ts)>::value, "");
@@ -4106,4 +4106,4 @@ _Static_assert(std::is_same<uint64_t, __decltype(uint64_ts ^= uint64_ts)>::value
 // GENERATED_ASSIGN:END
 
 
-}
+}

tools/clang/test/HLSL/scalar-operators-assign.hlsl

@@ -418,7 +418,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16float, __decltype(min16floats /= min16ints)>::value, "");
   _Static_assert(std::is_same<min16float, __decltype(min16floats /= min12ints)>::value, "");
   _Static_assert(std::is_same<min16float, __decltype(min16floats /= min16uints)>::value, "");
-  _Static_assert(std::is_same<min10float, __decltype(min10floats /= bools)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= uints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= halfs)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= floats)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= doubles)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16floats)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min10floats)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min12ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16uints)>::value, "");  (min16ints /= bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= bools)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= uints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= halfs)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= floats)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= doubles)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16floats)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min10floats)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min12ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats /= min16uints)>::value, "");  (min16ints /= bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
   _Static_assert(std::is_same<min16int, __decltype(min16ints /= ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints /= uints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints /= halfs)>::value, "");
@@ -520,8 +530,16 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16float, __decltype(min16floats %= min16ints)>::value, "");
   _Static_assert(std::is_same<min16float, __decltype(min16floats %= min12ints)>::value, "");
   _Static_assert(std::is_same<min16float, __decltype(min16floats %= min16uints)>::value, "");
-  _Static_assert(std::is_same<min10float, __decltype(min10floats %= bools)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= uints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= halfs)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= floats)>::value, "");  (min10floats %= doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
-  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16floats)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min10floats)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min12ints)>::value, "");  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16uints)>::value, "");  (min16ints %= bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= bools)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= uints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= halfs)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= floats)>::value, "");  (min10floats %= doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16floats)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min10floats)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min12ints)>::value, "");
+  _Static_assert(std::is_same<min10float, __decltype(min10floats %= min16uints)>::value, "");  (min16ints %= bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
   _Static_assert(std::is_same<min16int, __decltype(min16ints %= ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints %= uints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints %= halfs)>::value, "");
@@ -533,10 +551,15 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   (min16ints %= min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
   _Static_assert(std::is_same<min16int, __decltype(min16ints %= min16uints)>::value, "");
   (min12ints %= bools); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints %= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints %= uints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints %= halfs)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints %= floats)>::value, "");  (min12ints %= doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16floats)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min10floats)>::value, "");  (min12ints %= min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= uints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= halfs)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= floats)>::value, "");  (min12ints %= doubles); // expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16floats)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min10floats)>::value, "");  (min12ints %= min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
   (min12ints %= min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-pass {{}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints %= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints %= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints %= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints %= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints %= uints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints %= halfs)>::value, "");
@@ -646,12 +669,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16int, __decltype(min16ints <<= min16ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints <<= min12ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints <<= min16uints)>::value, "");
-  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= bools)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= uints)>::value, "");  (min12ints <<= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= uints)>::value, "");  (min12ints <<= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints <<= floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints <<= doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints <<= min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints <<= min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min16ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min12ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints <<= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min12ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints <<= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints <<= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints <<= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints <<= uints)>::value, "");
   (min16uints <<= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
@@ -761,12 +789,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16int, __decltype(min16ints >>= min16ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints >>= min12ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints >>= min16uints)>::value, "");
-  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= bools)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= uints)>::value, "");  (min12ints >>= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= uints)>::value, "");  (min12ints >>= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints >>= floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints >>= doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints >>= min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints >>= min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min16ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min12ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints >>= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min12ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints >>= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints >>= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints >>= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints >>= uints)>::value, "");
   (min16uints >>= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
@@ -876,12 +909,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16int, __decltype(min16ints &= min16ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints &= min12ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints &= min16uints)>::value, "");
-  _Static_assert(std::is_same<min12int, __decltype(min12ints &= bools)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints &= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints &= uints)>::value, "");  (min12ints &= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= uints)>::value, "");  (min12ints &= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints &= floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints &= doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints &= min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints &= min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min16ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min12ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints &= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min12ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints &= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints &= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints &= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints &= uints)>::value, "");
   (min16uints &= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
@@ -991,12 +1029,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16int, __decltype(min16ints |= min16ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints |= min12ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints |= min16uints)>::value, "");
-  _Static_assert(std::is_same<min12int, __decltype(min12ints |= bools)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints |= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints |= uints)>::value, "");  (min12ints |= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= uints)>::value, "");  (min12ints |= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints |= floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints |= doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints |= min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints |= min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min16ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min12ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints |= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min12ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints |= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints |= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints |= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints |= uints)>::value, "");
   (min16uints |= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
@@ -1106,12 +1149,17 @@ float4 plain(float4 param4 /* : FOO */) /*: FOO */{
   _Static_assert(std::is_same<min16int, __decltype(min16ints ^= min16ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints ^= min12ints)>::value, "");
   _Static_assert(std::is_same<min16int, __decltype(min16ints ^= min16uints)>::value, "");
-  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= bools)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= uints)>::value, "");  (min12ints ^= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= uints)>::value, "");  (min12ints ^= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints ^= floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints ^= doubles); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints ^= min16floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
   (min12ints ^= min10floats); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}
-  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min16ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min12ints)>::value, "");  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min16uints)>::value, "");  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^= bools)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min16ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min12ints)>::value, "");
+  _Static_assert(std::is_same<min12int, __decltype(min12ints ^= min16uints)>::value, "");
+  _Static_assert(std::is_same<min16uint, __decltype(min16uints ^= bools)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints ^= ints)>::value, "");
   _Static_assert(std::is_same<min16uint, __decltype(min16uints ^= uints)>::value, "");
   (min16uints ^= halfs); // expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}}

tools/clang/test/HLSL/scalar-operators-exact-precision.hlsl

@@ -155,7 +155,7 @@ _Static_assert(std::is_same<uint, __decltype(bools + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(bools + halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(bools + floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(bools + doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(bools + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16float, __decltype(bools + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} */
 _Static_assert(std::is_same<min10float, __decltype(bools + min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(bools + min16ints)>::value, "");
 _Static_assert(std::is_same<int, __decltype(bools + min12ints)>::value, "");
@@ -215,7 +215,7 @@ _Static_assert(std::is_same<half, __decltype(halfs + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs + halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(halfs + floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(halfs + doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(halfs + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<half, __decltype(halfs + min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<half, __decltype(halfs + min10floats)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs + min16ints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs + min12ints)>::value, "");
@@ -309,7 +309,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats + uint64_ts)>::va
 _Static_assert(std::is_same<float16_t, __decltype(min10floats + float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min10floats + float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min10floats + float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min16ints + bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints + bools)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints + ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16ints + halfs)>::value, "");
@@ -329,7 +329,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints + uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min16ints + float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16ints + float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16ints + float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min12ints + bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints + bools)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints + ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min12ints + halfs)>::value, "");
@@ -349,7 +349,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints + uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min12ints + float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min12ints + float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min12ints + float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(min16uints + bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints + bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints + ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16uints + halfs)>::value, "");
@@ -369,7 +369,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints + uint64_ts)>::value
 _Static_assert(std::is_same<float16_t, __decltype(min16uints + float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16uints + float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16uints + float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(int16_ts + bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts + bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts + ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(int16_ts + halfs)>::value, "");
@@ -377,9 +377,9 @@ _Static_assert(std::is_same<float, __decltype(int16_ts + floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(int16_ts + doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(int16_ts + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(int16_ts + min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts + min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts + min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts + min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts + min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts + min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts + int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts + int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts + int64_ts)>::value, "");
@@ -429,7 +429,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts + uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(int64_ts + float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(int64_ts + float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(int64_ts + float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(uint16_ts + bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts + bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts + ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts + uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(uint16_ts + halfs)>::value, "");
@@ -437,9 +437,9 @@ _Static_assert(std::is_same<float, __decltype(uint16_ts + floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(uint16_ts + doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(uint16_ts + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(uint16_ts + min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts + min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts + min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts + min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts + min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts + min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts + int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts + int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts + int64_ts)>::value, "");
@@ -495,7 +495,7 @@ _Static_assert(std::is_same<float16_t, __decltype(float16_ts + uints)>::value, "
 _Static_assert(std::is_same<half, __decltype(float16_ts + halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(float16_ts + floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(float16_ts + doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(float16_ts + min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<float16_t, __decltype(float16_ts + min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts + min10floats)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts + min16ints)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts + min12ints)>::value, "");
@@ -555,7 +555,7 @@ _Static_assert(std::is_same<uint, __decltype(bools - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(bools - halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(bools - floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(bools - doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(bools - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16float, __decltype(bools - min16floats)>::value, "");        /* expected-warning {{min16float is promoted to float16_t}} */
 _Static_assert(std::is_same<min10float, __decltype(bools - min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(bools - min16ints)>::value, "");
 _Static_assert(std::is_same<int, __decltype(bools - min12ints)>::value, "");
@@ -615,7 +615,7 @@ _Static_assert(std::is_same<half, __decltype(halfs - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs - halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(halfs - floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(halfs - doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(halfs - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<half, __decltype(halfs - min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<half, __decltype(halfs - min10floats)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs - min16ints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs - min12ints)>::value, "");
@@ -709,7 +709,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats - uint64_ts)>::va
 _Static_assert(std::is_same<float16_t, __decltype(min10floats - float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min10floats - float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min10floats - float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min16ints - bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints - bools)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints - ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16ints - halfs)>::value, "");
@@ -729,7 +729,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints - uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min16ints - float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16ints - float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16ints - float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min12ints - bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints - bools)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints - ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min12ints - halfs)>::value, "");
@@ -749,7 +749,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints - uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min12ints - float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min12ints - float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min12ints - float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(min16uints - bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints - bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints - ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16uints - halfs)>::value, "");
@@ -769,7 +769,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints - uint64_ts)>::value
 _Static_assert(std::is_same<float16_t, __decltype(min16uints - float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16uints - float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16uints - float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(int16_ts - bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts - bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts - ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(int16_ts - halfs)>::value, "");
@@ -777,9 +777,9 @@ _Static_assert(std::is_same<float, __decltype(int16_ts - floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(int16_ts - doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(int16_ts - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(int16_ts - min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts - min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts - min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts - min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts - min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts - min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts - int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts - int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts - int64_ts)>::value, "");
@@ -829,7 +829,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts - uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(int64_ts - float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(int64_ts - float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(int64_ts - float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(uint16_ts - bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts - bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts - ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts - uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(uint16_ts - halfs)>::value, "");
@@ -837,9 +837,9 @@ _Static_assert(std::is_same<float, __decltype(uint16_ts - floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(uint16_ts - doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(uint16_ts - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(uint16_ts - min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts - min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts - min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts - min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts - min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts - min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts - int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts - int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts - int64_ts)>::value, "");
@@ -895,7 +895,7 @@ _Static_assert(std::is_same<float16_t, __decltype(float16_ts - uints)>::value, "
 _Static_assert(std::is_same<half, __decltype(float16_ts - halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(float16_ts - floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(float16_ts - doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(float16_ts - min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<float16_t, __decltype(float16_ts - min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts - min10floats)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts - min16ints)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts - min12ints)>::value, "");
@@ -955,7 +955,7 @@ _Static_assert(std::is_same<uint, __decltype(bools / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(bools / halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(bools / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(bools / doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(bools / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16float, __decltype(bools / min16floats)>::value, "");        /* expected-warning {{min16float is promoted to float16_t}} */
 _Static_assert(std::is_same<min10float, __decltype(bools / min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(bools / min16ints)>::value, "");
 _Static_assert(std::is_same<int, __decltype(bools / min12ints)>::value, "");
@@ -1015,7 +1015,7 @@ _Static_assert(std::is_same<half, __decltype(halfs / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs / halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(halfs / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(halfs / doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(halfs / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<half, __decltype(halfs / min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<half, __decltype(halfs / min10floats)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs / min16ints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs / min12ints)>::value, "");
@@ -1109,7 +1109,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats / uint64_ts)>::va
 _Static_assert(std::is_same<float16_t, __decltype(min10floats / float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min10floats / float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min10floats / float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min16ints / bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints / bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints / ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16ints / halfs)>::value, "");
@@ -1117,8 +1117,8 @@ _Static_assert(std::is_same<float, __decltype(min16ints / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(min16ints / doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(min16ints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(min16ints / min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min16ints / min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min16ints / min12ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints / min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints / min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16uint, __decltype(min16ints / min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(min16ints / int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(min16ints / int32_ts)>::value, "");
@@ -1129,7 +1129,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints / uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min16ints / float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16ints / float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16ints / float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(min12ints / bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints / bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints / ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min12ints / halfs)>::value, "");
@@ -1137,8 +1137,8 @@ _Static_assert(std::is_same<float, __decltype(min12ints / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(min12ints / doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(min12ints / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(min12ints / min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min12ints / min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min12int, __decltype(min12ints / min12ints)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min12ints / min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints / min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16uint, __decltype(min12ints / min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(min12ints / int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(min12ints / int32_ts)>::value, "");
@@ -1149,7 +1149,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints / uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min12ints / float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min12ints / float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min12ints / float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(min16uints / bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints / bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints / ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16uints / halfs)>::value, "");
@@ -1169,7 +1169,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints / uint64_ts)>::value
 _Static_assert(std::is_same<float16_t, __decltype(min16uints / float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16uints / float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16uints / float64_ts)>::value, "");
-_Static_assert(std::is_same<int, __decltype(int16_ts / bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts / bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts / ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(int16_ts / halfs)>::value, "");
@@ -1177,9 +1177,9 @@ _Static_assert(std::is_same<float, __decltype(int16_ts / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(int16_ts / doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(int16_ts / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(int16_ts / min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts / min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts / min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts / min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts / min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts / min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts / int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts / int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts / int64_ts)>::value, "");
@@ -1229,7 +1229,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts / uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(int64_ts / float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(int64_ts / float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(int64_ts / float64_ts)>::value, "");
-_Static_assert(std::is_same<uint, __decltype(uint16_ts / bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts / bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts / ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts / uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(uint16_ts / halfs)>::value, "");
@@ -1237,9 +1237,9 @@ _Static_assert(std::is_same<float, __decltype(uint16_ts / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(uint16_ts / doubles)>::value, "");
 _Static_assert(std::is_same<min16float, __decltype(uint16_ts / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(uint16_ts / min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts / min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts / min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts / min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts / min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts / min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts / int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts / int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts / int64_ts)>::value, "");
@@ -1295,7 +1295,7 @@ _Static_assert(std::is_same<float16_t, __decltype(float16_ts / uints)>::value, "
 _Static_assert(std::is_same<half, __decltype(float16_ts / halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(float16_ts / floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(float16_ts / doubles)>::value, "");
-_Static_assert(std::is_same<min16float, __decltype(float16_ts / min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<float16_t, __decltype(float16_ts / min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts / min10floats)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts / min16ints)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts / min12ints)>::value, "");
@@ -1355,7 +1355,7 @@ _Static_assert(std::is_same<uint, __decltype(bools % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(bools % halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(bools % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(bools % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16float, __decltype(bools % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16float, __decltype(bools % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} */
 _Static_assert(std::is_same<min10float, __decltype(bools % min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(bools % min16ints)>::value, "");
 _Static_assert(std::is_same<int, __decltype(bools % min12ints)>::value, "");
@@ -1415,7 +1415,7 @@ _Static_assert(std::is_same<half, __decltype(halfs % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs % halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(halfs % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(halfs % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16float, __decltype(halfs % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<half, __decltype(halfs % min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<half, __decltype(halfs % min10floats)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs % min16ints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(halfs % min12ints)>::value, "");
@@ -1509,7 +1509,7 @@ _Static_assert(std::is_same<min10float, __decltype(min10floats % uint64_ts)>::va
 _Static_assert(std::is_same<float16_t, __decltype(min10floats % float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min10floats % float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min10floats % float64_ts)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<int, __decltype(min16ints % bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints % bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints % ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16ints % halfs)>::value, "");
@@ -1517,8 +1517,8 @@ _Static_assert(std::is_same<float, __decltype(min16ints % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(min16ints % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16float, __decltype(min16ints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(min16ints % min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min16ints % min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min16ints % min12ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints % min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints % min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16uint, __decltype(min16ints % min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(min16ints % int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(min16ints % int32_ts)>::value, "");
@@ -1529,7 +1529,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints % uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min16ints % float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16ints % float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16ints % float64_ts)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<int, __decltype(min12ints % bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints % bools)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints % ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min12ints % halfs)>::value, "");
@@ -1537,8 +1537,8 @@ _Static_assert(std::is_same<float, __decltype(min12ints % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(min12ints % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16float, __decltype(min12ints % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(min12ints % min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(min12ints % min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min12int, __decltype(min12ints % min12ints)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min12ints % min16ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints % min12ints)>::value, "");    /* expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16uint, __decltype(min12ints % min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(min12ints % int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(min12ints % int32_ts)>::value, "");
@@ -1549,7 +1549,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints % uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(min12ints % float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min12ints % float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min12ints % float64_ts)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<uint, __decltype(min16uints % bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints % bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints % ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(min16uints % halfs)>::value, "");
@@ -1569,7 +1569,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints % uint64_ts)>::value
 _Static_assert(std::is_same<float16_t, __decltype(min16uints % float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(min16uints % float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(min16uints % float64_ts)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<int, __decltype(int16_ts % bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts % bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts % ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(int16_ts % halfs)>::value, "");
@@ -1577,9 +1577,9 @@ _Static_assert(std::is_same<float, __decltype(int16_ts % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(int16_ts % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16float, __decltype(int16_ts % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(int16_ts % min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts % min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts % min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts % min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts % min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts % min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts % int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts % int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts % int64_ts)>::value, "");
@@ -1629,7 +1629,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts % uint64_ts)>::value,
 _Static_assert(std::is_same<float16_t, __decltype(int64_ts % float16_ts)>::value, "");
 _Static_assert(std::is_same<float32_t, __decltype(int64_ts % float32_ts)>::value, "");
 _Static_assert(std::is_same<float64_t, __decltype(int64_ts % float64_ts)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<uint, __decltype(uint16_ts % bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts % bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts % ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts % uints)>::value, "");
 _Static_assert(std::is_same<half, __decltype(uint16_ts % halfs)>::value, "");
@@ -1637,9 +1637,9 @@ _Static_assert(std::is_same<float, __decltype(uint16_ts % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(uint16_ts % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
 _Static_assert(std::is_same<min16float, __decltype(uint16_ts % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<min10float, __decltype(uint16_ts % min10floats)>::value, "");    /* expected-warning {{min10float is promoted to float16_t}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts % min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts % min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts % min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts % min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts % min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts % int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts % int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts % int64_ts)>::value, "");
@@ -1695,7 +1695,7 @@ _Static_assert(std::is_same<float16_t, __decltype(float16_ts % uints)>::value, "
 _Static_assert(std::is_same<half, __decltype(float16_ts % halfs)>::value, "");
 _Static_assert(std::is_same<float, __decltype(float16_ts % floats)>::value, "");
 _Static_assert(std::is_same<double, __decltype(float16_ts % doubles)>::value, "");    /* expected-error {{modulo cannot be used with doubles, cast to float first}} fxc-pass {{}} */
-_Static_assert(std::is_same<min16float, __decltype(float16_ts % min16floats)>::value, "");    /* expected-warning {{min16float is promoted to float16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<float16_t, __decltype(float16_ts % min16floats)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts % min10floats)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts % min16ints)>::value, "");
 _Static_assert(std::is_same<float16_t, __decltype(float16_ts % min12ints)>::value, "");
@@ -5109,7 +5109,7 @@ min10floats = (min10floats & uint64_ts);                    /* expected-error {{
 min10floats = (min10floats & float16_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min10floats = (min10floats & float32_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min10floats = (min10floats & float64_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min16ints & bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints & bools)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints & ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints & uints)>::value, "");
 min16ints = (min16ints & halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5129,7 +5129,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints & uint64_ts)>::value,
 min16ints = (min16ints & float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16ints = (min16ints & float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16ints = (min16ints & float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min12ints & bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints & bools)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints & ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints & uints)>::value, "");
 min12ints = (min12ints & halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5149,7 +5149,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints & uint64_ts)>::value,
 min12ints = (min12ints & float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min12ints = (min12ints & float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min12ints = (min12ints & float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(min16uints & bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints & bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints & ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints & uints)>::value, "");
 min16uints = (min16uints & halfs);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5169,7 +5169,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints & uint64_ts)>::value
 min16uints = (min16uints & float16_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16uints = (min16uints & float32_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16uints = (min16uints & float64_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(int16_ts & bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts & bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts & ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts & uints)>::value, "");
 int16_ts = (int16_ts & halfs);   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
@@ -5177,9 +5177,9 @@ int16_ts = (int16_ts & floats);  /* expected-error {{int or unsigned int type re
 int16_ts = (int16_ts & doubles); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts & min16floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts & min10floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts & min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts & min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts & min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts & min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts & min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts & int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts & int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts & int64_ts)>::value, "");
@@ -5229,7 +5229,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts & uint64_ts)>::value,
 int64_ts = (int64_ts & float16_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts & float32_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts & float64_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(uint16_ts & bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts & bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts & ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts & uints)>::value, "");
 uint16_ts = (uint16_ts & halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
@@ -5237,9 +5237,9 @@ uint16_ts = (uint16_ts & floats);                           /* expected-error {{
 uint16_ts = (uint16_ts & doubles);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts & min16floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts & min10floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts & min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts & min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts & min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts & min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts & min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts & int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts & int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts & int64_ts)>::value, "");
@@ -5509,7 +5509,7 @@ min10floats = (min10floats | uint64_ts);                    /* expected-error {{
 min10floats = (min10floats | float16_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min10floats = (min10floats | float32_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min10floats = (min10floats | float64_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min16ints | bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints | bools)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints | ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints | uints)>::value, "");
 min16ints = (min16ints | halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5529,7 +5529,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints | uint64_ts)>::value,
 min16ints = (min16ints | float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16ints = (min16ints | float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16ints = (min16ints | float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min12ints | bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints | bools)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints | ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints | uints)>::value, "");
 min12ints = (min12ints | halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5549,7 +5549,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints | uint64_ts)>::value,
 min12ints = (min12ints | float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min12ints = (min12ints | float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min12ints = (min12ints | float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(min16uints | bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints | bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints | ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints | uints)>::value, "");
 min16uints = (min16uints | halfs);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5569,7 +5569,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints | uint64_ts)>::value
 min16uints = (min16uints | float16_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16uints = (min16uints | float32_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16uints = (min16uints | float64_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(int16_ts | bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts | bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts | ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts | uints)>::value, "");
 int16_ts = (int16_ts | halfs);   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
@@ -5577,9 +5577,9 @@ int16_ts = (int16_ts | floats);  /* expected-error {{int or unsigned int type re
 int16_ts = (int16_ts | doubles); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts | min16floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts | min10floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts | min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts | min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts | min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts | min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts | min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts | int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts | int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts | int64_ts)>::value, "");
@@ -5629,7 +5629,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts | uint64_ts)>::value,
 int64_ts = (int64_ts | float16_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts | float32_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts | float64_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(uint16_ts | bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts | bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts | ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts | uints)>::value, "");
 uint16_ts = (uint16_ts | halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
@@ -5637,9 +5637,9 @@ uint16_ts = (uint16_ts | floats);                           /* expected-error {{
 uint16_ts = (uint16_ts | doubles);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts | min16floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts | min10floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts | min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts | min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts | min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts | min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts | min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts | int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts | int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts | int64_ts)>::value, "");
@@ -5909,7 +5909,7 @@ min10floats = (min10floats ^ uint64_ts);                    /* expected-error {{
 min10floats = (min10floats ^ float16_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min10floats = (min10floats ^ float32_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min10floats = (min10floats ^ float64_ts);                   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min16ints ^ bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16int, __decltype(min16ints ^ bools)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min16ints ^ ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16ints ^ uints)>::value, "");
 min16ints = (min16ints ^ halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5929,7 +5929,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16ints ^ uint64_ts)>::value,
 min16ints = (min16ints ^ float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16ints = (min16ints ^ float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16ints = (min16ints ^ float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(min12ints ^ bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min12int, __decltype(min12ints ^ bools)>::value, "");    /* expected-warning {{min12int is promoted to int16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(min12ints ^ ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min12ints ^ uints)>::value, "");
 min12ints = (min12ints ^ halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5949,7 +5949,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min12ints ^ uint64_ts)>::value,
 min12ints = (min12ints ^ float16_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min12ints = (min12ints ^ float32_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min12ints = (min12ints ^ float64_ts);                       /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(min16uints ^ bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<min16uint, __decltype(min16uints ^ bools)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(min16uints ^ ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(min16uints ^ uints)>::value, "");
 min16uints = (min16uints ^ halfs);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3082: int or unsigned int type required}} */
@@ -5969,7 +5969,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(min16uints ^ uint64_ts)>::value
 min16uints = (min16uints ^ float16_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float16_ts'}} */
 min16uints = (min16uints ^ float32_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float32_ts'}} */
 min16uints = (min16uints ^ float64_ts);                     /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'float64_ts'}} */
-_Static_assert(std::is_same<int, __decltype(int16_ts ^ bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts ^ bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int, __decltype(int16_ts ^ ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(int16_ts ^ uints)>::value, "");
 int16_ts = (int16_ts ^ halfs);   /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
@@ -5977,9 +5977,9 @@ int16_ts = (int16_ts ^ floats);  /* expected-error {{int or unsigned int type re
 int16_ts = (int16_ts ^ doubles); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts ^ min16floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
 int16_ts = (int16_ts ^ min10floats);                        /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int16_ts'}} */
-_Static_assert(std::is_same<min16int, __decltype(int16_ts ^ min16ints)>::value, "");    /* expected-warning {{min16int is promoted to int16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<int16_t, __decltype(int16_ts ^ min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts ^ min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(int16_ts ^ min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(int16_ts ^ min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<int16_t, __decltype(int16_ts ^ int16_ts)>::value, "");
 _Static_assert(std::is_same<int32_t, __decltype(int16_ts ^ int32_ts)>::value, "");
 _Static_assert(std::is_same<int64_t, __decltype(int16_ts ^ int64_ts)>::value, "");
@@ -6029,7 +6029,7 @@ _Static_assert(std::is_same<uint64_t, __decltype(int64_ts ^ uint64_ts)>::value,
 int64_ts = (int64_ts ^ float16_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts ^ float32_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
 int64_ts = (int64_ts ^ float64_ts);                         /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'int64_ts'}} */
-_Static_assert(std::is_same<uint, __decltype(uint16_ts ^ bools)>::value, "");    /* expected-error {{static_assert failed ""}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts ^ bools)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint, __decltype(uint16_ts ^ ints)>::value, "");
 _Static_assert(std::is_same<uint, __decltype(uint16_ts ^ uints)>::value, "");
 uint16_ts = (uint16_ts ^ halfs); /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
@@ -6037,9 +6037,9 @@ uint16_ts = (uint16_ts ^ floats);                           /* expected-error {{
 uint16_ts = (uint16_ts ^ doubles);                          /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts ^ min16floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
 uint16_ts = (uint16_ts ^ min10floats);                      /* expected-error {{int or unsigned int type required}} fxc-error {{X3004: undeclared identifier 'uint16_ts'}} */
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts ^ min16ints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts ^ min16ints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts ^ min12ints)>::value, "");
-_Static_assert(std::is_same<min16uint, __decltype(uint16_ts ^ min16uints)>::value, "");    /* expected-warning {{min16uint is promoted to uint16_t}} fxc-pass {{}} */
+_Static_assert(std::is_same<uint16_t, __decltype(uint16_ts ^ min16uints)>::value, "");    /* fxc-pass {{}} */
 _Static_assert(std::is_same<uint16_t, __decltype(uint16_ts ^ int16_ts)>::value, "");
 _Static_assert(std::is_same<uint32_t, __decltype(uint16_ts ^ int32_ts)>::value, "");
 _Static_assert(std::is_same<uint64_t, __decltype(uint16_ts ^ int64_ts)>::value, "");

tools/clang/test/HLSL/scalar-operators.hlsl

@@ -99,7 +99,7 @@ float4 plain(float4 param4 : FOO) : FOO {
   _Static_assert(std::is_same<uint, __decltype(uints + min16ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints + min12ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints + min16uints)>::value, "");
-  _Static_assert(std::is_same<float, __decltype(halfs + bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs + bools)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs + ints)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs + uints)>::value, "");
   _Static_assert(std::is_same<half, __decltype(halfs + halfs)>::value, "");
@@ -220,7 +220,7 @@ float4 plain(float4 param4 : FOO) : FOO {
   _Static_assert(std::is_same<uint, __decltype(uints - min16ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints - min12ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints - min16uints)>::value, "");
-  _Static_assert(std::is_same<float, __decltype(halfs - bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs - bools)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs - ints)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs - uints)>::value, "");
   _Static_assert(std::is_same<half, __decltype(halfs - halfs)>::value, "");
@@ -341,7 +341,7 @@ float4 plain(float4 param4 : FOO) : FOO {
   _Static_assert(std::is_same<uint, __decltype(uints / min16ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints / min12ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints / min16uints)>::value, "");
-  _Static_assert(std::is_same<float, __decltype(halfs / bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs / bools)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs / ints)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs / uints)>::value, "");
   _Static_assert(std::is_same<half, __decltype(halfs / halfs)>::value, "");
@@ -420,7 +420,7 @@ float4 plain(float4 param4 : FOO) : FOO {
   _Static_assert(std::is_same<min16float, __decltype(min12ints / min16floats)>::value, "");
   _Static_assert(std::is_same<min10float, __decltype(min12ints / min10floats)>::value, "");  // expected-warning {{min10float is promoted to min16float}}
   // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
-  min12ints = (min12ints / min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
+  min12ints = (min12ints / min16ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} expected-warning {{conversion from larger type 'min16int' to smaller type 'min12int', possible loss of data}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}} fxc-warning {{X3205: conversion from larger type to smaller, possible loss of data}}
   // X:\temp\Sfbl_grfx_dev_p\x86\chk\operators.js.hlsl(16,22-56): error X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.;compilation failed; no code produced;
   min12ints = (min12ints / min12ints); // expected-error {{signed integer division is not supported on minimum-precision types, cast to int to use 32-bit division}} fxc-error {{X3706: signed integer division is not supported on minimum-precision types. Cast to int to use 32-bit division.}}
   _Static_assert(std::is_same<min16uint, __decltype(min12ints / min16uints)>::value, "");
@@ -471,7 +471,7 @@ float4 plain(float4 param4 : FOO) : FOO {
   _Static_assert(std::is_same<uint, __decltype(uints % min16ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints % min12ints)>::value, "");
   _Static_assert(std::is_same<uint, __decltype(uints % min16uints)>::value, "");
-  _Static_assert(std::is_same<float, __decltype(halfs % bools)>::value, "");
+  _Static_assert(std::is_same<half, __decltype(halfs % bools)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs % ints)>::value, "");
   _Static_assert(std::is_same<float, __decltype(halfs % uints)>::value, "");
   _Static_assert(std::is_same<half, __decltype(halfs % halfs)>::value, "");

tools/clang/test/HLSL/vector-syntax-exact-precision.hlsl

@@ -101,8 +101,8 @@ void vector_unsigned() {
    unsigned bool3 boolvector;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned half4 halfvector;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned double1 doublevector;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min12int2 min12intvector;                       /* expected-warning {{min12int is promoted to int16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min16float3 min16floatvector;                   /* expected-error {{'half' cannot be signed or unsigned}} expected-warning {{min16float is promoted to float16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2 min12intvector;                       /* expected-error {{'min12int' cannot be signed or unsigned}} expected-warning {{min12int is promoted to int16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min16float3 min16floatvector;                   /* expected-error {{'min16float' cannot be signed or unsigned}} expected-warning {{min16float is promoted to float16_t}} fxc-error {{X3085: unsigned can not be used with type}} */
 
    unsigned int16_t1 int16_tvector;                         /* fxc-error {{X3000: syntax error: unexpected token 'int16_t1'}} */
    unsigned int32_t1 int32_tvector;                         /* fxc-error {{X3000: syntax error: unexpected token 'int32_t1'}} */

tools/clang/test/HLSL/vector-syntax.hlsl

@@ -99,9 +99,9 @@ void vector_unsigned() {
 
    unsigned float2 floatvector; /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned bool3 boolvector;   /* expected-error {{'bool' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned half4 halfvector;   /* expected-error {{'float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned half4 halfvector;   /* expected-error {{'half' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned double1 doublevector;                           /* expected-error {{'double' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
-   unsigned min12int2 min12intvector;                       /* expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
+   unsigned min12int2 min12intvector;                       /* expected-error {{'min12int' cannot be signed or unsigned}} expected-warning {{min12int is promoted to min16int}} fxc-error {{X3085: unsigned can not be used with type}} */
    unsigned min16float3 min16floatvector;                   /* expected-error {{'min16float' cannot be signed or unsigned}} fxc-error {{X3085: unsigned can not be used with type}} */
 }