[202x] Implementaiton of conforming literals (#6572)

This change implements the conforming literals proposal as documented in
proposal 0017:


https://github.com/microsoft/hlsl-specs/blob/main/proposals/0017-conform
ing-literals.md

Fixes #6537

---------

Co-authored-by: Damyan Pepper <[email protected]>

Author: llvm-beanz

tools/clang/include/clang/AST/HlslTypes.h

@@ -457,6 +457,7 @@ clang::QualType GetElementTypeOrType(clang::QualType type);
 bool HasHLSLMatOrientation(clang::QualType type, bool *pIsRowMajor = nullptr);
 bool IsHLSLMatRowMajor(clang::QualType type, bool defaultValue);
 bool IsHLSLUnsigned(clang::QualType type);
+bool IsHLSLMinPrecision(clang::QualType type);
 bool HasHLSLUNormSNorm(clang::QualType type, bool *pIsSNorm = nullptr);
 bool HasHLSLGloballyCoherent(clang::QualType type);
 bool IsHLSLInputPatchType(clang::QualType type);

tools/clang/lib/AST/HlslTypes.cpp

@@ -224,6 +224,22 @@ bool IsHLSLUnsigned(clang::QualType type) {
   return type->isUnsignedIntegerType();
 }
 
+bool IsHLSLMinPrecision(clang::QualType Ty) {
+  Ty = Ty.getCanonicalType().getNonReferenceType();
+  if (auto BT = Ty->getAs<clang::BuiltinType>()) {
+    switch (BT->getKind()) {
+    case clang::BuiltinType::Min12Int:
+    case clang::BuiltinType::Min16Int:
+    case clang::BuiltinType::Min16UInt:
+    case clang::BuiltinType::Min16Float:
+    case clang::BuiltinType::Min10Float:
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool HasHLSLUNormSNorm(clang::QualType type, bool *pIsSNorm) {
   // snorm/unorm can be on outer vector/matrix as well as element type
   // in the template form.  Outer-most type attribute wins.

tools/clang/lib/Basic/TargetInfo.cpp

@@ -278,6 +278,29 @@ void TargetInfo::adjust(const LangOptions &Opts) {
   if (Opts.ShortWChar)
     WCharType = UnsignedShort;
 
+  // HLSL Change Begin
+  // We should have always set these values for HLSL, but instead we hacked
+  // ASTContext::getTypeInfoImpl to override some of the uses (but not all).
+  // With 202x relying more on Clang's C/C++ support we need to correctly set
+  // the TargetInfo at least for this subset of types. This change probably
+  // shouldn't be dependent on the language version, but I made it this way to
+  // reduce any unforseen risk.
+  if (Opts.HLSL) {
+    // DXILTargetInfo in Tergets.cpp sets base values that aren't dependent on
+    // language options. The values here adjust the base values once the
+    // language options are initialized.
+    if (Opts.HLSLVersion >= hlsl::LangStd::v202x) {
+      IntWidth = IntAlign = 32;
+      LongLongWidth = LongLongAlign = 64;
+      if (!Opts.UseMinPrecision)
+        HalfWidth = HalfAlign = 16;
+      else
+        HalfWidth = HalfAlign = 32;
+      FloatWidth = FloatAlign = 32;
+    }
+  }
+  // HLSL Change End
+
   if (Opts.OpenCL) {
     // OpenCL C requires specific widths for types, irrespective of
     // what these normally are for the target.

tools/clang/lib/Frontend/InitPreprocessor.cpp

@@ -376,6 +376,10 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
     // HLSL Version
     Builder.defineMacro("__HLSL_VERSION",
                         Twine((unsigned int)LangOpts.HLSLVersion));
+    // This define is enabled in Clang and allows conditionally compiling code
+    // based on whether or not native 16-bit types are supported.
+    if (!LangOpts.UseMinPrecision)
+      Builder.defineMacro("__HLSL_ENABLE_16_BIT", "1");
     // Shader target information
     // "enums" for shader stages
     Builder.defineMacro("__SHADER_STAGE_VERTEX",  Twine((unsigned)hlsl::DXIL::ShaderKind::Vertex));

tools/clang/lib/Sema/SemaExpr.cpp

@@ -3257,7 +3257,7 @@ ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) {
   unsigned IntSize = Context.getTargetInfo().getIntWidth();
   // HLSL Change Starts - HLSL literal int
   QualType Ty;
-  if (getLangOpts().HLSL) {
+  if (getLangOpts().HLSL && getLangOpts().HLSLVersion < hlsl::LangStd::v202x) {
     IntSize = 64;
     Ty = Context.LitIntTy;
   } else
@@ -3451,13 +3451,21 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
 
       Ty = Context.FloatTy;
     // HLSL Change Starts
-    else if (getLangOpts().HLSL && !Literal.isLong && !Literal.isHalf)
+    else if (getLangOpts().HLSL &&
+             getLangOpts().HLSLVersion < hlsl::LangStd::v202x &&
+             !Literal.isLong && !Literal.isHalf)
       Ty = Context.LitFloatTy;
-    else if (getLangOpts().HLSL && Literal.isLong)
+    else if (Literal.isLong)
       Ty = Context.DoubleTy;
-    else if (getLangOpts().HLSL && Literal.isHalf) {
-      Ty = getLangOpts().UseMinPrecision ? Context.FloatTy : Context.HalfTy;
-    }
+    else if (Literal.isHalf) {
+      if (getLangOpts().HLSL &&
+          getLangOpts().HLSLVersion < hlsl::LangStd::v202x)
+        Ty = getLangOpts().UseMinPrecision ? Context.FloatTy : Context.HalfTy;
+      else
+        Ty = getLangOpts().UseMinPrecision ? Context.HalfFloatTy
+                                           : Context.HalfTy;
+    } else if (getLangOpts().HLSL)
+      Ty = Context.FloatTy;
     // HLSL Change Ends
     else if (!Literal.isLong)
       Ty = Context.DoubleTy;
@@ -3480,7 +3488,8 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
     return ExprError();
 
   // HLSL Change Starts
-  } else if (getLangOpts().HLSL) {
+  } else if (getLangOpts().HLSL &&
+             getLangOpts().HLSLVersion < hlsl::LangStd::v202x) {
     QualType Ty;
     unsigned Width = 64;
     llvm::APInt ResultVal(Width, 0);
@@ -3519,8 +3528,9 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
   } else {
     QualType Ty;
 
+    // HLSL Change: disable the warning below.
     // 'long long' is a C99 or C++11 feature.
-    if (!getLangOpts().C99 && Literal.isLongLong) {
+    if (!getLangOpts().HLSL && !getLangOpts().C99 && Literal.isLongLong) {
       if (getLangOpts().CPlusPlus)
         Diag(Tok.getLocation(),
              getLangOpts().CPlusPlus11 ?
@@ -3590,6 +3600,17 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
         }
       }
 
+      // HLSL Change Begin - Treat `long` literal as `long long`
+      // This is a bit hacky. HLSL doesn't really have a `long` or `long long`
+      // type so the specification has simplified the suffices. Unfortunately,
+      // rather than just treating `ll` as `l` we need to do the inverse. This
+      // is because we rely on the MSVC mangling which follows LLP64 (l being
+      // 32-bit and ll 64-bit). We should find a better solution to this in
+      // Clang.
+      if (getLangOpts().HLSL && !Literal.isLongLong)
+        Literal.isLongLong = Literal.isLong;
+      // HLSL Change End
+
       // Are long/unsigned long possibilities?
       if (Ty.isNull() && !Literal.isLongLong) {
         unsigned LongSize = Context.getTargetInfo().getLongWidth();
@@ -3603,7 +3624,9 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
             Ty = Context.UnsignedLongTy;
           // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2
           // is compatible.
-          else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {
+          // HLSL Change: HLSL will promote to the next signed integer type.
+          else if (!getLangOpts().HLSL && !getLangOpts().C99 &&
+                   !getLangOpts().CPlusPlus11) {
             const unsigned LongLongSize =
                 Context.getTargetInfo().getLongLongWidth();
             Diag(Tok.getLocation(),
@@ -6319,8 +6342,17 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
 
   // HLSL Change Starts: HLSL supports a vector condition and is
   // sufficiently different to merit its own checker.
-  if (getLangOpts().HLSL)
-    return hlsl::CheckVectorConditional(this, Cond, LHS, RHS, QuestionLoc);
+  if (getLangOpts().HLSL) {
+    // For HLSL 202x+ in a ternary operator we follow C++ rules unless both the
+    // right and left are minimum precision types, or either type is not a
+    // builtin scalar integer or float (e.g. vector, matrix, UDT).
+    QualType LHSTy = LHS.get()->getType();
+    QualType RHSTy = RHS.get()->getType();
+    if (getLangOpts().HLSLVersion < hlsl::LangStd::v202x ||
+        !LHSTy->isBuiltinType() || !RHSTy->isBuiltinType() ||
+        (hlsl::IsHLSLMinPrecision(LHSTy) && hlsl::IsHLSLMinPrecision(RHSTy)))
+      return hlsl::CheckVectorConditional(this, Cond, LHS, RHS, QuestionLoc);
+  }
   // HLSL Change Ends
 
   // C++ is sufficiently different to merit its own checker.

tools/clang/test/SemaHLSL/v202x/conforming-literals/asfloat16.hlsl

@@ -0,0 +1,7 @@
+// RUN: %dxc -T lib_6_3 -HV 202x -verify -enable-16bit-types %s
+
+void fn() {
+  half H = asfloat16(1.0);
+  // expected-error@-1{{no matching function for call to 'asfloat16'}}
+  // expected-note@-2{{candidate function not viable: no known conversion from 'float' to 'half' for 1st argument}}
+}