This is an archive of the discontinued LLVM Phabricator instance.

Differential D8367

[CodeGen] Properly support the half FP type with non-native operations (-fallow-half-args-and-returns)
ClosedPublic

Authored by ab on Mar 16 2015, 3:33 PM.

Details

Reviewers
olista01
Commits
rGd1801afeac1b: [CodeGen] Properly support the half FP type with non-native operations.
rC232971: [CodeGen] Properly support the half FP type with non-native operations.
rL232971: [CodeGen] Properly support the half FP type with non-native operations.
Summary

The previous behavior was tantamount to saying LangOpts.NativeHalfType was implied by LangOpts.HalfArgsAndReturns, which AFAICT isn't true, especially given the latter is enabled by default on AArch64.
Instead, teach the various parts of CodeGen that already know about half (using the intrinsics or not) about the weird in-between case, where the "half" type is legal, but any operation on it (other than conversion from/to float and storage) isn't.

This is a smaller intermediate step to the end-goal of removing the intrinsic, always using "half", and letting the backend do the legalization.

Depends on D4602.

-Ahmed

Diff Detail

Repository
rL LLVM

Event Timeline

ab updated this revision to Diff 22058.Mar 16 2015, 3:33 PM
ab retitled this revision from to [CodeGen] Properly support the half FP type with non-native operations (-fallow-half-args-and-returns).
ab updated this object.
ab edited the test plan for this revision. (Show Details)
ab added a reviewer: olista01.
ab added a parent revision: D4602: [CodeGen] Convert double -> __fp16 in one step..
ab added subscribers: t.p.northover, joey, Unknown Object (MLST).
Herald added a subscriber: aemerson. · View Herald TranscriptMar 16 2015, 3:33 PM
olista01 edited edge metadata.Mar 17 2015, 4:02 AM

You have marked this as depending on D4602, but this patch includes all of the changes from D4602, is this intentional?

This patch changes the behaviour for half<->int conversions, but I only see a test the for half->int direction. Could you add some more?

ab updated this revision to Diff 22401.Mar 20 2015, 6:19 PM
ab edited edge metadata.
  • Add missing int->half testcase
ab added a comment.Mar 20 2015, 6:21 PM
In D8367#141841, @olista01 wrote:

You have marked this as depending on D4602, but this patch includes all of the changes from D4602, is this intentional?

Yeah, I'm not sure it makes sense to do this in two parts, so let's say it supersedes D4602. If you want I can isolate the f64 changes back.

This patch changes the behaviour for half<->int conversions, but I only see a test the for half->int direction. Could you add some more?

Added, thanks!

-Ahmed

olista01 accepted this revision.Mar 23 2015, 9:59 AM
olista01 edited edge metadata.

Thanks, LGTM.

This revision is now accepted and ready to land.Mar 23 2015, 9:59 AM
Closed by commit rL232971: [CodeGen] Properly support the half FP type with non-native operations. (authored by ab). · Explain WhyMar 23 2015, 10:57 AM
This revision was automatically updated to reflect the committed changes.
ab added a comment.Mar 23 2015, 10:58 AM

Thanks Oliver!

I did commit them separately after all: r232968, r232971.

-Ahmed

Revision Contents

PathSize
cfe/
trunk/
lib/
CodeGen/
94 lines
test/
CodeGen/
282 lines

Diff 22488

cfe/trunk/lib/CodeGen/CGExprScalar.cpp

