[HLSL] Enable half type for hlsl.

[python3kgae]

Summary

HLSL supports half type.
When enable-16bit-types is not set, half will be treated as float.
When enable-16bit-types is set, half will be treated like real 16bit float type and map to llvm half type.
Also change CXXABI to Microsoft to match dxc behavior.
The mangle name for half is "$f16@" when half is treat as native half type and "$halff@" when treat as float.

In AST, half is still half.
The special thing is done at clang codeGen, when NativeHalfType is false, half will translated into float.

[aaron.ballman]

clang/include/clang/Driver/Options.td

6762–6763

clang/lib/Basic/LangOptions.cpp

196–197

Shouldn't this be looking for HLSL 2018? Or shader model 6.2?

clang/lib/Basic/Targets/DirectX.h

61

Should this be tied to the Half language option?

clang/lib/Sema/SemaType.cpp

1513

This change seems wrong to me -- if the half type isn't supported, how does the user spell the type such that we can even get here?

clang/test/CodeGenHLSL/half.hlsl

16

FWIW, this test seems to be failing precommit CI.

We should also have tests for the new driver flag and Sema tests showing that you can't spell half in unsupported HLSL modes.

[python3kgae]

clang/lib/Basic/LangOptions.cpp

196–197

half keyword is always available.
Without enable_16bit_types, half will be like using half=float.
With enable_16bit_types, half will be real half.

The check for HLSL 2018 and shader model 6.2 will be in another PR, still WIP. I'll add FIXME about it.

clang/lib/Basic/Targets/DirectX.h

61

We don't want to conversion FP16, with or without enable_16bit_types.
With enable_16bit_types, it is half, don't need conversion.
Without enable_16bit_types, it will be a float, don't need conversion either.

clang/lib/Sema/SemaType.cpp

1513

Half keyword is always available for hlsl.
When enable_16bit_types, NativeHalfType will be true, half will be a real half.
When not enable_16bit_types, NativeHalfType will be false, half will be float.

clang/test/CodeGenHLSL/half.hlsl

16

I think the issue is this test require build DirectX backend target.
I'll change it to work without DirectX backend target.

[aaron.ballman]

clang/lib/Basic/LangOptions.cpp

196–197

half keyword is always available.
Without enable_16bit_types, half will be like using half=float.
With enable_16bit_types, half will be real half.

Is there room for change here, or is this strictly required by HLSL? This strikes me as just begging to confuse users into creating ODR violations. CC @beanz

[python3kgae]

clang/lib/Basic/LangOptions.cpp

196–197

Here's the doc about half for dxc.
https://github.com/microsoft/DirectXShaderCompiler/wiki/16-Bit-Scalar-Types

Old doc for fxc (the old shader compiler for shader model <= 5.1) is here
https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-scalar

Change the behavior might affect a lot of existing shaders.

[python3kgae]

Add option -fcgl which output clang codeGen result to avoid test dependent on build DirectX backend.

[python3kgae]

clang/lib/Basic/LangOptions.cpp

196–197

More detail about half from https://github.com/tex3d.

half originally mapped to a fuzzy "partial precision" float, where some operations were designated as _pp, meaning the implementation was free to use lower-precision math for those operations (like 24-bit, but not specified for the language). All storage in host-visible memory would still be float. "partial precision" went away with DX9, eventually to be replaced with min-precision with a specific minimum precision an implementation was allowed to use. When "partial precision" went away, it simply mapped to float for DX10+.
People could have tried to use it liberally when they thought 32-bit precision wasn't necessary, without explicitly targeting/testing API/hardware that actually supported lower precision.

[aaron.ballman]

In D124790#3489690, @python3kgae wrote:

Add option -fcgl which output clang codeGen result to avoid test dependent on build DirectX backend.

Thanks -- I think this should actually be a separate patch though, because it's not really related to the half datatype. (You can always wait to land this patch until after the -fcgl one has landed.)

Aside from the -fcgl flag, this looks ready to go though.

clang/lib/Basic/LangOptions.cpp

196–197

