[X86] Support `_Float16` on SSE2 and up

[pengfei]

Summary

This is split from D113107 to address #56204 and https://discourse.llvm.org/t/how-to-build-compiler-rt-for-new-x86-half-float-abi/63366

[bkramer]

Thanks

[rjmccall]

clang/docs/LanguageExtensions.rst

746–752

Could you take the wording I suggested from the other patch? You'll need to drop the part about avoiding intermediate truncations, but it's important to still document the practical/performance difference when AVX512-FP16 is not available, even if the observable behavior is the same.

clang/docs/ReleaseNotes.rst

523

clang/test/SemaCXX/Float16.cpp

8

This test (and Float16.c) should continue to have positive and negative examples even if generic x86_64 is no longer negative. Generic i386 should still be negative, for example.

[pengfei]

Address review comments. Thanks @rjmccall !

[rjmccall]

Thank you, LGTM.

[zahiraam]

LGTM.

[pengfei]

Thanks @vitalybuka ! I believe the fail was caused by missing COMPILER_RT_HAS_FLOAT16 in these tests. Relanded.

[benlangmuir]

This broke some compiler-rt tests on Darwin:
https://green.lab.llvm.org/green/job/clang-stage1-RA/29920/

Test Result (3 failures / +3)
Builtins-x86_64-darwin.Builtins-x86_64-darwin.extendhfsf2_test.c
Builtins-x86_64-darwin.Builtins-x86_64-darwin.truncdfhf2_test.c
Builtins-x86_64-darwin.Builtins-x86_64-darwin.truncsfhf2_test.c

[benlangmuir]

Reverted in eab2a06f0fde due to the Darwin test failures.

[alexfh]

@pengfei could you fix the Darwin tests as well? And a general comment regarding the ongoing _Float16 effort: I think that this change should have been a part of https://reviews.llvm.org/D107082 to make it possible to build a consistently working toolchain. Thus, if this commit can't be landed in a reasonable time, I'd suggest reverting https://reviews.llvm.org/D107082.

[pengfei]

Thanks @benlangmuir for the revert. The problem seems Darwin supports the _Float16 type already but with a different ABI. I have no idea how to solve the problem ATM. Post a question on discourse: https://discourse.llvm.org/t/compiler-rt-tests-fail-on-darwin-stage1-build-after-the-abi-change-of-half-type-on-x86/63508

[pengfei]

In D128571#3619265, @alexfh wrote:

@pengfei could you fix the Darwin tests as well? And a general comment regarding the ongoing _Float16 effort: I think that this change should have been a part of https://reviews.llvm.org/D107082 to make it possible to build a consistently working toolchain. Thus, if this commit can't be landed in a reasonable time, I'd suggest reverting https://reviews.llvm.org/D107082.

@alexfh I'm working on that. I'm asking suggestion on solving it in a better way, but at least we can disable the test for Darwin (maybe just for stage1 if possible) since it's expected due to the ABI change.

[pengfei]

Disable extendhfsf2/truncsfhf2 tests on Darwin to avoid the fail.

[pengfei]

In D128571#3619438, @pengfei wrote:

In D128571#3619265, @alexfh wrote:

@pengfei could you fix the Darwin tests as well? And a general comment regarding the ongoing _Float16 effort: I think that this change should have been a part of https://reviews.llvm.org/D107082 to make it possible to build a consistently working toolchain. Thus, if this commit can't be landed in a reasonable time, I'd suggest reverting https://reviews.llvm.org/D107082.

@alexfh I'm working on that. I'm asking suggestion on solving it in a better way, but at least we can disable the test for Darwin (maybe just for stage1 if possible) since it's expected due to the ABI change.

Disabled these tests for Darwin. I'll reland the patch in one day if no objections.

[pengfei]

Exclude the ABI change on Darwin platform. Will enable it by a followup.

[MaskRay]

clang/test/CodeGen/X86/Float16-arithmetic.c

2

Use one line for RUN. This isn't long. Delete excess spaces.

x86_64-unknown-unknown can be simplified as x86_64

3

Delete --check-prefixes=CHECK. This is the default.

5

The test only has negative patterns. Such a test is prone to be stale without being noticed.

Add some positive CHECK lines.

[MaskRay]

clang/lib/Basic/Targets/X86.cpp

357

_Float16

for x86 convey no extra information since this file is for x86.

[pengfei]

Address review comments. Thanks @MaskRay !

[MaskRay]

clang/lib/Basic/Targets/X86.cpp

357

Thinking again: The comment just repeats what the code does. So it can be deleted.

[pengfei]

clang/lib/Basic/Targets/X86.cpp

357

Yeah, I had the same feeling when updating. Will delete, thanks! :)

clang/docs/LanguageExtensions.rst

 ``__fp16`` is supported on every target, as it is purely a storage format; see below.
 ``_Float16`` is currently only supported on the following targets, with further
 targets pending ABI standardization:
 
 * 32-bit ARM
 * 64-bit ARM (AArch64)
 * AMDGPU
 * SPIR
