Enable `_Float16` type support on X86 without the avx512fp16 flag

[pengfei]

Summary

The _Float16 type is supported on x86 systems with SSE2 enabled. Operations are emulated by software emulation and “float” instructions. This patch is allowing the support of _Float16 type without the use of -max512fp16 flag. The final goal being, perform _Float16 emulation for all arithmetic expressions.

[rjmccall]

clang/lib/Basic/Targets/X86.cpp

242

We should probably be setting HasLegalHalfType here.

373

Out of curiosity, why SSE2? SSE2 adds double-precision, but we just need single-precision, which is in the original SSE.

It doesn't much matter anymore, of course, since both are ubiquitous.

[pengfei]

clang/lib/Basic/Targets/X86.cpp

372

sse2?

373

https://lists.llvm.org/pipermail/llvm-dev/2021-July/151618.html

clang/test/CodeGen/X86/avx512fp16-abi.c

1

Why don't move it to fp16-abi.c directly?

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

1

Change the file name?

[rjmccall]

clang/lib/Basic/Targets/X86.cpp

373

Ah, makes sense.

[tschuett]

clang/docs/LanguageExtensions.rst

676

Would something like SSE2 and up help understanding?

[rjmccall]

clang/test/SemaCXX/Float16.cpp

6

This test (and Float16.c) should test at least one target that doesn't have _Float16 support, so please just add -DHAVE to the x86_64 line and add, I dunno, a generic i386 or SPARC line.

[rjmccall]

Thanks, LGTM

[zahiraam]

rG6623c02d70c3

[sylvestre.ledru]

As mentioned in
https://github.com/llvm/llvm-project/commit/6623c02d70c3732dbea59c6d79c69501baf9627b#commitcomment-60741407

This change is breaking build of compiler-rt on Ubuntu bionic and others on amd64:

"/build/llvm-toolchain-snapshot-14~++20211119100719+d729f4c38fca/build-llvm/./bin/clang" --target=x86_64-pc-linux-gnu -DVISIBILITY_HIDDEN  -fstack-protector-strong -Wformat -Werror=format-security -Wno-unused-command-line-argument -Wdate-time -D_FORTIFY_SOURCE=2 -O3 -DNDEBUG  -m32 -DCOMPILER_RT_HAS_FLOAT16 -std=c11 -fPIC -fno-builtin -fvisibility=hidden -fomit-frame-pointer -MD -MT CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o -MF CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o.d -o CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o -c '/build/llvm-toolchain-snapshot-14~++20211119100719+d729f4c38fca/compiler-rt/lib/builtins/extendhfsf2.c'
In file included from /build/llvm-toolchain-snapshot-14~++20211119100719+d729f4c38fca/compiler-rt/lib/builtins/extendhfsf2.c:11:
In file included from /build/llvm-toolchain-snapshot-14~++20211119100719+d729f4c38fca/compiler-rt/lib/builtins/fp_extend_impl.inc:38:
/build/llvm-toolchain-snapshot-14~++20211119100719+d729f4c38fca/compiler-rt/lib/builtins/fp_extend.h:44:9: error: _Float16 is not supported on this target
typedef _Float16 src_t;
        ^
1 error generated.

[sylvestre.ledru]

Full log:
https://llvm-jenkins.debian.net/view/Debian%20sid/job/llvm-toolchain-binaries/architecture=amd64,distribution=unstable,label=amd64/104/consoleFull

[sylvestre.ledru]

Actually, it breaks on all Debian.
Could you please revert it?

[zahiraam]

In D114099#3148631, @sylvestre.ledru wrote:

Actually, it breaks on all Debian.
Could you please revert it?

Done.

[zahiraam]

In D114099#3148665, @zahiraam wrote:

In D114099#3148631, @sylvestre.ledru wrote:

Actually, it breaks on all Debian.
Could you please revert it?

Done.

