Skip to content

Commit 8c24f33

Browse files
stuijstuij
committed
[IR][BFloat] Add BFloat IR type
Summary: The BFloat IR type is introduced to provide support for, initially, the BFloat16 datatype introduced with the Armv8.6 architecture (optional from Armv8.2 onwards). It has an 8-bit exponent and a 7-bit mantissa and behaves like an IEEE 754 floating point IR type. This is part of a patch series upstreaming Armv8.6 features. Subsequent patches will upstream intrinsics support and C-lang support for BFloat. Reviewers: SjoerdMeijer, rjmccall, rsmith, liutianle, RKSimon, craig.topper, jfb, LukeGeeson, sdesmalen, deadalnix, ctetreau Subscribers: hiraditya, llvm-commits, danielkiss, arphaman, kristof.beyls, dexonsmith Tags: #llvm Differential Revision: https://reviews.llvm.org/D78190
1 parent 7063a83 commit 8c24f33

File tree

28 files changed

+354
-129
lines changed

28 files changed

+354
-129
lines changed

‎clang/lib/Sema/SemaOpenMP.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14936,9 +14936,9 @@ static bool actOnOMPReductionKindClause(
1493614936
if (auto *ComplexTy = OrigType->getAs<ComplexType>())
1493714937
Type = ComplexTy->getElementType();
1493814938
if (Type->isRealFloatingType()) {
14939-
llvm::APFloat InitValue =
14940-
llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type),
14941-
/*isIEEE=*/true);
14939+
llvm::APFloat InitValue = llvm::APFloat::getAllOnesValue(
14940+
Context.getFloatTypeSemantics(Type),
14941+
Context.getTypeSize(Type));
1494214942
Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true,
1494314943
Type, ELoc);
1494414944
} else if (Type->isScalarType()) {

‎llvm/docs/BitCodeFormat.rst

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1107,6 +1107,14 @@ TYPE_CODE_HALF Record
11071107
The ``HALF`` record (code 10) adds a ``half`` (16-bit floating point) type to
11081108
the type table.
11091109

1110+
TYPE_CODE_BFLOAT Record
1111+
^^^^^^^^^^^^^^^^^^^^^
1112+
1113+
``[BFLOAT]``
1114+
1115+
The ``BFLOAT`` record (code 23) adds a ``bfloat`` (16-bit brain floating point)
1116+
type to the type table.
1117+
11101118
TYPE_CODE_FLOAT Record
11111119
^^^^^^^^^^^^^^^^^^^^^^
11121120

‎llvm/docs/LangRef.rst

Lines changed: 21 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -2963,14 +2963,20 @@ Floating-Point Types
29632963
* - ``half``
29642964
- 16-bit floating-point value
29652965

2966+
* - ``bfloat``
2967+
- 16-bit "brain" floating-point value (7-bit significand). Provides the
2968+
same number of exponent bits as ``float``, so that it matches its dynamic
2969+
range, but with greatly reduced precision. Used in Intel's AVX-512 BF16
2970+
extensions and Arm's ARMv8.6-A extensions, among others.
2971+
29662972
* - ``float``
29672973
- 32-bit floating-point value
29682974

29692975
* - ``double``
29702976
- 64-bit floating-point value
29712977

29722978
* - ``fp128``
2973-
- 128-bit floating-point value (112-bit mantissa)
2979+
- 128-bit floating-point value (112-bit significand)
29742980

29752981
* - ``x86_fp80``
29762982
- 80-bit floating-point value (X87)
@@ -3303,20 +3309,20 @@ number of digits. For example, NaN's, infinities, and other special
33033309
values are represented in their IEEE hexadecimal format so that assembly
33043310
and disassembly do not cause any bits to change in the constants.
33053311

3306-
When using the hexadecimal form, constants of types half, float, and
3307-
double are represented using the 16-digit form shown above (which
3308-
matches the IEEE754 representation for double); half and float values
3309-
must, however, be exactly representable as IEEE 754 half and single
3310-
precision, respectively. Hexadecimal format is always used for long
3311-
double, and there are three forms of long double. The 80-bit format used
3312-
by x86 is represented as ``0xK`` followed by 20 hexadecimal digits. The
3313-
128-bit format used by PowerPC (two adjacent doubles) is represented by
3314-
``0xM`` followed by 32 hexadecimal digits. The IEEE 128-bit format is
3315-
represented by ``0xL`` followed by 32 hexadecimal digits. Long doubles
3316-
will only work if they match the long double format on your target.
3317-
The IEEE 16-bit format (half precision) is represented by ``0xH``
3318-
followed by 4 hexadecimal digits. All hexadecimal formats are big-endian
3319-
(sign bit at the left).
3312+
When using the hexadecimal form, constants of types bfloat, half, float, and
3313+
double are represented using the 16-digit form shown above (which matches the
3314+
IEEE754 representation for double); bfloat, half and float values must, however,
3315+
be exactly representable as bfloat, IEEE 754 half, and IEEE 754 single
3316+
precision respectively. Hexadecimal format is always used for long double, and
3317+
there are three forms of long double. The 80-bit format used by x86 is
3318+
represented as ``0xK`` followed by 20 hexadecimal digits. The 128-bit format
3319+
used by PowerPC (two adjacent doubles) is represented by ``0xM`` followed by 32
3320+
hexadecimal digits. The IEEE 128-bit format is represented by ``0xL`` followed
3321+
by 32 hexadecimal digits. Long doubles will only work if they match the long
3322+
double format on your target. The IEEE 16-bit format (half precision) is
3323+
represented by ``0xH`` followed by 4 hexadecimal digits. The bfloat 16-bit
3324+
format is represented by ``0xR`` followed by 4 hexadecimal digits. All
3325+
hexadecimal formats are big-endian (sign bit at the left).
33203326

33213327
There are no constants of type x86_mmx.
33223328

‎llvm/include/llvm-c/Core.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -146,6 +146,7 @@ typedef enum {
146146
typedef enum {
147147
LLVMVoidTypeKind, /**< type with no size */
148148
LLVMHalfTypeKind, /**< 16 bit floating point type */
149+
LLVMBFloatTypeKind, /**< 16 bit brain floating point type */
149150
LLVMFloatTypeKind, /**< 32 bit floating point type */
150151
LLVMDoubleTypeKind, /**< 64 bit floating point type */
151152
LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
@@ -1163,6 +1164,11 @@ unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
11631164
*/
11641165
LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
11651166

1167+
/**
1168+
* Obtain a 16-bit brain floating point type from a context.
1169+
*/
1170+
LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C);
1171+
11661172
/**
11671173
* Obtain a 32-bit floating point type from a context.
11681174
*/
@@ -1195,6 +1201,7 @@ LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
11951201
* These map to the functions in this group of the same name.
11961202
*/
11971203
LLVMTypeRef LLVMHalfType(void);
1204+
LLVMTypeRef LLVMBFloatType(void);
11981205
LLVMTypeRef LLVMFloatType(void);
11991206
LLVMTypeRef LLVMDoubleType(void);
12001207
LLVMTypeRef LLVMX86FP80Type(void);

‎llvm/include/llvm/ADT/APFloat.h

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -151,6 +151,7 @@ struct APFloatBase {
151151
/// @{
152152
enum Semantics {
153153
S_IEEEhalf,
154+
S_BFloat,
154155
S_IEEEsingle,
155156
S_IEEEdouble,
156157
S_x87DoubleExtended,
@@ -162,6 +163,7 @@ struct APFloatBase {
162163
static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem);
163164

164165
static const fltSemantics &IEEEhalf() LLVM_READNONE;
166+
static const fltSemantics &BFloat() LLVM_READNONE;
165167
static const fltSemantics &IEEEsingle() LLVM_READNONE;
166168
static const fltSemantics &IEEEdouble() LLVM_READNONE;
167169
static const fltSemantics &IEEEquad() LLVM_READNONE;
@@ -541,13 +543,15 @@ class IEEEFloat final : public APFloatBase {
541543
/// @}
542544

543545
APInt convertHalfAPFloatToAPInt() const;
546+
APInt convertBFloatAPFloatToAPInt() const;
544547
APInt convertFloatAPFloatToAPInt() const;
545548
APInt convertDoubleAPFloatToAPInt() const;
546549
APInt convertQuadrupleAPFloatToAPInt() const;
547550
APInt convertF80LongDoubleAPFloatToAPInt() const;
548551
APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
549552
void initFromAPInt(const fltSemantics *Sem, const APInt &api);
550553
void initFromHalfAPInt(const APInt &api);
554+
void initFromBFloatAPInt(const APInt &api);
551555
void initFromFloatAPInt(const APInt &api);
552556
void initFromDoubleAPInt(const APInt &api);
553557
void initFromQuadrupleAPInt(const APInt &api);
@@ -954,9 +958,10 @@ class APFloat : public APFloatBase {
954958

955959
/// Returns a float which is bitcasted from an all one value int.
956960
///
961+
/// \param Semantics - type float semantics
957962
/// \param BitWidth - Select float type
958-
/// \param isIEEE - If 128 bit number, select between PPC and IEEE
959-
static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
963+
static APFloat getAllOnesValue(const fltSemantics &Semantics,
964+
unsigned BitWidth);
960965

961966
/// Used to insert APFloat objects, or objects that contain APFloat objects,
962967
/// into FoldingSets.

‎llvm/include/llvm/Bitcode/LLVMBitCodes.h

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -166,7 +166,9 @@ enum TypeCodes {
166166

167167
TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
168168

169-
TYPE_CODE_TOKEN = 22 // TOKEN
169+
TYPE_CODE_TOKEN = 22, // TOKEN
170+
171+
TYPE_CODE_BFLOAT = 23 // BRAIN FLOATING POINT
170172
};
171173

172174
enum OperandBundleTagCode {

‎llvm/include/llvm/IR/Constants.h

Lines changed: 18 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -721,14 +721,15 @@ class ConstantDataArray final : public ConstantDataSequential {
721721
return getImpl(Data, Ty);
722722
}
723723

724-
/// getFP() constructors - Return a constant with array type with an element
725-
/// count and element type of float with precision matching the number of
726-
/// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
727-
/// double for 64bits) Note that this can return a ConstantAggregateZero
728-
/// object.
729-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
730-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
731-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
724+
/// getFP() constructors - Return a constant of array type with a float
725+
/// element type taken from argument `ElementType', and count taken from
726+
/// argument `Elts'. The amount of bits of the contained type must match the
727+
/// number of bits of the type contained in the passed in ArrayRef.
728+
/// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
729+
/// that this can return a ConstantAggregateZero object.
730+
static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
731+
static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
732+
static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
732733

733734
/// This method constructs a CDS and initializes it with a text string.
734735
/// The default behavior (AddNull==true) causes a null terminator to
@@ -780,14 +781,15 @@ class ConstantDataVector final : public ConstantDataSequential {
780781
static Constant *get(LLVMContext &Context, ArrayRef<float> Elts);
781782
static Constant *get(LLVMContext &Context, ArrayRef<double> Elts);
782783

783-
/// getFP() constructors - Return a constant with vector type with an element
784-
/// count and element type of float with the precision matching the number of
785-
/// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits,
786-
/// double for 64bits) Note that this can return a ConstantAggregateZero
787-
/// object.
788-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts);
789-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts);
790-
static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts);
784+
/// getFP() constructors - Return a constant of vector type with a float
785+
/// element type taken from argument `ElementType', and count taken from
786+
/// argument `Elts'. The amount of bits of the contained type must match the
787+
/// number of bits of the type contained in the passed in ArrayRef.
788+
/// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
789+
/// that this can return a ConstantAggregateZero object.
790+
static Constant *getFP(Type *ElementType, ArrayRef<uint16_t> Elts);
791+
static Constant *getFP(Type *ElementType, ArrayRef<uint32_t> Elts);
792+
static Constant *getFP(Type *ElementType, ArrayRef<uint64_t> Elts);
791793

792794
/// Return a ConstantVector with the specified constant in each element.
793795
/// The specified constant has to be a of a compatible type (i8/i16/

‎llvm/include/llvm/IR/DataLayout.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -651,6 +651,7 @@ inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const {
651651
case Type::IntegerTyID:
652652
return TypeSize::Fixed(Ty->getIntegerBitWidth());
653653
case Type::HalfTyID:
654+
case Type::BFloatTyID:
654655
return TypeSize::Fixed(16);
655656
case Type::FloatTyID:
656657
return TypeSize::Fixed(32);

‎llvm/include/llvm/IR/IRBuilder.h

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -477,6 +477,11 @@ class IRBuilderBase {
477477
return Type::getHalfTy(Context);
478478
}
479479

480+
/// Fetch the type representing a 16-bit brain floating point value.
481+
Type *getBFloatTy() {
482+
return Type::getBFloatTy(Context);
483+
}
484+
480485
/// Fetch the type representing a 32-bit floating point value.
481486
Type *getFloatTy() {
482487
return Type::getFloatTy(Context);

‎llvm/include/llvm/IR/Type.h

Lines changed: 27 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -54,27 +54,28 @@ class Type {
5454
///
5555
enum TypeID {
5656
// PrimitiveTypes - make sure LastPrimitiveTyID stays up to date.
57-
VoidTyID = 0, ///< 0: type with no size
58-
HalfTyID, ///< 1: 16-bit floating point type
59-
FloatTyID, ///< 2: 32-bit floating point type
60-
DoubleTyID, ///< 3: 64-bit floating point type
61-
X86_FP80TyID, ///< 4: 80-bit floating point type (X87)
62-
FP128TyID, ///< 5: 128-bit floating point type (112-bit mantissa)
63-
PPC_FP128TyID, ///< 6: 128-bit floating point type (two 64-bits, PowerPC)
64-
LabelTyID, ///< 7: Labels
65-
MetadataTyID, ///< 8: Metadata
66-
X86_MMXTyID, ///< 9: MMX vectors (64 bits, X86 specific)
67-
TokenTyID, ///< 10: Tokens
57+
VoidTyID = 0, ///< 0: type with no size
58+
HalfTyID, ///< 1: 16-bit floating point type
59+
BFloatTyID, ///< 2: 16-bit floating point type (7-bit significand)
60+
FloatTyID, ///< 3: 32-bit floating point type
61+
DoubleTyID, ///< 4: 64-bit floating point type
62+
X86_FP80TyID, ///< 5: 80-bit floating point type (X87)
63+
FP128TyID, ///< 6: 128-bit floating point type (112-bit significand)
64+
PPC_FP128TyID, ///< 7: 128-bit floating point type (two 64-bits, PowerPC)
65+
LabelTyID, ///< 8: Labels
66+
MetadataTyID, ///< 9: Metadata
67+
X86_MMXTyID, ///< 10: MMX vectors (64 bits, X86 specific)
68+
TokenTyID, ///< 11: Tokens
6869

6970
// Derived types... see DerivedTypes.h file.
7071
// Make sure FirstDerivedTyID stays up to date!
71-
IntegerTyID, ///< 11: Arbitrary bit width integers
72-
FunctionTyID, ///< 12: Functions
73-
StructTyID, ///< 13: Structures
74-
ArrayTyID, ///< 14: Arrays
75-
PointerTyID, ///< 15: Pointers
76-
FixedVectorTyID, ///< 16: Fixed width SIMD vector type
77-
ScalableVectorTyID ///< 17: Scalable SIMD vector type
72+
IntegerTyID, ///< 12: Arbitrary bit width integers
73+
FunctionTyID, ///< 13: Functions
74+
StructTyID, ///< 14: Structures
75+
ArrayTyID, ///< 15: Arrays
76+
PointerTyID, ///< 16: Pointers
77+
FixedVectorTyID, ///< 17: Fixed width SIMD vector type
78+
ScalableVectorTyID ///< 18: Scalable SIMD vector type
7879
};
7980

8081
private:
@@ -140,6 +141,9 @@ class Type {
140141
/// Return true if this is 'half', a 16-bit IEEE fp type.
141142
bool isHalfTy() const { return getTypeID() == HalfTyID; }
142143

144+
/// Return true if this is 'bfloat', a 16-bit bfloat type.
145+
bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
146+
143147
/// Return true if this is 'float', a 32-bit IEEE fp type.
144148
bool isFloatTy() const { return getTypeID() == FloatTyID; }
145149

@@ -157,15 +161,16 @@ class Type {
157161

158162
/// Return true if this is one of the six floating-point types
159163
bool isFloatingPointTy() const {
160-
return getTypeID() == HalfTyID || getTypeID() == FloatTyID ||
161-
getTypeID() == DoubleTyID ||
164+
return getTypeID() == HalfTyID || getTypeID() == BFloatTyID ||
165+
getTypeID() == FloatTyID || getTypeID() == DoubleTyID ||
162166
getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
163167
getTypeID() == PPC_FP128TyID;
164168
}
165169

166170
const fltSemantics &getFltSemantics() const {
167171
switch (getTypeID()) {
168172
case HalfTyID: return APFloat::IEEEhalf();
173+
case BFloatTyID: return APFloat::BFloat();
169174
case FloatTyID: return APFloat::IEEEsingle();
170175
case DoubleTyID: return APFloat::IEEEdouble();
171176
case X86_FP80TyID: return APFloat::x87DoubleExtended();
@@ -387,6 +392,7 @@ class Type {
387392
static Type *getVoidTy(LLVMContext &C);
388393
static Type *getLabelTy(LLVMContext &C);
389394
static Type *getHalfTy(LLVMContext &C);
395+
static Type *getBFloatTy(LLVMContext &C);
390396
static Type *getFloatTy(LLVMContext &C);
391397
static Type *getDoubleTy(LLVMContext &C);
392398
static Type *getMetadataTy(LLVMContext &C);
@@ -422,6 +428,7 @@ class Type {
422428
// types as pointee.
423429
//
424430
static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
431+
static PointerType *getBFloatPtrTy(LLVMContext &C, unsigned AS = 0);
425432
static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
426433
static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
427434
static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);

‎llvm/lib/AsmParser/LLLexer.cpp

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -820,6 +820,7 @@ lltok::Kind LLLexer::LexIdentifier() {
820820

821821
TYPEKEYWORD("void", Type::getVoidTy(Context));
822822
TYPEKEYWORD("half", Type::getHalfTy(Context));
823+
TYPEKEYWORD("bfloat", Type::getBFloatTy(Context));
823824
TYPEKEYWORD("float", Type::getFloatTy(Context));
824825
TYPEKEYWORD("double", Type::getDoubleTy(Context));
825826
TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context));
@@ -985,11 +986,13 @@ lltok::Kind LLLexer::LexIdentifier() {
985986
/// HexFP128Constant 0xL[0-9A-Fa-f]+
986987
/// HexPPC128Constant 0xM[0-9A-Fa-f]+
987988
/// HexHalfConstant 0xH[0-9A-Fa-f]+
989+
/// HexBFloatConstant 0xR[0-9A-Fa-f]+
988990
lltok::Kind LLLexer::Lex0x() {
989991
CurPtr = TokStart + 2;
990992

991993
char Kind;
992-
if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H') {
994+
if ((CurPtr[0] >= 'K' && CurPtr[0] <= 'M') || CurPtr[0] == 'H' ||
995+
CurPtr[0] == 'R') {
993996
Kind = *CurPtr++;
994997
} else {
995998
Kind = 'J';
@@ -1007,7 +1010,7 @@ lltok::Kind LLLexer::Lex0x() {
10071010
if (Kind == 'J') {
10081011
// HexFPConstant - Floating point constant represented in IEEE format as a
10091012
// hexadecimal number for when exponential notation is not precise enough.
1010-
// Half, Float, and double only.
1013+
// Half, BFloat, Float, and double only.
10111014
APFloatVal = APFloat(APFloat::IEEEdouble(),
10121015
APInt(64, HexIntToVal(TokStart + 2, CurPtr)));
10131016
return lltok::APFloat;
@@ -1035,6 +1038,11 @@ lltok::Kind LLLexer::Lex0x() {
10351038
APFloatVal = APFloat(APFloat::IEEEhalf(),
10361039
APInt(16,HexIntToVal(TokStart+3, CurPtr)));
10371040
return lltok::APFloat;
1041+
case 'R':
1042+
// Brain floating point
1043+
APFloatVal = APFloat(APFloat::BFloat(),
1044+
APInt(16, HexIntToVal(TokStart + 3, CurPtr)));
1045+
return lltok::APFloat;
10381046
}
10391047
}
10401048

‎llvm/lib/AsmParser/LLParser.cpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5247,13 +5247,16 @@ bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
52475247
!ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
52485248
return Error(ID.Loc, "floating point constant invalid for type");
52495249

5250-
// The lexer has no type info, so builds all half, float, and double FP
5251-
// constants as double. Fix this here. Long double does not need this.
5250+
// The lexer has no type info, so builds all half, bfloat, float, and double
5251+
// FP constants as double. Fix this here. Long double does not need this.
52525252
if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
52535253
bool Ignored;
52545254
if (Ty->isHalfTy())
52555255
ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
52565256
&Ignored);
5257+
else if (Ty->isBFloatTy())
5258+
ID.APFloatVal.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven,
5259+
&Ignored);
52575260
else if (Ty->isFloatTy())
52585261
ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
52595262
&Ignored);

0 commit comments

Comments
 (0)