-* X86 (Only available under feature AVX512-FP16)
+* X86 (see below)
+
+On X86 targets, ``_Float16`` is supported as long as SSE2 is available, which
+includes all 64-bit and all recent 32-bit processors. When the target supports
+AVX512-FP16, ``_Float16`` arithmetic is performed using that native support.
+Otherwise, ``_Float16`` arithmetic is performed by promoting to ``float``,
+performing the operation, and then truncating to ``_Float16``.
 
 ``_Float16`` will be supported on more targets as they define ABIs for it.
 
 ``__bf16`` is purely a storage format; it is currently only supported on the following targets:
 * 32-bit ARM
 * 64-bit ARM (AArch64)
 
 The ``__bf16`` type is only available when supported in hardware.

clang/docs/ReleaseNotes.rst

 
 - ...
 
 X86 Support in Clang
 --------------------
 
 - Support ``-mharden-sls=[none|all|return|indirect-jmp]`` for straight-line
   speculation hardening.
+- Support for the ``_Float16`` type has been added for all targets with SSE2.
+  When AVX512-FP16 is not available, arithmetic on ``_Float16`` is emulated
+  using ``float``.
 
 DWARF Support in Clang
 ----------------------
 
 - clang now adds DWARF information for inline strings in C/C++ programs,
   allowing ``line:column`` symbolization of strings. Some debugging programs may
   require updating, as this takes advantage of DWARF ``DW_TAG_variable``
   structures *without* a ``DW_AT_name`` field, which is valid DWARF, but may be
   handled incorrectly by some software (e.g. new failures with incorrect
   assertions).

clang/lib/Basic/Targets/X86.cpp

for (const auto &Feature : Features) {
     } else if (Feature == "+avx512vnni") {
       HasAVX512VNNI = true;
     } else if (Feature == "+avx512bf16") {
       HasAVX512BF16 = true;
     } else if (Feature == "+avx512er") {
       HasAVX512ER = true;
     } else if (Feature == "+avx512fp16") {
       HasAVX512FP16 = true;
-      HasFloat16 = true;
     } else if (Feature == "+avx512pf") {
       HasAVX512PF = true;
     } else if (Feature == "+avx512dq") {
       HasAVX512DQ = true;
     } else if (Feature == "+avx512bitalg") {
       HasAVX512BITALG = true;
     } else if (Feature == "+avx512bw") {
       HasAVX512BW = true;
X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
                            .Case("+sse4.1", SSE41)
                            .Case("+ssse3", SSSE3)
                            .Case("+sse3", SSE3)
                            .Case("+sse2", SSE2)
                            .Case("+sse", SSE1)
                            .Default(NoSSE);
     SSELevel = std::max(SSELevel, Level);
 
+    HasFloat16 = SSELevel >= SSE2;
+
     MMX3DNowEnum ThreeDNowLevel = llvm::StringSwitch<MMX3DNowEnum>(Feature)
                                       .Case("+3dnowa", AMD3DNowAthlon)
                                       .Case("+3dnow", AMD3DNow)
                                       .Case("+mmx", MMX)
                                       .Default(NoMMX3DNow);
     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
 
     XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)

