[HLSL] Add abs library function

[beanz]

Summary

This change exposes the abs library function for HLSL scalar types. Abs
is supported for all scalar, vector and matrix types. This patch only
adds a subset of scalar type support.

Fixes #57100 (https://llvm.org/pr57100)

The full documentation of the HLSL abs function is available here:
https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-abs

[python3kgae]

clang/lib/Headers/hlsl/hlsl_intrinsics.h

17

How to add 16bit abs?
Something like this?

#ifdef HLSL_ENABLE_16_BIT
attribute((clang_builtin_alias(builtin_fabsf16))) half abs(half In);
#endif

[beanz]

Adding missing test coverage for 64-bit types

[beanz]

Updating with a fix for half type parameters. This addresses the issue I filed here: https://github.com/llvm/llvm-project/issues/57100

The issue was caused by HLSL not implying options to allow half types to be used as parameters and return types.

[bob80905]

clang/test/CodeGenHLSL/builtins/abs.hlsl

20

Is there a reason why we don't check the function parameter here, but we do check for function parameters when actually calling the builtin intrinsic on the next call line?

[bob80905]

clang/include/clang/Driver/Options.td

6130

In Clang.cpp, you removed CmdArgs.push_back("-fallow-half-arguments-and-returns");
But here, you add an extra condition to imply fnative-half-arguments-and-returns
Wouldn't this change the behavior? or is it really alright for the definition below, fallow_half_arguments_and_returns , to be missing hlsl.KeyPath in the implication list?

[beanz]

clang/include/clang/Driver/Options.td

6130

The big issue with the change in Clang.cpp is that it only works if you invoke clang-dxc, not if you invoke clang directly with an hlsl source. That has the undesirable effect of making clang HLSL support only work through the clang-dxc driver, which isn't what we want.

There is also a subtle difference between native and non-native half arguments and returns, where non-native half arguments and returns are actually passed as larger float types. Which also isn't correct for HLSL.

This change follows how OpenCL works, and enables -fnative-half-arguments-and-returns whenever the HLSL language mode is enabled, and that option also implies -fhalf-arguments-and-returns.

The big functional change here is that you don't need to ever manually pass these flags to clang if your language is HLSL, so you can use any clang driver entry and get the correct behavior for the language.

clang/test/CodeGenHLSL/builtins/abs.hlsl

20

The check lines on the function declarations are really just to make sure that the next match occurs in the function body. The real test is to make sure the body gets generated correctly.

That said, matching the full mangled name has the same impact as matching the parameters too because the name mangling encodes the parameters too. The NN specifies the return and first argument parameters are doubles.

[bogner]

LGTM. Make sure you update the description from saying that this doesn't handle half because of https://llvm.org/pr57100 to saying that it fixes the bug instead.

clang/include/clang/Driver/Options.td

 defvar c2x = LangOpts<"C2x">;
 defvar lang_std = LangOpts<"LangStd">;
 defvar open_cl = LangOpts<"OpenCL">;
 defvar cuda = LangOpts<"CUDA">;
 defvar render_script = LangOpts<"RenderScript">;
 defvar hip = LangOpts<"HIP">;
 defvar gnu_mode = LangOpts<"GNUMode">;
 defvar asm_preprocessor = LangOpts<"AsmPreprocessor">;
+defvar hlsl = LangOpts<"HLSL">;
 
 defvar std = !strconcat("LangStandard::getLangStandardForKind(", lang_std.KeyPath, ")");
 
 /////////
 // Options
 
 // The internal option ID must be a valid C++ identifier and results in a
 // clang::driver::options::OPT_XX enum constant for XX.
def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">,
   MarshallingInfoInt<LangOpts<"VtorDispMode">, "1">;
 def fnative_half_type: Flag<["-"], "fnative-half-type">,
   HelpText<"Use the native half type for __fp16 instead of promoting to float">,
   MarshallingInfoFlag<LangOpts<"NativeHalfType">>,
   ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath]>;
 def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and-returns">,
   HelpText<"Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)">,
   MarshallingInfoFlag<LangOpts<"NativeHalfArgsAndReturns">>,