Show First 20 Lines • Show All 745 Lines • ▼ Show 20 LinesValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
llvm::Type *SrcTy = Src->getType(); llvm::Type *SrcTy = Src->getType();
// Handle conversions to bool first, they are special: comparisons against 0. // Handle conversions to bool first, they are special: comparisons against 0.
if (DstType->isBooleanType()) if (DstType->isBooleanType())
return EmitConversionToBool(Src, SrcType); return EmitConversionToBool(Src, SrcType);
llvm::Type *DstTy = ConvertType(DstType); llvm::Type *DstTy = ConvertType(DstType);
// Cast from storage-only half FP using the special intrinsic. // Cast from half through float if half isn't a native type.
if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType && if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
!CGF.getContext().getLangOpts().HalfArgsAndReturns) { // Cast to FP using the intrinsic if the half type itself isn't supported.
if (DstTy->isFloatingPointTy()) if (DstTy->isFloatingPointTy()) {
if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
return Builder.CreateCall( return Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy), Src); CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
Src);
// If this isn't an FP->FP conversion, go through float. } else {
// Cast to other types through float, using either the intrinsic or FPExt,
// depending on whether the half type itself is supported
// (as opposed to operations on half, available with NativeHalfType).
if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
Src = Builder.CreateCall( Src = Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
CGF.CGM.FloatTy), CGF.CGM.FloatTy),
Src); Src);
} else {
Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
}
SrcType = CGF.getContext().FloatTy; SrcType = CGF.getContext().FloatTy;
SrcTy = CGF.FloatTy; SrcTy = CGF.FloatTy;
} }
}
// Ignore conversions like int -> uint. // Ignore conversions like int -> uint.
if (SrcTy == DstTy) if (SrcTy == DstTy)
return Src; return Src;
// Handle pointer conversions next: pointers can only be converted to/from // Handle pointer conversions next: pointers can only be converted to/from
// other pointers and integers. Check for pointer types in terms of LLVM, as // other pointers and integers. Check for pointer types in terms of LLVM, as
// some native types (like Obj-C id) may map to a pointer type. // some native types (like Obj-C id) may map to a pointer type.
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 LinesValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
// An overflowing conversion has undefined behavior if either the source type // An overflowing conversion has undefined behavior if either the source type
// or the destination type is a floating-point type. // or the destination type is a floating-point type.
if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) && if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
(OrigSrcType->isFloatingType() || DstType->isFloatingType())) (OrigSrcType->isFloatingType() || DstType->isFloatingType()))
EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType,
DstTy); DstTy);
// Cast to half using the intrinsic if from FP type, through float otherwise. // Cast to half through float if half isn't a native type.
if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType && if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
!CGF.getContext().getLangOpts().HalfArgsAndReturns) { // Make sure we cast in a single step if from another FP type.
if (SrcTy->isFloatingPointTy()) if (SrcTy->isFloatingPointTy()) {
// Use the intrinsic if the half type itself isn't supported
// (as opposed to operations on half, available with NativeHalfType).
if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
return Builder.CreateCall( return Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src); CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
// If the half type is supported, just use an fptrunc.
return Builder.CreateFPTrunc(Src, DstTy);
}
DstTy = CGF.FloatTy; DstTy = CGF.FloatTy;
} }
if (isa<llvm::IntegerType>(SrcTy)) { if (isa<llvm::IntegerType>(SrcTy)) {
bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
if (isa<llvm::IntegerType>(DstTy)) if (isa<llvm::IntegerType>(DstTy))
Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
else if (InputSigned) else if (InputSigned)
Show All 11 Lines assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() &&
"Unknown real conversion"); "Unknown real conversion");
if (DstTy->getTypeID() < SrcTy->getTypeID()) if (DstTy->getTypeID() < SrcTy->getTypeID())
Res = Builder.CreateFPTrunc(Src, DstTy, "conv"); Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
else else
Res = Builder.CreateFPExt(Src, DstTy, "conv"); Res = Builder.CreateFPExt(Src, DstTy, "conv");
} }
if (DstTy != ResTy) { if (DstTy != ResTy) {
if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion"); assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion");
Res = Builder.CreateCall( Res = Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy), CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
Res); Res);
} else {
Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
}
} }
return Res; return Res;
} }
/// EmitComplexToScalarConversion - Emit a conversion from the specified complex /// EmitComplexToScalarConversion - Emit a conversion from the specified complex
/// type to the specified destination type, where the destination type is an /// type to the specified destination type, where the destination type is an
/// LLVM scalar type. /// LLVM scalar type.
▲ Show 20 Lines • Show All 886 Lines • ▼ Show 20 Lines if (type->hasIntegerRepresentation()) {
isInc ? "inc" : "dec"); isInc ? "inc" : "dec");
} }
// Floating point. // Floating point.
} else if (type->isRealFloatingType()) { } else if (type->isRealFloatingType()) {
// Add the inc/dec to the real part. // Add the inc/dec to the real part.
llvm::Value *amt; llvm::Value *amt;
if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType && if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
// Another special case: half FP increment should be done via float // Another special case: half FP increment should be done via float
if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
value = Builder.CreateCall( value = Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
CGF.CGM.FloatTy), CGF.CGM.FloatTy),
input); input, "incdec.conv");
} else {
value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
}
} }
if (value->getType()->isFloatTy()) if (value->getType()->isFloatTy())
amt = llvm::ConstantFP::get(VMContext, amt = llvm::ConstantFP::get(VMContext,
llvm::APFloat(static_cast<float>(amount))); llvm::APFloat(static_cast<float>(amount)));
else if (value->getType()->isDoubleTy()) else if (value->getType()->isDoubleTy())
amt = llvm::ConstantFP::get(VMContext, amt = llvm::ConstantFP::get(VMContext,
llvm::APFloat(static_cast<double>(amount))); llvm::APFloat(static_cast<double>(amount)));
else { else {
llvm::APFloat F(static_cast<float>(amount)); llvm::APFloat F(static_cast<float>(amount));
bool ignored; bool ignored;
F.convert(CGF.getTarget().getLongDoubleFormat(), F.convert(CGF.getTarget().getLongDoubleFormat(),
llvm::APFloat::rmTowardZero, &ignored); llvm::APFloat::rmTowardZero, &ignored);
amt = llvm::ConstantFP::get(VMContext, F); amt = llvm::ConstantFP::get(VMContext, F);
} }
value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec"); value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType && if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
!CGF.getContext().getLangOpts().HalfArgsAndReturns) if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
value = Builder.CreateCall( value = Builder.CreateCall(
CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
CGF.CGM.FloatTy), CGF.CGM.FloatTy),
value); value, "incdec.conv");
} else {
value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
}
}
// Objective-C pointer types. // Objective-C pointer types.
} else { } else {
const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>(); const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>();
value = CGF.EmitCastToVoidPtr(value); value = CGF.EmitCastToVoidPtr(value);
CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType()); CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
if (!isInc) size = -size; if (!isInc) size = -size;
▲ Show 20 Lines • Show All 1,732 Lines • Show Last 20 Lines

