[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

6848–6849

clang/lib/Basic/LangOptions.cpp

198–199

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

clang/lib/Basic/Targets/DirectX.h

62

Should this be tied to the Half language option?

clang/lib/Sema/SemaType.cpp

1514 ↗

(On Diff #426461)

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

198–199

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

62

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

1514 ↗

(On Diff #426461)

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

198–199

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

198–199

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

198–199

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

198–199

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

[beanz]

clang/lib/Basic/LangOptions.cpp

198–199

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

166

-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

198–199

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

198–199

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

1713–1719

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 dxc_D : Option<["--", "/", "-"], "D", KIND_JOINED_OR_SEPARATE>,
   Group<dxc_Group>, Flags<[DXCOption, NoXarchOption]>, Alias<D>;
 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/AST/ASTContext.cpp

 /// scalar floating point type.
 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   switch (T->castAs<BuiltinType>()->getKind()) {
   default:
     llvm_unreachable("Not a floating point type!");
   case BuiltinType::BFloat16:
     return Target->getBFloat16Format();
   case BuiltinType::Float16:
+    return Target->getHalfFormat();
   case BuiltinType::Half:
+    // For HLSL, when the native half type is disabled, half will be treat as
+    // float.
+    if (getLangOpts().HLSL)
+      if (getLangOpts().NativeHalfType)
+        return Target->getHalfFormat();
+      else
+        return Target->getFloatFormat();
+    else
       return Target->getHalfFormat();
   case BuiltinType::Float:      return Target->getFloatFormat();
   case BuiltinType::Double:     return Target->getDoubleFormat();
   case BuiltinType::Ibm128:
     return Target->getIbm128Format();
   case BuiltinType::LongDouble:
     if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)
       return AuxTarget->getLongDoubleFormat();
     return Target->getLongDoubleFormat();

clang/lib/AST/MicrosoftMangle.cpp

case BuiltinType::NullPtr:
     Out << "$$T";
     break;
 
   case BuiltinType::Float16:
     mangleArtificialTagType(TTK_Struct, "_Float16", {"__clang"});
     break;
 
   case BuiltinType::Half:
+    if (!getASTContext().getLangOpts().HLSL)
       mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
+    else if (getASTContext().getLangOpts().NativeHalfType)
+      Out << "$f16@";
+    else
+      Out << "$halff@";
     break;
 
 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define PPC_VECTOR_TYPE(Name, Id, Size) \
   case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"

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");
+    TheCXXABI.set(TargetCXXABI::Microsoft);
   }
-
+  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) ||
       !Args.hasArg(options::OPT_cl_no_stdinc)) {
     CmdArgs.push_back("-finclude-default-header");
     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_D, options::OPT_S,
-      options::OPT_emit_llvm, options::OPT_disable_llvm_passes};
+  const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
+                                         options::OPT_D,
+                                         options::OPT_S,
+                                         options::OPT_emit_llvm,
+                                         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);
   // Add the default headers if dxc_no_stdinc is not set.
   if (!Args.hasArg(options::OPT_dxc_no_stdinc))
     CmdArgs.push_back("-finclude-default-header");
+  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/test/CodeGenHLSL/basic_types.hlsl

 // RUN: %clang_dxc  -Tlib_6_7 -fcgl -Fo - %s | FileCheck %s
 
 // FIXME: check 16bit types once enable-16bit-types is ready.
 