Thank you for the extra information, it sounds like we're stuck supporting this.

[beanz]

clang/lib/Basic/LangOptions.cpp

196–197

Because HLSL’s library linking mode is pretty constrained, in practice this hasn’t hurt us yet. That said, I think we probably should consider some retroactive changes to how we handle float-16, especially in the presence of library shaders…

I’ll try and float this topic in some team meetings this week and see if we can come up with a set of tweaks that may have limited impact on existing code. We might be able to change the default behavior in clang with a switch to toggle back to the old mode for legacy code.

clang/lib/Driver/ToolChains/HLSL.cpp

177

-fcgl also should imply -disable-llvm-options

[python3kgae]

Rebase for fcgl change.

[aaron.ballman]

This change should likely also have some Sema tests demonstrating what happens during constant expression evaluation, or narrowing conversions, etc given that the type may have different behavior.

clang/lib/Basic/LangOptions.cpp

196–197

I’ll try and float this topic in some team meetings this week and see if we can come up with a set of tweaks that may have limited impact on existing code. We might be able to change the default behavior in clang with a switch to toggle back to the old mode for legacy code.

Thanks, both for the awesome pun ("float this topic", lol) and for checking on this. Let's hold off on this patch until we hear more on whether we want to change the default behavior in Clang here or not.

[python3kgae]

Add Sema test.

[python3kgae]

clang/lib/Basic/LangOptions.cpp

196–197

Finally got this discussed today.
The result is we should do the same thing as dxc for back-compat.
And that will require half has a special name when mangling even when half is 16bit type.
Will update the PR shortly.

[python3kgae]

Change CXXABI to Microsoft to match dxc behavior.
The mangle name for half is "$f16@" when half is treat as native half type and "$halff@" when treat as float.

And now in AST, half is still half. Only in clang codeGen half will translated into float when enable-16bit-types is flase.

[aaron.ballman]

LGTM aside from some minor changes.

clang/lib/AST/ASTContext.cpp

1712 ↗

(On Diff #438220)

1713–1719 ↗

(On Diff #438220)

clang/lib/Basic/Targets/DirectX.h

60

Though I'd also be fine removing the comment as it doesn't really do much except restate the next line.

[python3kgae]

Cleanup comments.

[python3kgae]

Thanks for the review.
Updated the comments.

clang/include/clang/Driver/Options.td

Values<"ps_6_0, ps_6_1, ps_6_2, ps_6_3, ps_6_4, ps_6_5, ps_6_6, ps_6_7,"
          "gs_6_0, gs_6_1, gs_6_2, gs_6_3, gs_6_4, gs_6_5, gs_6_6, gs_6_7,"
          "hs_6_0, hs_6_1, hs_6_2, hs_6_3, hs_6_4, hs_6_5, hs_6_6, hs_6_7,"
          "ds_6_0, ds_6_1, ds_6_2, ds_6_3, ds_6_4, ds_6_5, ds_6_6, ds_6_7,"
          "cs_6_0, cs_6_1, cs_6_2, cs_6_3, cs_6_4, cs_6_5, cs_6_6, cs_6_7,"
          "lib_6_3, lib_6_4, lib_6_5, lib_6_6, lib_6_7, lib_6_x,"
          "ms_6_5, ms_6_6, ms_6_7,"
          "as_6_5, as_6_6, as_6_7">;
 def emit_pristine_llvm : DXCFlag<"emit-pristine-llvm">,
   HelpText<"Emit pristine LLVM IR from the frontend by not running any LLVM passes at all."
            "Same as -S + -emit-llvm + -disable-llvm-passes.">;
 def fcgl : DXCFlag<"fcgl">, Alias<emit_pristine_llvm>;
+def enable_16bit_types : DXCFlag<"enable-16bit-types">, Alias<fnative_half_type>,
+  HelpText<"Enable 16-bit types and disable min precision types."
+           "Available in HLSL 2018 and shader model 6.2.">;

clang/lib/Basic/LangOptions.cpp

if (Opts.HIP) {
     Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
   }
 
   Opts.RenderScript = Lang == Language::RenderScript;
 
   // OpenCL, C++ and C2x have bool, true, false keywords.
   Opts.Bool = Opts.OpenCL || Opts.CPlusPlus || Opts.C2x;
 
-  // OpenCL has half keyword
-  Opts.Half = Opts.OpenCL;
+  // OpenCL and HLSL have half keyword
+  Opts.Half = Opts.OpenCL || Opts.HLSL;
 }
 
 FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
   FPOptions result(LO);
   return result;
 }
 
 LLVM_DUMP_METHOD void FPOptions::dump() {

clang/lib/Basic/Targets/DirectX.h

DirectXTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
     LongWidth = LongAlign = 64;
     AddrSpaceMap = &DirectXAddrSpaceMap;
     UseAddrSpaceMapMangling = true;
     HasLegalHalfType = true;
     HasFloat16 = true;
     NoAsmVariants = true;
     resetDataLayout("e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:"
                     "32-f64:64-n8:16:32:64");
   }
