2012-07-10 02:34:21 +08:00
|
|
|
// REQUIRES: arm-registered-target
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple arm-none-linux-gnueabi %s | FileCheck %s --check-prefix=NOHALF --check-prefix=CHECK
|
|
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple aarch64-none-linux-gnueabi %s | FileCheck %s --check-prefix=NOHALF --check-prefix=CHECK
|
|
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple arm-none-linux-gnueabi -fallow-half-arguments-and-returns %s | FileCheck %s --check-prefix=HALF --check-prefix=CHECK
|
|
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple aarch64-none-linux-gnueabi -fallow-half-arguments-and-returns %s | FileCheck %s --check-prefix=HALF --check-prefix=CHECK
|
2015-05-15 07:44:18 +08:00
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple arm-none-linux-gnueabi -fnative-half-type %s \
|
|
|
|
|
// RUN: | FileCheck %s --check-prefix=NATIVE-HALF
|
|
|
|
|
// RUN: %clang_cc1 -emit-llvm -o - -triple aarch64-none-linux-gnueabi -fnative-half-type %s \
|
|
|
|
|
// RUN: | FileCheck %s --check-prefix=NATIVE-HALF
|
2011-10-15 07:32:50 +08:00
|
|
|
typedef unsigned cond_t;
|
|
|
|
|
|
|
|
|
|
volatile cond_t test;
|
2015-05-30 06:54:57 +08:00
|
|
|
volatile int i0;
|
2011-10-15 07:32:50 +08:00
|
|
|
volatile __fp16 h0 = 0.0, h1 = 1.0, h2;
|
|
|
|
|
volatile float f0, f1, f2;
|
2015-03-24 01:48:07 +08:00
|
|
|
volatile double d0;
|
2011-10-15 07:32:50 +08:00
|
|
|
|
|
|
|
|
void foo(void) {
|
2013-08-15 14:47:53 +08:00
|
|
|
// CHECK-LABEL: define void @foo()
|
2011-10-15 07:32:50 +08:00
|
|
|
|
|
|
|
|
// Check unary ops
|
|
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: [[F16TOF32:call float @llvm.convert.from.fp16.f32]]
|
|
|
|
|
// HALF: [[F16TOF32:fpext half]]
|
2015-03-14 09:10:19 +08:00
|
|
|
// CHECK: fptoui float
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fptoui half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: uitofp i32
|
|
|
|
|
// NOHALF: [[F32TOF16:call i16 @llvm.convert.to.fp16.f32]]
|
|
|
|
|
// HALF: [[F32TOF16:fptrunc float]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: uitofp i32 {{.*}} to half
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
h0 = (test);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fcmp une float
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fcmp une half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (!h1);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: [[F32TOF16]]
|
|
|
|
|
// HALF: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fsub half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = -h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: load volatile half
|
|
|
|
|
// NATIVE-HALF-NEXT: store volatile half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = +h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1++;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
++h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
--h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1--;
|
|
|
|
|
|
|
|
|
|
// Check binary ops with various operands
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fmul half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = h0 * h2;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F32TOF16]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fmul half
|
2015-03-24 01:48:07 +08:00
|
|
|
h1 = h0 * (__fp16) -2.0f;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fmul float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = h0 * f2;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fmul float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = f0 * h2;
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fmul float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: fmul half
|
|
|
|
|
h1 = h0 * i0;
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fdiv half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h0 / h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fdiv half
|
2015-03-24 01:48:07 +08:00
|
|
|
h1 = (h0 / (__fp16) -2.0f);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fdiv float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h0 / f2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fdiv float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (f0 / h2);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fdiv float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: fdiv half
|
|
|
|
|
h1 = (h0 / i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h2 + h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = ((__fp16)-2.0 + h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fadd float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h2 + f0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fadd float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (f2 + h0);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fadd float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: fadd half
|
|
|
|
|
h1 = (h0 + i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fsub half
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h2 - h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fsub half
|
2015-03-24 01:48:07 +08:00
|
|
|
h1 = ((__fp16)-2.0f - h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fsub float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h2 - f0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fsub float
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (f2 - h0);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fsub float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: fsub half
|
|
|
|
|
h1 = (h0 - i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fcmp olt half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 < h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fcmp olt half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 < (__fp16)42.0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp olt float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 < f0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp olt float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f2 < h0);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fcmp olt half
|
|
|
|
|
test = (i0 < h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp olt float
|
|
|
|
|
// NATIVE-HALF: fcmp olt half
|
|
|
|
|
test = (h0 < i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fcmp ogt half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0 > h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fcmp ogt half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = ((__fp16)42.0 > h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp ogt float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0 > f2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp ogt float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f0 > h2);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fcmp ogt half
|
|
|
|
|
test = (i0 > h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp ogt float
|
|
|
|
|
// NATIVE-HALF: fcmp ogt half
|
|
|
|
|
test = (h0 > i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fcmp ole half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 <= h0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fcmp ole half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 <= (__fp16)42.0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp ole float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h2 <= f0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp ole float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f2 <= h0);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fcmp ole half
|
|
|
|
|
test = (i0 <= h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp ole float
|
|
|
|
|
// NATIVE-HALF: fcmp ole half
|
|
|
|
|
test = (h0 <= i0);
|
|
|
|
|
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fcmp oge half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0 >= h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fcmp oge half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0 >= (__fp16)-2.0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp oge float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h0 >= f2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp oge float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f0 >= h2);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fcmp oge half
|
|
|
|
|
test = (i0 >= h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp oge float
|
|
|
|
|
// NATIVE-HALF: fcmp oge half
|
|
|
|
|
test = (h0 >= i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fcmp oeq half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 == h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fcmp oeq half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 == (__fp16)1.0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp oeq float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 == f1);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp oeq float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f1 == h1);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fcmp oeq half
|
|
|
|
|
test = (i0 == h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp oeq float
|
|
|
|
|
// NATIVE-HALF: fcmp oeq half
|
|
|
|
|
test = (h0 == i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fcmp une half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 != h2);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fcmp une half
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 != (__fp16)1.0);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp une float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (h1 != f1);
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fcmp une float
|
2011-10-15 07:32:50 +08:00
|
|
|
test = (f1 != h1);
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fcmp une half
|
|
|
|
|
test = (i0 != h0);
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fcmp une float
|
|
|
|
|
// NATIVE-HALF: fcmp une half
|
|
|
|
|
test = (h0 != i0);
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fcmp une float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fcmp une half {{.*}}, 0xH0000
|
2011-10-15 07:32:50 +08:00
|
|
|
h1 = (h1 ? h2 : h0);
|
|
|
|
|
// Check assignments (inc. compound)
|
|
|
|
|
h0 = h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: [[F32TOF16]]
|
|
|
|
|
// HALF: store {{.*}} half 0xHC000
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: store {{.*}} half 0xHC000
|
2015-03-24 01:48:07 +08:00
|
|
|
h0 = (__fp16)-2.0f;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fptrunc float
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 = f0;
|
|
|
|
|
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
h0 = i0;
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fptosi float {{.*}} to i32
|
|
|
|
|
// NATIVE-HALF: fptosi half {{.*}} to i32
|
|
|
|
|
i0 = h0;
|
|
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2011-10-15 07:32:50 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 += h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fadd half
|
2015-03-24 01:48:07 +08:00
|
|
|
h0 += (__fp16)1.0f;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fadd float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fadd float
|
|
|
|
|
// NATIVE-HALF: fptrunc float
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 += f2;
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: fadd float
|
|
|
|
|
// CHECK: fptosi float {{.*}} to i32
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fadd half
|
|
|
|
|
// NATIVE-HALF: fptosi half {{.*}} to i32
|
|
|
|
|
i0 += h0;
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fadd float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fadd half
|
|
|
|
|
h0 += i0;
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fsub half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 -= h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fsub half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 -= (__fp16)1.0;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fsub float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fsub float
|
|
|
|
|
// NATIVE-HALF: fptrunc float
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 -= f2;
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: fsub float
|
|
|
|
|
// CHECK: fptosi float {{.*}} to i32
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fsub half
|
|
|
|
|
// NATIVE-HALF: fptosi half {{.*}} to i32
|
|
|
|
|
i0 -= h0;
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fsub float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fsub half
|
|
|
|
|
h0 -= i0;
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fmul half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 *= h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fmul half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 *= (__fp16)1.0;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fmul float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fmul float
|
|
|
|
|
// NATIVE-HALF: fptrunc float
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 *= f2;
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: fmul float
|
|
|
|
|
// CHECK: fptosi float {{.*}} to i32
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fmul half
|
|
|
|
|
// NATIVE-HALF: fptosi half {{.*}} to i32
|
|
|
|
|
i0 *= h0;
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fmul float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fmul half
|
|
|
|
|
h0 *= i0;
|
2011-10-15 07:32:50 +08:00
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fdiv half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 /= h1;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// NOHALF: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fdiv half
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 /= (__fp16)1.0;
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// CHECK: fdiv float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// CHECK: [[F32TOF16]]
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half
|
|
|
|
|
// NATIVE-HALF: fdiv float
|
|
|
|
|
// NATIVE-HALF: fptrunc float
|
2011-10-15 07:32:50 +08:00
|
|
|
h0 /= f2;
|
2015-05-30 06:54:57 +08:00
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: fdiv float
|
|
|
|
|
// CHECK: fptosi float {{.*}} to i32
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fdiv half
|
|
|
|
|
// NATIVE-HALF: fptosi half {{.*}} to i32
|
|
|
|
|
i0 /= h0;
|
|
|
|
|
// CHECK: sitofp i32 {{.*}} to float
|
|
|
|
|
// CHECK: [[F16TOF32]]
|
|
|
|
|
// CHECK: fdiv float
|
|
|
|
|
// CHECK: [[F32TOF16]]
|
|
|
|
|
// NATIVE-HALF: sitofp i32 {{.*}} to half
|
|
|
|
|
// NATIVE-HALF: fdiv half
|
|
|
|
|
h0 /= i0;
|
2015-03-24 01:48:07 +08:00
|
|
|
|
|
|
|
|
// Check conversions to/from double
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: call i16 @llvm.convert.to.fp16.f64(
|
|
|
|
|
// HALF: fptrunc double {{.*}} to half
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fptrunc double {{.*}} to half
|
2015-03-24 01:48:07 +08:00
|
|
|
h0 = d0;
|
|
|
|
|
|
|
|
|
|
// CHECK: [[MID:%.*]] = fptrunc double {{%.*}} to float
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: call i16 @llvm.convert.to.fp16.f32(float [[MID]])
|
|
|
|
|
// HALF: fptrunc float [[MID]] to half
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: [[MID:%.*]] = fptrunc double {{%.*}} to float
|
|
|
|
|
// NATIVE-HALF: fptrunc float {{.*}} to half
|
2015-03-24 01:48:07 +08:00
|
|
|
h0 = (float)d0;
|
|
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: call double @llvm.convert.from.fp16.f64(
|
|
|
|
|
// HALF: fpext half {{.*}} to double
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: fpext half {{.*}} to double
|
2015-03-24 01:48:07 +08:00
|
|
|
d0 = h0;
|
|
|
|
|
|
[CodeGen] Properly support the half FP type with non-native operations.
On AArch64, the -fallow-half-args-and-returns option is the default.
With it, the half type is considered legal (rather than the i16 used
normally for __fp16), but no operation is, except conversions and
load/stores and such.
The previous behavior was tantamount to saying LangOpts.NativeHalfType
was implied by LangOpts.HalfArgsAndReturns, which isn't true.
Instead, teach the various parts of CodeGen that already know about
half (using the intrinsics or not) about this weird in-between case,
where the "half" type is legal, but operations on it aren't.
This is a smaller intermediate step to the end-goal of removing the
intrinsic, always using "half", and letting the backend legalize.
Builds on r232968.
rdar://20045970, rdar://17468714
Differential Revision: http://reviews.llvm.org/D8367
llvm-svn: 232971
2015-03-24 01:54:16 +08:00
|
|
|
// NOHALF: [[MID:%.*]] = call float @llvm.convert.from.fp16.f32(
|
|
|
|
|
// HALF: [[MID:%.*]] = fpext half {{.*}} to float
|
2015-03-24 01:48:07 +08:00
|
|
|
// CHECK: fpext float [[MID]] to double
|
2015-05-15 07:44:18 +08:00
|
|
|
// NATIVE-HALF: [[MID:%.*]] = fpext half {{.*}} to float
|
|
|
|
|
// NATIVE-HALF: fpext float [[MID]] to double
|
2015-03-24 01:48:07 +08:00
|
|
|
d0 = (float)h0;
|
2011-10-15 07:32:50 +08:00
|
|
|
}
|