I have reverted this patch but would like to push it in at some point (may be after the back end changes https://reviews.llvm.org/D107082 will be merged in.
But I see in the command above that it is compiling with -DCOMPILER_RT_HAS_FLOAT16. @sylvestre.ledru is this flag really supposed to be on? Was it the case before this patch? @rjmccall isn't this because we turned on HasLegalHalfType?

[sylvestre.ledru]

@zahiraam

Sorry, i missed your questions

But I see in the command above that it is compiling with -DCOMPILER_RT_HAS_FLOAT16. @sylvestre.ledru is this flag really supposed to be on?

dunno, I guess this is set by the build system (I didn't set it)

The issue is back but mostly on ubuntu bionic on amd64:

"/build/llvm-toolchain-snapshot-15~++20220702091600+23ee84f43201/build-llvm/./bin/clang" --target=x86_64-pc-linux-gnu -DVISIBILITY_HIDDEN  -fstack-protector-strong -Wformat -Werror=format-security -Wno-unused-command-line-argument -Wdate-time -D_FORTIFY_SOURCE=2 -O3 -DNDEBUG -m32 -DCOMPILER_RT_HAS_FLOAT16 -std=c11 -fPIC -fno-builtin -fvisibility=hidden -fomit-frame-pointer -MD -MT CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o -MF CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o.d -o CMakeFiles/clang_rt.builtins-i386.dir/extendhfsf2.c.o -c '/build/llvm-toolchain-snapshot-15~++20220702091600+23ee84f43201/compiler-rt/lib/builtins/extendhfsf2.c'
In file included from /build/llvm-toolchain-snapshot-15~++20220702091600+23ee84f43201/compiler-rt/lib/builtins/extendhfsf2.c:11:
In file included from /build/llvm-toolchain-snapshot-15~++20220702091600+23ee84f43201/compiler-rt/lib/builtins/fp_extend_impl.inc:38:
/build/llvm-toolchain-snapshot-15~++20220702091600+23ee84f43201/compiler-rt/lib/builtins/fp_extend.h:44:9: error: _Float16 is not supported on this target
typedef _Float16 src_t;
        ^
1 error generated.

[pengfei]

This patch was replaced by D128571. Let me commandeer and abandon it.

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 (Available with feature SSE2 and up enabled)
 
 ``_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 for ``AVX512-FP16`` instructions has been added.
+- Support for ``_Float16`` type has been added.
 
 Arm and AArch64 Support in Clang
 --------------------------------
 
 - Support has been added for the following processors (command-line identifiers in parentheses):
   - Arm Cortex-A510 (``cortex-a510``)
   - Arm Cortex-X2 (``cortex-x2``)
 

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;
+      HasLegalHalfType = true;
     } else if (Feature == "+avx512dq") {
       HasAVX512DQ = true;
     } else if (Feature == "+avx512bitalg") {
       HasAVX512BITALG = true;
     } else if (Feature == "+avx512bw") {
       HasAVX512BW = true;
     } else if (Feature == "+avx512vl") {
       HasAVX512VL = true;
for (const auto &Feature : Features) {
 
     XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
                          .Case("+xop", XOP)
                          .Case("+fma4", FMA4)
                          .Case("+sse4a", SSE4A)
                          .Default(NoXOP);
     XOPLevel = std::max(XOPLevel, XLevel);
   }
+  // Turn on _float16 for x86 (feature sse2)
+  HasFloat16 = SSELevel >= SSE2;
 
   // LLVM doesn't have a separate switch for fpmath, so only accept it if it
   // matches the selected sse level.
   if ((FPMath == FP_SSE && SSELevel < SSE1) ||
       (FPMath == FP_387 && SSELevel >= SSE1)) {
     Diags.Report(diag::err_target_unsupported_fpmath)
         << (FPMath == FP_SSE ? "sse" : "387");
     return false;

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

+// RUN: %clang_cc1 -triple  x86_64-unknown-unknown -emit-llvm  \
+// RUN: < %s  | FileCheck %s --check-prefixes=CHECK
+
+_Float16 add1(_Float16 a, _Float16 b) {
+  // CHECK-LABEL: define{{.*}} half @add1
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: load half, half*
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fadd half {{.*}}, {{.*}}
+  // CHECK: ret half
+  return a + b;
+}
+
+_Float16 add2(_Float16 a, _Float16 b, _Float16 c) {
+  // CHECK-LABEL: define{{.*}} half @add2
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: load half, half* {{.*}}
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fadd half {{.*}}, {{.*}}
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fadd half {{.*}}, {{.*}}
+  // CHECK: ret half
+    return a + b + c;
+}
+
+_Float16 sub(_Float16 a, _Float16 b) {
+  // CHECK-LABEL: define{{.*}} half @sub
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: load half, half*
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fsub half {{.*}}, {{.*}}
+  // CHECK: ret half
+  return a - b;
+}
+
+_Float16 div(_Float16 a, _Float16 b) {
+  // CHECK-LABEL: define{{.*}} half @div
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: load half, half* {{.*}}
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fdiv half {{.*}}, {{.*}}
+  // CHECK: ret half
+  return a / b;
+}
+
+_Float16 mul(_Float16 a, _Float16 b) {
+  // CHECK-LABEL: define{{.*}} half @mul
+  // CHECK: alloca half
+  // CHECK: alloca half
+  // CHECK: store half {{.*}}, half*
+  // CHECK: store half {{.*}}, half*
+  // CHECK: load half, half* {{.*}}
+  // CHECK: load half, half* {{.*}}
+  // CHECK: fmul half {{.*}}, {{.*}}
+  // CHECK: ret half
+  return a * b;
+}
+
+

clang/test/CodeGen/X86/fp16-abi.c

 // RUN: %clang_cc1 -triple x86_64-linux -emit-llvm  -target-feature +avx512fp16 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-C
+// RUN: %clang_cc1 -triple x86_64-linux -emit-llvm  < %s | FileCheck %s --check-prefixes=CHECK,CHECK-C
 // RUN: %clang_cc1 -triple x86_64-linux -emit-llvm  -target-feature +avx512fp16 -x c++ -std=c++11 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CPP
+// RUN: %clang_cc1 -triple x86_64-linux -emit-llvm -x c++ -std=c++11 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CPP
 
 struct half1 {
   _Float16 a;
 };
 
 struct half1 h1(_Float16 a) {
   // CHECK: define{{.*}}half @
   struct half1 x;

clang/test/CodeGen/X86/fp16-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 %s -DHAVE
 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux-pc -target-feature +avx512fp16 %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
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i386-pc-linux-gnu %s
 
 #ifndef HAVE
 // expected-error@+2{{_Float16 is not supported on this target}}
 #endif // HAVE
 _Float16 f;
 
 #ifdef HAVE
 _Complex _Float16 a;
 void builtin_complex() {
   _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() {
   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 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
+// RUN: %clang_cc1 -fsyntax-only -verify -triple i386-pc-linux-gnu %s
 
 #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;