-
+  bool useFP16ConversionIntrinsics() const override { return false; }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   bool hasFeature(StringRef Feature) const override {
     return Feature == "directx";
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }

clang/lib/Driver/ToolChains/Clang.cpp

if ((types::isOpenCL(InputType) ||
     CmdArgs.push_back("-fdeclare-opencl-builtins");
   }
 }
 
 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs,
                               types::ID InputType) {
   const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
                                          options::OPT_S, options::OPT_emit_llvm,
-                                         options::OPT_disable_llvm_passes};
+                                         options::OPT_disable_llvm_passes,
+                                         options::OPT_fnative_half_type};
 
   for (const auto &Arg : ForwardedArguments)
     if (const auto *A = Args.getLastArg(Arg))
       A->renderAsInput(Args, CmdArgs);
+  CmdArgs.push_back("-fallow-half-arguments-and-returns");
 }
 
 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args,
                                         ArgStringList &CmdArgs) {
   bool ARCMTEnabled = false;
   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
                                        options::OPT_ccc_arcmt_modify,

clang/lib/Driver/ToolChains/HLSL.cpp

if (A->getOption().getID() == options::OPT_dxil_validator_version) {
       if (!isLegalValidatorVersion(ValVerStr, getDriver()))
         continue;
     }
     if (A->getOption().getID() == options::OPT_emit_pristine_llvm) {
       // Translate fcgl into -S -emit-llvm and -disable-llvm-passes.
       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_S));
       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_emit_llvm));
       DAL->AddFlagArg(nullptr,
                       Opts.getOption(options::OPT_disable_llvm_passes));
       A->claim();
       continue;
     }
     DAL->append(A);
   }
   // Add default validator version if not set.
   // TODO: remove this once read validator version from validator.
   if (!DAL->hasArg(options::OPT_dxil_validator_version)) {
     const StringRef DefaultValidatorVer = "1.7";
     DAL->AddSeparateArg(nullptr,
                         Opts.getOption(options::OPT_dxil_validator_version),
                         DefaultValidatorVer);
   }
+  // FIXME: add validation for enable_16bit_types should be after HLSL 2018 and
+  // shader model 6.2.
   return DAL;
 }

clang/lib/Sema/SemaType.cpp