clang/test/CodeGen/X86/Float16-arithmetic.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+
+// CHECK-LABEL: @add1(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[ADD:%.*]] = fadd half [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret half [[ADD]]
+//
+_Float16 add1(_Float16 a, _Float16 b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add2(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    store half [[C:%.*]], ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[ADD:%.*]] = fadd half [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    [[ADD1:%.*]] = fadd half [[ADD]], [[TMP2]]
+// CHECK-NEXT:    ret half [[ADD1]]
+//
+_Float16 add2(_Float16 a, _Float16 b, _Float16 c) {
+  return a + b + c;
+}
+
+// CHECK-LABEL: @div(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv half [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret half [[DIV]]
+//
+_Float16 div(_Float16 a, _Float16 b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @mul(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[MUL:%.*]] = fmul half [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    ret half [[MUL]]
+//
+_Float16 mul(_Float16 a, _Float16 b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @add_and_mul1(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[D_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    store half [[C:%.*]], ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    store half [[D:%.*]], ptr [[D_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[MUL:%.*]] = fmul half [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    [[TMP3:%.*]] = load half, ptr [[D_ADDR]], align 2
+// CHECK-NEXT:    [[MUL1:%.*]] = fmul half [[TMP2]], [[TMP3]]
+// CHECK-NEXT:    [[ADD:%.*]] = fadd half [[MUL]], [[MUL1]]
+// CHECK-NEXT:    ret half [[ADD]]
+//
+_Float16 add_and_mul1(_Float16 a, _Float16 b, _Float16 c, _Float16 d) {
+  return a * b + c * d;
+}
+
+// CHECK-LABEL: @add_and_mul2(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[D_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[A:%.*]], ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    store half [[B:%.*]], ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    store half [[C:%.*]], ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    store half [[D:%.*]], ptr [[D_ADDR]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[A_ADDR]], align 2
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[B_ADDR]], align 2
+// CHECK-NEXT:    [[MUL:%.*]] = fmul half 0xH4600, [[TMP1]]
+// CHECK-NEXT:    [[SUB:%.*]] = fsub half [[TMP0]], [[MUL]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[C_ADDR]], align 2
+// CHECK-NEXT:    [[ADD:%.*]] = fadd half [[SUB]], [[TMP2]]
+// CHECK-NEXT:    ret half [[ADD]]
+//
+_Float16 add_and_mul2(_Float16 a, _Float16 b, _Float16 c, _Float16 d) {
+  return (a - 6 * b) + c;
+}

clang/test/CodeGen/X86/Float16-complex.c

 // RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -target-feature +avx512fp16 -o - | FileCheck %s --check-prefix=X86
+// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86
 
 _Float16 _Complex add_half_rr(_Float16 a, _Float16 b) {
   // X86-LABEL: @add_half_rr(
   // X86: fadd
   // X86-NOT: fadd
   // X86: ret
   return a + b;
 }

clang/test/Sema/Float16.c

-// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc %s
-// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc -target-feature +avx512fp16 %s -DHAVE
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-pc %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-pc -target-feature +sse2 %s -DHAVE
+// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple spir-unknown-unknown %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple armv7a-linux-gnu %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple aarch64-linux-gnu %s -DHAVE
 
 #ifndef HAVE
 // expected-error@+2{{_Float16 is not supported on this target}}
 #endif // HAVE
 _Float16 f;
 
 #ifdef HAVE
 _Complex _Float16 a;
 void builtin_complex(void) {
   _Float16 a = 0;
   (void)__builtin_complex(a, a); // expected-error {{'_Complex _Float16' is invalid}}
 }
 #endif

clang/test/Sema/conversion-target-dep.c

 // RUN: %clang_cc1 -Wdouble-promotion -Wimplicit-float-conversion %s -triple x86_64-apple-macosx10.12 -verify=x86,expected
 // RUN: %clang_cc1 -Wdouble-promotion -Wimplicit-float-conversion %s -triple armv7-apple-ios9.0 -verify=arm,expected
 
 // On ARM, long double and double both map to double precision 754s, so there
 // isn't any reason to warn on conversions back and forth.
 
 long double ld;
 double d;
-_Float16 f16; // x86-error {{_Float16 is not supported on this target}}
+_Float16 f16;
 
 int main(void) {
   ld = d; // x86-warning {{implicit conversion increases floating-point precision: 'double' to 'long double'}}
   d = ld; // x86-warning {{implicit conversion loses floating-point precision: 'long double' to 'double'}}
 
   ld += d; // x86-warning {{implicit conversion increases floating-point precision: 'double' to 'long double'}}
   d += ld; // x86-warning {{implicit conversion when assigning computation result loses floating-point precision: 'long double' to 'double'}}
 
   f16 = ld; // expected-warning {{implicit conversion loses floating-point precision: 'long double' to '_Float16'}}
   ld = f16; // expected-warning {{implicit conversion increases floating-point precision: '_Float16' to 'long double'}}
 
   f16 += ld; // expected-warning {{implicit conversion when assigning computation result loses floating-point precision: 'long double' to '_Float16'}}
   ld += f16; // expected-warning {{implicit conversion increases floating-point precision: '_Float16' to 'long double'}}
 }
 

clang/test/SemaCXX/Float16.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-pc %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-pc -target-feature +sse2 %s -DHAVE
+// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple spir-unknown-unknown %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple armv7a-linux-gnu %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple aarch64-linux-gnu %s -DHAVE
 
 #ifdef HAVE
 // expected-no-diagnostics
 #endif // HAVE
 
 #ifndef HAVE
 // expected-error@+2{{_Float16 is not supported on this target}}
 #endif // !HAVE
 _Float16 f;
 
 #ifndef HAVE
 // expected-error@+2{{invalid suffix 'F16' on floating constant}}
 #endif // !HAVE
 const auto g = 1.1F16;

compiler-rt/test/builtins/CMakeLists.txt

if (${arch} STREQUAL "armhf")
     string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
   endif()
 
   if (${arch} STREQUAL "riscv32")
     list(APPEND BUILTINS_TEST_TARGET_CFLAGS -fforce-enable-int128)
     string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
   endif()
 
+  if(APPLE)
+    # TODO: Support the new ABI on Apple platforms.
     if (${arch} MATCHES "arm|aarch64|arm64" AND COMPILER_RT_HAS_FLOAT16)
       list(APPEND BUILTINS_TEST_TARGET_CFLAGS -DCOMPILER_RT_HAS_FLOAT16)
       string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
     endif()
+  else()
+    if (${arch} MATCHES "arm|aarch64|arm64|i?86|x86_64|AMD64" AND COMPILER_RT_HAS_FLOAT16)
+      list(APPEND BUILTINS_TEST_TARGET_CFLAGS -DCOMPILER_RT_HAS_FLOAT16)
+      string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
+    endif()
+  endif()
 
   if(COMPILER_RT_ENABLE_CET)
     if(NOT arch MATCHES "i?86|x86_64|AMD64")
       message(SEND_ERROR "${arch} does not support CET")
     endif()
     if(COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
       list(APPEND BUILTINS_TEST_TARGET_CFLAGS -fcf-protection=full)
       string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")