cfe/trunk/test/CodeGen/fp16-ops.c

// REQUIRES: arm-registered-target // REQUIRES: arm-registered-target
// RUN: %clang_cc1 -emit-llvm -o - -triple arm-none-linux-gnueabi %s | FileCheck %s // 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
typedef unsigned cond_t; typedef unsigned cond_t;
volatile cond_t test; volatile cond_t test;
volatile __fp16 h0 = 0.0, h1 = 1.0, h2; volatile __fp16 h0 = 0.0, h1 = 1.0, h2;
volatile float f0, f1, f2; volatile float f0, f1, f2;
volatile double d0; volatile double d0;
void foo(void) { void foo(void) {
// CHECK-LABEL: define void @foo() // CHECK-LABEL: define void @foo()
// Check unary ops // Check unary ops
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32:call float @llvm.convert.from.fp16.f32]]
// HALF: [[F16TOF32:fpext half]]
// CHECK: fptoui float // CHECK: fptoui float
test = (h0); test = (h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: uitofp i32
// NOHALF: [[F32TOF16:call i16 @llvm.convert.to.fp16.f32]]
// HALF: [[F32TOF16:fptrunc float]]
h0 = (test);
// CHECK: [[F16TOF32]]
// CHECK: fcmp une float // CHECK: fcmp une float
test = (!h1); test = (!h1);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub float // CHECK: fsub float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // NOHALF: [[F32TOF16]]
// HALF: [[F32TOF16]]
h1 = -h1; h1 = -h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = +h1; h1 = +h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1++; h1++;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
++h1; ++h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
--h1; --h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1--; h1--;
// Check binary ops with various operands // Check binary ops with various operands
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fmul float // CHECK: fmul float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = h0 * h2; h1 = h0 * h2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call i16 @llvm.convert.to.fp16.f32( // NOHALF: [[F32TOF16]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fmul float // CHECK: fmul float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = h0 * (__fp16) -2.0f; h1 = h0 * (__fp16) -2.0f;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fmul float // CHECK: fmul float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = h0 * f2; h1 = h0 * f2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fmul float // CHECK: fmul float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = f0 * h2; h1 = f0 * h2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fdiv float // CHECK: fdiv float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h0 / h2); h1 = (h0 / h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fdiv float // CHECK: fdiv float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h0 / (__fp16) -2.0f); h1 = (h0 / (__fp16) -2.0f);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fdiv float // CHECK: fdiv float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h0 / f2); h1 = (h0 / f2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fdiv float // CHECK: fdiv float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (f0 / h2); h1 = (f0 / h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h2 + h0); h1 = (h2 + h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = ((__fp16)-2.0 + h0); h1 = ((__fp16)-2.0 + h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h2 + f0); h1 = (h2 + f0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (f2 + h0); h1 = (f2 + h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub float // CHECK: fsub float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h2 - h0); h1 = (h2 - h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fsub float // CHECK: fsub float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = ((__fp16)-2.0f - h0); h1 = ((__fp16)-2.0f - h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub float // CHECK: fsub float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h2 - f0); h1 = (h2 - f0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub float // CHECK: fsub float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (f2 - h0); h1 = (f2 - h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp olt // CHECK: fcmp olt
test = (h2 < h0); test = (h2 < h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp olt // CHECK: fcmp olt
test = (h2 < (__fp16)42.0); test = (h2 < (__fp16)42.0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp olt // CHECK: fcmp olt
test = (h2 < f0); test = (h2 < f0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp olt // CHECK: fcmp olt
test = (f2 < h0); test = (f2 < h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ogt // CHECK: fcmp ogt
test = (h0 > h2); test = (h0 > h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp ogt // CHECK: fcmp ogt
test = ((__fp16)42.0 > h2); test = ((__fp16)42.0 > h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ogt // CHECK: fcmp ogt
test = (h0 > f2); test = (h0 > f2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ogt // CHECK: fcmp ogt
test = (f0 > h2); test = (f0 > h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ole // CHECK: fcmp ole
test = (h2 <= h0); test = (h2 <= h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp ole // CHECK: fcmp ole
test = (h2 <= (__fp16)42.0); test = (h2 <= (__fp16)42.0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ole // CHECK: fcmp ole
test = (h2 <= f0); test = (h2 <= f0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp ole // CHECK: fcmp ole
test = (f2 <= h0); test = (f2 <= h0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oge // CHECK: fcmp oge
test = (h0 >= h2); test = (h0 >= h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp oge // CHECK: fcmp oge
test = (h0 >= (__fp16)-2.0); test = (h0 >= (__fp16)-2.0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oge // CHECK: fcmp oge
test = (h0 >= f2); test = (h0 >= f2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oge // CHECK: fcmp oge
test = (f0 >= h2); test = (f0 >= h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oeq // CHECK: fcmp oeq
test = (h1 == h2); test = (h1 == h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp oeq // CHECK: fcmp oeq
test = (h1 == (__fp16)1.0); test = (h1 == (__fp16)1.0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oeq // CHECK: fcmp oeq
test = (h1 == f1); test = (h1 == f1);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp oeq // CHECK: fcmp oeq
test = (f1 == h1); test = (f1 == h1);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp une // CHECK: fcmp une
test = (h1 != h2); test = (h1 != h2);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fcmp une // CHECK: fcmp une
test = (h1 != (__fp16)1.0); test = (h1 != (__fp16)1.0);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp une // CHECK: fcmp une
test = (h1 != f1); test = (h1 != f1);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp une // CHECK: fcmp une
test = (f1 != h1); test = (f1 != h1);
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fcmp une // CHECK: fcmp une
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h1 = (h1 ? h2 : h0); h1 = (h1 ? h2 : h0);
// Check assignments (inc. compound) // Check assignments (inc. compound)
h0 = h1; h0 = h1;
// CHECK: call i16 @llvm.convert.to.fp16.f32( // NOHALF: [[F32TOF16]]
// HALF: store {{.*}} half 0xHC000
h0 = (__fp16)-2.0f; h0 = (__fp16)-2.0f;
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 = f0; h0 = f0;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd float // CHECK: fadd float
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 += h1; h0 += h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fadd // CHECK: fadd
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 += (__fp16)1.0f; h0 += (__fp16)1.0f;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fadd // CHECK: fadd
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 += f2; h0 += f2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub // CHECK: fsub
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 -= h1; h0 -= h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fsub // CHECK: fsub
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 -= (__fp16)1.0; h0 -= (__fp16)1.0;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fsub // CHECK: fsub
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 -= f2; h0 -= f2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fmul // CHECK: fmul
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 *= h1; h0 *= h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fmul // CHECK: fmul
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 *= (__fp16)1.0; h0 *= (__fp16)1.0;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fmul // CHECK: fmul
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 *= f2; h0 *= f2;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fdiv // CHECK: fdiv
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 /= h1; h0 /= h1;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: call float @llvm.convert.from.fp16.f32( // NOHALF: [[F16TOF32]]
// CHECK: fdiv // CHECK: fdiv
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 /= (__fp16)1.0; h0 /= (__fp16)1.0;
// CHECK: call float @llvm.convert.from.fp16.f32( // CHECK: [[F16TOF32]]
// CHECK: fdiv // CHECK: fdiv
// CHECK: call i16 @llvm.convert.to.fp16.f32( // CHECK: [[F32TOF16]]
h0 /= f2; h0 /= f2;
// Check conversions to/from double // Check conversions to/from double
// CHECK: call i16 @llvm.convert.to.fp16.f64( // NOHALF: call i16 @llvm.convert.to.fp16.f64(
// HALF: fptrunc double {{.*}} to half
h0 = d0; h0 = d0;
// CHECK: [[MID:%.*]] = fptrunc double {{%.*}} to float // CHECK: [[MID:%.*]] = fptrunc double {{%.*}} to float
// CHECK: call i16 @llvm.convert.to.fp16.f32(float [[MID]]) // NOHALF: call i16 @llvm.convert.to.fp16.f32(float [[MID]])
// HALF: fptrunc float [[MID]] to half
h0 = (float)d0; h0 = (float)d0;
// CHECK: call double @llvm.convert.from.fp16.f64( // NOHALF: call double @llvm.convert.from.fp16.f64(
// HALF: fpext half {{.*}} to double
d0 = h0; d0 = h0;
// CHECK: [[MID:%.*]] = call float @llvm.convert.from.fp16.f32( // NOHALF: [[MID:%.*]] = call float @llvm.convert.from.fp16.f32(
// HALF: [[MID:%.*]] = fpext half {{.*}} to float
// CHECK: fpext float [[MID]] to double // CHECK: fpext float [[MID]] to double
d0 = (float)h0; d0 = (float)h0;
} }