-// CHECK:@uint_Val = global i32 0, align 4
-// CHECK:@uint64_t_Val = global i64 0, align 8
-// CHECK:@int64_t_Val = global i64 0, align 8
-// CHECK:@int2_Val = global <2 x i32> zeroinitializer, align 8
-// CHECK:@int3_Val = global <3 x i32> zeroinitializer, align 16
-// CHECK:@int4_Val = global <4 x i32> zeroinitializer, align 16
-// CHECK:@uint2_Val = global <2 x i32> zeroinitializer, align 8
-// CHECK:@uint3_Val = global <3 x i32> zeroinitializer, align 16
-// CHECK:@uint4_Val = global <4 x i32> zeroinitializer, align 16
-// CHECK:@int64_t2_Val = global <2 x i64> zeroinitializer, align 16
-// CHECK:@int64_t3_Val = global <3 x i64> zeroinitializer, align 32
-// CHECK:@int64_t4_Val = global <4 x i64> zeroinitializer, align 32
-// CHECK:@uint64_t2_Val = global <2 x i64> zeroinitializer, align 16
-// CHECK:@uint64_t3_Val = global <3 x i64> zeroinitializer, align 32
-// CHECK:@uint64_t4_Val = global <4 x i64> zeroinitializer, align 32
-// CHECK:@float2_Val = global <2 x float> zeroinitializer, align 8
-// CHECK:@float3_Val = global <3 x float> zeroinitializer, align 16
-// CHECK:@float4_Val = global <4 x float> zeroinitializer, align 16
-// CHECK:@double2_Val = global <2 x double> zeroinitializer, align 16
-// CHECK:@double3_Val = global <3 x double> zeroinitializer, align 32
-// CHECK:@double4_Val = global <4 x double> zeroinitializer, align 32
+// CHECK:"?uint_Val@@3IA" = global i32 0, align 4
+// CHECK:"?uint64_t_Val@@3KA" = global i64 0, align 8
+// CHECK:"?int64_t_Val@@3JA" = global i64 0, align 8
+// CHECK:"?int2_Val@@3T?$__vector@H$01@__clang@@A" = global <2 x i32> zeroinitializer, align 8
+// CHECK:"?int3_Val@@3T?$__vector@H$02@__clang@@A" = global <3 x i32> zeroinitializer, align 16
+// CHECK:"?int4_Val@@3T?$__vector@H$03@__clang@@A" = global <4 x i32> zeroinitializer, align 16
+// CHECK:"?uint2_Val@@3T?$__vector@I$01@__clang@@A" = global <2 x i32> zeroinitializer, align 8
+// CHECK:"?uint3_Val@@3T?$__vector@I$02@__clang@@A" = global <3 x i32> zeroinitializer, align 16
+// CHECK:"?uint4_Val@@3T?$__vector@I$03@__clang@@A" = global <4 x i32> zeroinitializer, align 16
+// CHECK:"?int64_t2_Val@@3T?$__vector@J$01@__clang@@A" = global <2 x i64> zeroinitializer, align 16
+// CHECK:"?int64_t3_Val@@3T?$__vector@J$02@__clang@@A" = global <3 x i64> zeroinitializer, align 32
+// CHECK:"?int64_t4_Val@@3T?$__vector@J$03@__clang@@A" = global <4 x i64> zeroinitializer, align 32
+// CHECK:"?uint64_t2_Val@@3T?$__vector@K$01@__clang@@A" = global <2 x i64> zeroinitializer, align 16
+// CHECK:"?uint64_t3_Val@@3T?$__vector@K$02@__clang@@A" = global <3 x i64> zeroinitializer, align 32
+// CHECK:"?uint64_t4_Val@@3T?$__vector@K$03@__clang@@A" = global <4 x i64> zeroinitializer, align 32
+// CHECK:"?float2_Val@@3T?$__vector@M$01@__clang@@A" = global <2 x float> zeroinitializer, align 8
+// CHECK:"?float3_Val@@3T?$__vector@M$02@__clang@@A" = global <3 x float> zeroinitializer, align 16
+// CHECK:"?float4_Val@@3T?$__vector@M$03@__clang@@A" = global <4 x float> zeroinitializer, align 16
+// CHECK:"?double2_Val@@3T?$__vector@N$01@__clang@@A" = global <2 x double> zeroinitializer, align 16
+// CHECK:"?double3_Val@@3T?$__vector@N$02@__clang@@A" = global <3 x double> zeroinitializer, align 32
+// CHECK:"?double4_Val@@3T?$__vector@N$03@__clang@@A" = global <4 x double> zeroinitializer, align 32
 
 #define TYPE_DECL(T)  T T##_Val
 
 #ifdef __HLSL_ENABLE_16_BIT
 TYPE_DECL(uint16_t);
 TYPE_DECL(int16_t);
 #endif
 

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 @"?foo@@YA$halff@$halff@0@Z"(float{{[^,]+}}, float{{[^,)]+}})
+// FLOAT-NOT:half
+// FLOAT:ret float %
+
+// Make sure use half when enable-16bit-types.
+// HALF:define {{.*}}half @"?foo@@YA$f16@$f16@0@Z"(half{{[^,]+}}, half{{[^,)]+}})
+// HALF-NOT:float
+// HALF:ret half %
+half foo(half a, half b) {
+  return a+b;
+}