-  ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath]>;
+  ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath, hlsl.KeyPath]>;
 def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">,
   HelpText<"Allow function arguments and returns of type half">,
   MarshallingInfoFlag<LangOpts<"HalfArgsAndReturns">>,
   ImpliedByAnyOf<[fnative_half_arguments_and_returns.KeyPath]>;
 def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">,
   HelpText<"Set default calling convention">,
   Values<"cdecl,fastcall,stdcall,vectorcall,regcall">,
   NormalizedValuesScope<"LangOptions">,
   NormalizedValues<["DCC_CDecl", "DCC_FastCall", "DCC_StdCall", "DCC_VectorCall", "DCC_RegCall"]>,
   MarshallingInfoEnum<LangOpts<"DefaultCallingConv">, "DCC_None">;
 
 // These options cannot be marshalled, because they are used to set up the LangOptions defaults.

clang/lib/Driver/ToolChains/Clang.cpp

const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version,
                                          options::OPT_hlsl_entrypoint};
 
   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/Headers/hlsl/hlsl_intrinsics.h

 //===----- hlsl_intrinsics.h - HLSL definitions for intrinsics ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _HLSL_HLSL_INTRINSICS_H_
 #define _HLSL_HLSL_INTRINSICS_H_
 
 __attribute__((clang_builtin_alias(__builtin_hlsl_wave_active_count_bits))) uint
 WaveActiveCountBits(bool bBit);
 
+__attribute__((clang_builtin_alias(__builtin_abs))) int abs(int In);
+__attribute__((clang_builtin_alias(__builtin_labs))) int64_t abs(int64_t In);
+__attribute__((clang_builtin_alias(__builtin_fabsf))) float abs(float In);
+__attribute__((clang_builtin_alias(__builtin_fabs))) double abs(double In);
+
+#ifdef __HLSL_ENABLE_16_BIT
+__attribute__((clang_builtin_alias(__builtin_fabsf16))) half abs(half In);
+#endif
+
 #endif //_HLSL_HLSL_INTRINSICS_H_

clang/test/CodeGenHLSL/builtins/abs.hlsl

+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -fnative-half-type \
+// RUN:   -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes \
+// RUN:   -o - | FileCheck %s --check-prefix=NO_HALF
+
+
+float abs_float(float X) {
+  return abs(X);
+}
+
+// CHECK: define noundef float @"?abs_float@@YAMM@Z"(
+// CHECK: call float @llvm.fabs.f32(float %0)
+
+double abs_double(double X) {
+  return abs(X);
+}
+
+// CHECK: define noundef double @"?abs_double@@YANN@Z"(
+// CHECK: call double @llvm.fabs.f64(double %0)
+
+half abs_half(half X) {
+  return abs(X);
+}
+
+// CHECK: define noundef half @"?abs_half@@YA$f16@$f16@@Z"(
+// CHECK: call half @llvm.fabs.f16(half %0)
+// NO_HALF: define noundef float @"?abs_half@@YA$halff@$halff@@Z"(
+// NO_HALF: call float @llvm.fabs.f32(float %0)
+
+int abs_int(int X) {
+  return abs(X);
+}
+
+// NO_HALF: define noundef i32 @"?abs_int@@YAHH@Z"(i32
+// CHECK: define noundef i32 @"?abs_int@@YAHH@Z"(i32
+// CHECK:         [[A_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i32 [[A:%.*]], ptr [[A_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[A_ADDR]], align 4
+// CHECK-NEXT:    [[NEG:%.*]] = sub nsw i32 0, [[TMP0]]
+// CHECK-NEXT:    [[ABSCOND:%.*]] = icmp slt i32 [[TMP0]], 0
+// CHECK-NEXT:    [[ABS:%.*]] = select i1 [[ABSCOND]], i32 [[NEG]], i32 [[TMP0]]
+// CHECK-NEXT:    ret i32 [[ABS]]
+
+int64_t abs_int64(int64_t X) {
+  return abs(X);
+}
+
+// CHECK: define noundef i64 @"?abs_int64@@YAJJ@Z"(i64
+// CHECK:         [[A_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    store i64 [[A:%.*]], ptr [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, ptr [[A_ADDR]], align 8
+// CHECK-NEXT:    [[NEG:%.*]] = sub nsw i64 0, [[TMP0]]
+// CHECK-NEXT:    [[ABSCOND:%.*]] = icmp slt i64 [[TMP0]], 0
+// CHECK-NEXT:    [[ABS:%.*]] = select i1 [[ABSCOND]], i64 [[NEG]], i64 [[TMP0]]
+// CHECK-NEXT:    ret i64 [[ABS]]