case DeclSpec::TST_float16:
     // do not diagnose _Float16 usage to avoid false alarm.
     // ToDo: more precise diagnostics for CUDA.
     if (!S.Context.getTargetInfo().hasFloat16Type() && !S.getLangOpts().CUDA &&
         !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "_Float16";
     Result = Context.Float16Ty;
     break;
-  case DeclSpec::TST_half:    Result = Context.HalfTy; break;
+  case DeclSpec::TST_half:
+    // For HLSL, when not enable native half type, half will be treat as float.
+    if (S.getLangOpts().HLSL && !S.getLangOpts().NativeHalfType)
+      Result = Context.FloatTy;
+    else
+      Result = Context.HalfTy;
+    break;
   case DeclSpec::TST_BFloat16:
     if (!S.Context.getTargetInfo().hasBFloat16Type())
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "__bf16";
     Result = Context.BFloat16Ty;
     break;
   case DeclSpec::TST_float:   Result = Context.FloatTy; break;
   case DeclSpec::TST_double:

clang/test/CodeGenHLSL/half.hlsl

+// RUN: %clang_dxc -Tlib_6_7 -fcgl  -Fo - %s | FileCheck %s --check-prefix=FLOAT
+// RUN: %clang_dxc -Tlib_6_7 -enable-16bit-types -fcgl  -Fo - %s | FileCheck %s --check-prefix=HALF
+
+// Make sure use float when not enable-16bit-types.
+// FLOAT:define {{.*}}float @_Z3fooff(float{{[^,]+}}, float{{[^,)]+}})
+// FLOAT-NOT:half
+// FLOAT:ret float %
+
+// Make sure use half when enable-16bit-types.
+// HALF:define {{.*}}half @_Z3fooDhDh(half{{[^,]+}}, half{{[^,)]+}})
+// HALF-NOT:float
+// HALF:ret half %
+half foo(half a, half b) {
+  return a+b;
+}

clang/test/SemaHLSL/half.hlsl

+// RUN: %clang_cc1 -xhlsl -triple dxil-pc-shadermodel6.7-compute -validator-version 1.0 -fnative-half-arguments-and-returns -ast-dump -fnative-half-type -o - %s | FileCheck %s --check-prefix=F16
+// RUN: %clang_cc1 -xhlsl -triple dxil-pc-shadermodel6.7-compute -validator-version 1.0 -fnative-half-arguments-and-returns -ast-dump -o - %s | FileCheck %s --check-prefix=F32
+
+// Make sure when -fnative-half-type is enabled, half is half in ast.
+// F16:FunctionDecl 0x{{.*}} <{{.*}}\half.hlsl:27:1, line:29:1> line:27:6 foo 'half (half, float)'
+// F16:ParmVarDecl 0x{{.*}} <col:10, col:15> col:15 used a 'half'
+// F16:ImplicitCastExpr 0x{{.*}} <col:10, col:12> 'half' <FloatingCast>
+// F16:BinaryOperator 0x{{.*}} <col:10, col:12> 'float' '+'
+// F16:VarDecl 0x{{.*}} <line:31:1, col:23> col:19 used h 'const half' static cinit
+// F16:ImplicitCastExpr 0x{{.*}} <col:23> 'const half' <FloatingCast>
+// F16:VarDecl 0x{{.*}} <line:32:1, col:24> col:20 used f 'const float' static cinit
+// F16:VarDecl 0x{{.*}} <line:33:1, col:28> col:19 h2 'const half' static cinit
+// F16:ImplicitCastExpr 0x{{.*}} <col:24, col:28> 'const half' <FloatingCast>
+
+// Make sure when -fnative-half-type is disabled, half is float in ast.
+// F32:FunctionDecl 0x{{.*}} <{{.*}}\half.hlsl:27:1, line:29:1> line:27:6 foo 'float (float, float)'
+// F32:ParmVarDecl 0x{{.*}} <col:10, col:15> col:15 used a 'float'
+// F32-NOT:FloatingCast
+// F32:BinaryOperator 0x{{.*}} <col:10, col:12> 'float' '+'
+// F32:VarDecl 0x{{.*}} <line:31:1, col:23> col:19 used h 'const float' static cinit
+// F32-NOT:FloatingCast
+// F32:VarDecl 0x{{.*}} <line:32:1, col:24> col:20 used f 'const float' static cinit
+// F32-NOT:FloatingCast
+// F32:VarDecl 0x{{.*}} <line:33:1, col:28> col:19 h2 'const float' static cinit
+// F32:BinaryOperator 0x{{.*}} <col:24, col:28> 'float' '+'
+
+half foo(half a, float b) {
+  return a+b;
+}
+
+static const half h = 1.0f;
+static const float f = 2.0f;
+static const half h2 = h + f;
+
+