Add _Float16 as a C/C++ source language type

[SjoerdMeijer]

Summary

This adds _Float16 as a source language type, which is a 16-bit floating point type defined in C11 extension ISO/IEC TS 18661-3.

[rogfer01]

include/clang-c/Index.h

3118

This enumerator is the same as CXType_Float128 above, is that intended?

[SjoerdMeijer]

include/clang-c/Index.h

3118

Ah, thanks, copy-paste mistake. Will fix.

[javed.absar]

include/clang/Sema/DeclSpec.h

283

Any particular reason why its not "TST_float16" ?

[SjoerdMeijer]

Fixed typos 'TST_float16' and 'CXType_Float16 = 30', and have also added it to a switch that I had missed.

[bruno]

Hi Sjoerd,

Thanks for working on this. Can you add context to your patch?

test/CodeGenCXX/float16-declarations-error.cpp

1 ↗

(On Diff #100866)

You don't need codegen to test this. Please move this test to test/Lexer, (see test/Lexer/half-literal.cpp).

Also, is --target=aarch64 really needed here? I don't see anything ARM specific in this patch (maybe because I'm missing more context on the patch?).

test/CodeGenCXX/float16-declarations.cpp

60

Please use -std=c++11 in the RUN line on top of the file and remove the #if here. Can you provide a more reduced testcase and try to put the CHECK lines closer to the statements you want to check? The same ARM question from the comment above also applies here.

[ahatanak]

include/clang/Basic/TokenKinds.def

379

Just wanted to confirm that your intention is to unconditionally support _Float16 (for example, c99 supports it too) even though it is a c11 extension. Is that correct?

lib/Lex/LiteralSupport.cpp

588

Do you want to break out of the switch only when the second digit of the suffix is not 6 (for example, f15)?

I feel this is a bit simpler:

if (s + 2 < ThisTokEnd && s[1] == '1' && s[2] == '6')
  s += 2;

[ahatanak]

Also, please create your new patch with context (git diff -U999999 other-branch).

[SjoerdMeijer]

Hi Bruno, Akira,
Many thanks for your feedback! Apologies for the missing context. The patch touches many files and thus with context it is quite big (~4MB). Thought this would be too much if we need a few iterations. Anyway, will include it from now on.

I am working on a new revision and fixing an issue that I noticed while restructuring the regression test: it was actually not creating float16 literals properly. About the tests and using --target=aarch64: you're right that there should nothing be ARM specific here, but it is just that for Aarch64 it will show "half" IR types which I preferred, while it looks like x86 way of dealing with is to convert it and work on i16 types. Perhaps I need tests for both?

Yes, initially I wanted to unconditionally support _Float16, but now that you asked how about it, I agree it makes more sense to enable it for C11 and C++11 and have: KEYWORD(_Float16 , KEYC11|KEYCXX11)

Thanks,
Sjoerd.

[bruno]

About the tests and using --target=aarch64: you're right that there should nothing be ARM specific here, but it is just that for Aarch64 it will show "half" IR types which I preferred, while it looks like x86 way of dealing with is to convert it and work on i16 types. Perhaps I need tests for both?

The ideal is to have x86 and ARM tests when testing for the codegen part of it. Keep in mind that you need "REQUIRES: <target>-registered-target" for those.

[SjoerdMeijer]

Float16 is added as a native type. Implementing it as some sort of alias to fp16 caused too many type issues in expression/literals/etc., and thus was not an easier first step, and also in the end we want it to be a native type anyway. The tests have been restructured, and now also x86 is tested. It turned out I needed a helper function isFloat16Ty, for which I created llvm patch D34205.

[rogfer01]

include/clang/AST/Type.h

1669 ↗

(On Diff #102543)

I think you want to make clear that this is

// C11 extension ISO/IEC TS 18661-3

lib/AST/StmtPrinter.cpp

1434

Should this be .f16 as suffix for consistency with the floating literal syntax?

lib/CodeGen/CGExprScalar.cpp

2016–2017

I think you don't need this new LLVM type (that you introduce in D34205) as you are already able to tell the two types apart (_fp16 and _Float16) at the level of clang types. And your change does not seem to need it in any other place.

lib/CodeGen/CodeGenTypes.cpp

445

I think you can make this more obvious to the reader with a comment for this bool parameter.

/* UseNativeHalf */ true

[SjoerdMeijer]

Thanks Roger. I did the clean up; there were indeed still a few fixmes there. The good thing is that it's a self-contained clang patch again: we don't need D34205, which I have abandoned.

[SjoerdMeijer]

I have added a fix for mixed __fp16 and _Float16 expressions: _Float16 type is converted to __fp16 type and then the operation is completed as if both operands were of __fp16 type. I've implemented this by adding _Float16 to the FloatingRank. By declaring Float16Rank to be smaller than HalfRank, we automatically get the promotions to __fp16 when required. I thought this approach is more elegant than adding more special cases in the floating point conversion functions.

I've added another test case test/Frontend/float16.cpp that checks the AST (this is in addition to the codegen test that we already have). This test also checks mixed type expressions.

[SjoerdMeijer]

This fixes the “DefaultVariadicArgumentPromotion” for Float16: they should be promoted to double, which makes now e.g. printf work.
I have added printf tests to both the AST and codegen test to check variadic functions (and thus checked that printf works), and also restructured the AST test a bit so that the check lines are near the corresponding program statement.

Yesterday I fixed mixed type (fp16 and float16) expressions, and with this fix for variadic arguments, I think the C support is ready. Do you agree @bruno, or do you think I've missed anything?

[SjoerdMeijer]

I have create a separate patch for the _Float16 preprocessor macro definitions in D34695.

[rsmith]

We need to be completely clear on the differences and interactions between _Float16 and __fp16; you should include a documentation update that describes this as part of this change or as a companion change. In particular, an explanation of why we need two different types here is essential.

lib/AST/ItaniumMangle.cpp

2458–2461

Distinct types should have distinct manglings. Please open an issue at https://github.com/itanium-cxx-abi/cxx-abi/ to discuss how to mangle these cases.

lib/Lex/LiteralSupport.cpp

594

s/tokens/characters/

[SjoerdMeijer]

Thanks Richard. I've opened an cxx abi issue, see comments inline. I will start working now on the doc update, and will do that in a companion change. Cheers.

lib/AST/ItaniumMangle.cpp

2458–2461

I've opened issue:
https://github.com/itanium-cxx-abi/cxx-abi/issues/21

[SjoerdMeijer]

I've created revision D35295 for the documentation update.

[SjoerdMeijer]

This fixes:

• type mangling for _Float16 (approved here: https://github.com/itanium-cxx-abi/cxx-abi/pull/22, but not yet committed. )
• removed the argument promotion for _Float16 that I added because it turns out that it does not apply to _Float16 but only to the standard float types.
• the nit in the comments of the literal parser.

[SjoerdMeijer]

Ping.

(CXX ABI change committed, doc patch created)

[SjoerdMeijer]

Ping

[SjoerdMeijer]

Ping

[rogfer01]

There are a few tests checking the precise interaction between __fp16 and _Float16 values but I don't see tests interacting _Float16 and the other standard floating types float, double and long double.

Do you reckon it is worth adding them as well?

test/Frontend/float16.cpp

82

Is this XXXXX some form of TODO?

[SjoerdMeijer]

No changes were needed to make the conversions work, the existing logic is taking care of that, but I agree it doesn't hurt to add a few test cases. So I've added tests to both files, and cleaned up that comment.

[rogfer01]

Thanks @SjoerdMeijer

This LGTM now. Wait a couple of days in case @rsmith has more comments.

[rsmith]

lib/Sema/SemaExpr.cpp

834–835

Do you mean "there is no default argument promotion for '_Float16'"? I think you could be even more specific: default argument promotion applies only to float. (And apparently to __half / __fp16.)

test/Frontend/float16.cpp

2–3

If you're going to check the tree structure from an AST dump, you should turn on --strict-whitespace in FileCheck.

[SjoerdMeijer]

Comments addressed. Thanks for reviewing.

[SjoerdMeijer]

I am going to commit this within a few days. That looks reasonable to me given that the comments in the last reviews were very minor (which I have of course addressed already). Also, in case of issues, I am guessing fixes and/or addition can be easily done post-commit, and if not a revert is cheap.

Committing this allows me to make some progress on the FP16 work. I have mostly fixed up the AArch64 back-end, and will now focus on ARM and the remaining Clang patches (documentation).

Comments are still welcome of course, which I then will address before committing.

[SjoerdMeijer]

Many thanks for reviewing and your help!

include/clang-c/Index.h

enum CXTypeKind {
   CXType_NullPtr = 24,
   CXType_Overload = 25,
   CXType_Dependent = 26,
   CXType_ObjCId = 27,
   CXType_ObjCClass = 28,
   CXType_ObjCSel = 29,
   CXType_Float128 = 30,
   CXType_Half = 31,
+  CXType_Float16 = 32,
   CXType_FirstBuiltin = CXType_Void,
-  CXType_LastBuiltin  = CXType_Half,
+  CXType_LastBuiltin  = CXType_Float16,
 
   CXType_Complex = 100,
   CXType_Pointer = 101,
   CXType_BlockPointer = 102,
   CXType_LValueReference = 103,
   CXType_RValueReference = 104,
   CXType_Record = 105,
   CXType_Enum = 106,

include/clang/AST/ASTContext.h

public:
   CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
   CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
   CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
   CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
   CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
   CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
   CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
   CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
+  CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
   CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
   CanQualType Float128ComplexTy;
   CanQualType VoidPtrTy, NullPtrTy;
   CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
   CanQualType BuiltinFnTy;
   CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;

include/clang/AST/BuiltinTypes.def

 FLOATING_TYPE(Float, FloatTy)
 
 // 'double'
 FLOATING_TYPE(Double, DoubleTy)
 
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
+// '_Float16'
+FLOATING_TYPE(Float16, HalfTy)
+
 // '__float128'
 FLOATING_TYPE(Float128, Float128Ty)
 
 //===- Language-specific types --------------------------------------------===//
 
 // This is the type of C++0x 'nullptr'.
 BUILTIN_TYPE(NullPtr, NullPtrTy)
 

include/clang/Basic/Specifiers.h

enum TypeSpecifierType {
     TST_void,
     TST_char,
     TST_wchar,        // C++ wchar_t
     TST_char16,       // C++11 char16_t
     TST_char32,       // C++11 char32_t
     TST_int,
     TST_int128,
     TST_half,         // OpenCL half, ARM NEON __fp16
+    TST_Float16,      // C11 extension ISO/IEC TS 18661-3
     TST_float,
     TST_double,
     TST_float128,
     TST_bool,         // _Bool
     TST_decimal32,    // _Decimal32
     TST_decimal64,    // _Decimal64
     TST_decimal128,   // _Decimal128
     TST_enum,

include/clang/Basic/TokenKinds.def

 KEYWORD(co_await                    , KEYCOROUTINES)
 KEYWORD(co_return                   , KEYCOROUTINES)
 KEYWORD(co_yield                    , KEYCOROUTINES)
 
 // C++ modules TS keywords
 MODULES_KEYWORD(module)
 MODULES_KEYWORD(import)
 
+// C11 Extension
+KEYWORD(_Float16                    , KEYALL)
+
 // GNU Extensions (in impl-reserved namespace)
 KEYWORD(_Decimal32                  , KEYALL)
 KEYWORD(_Decimal64                  , KEYALL)
 KEYWORD(_Decimal128                 , KEYALL)
 KEYWORD(__null                      , KEYCXX)
 KEYWORD(__alignof                   , KEYALL)
 KEYWORD(__attribute                 , KEYALL)
 KEYWORD(__builtin_choose_expr       , KEYALL)

include/clang/Lex/LiteralSupport.h

NumericLiteralParser(StringRef TokSpelling,
                        Preprocessor &PP);
   bool hadError : 1;
   bool isUnsigned : 1;
   bool isLong : 1;          // This is *not* set for long long.
   bool isLongLong : 1;
   bool isHalf : 1;          // 1.0h
   bool isFloat : 1;         // 1.0f
   bool isImaginary : 1;     // 1.0i
+  bool isFloat16 : 1;       // 1.0f16
   bool isFloat128 : 1;      // 1.0q
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
   bool isIntegerLiteral() const {
     return !saw_period && !saw_exponent;
   }
   bool isFloatingLiteral() const {
     return saw_period || saw_exponent;

include/clang/Sema/DeclSpec.h

public:
   static const TST TST_wchar = clang::TST_wchar;
   static const TST TST_char16 = clang::TST_char16;
   static const TST TST_char32 = clang::TST_char32;
   static const TST TST_int = clang::TST_int;
   static const TST TST_int128 = clang::TST_int128;
   static const TST TST_half = clang::TST_half;
   static const TST TST_float = clang::TST_float;
   static const TST TST_double = clang::TST_double;
+  static const TST TST_float16 = clang::TST_Float16;
   static const TST TST_float128 = clang::TST_float128;
   static const TST TST_bool = clang::TST_bool;
   static const TST TST_decimal32 = clang::TST_decimal32;
   static const TST TST_decimal64 = clang::TST_decimal64;
   static const TST TST_decimal128 = clang::TST_decimal128;
   static const TST TST_enum = clang::TST_enum;
   static const TST TST_union = clang::TST_union;
   static const TST TST_struct = clang::TST_struct;

include/clang/Serialization/ASTBitCodes.h

enum PredefinedTypeIDs {
       /// \brief OpenCL queue type.
       PREDEF_TYPE_QUEUE_ID      = 40,
       /// \brief OpenCL reserve_id type.
       PREDEF_TYPE_RESERVE_ID_ID = 41,
       /// \brief The placeholder type for OpenMP array section.
       PREDEF_TYPE_OMP_ARRAY_SECTION = 42,
       /// \brief The '__float128' type
       PREDEF_TYPE_FLOAT128_ID = 43,
+      /// \brief The '_Float16' type
+      PREDEF_TYPE_FLOAT16_ID = 44,
       /// \brief OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"
     };
 
     /// \brief The number of predefined type IDs that are reserved for
     /// the PREDEF_TYPE_* constants.

lib/AST/ASTContext.cpp

 unsigned ASTContext::NumImplicitCopyAssignmentOperators;
 unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
 unsigned ASTContext::NumImplicitMoveAssignmentOperators;
 unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
 unsigned ASTContext::NumImplicitDestructors;
 unsigned ASTContext::NumImplicitDestructorsDeclared;
 
 enum FloatingRank {
-  HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
+  Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
 };
 
 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
   if (!CommentsLoaded && ExternalSource) {
     ExternalSource->ReadComments();
 
 #ifndef NDEBUG
     ArrayRef<RawComment *> RawComments = Comments.getComments();
void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
   // C99 6.2.5p10.
   InitBuiltinType(FloatTy,             BuiltinType::Float);
   InitBuiltinType(DoubleTy,            BuiltinType::Double);
   InitBuiltinType(LongDoubleTy,        BuiltinType::LongDouble);
 
   // GNU extension, __float128 for IEEE quadruple precision
   InitBuiltinType(Float128Ty,          BuiltinType::Float128);
 
+  // C11 extension ISO/IEC TS 18661-3
+  InitBuiltinType(Float16Ty,           BuiltinType::Float16);
+
   // GNU extension, 128-bit integers.
   InitBuiltinType(Int128Ty,            BuiltinType::Int128);
   InitBuiltinType(UnsignedInt128Ty,    BuiltinType::UInt128);
 
   // C++ 3.9.1p5
   if (TargetInfo::isTypeSigned(Target.getWCharType()))
     InitBuiltinType(WCharTy,           BuiltinType::WChar_S);
   else  // -fshort-wchar makes wchar_t be unsigned.

 
 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
 /// scalar floating point type.
 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   const BuiltinType *BT = T->getAs<BuiltinType>();
   assert(BT && "Not a floating point type!");
   switch (BT->getKind()) {
   default: llvm_unreachable("Not a floating point type!");
-  case BuiltinType::Half:       return Target->getHalfFormat();
+  case BuiltinType::Float16:
+  case BuiltinType::Half:
+    return Target->getHalfFormat();
   case BuiltinType::Float:      return Target->getFloatFormat();
   case BuiltinType::Double:     return Target->getDoubleFormat();
   case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
   case BuiltinType::Float128:   return Target->getFloat128Format();
   }
 }
 
 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
case BuiltinType::LongLong:
       Width = Target->getLongLongWidth();
       Align = Target->getLongLongAlign();
       break;
     case BuiltinType::Int128:
     case BuiltinType::UInt128:
       Width = 128;
       Align = 128; // int128_t is 128-bit aligned on all targets.
       break;
+    case BuiltinType::Float16:
     case BuiltinType::Half:
       Width = Target->getHalfWidth();
       Align = Target->getHalfAlign();
       break;
     case BuiltinType::Float:
       Width = Target->getFloatWidth();
       Align = Target->getFloatAlign();
       break;

 /// This routine will assert if passed a built-in type that isn't a float.
 static FloatingRank getFloatingRank(QualType T) {
   if (const ComplexType *CT = T->getAs<ComplexType>())
     return getFloatingRank(CT->getElementType());
 
   assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
   switch (T->getAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("getFloatingRank(): not a floating type");
+  case BuiltinType::Float16:    return Float16Rank;
   case BuiltinType::Half:       return HalfRank;
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
   }
 }
 
 /// getFloatingTypeOfSizeWithinDomain - Returns a real floating
 /// point or a complex type (based on typeDomain/typeSize).
 /// 'typeDomain' is a real floating point or complex type.
 /// 'typeSize' is a real floating point or complex type.
 QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
                                                        QualType Domain) const {
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
     switch (EltRank) {
+    case Float16Rank:
     case HalfRank: llvm_unreachable("Complex half is not supported");
     case FloatRank:      return FloatComplexTy;
     case DoubleRank:     return DoubleComplexTy;
     case LongDoubleRank: return LongDoubleComplexTy;
     case Float128Rank:   return Float128ComplexTy;
     }
   }
 
   assert(Domain->isRealFloatingType() && "Unknown domain!");
   switch (EltRank) {
+  case Float16Rank:    return HalfTy;
   case HalfRank:       return HalfTy;
   case FloatRank:      return FloatTy;
   case DoubleRank:     return DoubleTy;
   case LongDoubleRank: return LongDoubleTy;
   case Float128Rank:   return Float128Ty;
   }
   llvm_unreachable("getFloatingRank(): illegal value for rank");
 }
case BuiltinType::Long:
       return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
     case BuiltinType::LongLong:   return 'q';
     case BuiltinType::Int128:     return 't';
     case BuiltinType::Float:      return 'f';
     case BuiltinType::Double:     return 'd';
     case BuiltinType::LongDouble: return 'D';
     case BuiltinType::NullPtr:    return '*'; // like char*
 
+    case BuiltinType::Float16:
     case BuiltinType::Float128:
     case BuiltinType::Half:
       // FIXME: potentially need @encodes for these!
       return ' ';
 
     case BuiltinType::ObjCId:
     case BuiltinType::ObjCClass:
     case BuiltinType::ObjCSel:

lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(const BuiltinType *T) {
   //                 ::= f  # float
   //                 ::= d  # double
   //                 ::= e  # long double, __float80
   //                 ::= g  # __float128
   // UNSUPPORTED:    ::= Dd # IEEE 754r decimal floating point (64 bits)
   // UNSUPPORTED:    ::= De # IEEE 754r decimal floating point (128 bits)
   // UNSUPPORTED:    ::= Df # IEEE 754r decimal floating point (32 bits)
   //                 ::= Dh # IEEE 754r half-precision floating point (16 bits)
+  //                 ::= DF <number> _ # ISO/IEC TS 18661 binary floating point type _FloatN (N bits);
   //                 ::= Di # char32_t
   //                 ::= Ds # char16_t
   //                 ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
   //                 ::= u <source-name>    # vendor extended type
   std::string type_name;
   switch (T->getKind()) {
   case BuiltinType::Void:
     Out << 'v';
case BuiltinType::Long:
     Out << 'l';
     break;
   case BuiltinType::LongLong:
     Out << 'x';
     break;
   case BuiltinType::Int128:
     Out << 'n';
     break;
+  case BuiltinType::Float16:
+    Out << "DF16_";
+    break;
   case BuiltinType::Half:
     Out << "Dh";
     break;
   case BuiltinType::Float:
     Out << 'f';
     break;
   case BuiltinType::Double:
     Out << 'd';
     break;

lib/AST/MicrosoftMangle.cpp

case BuiltinType::OCLReserveID:
     Out << "PA";
     mangleArtificalTagType(TTK_Struct, "ocl_reserveid");
     break;
 
   case BuiltinType::NullPtr:
     Out << "$$T";
     break;
 
+  case BuiltinType::Float16:
   case BuiltinType::Float128:
   case BuiltinType::Half: {
     DiagnosticsEngine &Diags = Context.getDiags();
     unsigned DiagID = Diags.getCustomDiagID(
         DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
     Diags.Report(Range.getBegin(), DiagID)
         << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
     break;

lib/AST/NSAPI.cpp

NSAPI::getNSNumberFactoryMethodKind(QualType T) const {
   case BuiltinType::Void:
   case BuiltinType::WChar_U:
   case BuiltinType::WChar_S:
   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::Int128:
   case BuiltinType::LongDouble:
   case BuiltinType::UInt128:
+  case BuiltinType::Float16:
   case BuiltinType::Float128:
   case BuiltinType::NullPtr:
   case BuiltinType::ObjCClass:
   case BuiltinType::ObjCId:
   case BuiltinType::ObjCSel:
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"

lib/AST/StmtPrinter.cpp

if (Str.find_first_not_of("-0123456789") == StringRef::npos)
     OS << '.'; // Trailing dot in order to separate from ints.
 
   if (!PrintSuffix)
     return;
 
   // Emit suffixes.  Float literals are always a builtin float type.
   switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("Unexpected type for float literal!");
   case BuiltinType::Half:       break; // FIXME: suffix?
   case BuiltinType::Double:     break; // no suffix.
+  case BuiltinType::Float16:    OS << "F16"; break;
   case BuiltinType::Float:      OS << 'F'; break;
   case BuiltinType::LongDouble: OS << 'L'; break;
   case BuiltinType::Float128:   OS << 'Q'; break;
   }
 }
 
 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
   PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);

lib/AST/Type.cpp

StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case Half:
     return Policy.Half ? "half" : "__fp16";
   case Float:
     return "float";
   case Double:
     return "double";
   case LongDouble:
     return "long double";
+  case Float16:
+    return "_Float16";
   case Float128:
     return "__float128";
   case WChar_S:
   case WChar_U:
     return Policy.MSWChar ? "__wchar_t" : "wchar_t";
   case Char16:
     return "char16_t";
   case Char32:

lib/AST/TypeLoc.cpp

TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::Int:
   case BuiltinType::Long:
   case BuiltinType::LongLong:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::Double:
   case BuiltinType::LongDouble:
+  case BuiltinType::Float16:
   case BuiltinType::Float128:
     llvm_unreachable("Builtin type needs extra local data!");
     // Fall through, if the impossible happens.
       
   case BuiltinType::NullPtr:
   case BuiltinType::Overload:
   case BuiltinType::Dependent:
   case BuiltinType::BoundMember:

lib/Analysis/PrintfFormatString.cpp

bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
   case BuiltinType::Bool:
   case BuiltinType::WChar_U:
   case BuiltinType::WChar_S:
   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::UInt128:
   case BuiltinType::Int128:
   case BuiltinType::Half:
+  case BuiltinType::Float16:
   case BuiltinType::Float128:
     // Various types which are non-trivial to correct.
     return false;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
 #define SIGNED_TYPE(Id, SingletonId)

lib/CodeGen/CGDebugInfo.cpp

case BuiltinType::LongLong:
     Encoding = llvm::dwarf::DW_ATE_signed;
     break;
   case BuiltinType::Bool:
     Encoding = llvm::dwarf::DW_ATE_boolean;
     break;
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
+  case BuiltinType::Float16:
   case BuiltinType::Float128:
   case BuiltinType::Double:
     // FIXME: For targets where long double and __float128 have the same size,
     // they are currently indistinguishable in the debugger without some
     // special treatment. However, there is currently no consensus on encoding
     // and this should be updated once a DWARF encoding exists for distinct
     // floating point types of the same size.
     Encoding = llvm::dwarf::DW_ATE_float;

lib/CodeGen/CGExprScalar.cpp

Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   }
 
   case CK_ZeroToOCLQueue: {
     assert(DestTy->isQueueT() && "CK_ZeroToOCLQueue cast on non queue_t type");
     return llvm::Constant::getNullValue(ConvertType(DestTy));
   }
 
   case CK_IntToOCLSampler:
-    return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);
+    return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);
 
   } // end of switch
 
   llvm_unreachable("unknown scalar cast");
 }
 
 Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
   CodeGenFunction::StmtExprEvaluation eval(CGF);
else {
       bool ignored;
       const llvm::fltSemantics *FS;
       // Don't use getFloatTypeSemantics because Half isn't
       // necessarily represented using the "half" LLVM type.
       if (value->getType()->isFP128Ty())
         FS = &CGF.getTarget().getFloat128Format();
       else if (value->getType()->isHalfTy())
         FS = &CGF.getTarget().getHalfFormat();
       else
         FS = &CGF.getTarget().getLongDoubleFormat();
       F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
       amt = llvm::ConstantFP::get(VMContext, F);
     }
     value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
 
     if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
       if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
         value = Builder.CreateCall(

lib/CodeGen/CodeGenTypes.cpp

case Type::Builtin: {
     case BuiltinType::WChar_S:
     case BuiltinType::WChar_U:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
       ResultType = llvm::IntegerType::get(getLLVMContext(),
                                  static_cast<unsigned>(Context.getTypeSize(T)));
       break;
 
+    case BuiltinType::Float16:
+      ResultType =
+          getTypeForFormat(getLLVMContext(), Context.getFloatTypeSemantics(T),
+                           /* UseNativeHalf = */ true);
+      break;
+
     case BuiltinType::Half:
       // Half FP can either be storage-only (lowered to i16) or native.
       ResultType =
           getTypeForFormat(getLLVMContext(), Context.getFloatTypeSemantics(T),
                            Context.getLangOpts().NativeHalfType ||
                                Context.getLangOpts().HalfArgsAndReturns);
       break;
     case BuiltinType::Float:

lib/CodeGen/ItaniumCXXABI.cpp

switch (Ty->getKind()) {
     case BuiltinType::Long:
     case BuiltinType::ULong:
     case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
     case BuiltinType::Half:
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:
+    case BuiltinType::Float16:
     case BuiltinType::Float128:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
     case BuiltinType::Int128:
     case BuiltinType::UInt128:
       return true;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \

lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_void:
   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::annot_typename:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:

lib/Index/USRGeneration.cpp

if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
         case BuiltinType::Int:
           c = 'I'; break;
         case BuiltinType::Long:
           c = 'L'; break;
         case BuiltinType::LongLong:
           c = 'K'; break;
         case BuiltinType::Int128:
           c = 'J'; break;
+        case BuiltinType::Float16:
         case BuiltinType::Half:
           c = 'h'; break;
         case BuiltinType::Float:
           c = 'f'; break;
         case BuiltinType::Double:
           c = 'd'; break;
         case BuiltinType::LongDouble:
           c = 'D'; break;

lib/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   saw_period = false;
   saw_ud_suffix = false;
   isLong = false;
   isUnsigned = false;
   isLongLong = false;
   isHalf = false;
   isFloat = false;
   isImaginary = false;
+  isFloat16 = false;
   isFloat128 = false;
   MicrosoftInteger = 0;
   hadError = false;
 
   if (*s == '0') { // parse radix
     ParseNumberStartingWithZero(TokLoc);
     if (hadError)
       return;
for (; s != ThisTokEnd; ++s) {
     case 'H':
       // OpenCL Extension v1.2 s9.5 - h or H suffix for half type.
       if (!PP.getLangOpts().Half) break;
       if (!isFPConstant) break;  // Error for integer constant.
       if (isHalf || isFloat || isLong) break; // HH, FH, LH invalid.
       isHalf = true;
       continue;  // Success.
     case 'f':      // FP Suffix for "float"
     case 'F':
       if (!isFPConstant) break;  // Error for integer constant.
       if (isHalf || isFloat || isLong || isFloat128)
         break; // HF, FF, LF, QF invalid.
+
+      if (s + 2 < ThisTokEnd && s[1] == '1' && s[2] == '6') {
+          s += 2; // success, eat up 2 characters.
+          isFloat16 = true;
+          continue;
+      }
+
       isFloat = true;
       continue;  // Success.
     case 'q':    // FP Suffix for "__float128"
     case 'Q':
       if (!isFPConstant) break;  // Error for integer constant.
       if (isHalf || isFloat || isLong || isFloat128)
         break; // HQ, FQ, LQ, QQ invalid.
       isFloat128 = true;
if (s != ThisTokEnd) {
     expandUCNs(UDSuffixBuf, StringRef(SuffixBegin, ThisTokEnd - SuffixBegin));
     if (isValidUDSuffix(PP.getLangOpts(), UDSuffixBuf)) {
       // Any suffix pieces we might have parsed are actually part of the
       // ud-suffix.
       isLong = false;
       isUnsigned = false;
       isLongLong = false;
       isFloat = false;
+      isFloat16 = false;
       isHalf = false;
       isImaginary = false;
       MicrosoftInteger = 0;
 
       saw_ud_suffix = true;
       return;
     }
 

lib/Parse/ParseDecl.cpp

while (1) {
     case tok::kw_float:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_double:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
+    case tok::kw__Float16:
+      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec,
+                                     DiagID, Policy);
+      break;
     case tok::kw___float128:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_wchar_t:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
bool Parser::isTypeSpecifierQualifier() {
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
 
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 

lib/Parse/ParseExpr.cpp

#undef RTT_JOIN
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_void:
   case tok::kw_typename:
   case tok::kw_typeof:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
   {

lib/Parse/ParseExprCXX.cpp

case tok::kw_half:
     DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_float:
     DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_double:
     DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
     break;
+  case tok::kw__Float16:
+    DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
+    break;
   case tok::kw___float128:
     DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_wchar_t:
     DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_char16_t:
     DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);

lib/Parse/ParseTentative.cpp

#define TYPE_TRAIT(N,Spelling,K) \
   case tok::kw_##Spelling:
 #include "clang/Basic/TokenKinds.def"
     return TPResult::True;
       
   // Obviously starts a type-specifier-seq:
   case tok::kw_char:
   case tok::kw_const:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_enum:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_int:
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_void:
   case tok::annot_decltype:
     if (NextToken().is(tok::l_paren))
       return TPResult::Ambiguous;
 
     // This is a function-style cast in all cases we disambiguate other than
     // one:
bool Parser::isCXXDeclarationSpecifierAType() {
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_void:
   case tok::kw___unknown_anytype:
   case tok::kw___auto_type:
     return true;
 
   case tok::kw_auto:
     return getLangOpts().CPlusPlus11;

lib/Sema/DeclSpec.cpp

switch (DS.getTypeSpecType()) {
     case TST_char:
     case TST_char16:
     case TST_char32:
     case TST_class:
     case TST_decimal128:
     case TST_decimal32:
     case TST_decimal64:
     case TST_double:
+    case TST_Float16:
     case TST_float128:
     case TST_enum:
     case TST_error:
     case TST_float:
     case TST_half:
     case TST_int:
     case TST_int128:
     case TST_struct:
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_wchar:       return Policy.MSWChar ? "__wchar_t" : "wchar_t";
   case DeclSpec::TST_char16:      return "char16_t";
   case DeclSpec::TST_char32:      return "char32_t";
   case DeclSpec::TST_int:         return "int";
   case DeclSpec::TST_int128:      return "__int128";
   case DeclSpec::TST_half:        return "half";
   case DeclSpec::TST_float:       return "float";
   case DeclSpec::TST_double:      return "double";
+  case DeclSpec::TST_float16:     return "_Float16";
   case DeclSpec::TST_float128:    return "__float128";
   case DeclSpec::TST_bool:        return Policy.Bool ? "bool" : "_Bool";
   case DeclSpec::TST_decimal32:   return "_Decimal32";
   case DeclSpec::TST_decimal64:   return "_Decimal64";
   case DeclSpec::TST_decimal128:  return "_Decimal128";
   case DeclSpec::TST_enum:        return "enum";
   case DeclSpec::TST_class:       return "class";
   case DeclSpec::TST_union:       return "union";

lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_void:
   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___auto_type:
     return true;
 
   case tok::annot_typename:

lib/Sema/SemaExpr.cpp

ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
   QualType Ty = E->getType();
   assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
 
   ExprResult Res = UsualUnaryConversions(E);
   if (Res.isInvalid())
     return ExprError();
   E = Res.get();
 
-  // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to
-  // double.
+  // If this is a 'float'  or '__fp16' (CVR qualified or typedef)
+  // promote to double.
+  // Note that there is default argument promotion for '_Float16'; this
+  // applies to the standard floating types only.
   const BuiltinType *BTy = Ty->getAs<BuiltinType>();
   if (BTy && (BTy->getKind() == BuiltinType::Half ||
               BTy->getKind() == BuiltinType::Float)) {
     if (getLangOpts().OpenCL &&
         !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
         if (BTy->getKind() == BuiltinType::Half) {
             E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
         }
if (Literal.isHalf){
       else {
         Diag(Tok.getLocation(), diag::err_half_const_requires_fp16);
         return ExprError();
       }
     } else if (Literal.isFloat)
       Ty = Context.FloatTy;
     else if (Literal.isLong)
       Ty = Context.LongDoubleTy;
+    else if (Literal.isFloat16)
+      Ty = Context.Float16Ty;
     else if (Literal.isFloat128)
       Ty = Context.Float128Ty;
     else
       Ty = Context.DoubleTy;
 
     Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
 
     if (Ty == Context.DoubleTy) {

lib/Sema/SemaTemplateVariadic.cpp

bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   case TST_wchar:
   case TST_char16:
   case TST_char32:
   case TST_int:
   case TST_int128:
   case TST_half:
   case TST_float:
   case TST_double:
+  case TST_Float16:
   case TST_float128:
   case TST_bool:
   case TST_decimal32:
   case TST_decimal64:
   case TST_decimal128:
   case TST_enum:
   case TST_union:
   case TST_struct:

lib/Sema/SemaType.cpp

case DeclSpec::TST_int128:
     if (!S.Context.getTargetInfo().hasInt128Type())
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "__int128";
     if (DS.getTypeSpecSign() == DeclSpec::TSS_unsigned)
       Result = Context.UnsignedInt128Ty;
     else
       Result = Context.Int128Ty;
     break;
-  case DeclSpec::TST_half: Result = Context.HalfTy; break;
-  case DeclSpec::TST_float: Result = Context.FloatTy; break;
+  case DeclSpec::TST_float16: Result = Context.Float16Ty; break;
+  case DeclSpec::TST_half:    Result = Context.HalfTy; break;
+  case DeclSpec::TST_float:   Result = Context.FloatTy; break;
   case DeclSpec::TST_double:
     if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
       Result = Context.LongDoubleTy;
     else
       Result = Context.DoubleTy;
     break;
   case DeclSpec::TST_float128:
     if (!S.Context.getTargetInfo().hasFloat128Type())

lib/Serialization/ASTCommon.cpp

case BuiltinType::Float:
     ID = PREDEF_TYPE_FLOAT_ID;
     break;
   case BuiltinType::Double:
     ID = PREDEF_TYPE_DOUBLE_ID;
     break;
   case BuiltinType::LongDouble:
     ID = PREDEF_TYPE_LONGDOUBLE_ID;
     break;
+  case BuiltinType::Float16:
+    ID = PREDEF_TYPE_FLOAT16_ID;
+    break;
   case BuiltinType::Float128:
     ID = PREDEF_TYPE_FLOAT128_ID;
     break;
   case BuiltinType::NullPtr:
     ID = PREDEF_TYPE_NULLPTR_ID;
     break;
   case BuiltinType::Char16:
     ID = PREDEF_TYPE_CHAR16_ID;

lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_FLOAT_ID:
       T = Context.FloatTy;
       break;
     case PREDEF_TYPE_DOUBLE_ID:
       T = Context.DoubleTy;
       break;
     case PREDEF_TYPE_LONGDOUBLE_ID:
       T = Context.LongDoubleTy;
       break;
+    case PREDEF_TYPE_FLOAT16_ID:
+      T = Context.Float16Ty;
+      break;
     case PREDEF_TYPE_FLOAT128_ID:
       T = Context.Float128Ty;
       break;
     case PREDEF_TYPE_OVERLOAD_ID:
       T = Context.OverloadTy;
       break;
     case PREDEF_TYPE_BOUND_MEMBER:
       T = Context.BoundMemberTy;

test/CodeGenCXX/float16-declarations.cpp

+// RUN: %clang -std=c++11 --target=aarch64-arm--eabi -S -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK --check-prefix=CHECK-AARCH64
+// RUN: %clang -std=c++11 --target=x86_64 -S -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK --check-prefix=CHECK-X86
+
+/*  Various contexts where type _Float16 can appear. */
+
+
+/*  Namespace */
+
+namespace {
+  _Float16 f1n;
+// CHECK-DAG: @_ZN12_GLOBAL__N_13f1nE = internal global half 0xH0000, align 2
+
+  _Float16 f2n = 33.f16;
+// CHECK-AARCH64-DAG: @_ZN12_GLOBAL__N_13f2nE = internal global half 0xH5020, align 2
+// CHECK-X86-DAG:     @_ZN12_GLOBAL__N_13f2nE = internal global i16 20512, align 2
+
+  _Float16 arr1n[10];
+// CHECK-AARCH64-DAG: @_ZN12_GLOBAL__N_15arr1nE = internal global [10 x half] zeroinitializer, align 2
+// CHECK-X86-DAG:     @_ZN12_GLOBAL__N_15arr1nE = internal global [10 x half] zeroinitializer, align 16
+
+  _Float16 arr2n[] = { 1.2, 3.0, 3.e4 };
+// CHECK-AARCH64-DAG: @_ZN12_GLOBAL__N_15arr2nE = internal global [3 x half] [half 0xH3CCD, half 0xH4200, half 0xH7753], align 2
+// CHECK-X86-DAG:     @_ZN12_GLOBAL__N_15arr2nE = internal global [3 x i16] [i16 15565, i16 16896, i16 30547], align 2
+
+  const volatile _Float16 func1n(const _Float16 &arg) {
+    return arg + f2n + arr1n[4] - arr2n[1];
+  }
+}
+
+
+/* File */
+
+_Float16 f1f;
+// CHECK-AARCH64-DAG: @f1f = global half 0xH0000, align 2
+// CHECK-X86-DAG: @f1f = global half 0xH0000, align 2
+
+_Float16 f2f = 32.4;
+// CHECK-AARCH64-DAG: @f2f = global half 0xH500D, align 2
+// CHECK-X86-DAG: @f2f = global i16 20493, align 2
+
+_Float16 arr1f[10];
+// CHECK-AARCH64-DAG: @arr1f = global [10 x half] zeroinitializer, align 2
+// CHECK-X86-DAG: @arr1f = global [10 x half] zeroinitializer, align 16
+
+_Float16 arr2f[] = { -1.2, -3.0, -3.e4 };
+// CHECK-AARCH64-DAG: @arr2f = global [3 x half] [half 0xHBCCD, half 0xHC200, half 0xHF753], align 2
+// CHECK-X86-DAG: @arr2f = global [3 x i16] [i16 -17203, i16 -15872, i16 -2221], align 2
+
+_Float16 func1f(_Float16 arg);
+
+
+/* Class */
+
+class C1 {
+  _Float16 f1c;
+
+  static const _Float16 f2c;
+// CHECK-DAG: @_ZN2C13f2cE = external constant half, align 2
+
+  volatile _Float16 f3c;
+
+public:
+  C1(_Float16 arg) : f1c(arg), f3c(arg) { }
+// Check that we mangle _Float16 to DF16_
+// CHECK-DAG: define linkonce_odr void @_ZN2C1C2EDF16_(%class.C1* %this, half %arg)
+
+  _Float16 func1c(_Float16 arg ) {
+    return f1c + arg;
+  }
+// CHECK-DAG: define linkonce_odr half @_ZN2C16func1cEDF16_(%class.C1* %this, half %arg)
+
+  static _Float16 func2c(_Float16 arg) {
+    return arg * C1::f2c;
+  }
+// CHECK-DAG: define linkonce_odr half @_ZN2C16func2cEDF16_(half %arg)
+};
+
+/*  Template */
+
+template <class C> C func1t(C arg) {
+  return arg * 2.f16;
+}
+// CHECK-DAG: define linkonce_odr half @_Z6func1tIDF16_ET_S0_(half %arg)
+
+template <class C> struct S1 {
+  C mem1;
+};
+
+template <> struct S1<_Float16> {
+  _Float16 mem2;
+};
+
+
+/* Local */
+
+extern int printf (const char *__restrict __format, ...);
+
+int main(void) {
+  _Float16 f1l = 1e3f16;
+// CHECK-DAG: store half 0xH63D0, half* %f1l, align 2
+
+  _Float16 f2l = -0.f16;
+// CHECK-DAG: store half 0xH8000, half* %f2l, align 2
+
+  _Float16 f3l = 1.000976562;
+// CHECK-DAG: store half 0xH3C01, half* %f3l, align 2
+
+  C1 c1(f1l);
+// CHECK-DAG:  [[F1L:%[a-z0-9]+]] = load half, half* %f1l, align 2
+// CHECK-DAG:  call void @_ZN2C1C2EDF16_(%class.C1* %c1, half [[F1L]])
+
+  S1<_Float16> s1 = { 132.f16 };
+// CHECK-AARCH64-DAG: @_ZZ4mainE2s1 = private unnamed_addr constant %struct.S1 { half 0xH5820 }, align 2
+// CHECK-X86-DAG:     @_ZZ4mainE2s1 = private unnamed_addr constant { i16 } { i16 22560 }, align 2
+// CHECK-DAG:  [[S1:%[0-9]+]] = bitcast %struct.S1* %s1 to i8*
+// CHECK-AARCH64-DAG: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[S1]], i8* bitcast (%struct.S1* @_ZZ4mainE2s1 to i8*), i64 2, i32 2, i1 false)
+// CHECK-X86-DAG:     call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast ({ i16 }* @_ZZ4mainE2s1 to i8*), i64 2, i32 2, i1 false)
+
+  _Float16 f4l = func1n(f1l)  + func1f(f2l) + c1.func1c(f3l) + c1.func2c(f1l) +
+    func1t(f1l) + s1.mem2 - f1n + f2n;
+
+  auto f5l = -1.f16, *f6l = &f2l, f7l = func1t(f3l);
+// CHECK-DAG:  store half 0xHBC00, half* %f5l, align 2
+// CHECK-DAG:  store half* %f2l, half** %f6l, align 8
+
+  _Float16 f8l = f4l++;
+// CHECK-DAG:  [[F4L:%[a-z0-9]+]] = load half, half* %f4l, align 2
+// CHECK-DAG:  [[INC:%inc[0-9]*]] = fadd half [[F4L]], 0xH3C00
+// CHECK-DAG:  store half [[INC]], half* %f4l, align 2
+
+  _Float16 arr1l[] = { -1.f16, -0.f16, -11.f16 };
+// CHECK-AARCH64-DAG: @_ZZ4mainE5arr1l = private unnamed_addr constant [3 x half] [half 0xHBC00, half 0xH8000, half 0xHC980], align 2
+// CHECK-X86-DAG:     @_ZZ4mainE5arr1l = private unnamed_addr constant [3 x i16] [i16 -17408, i16 -32768, i16 -13952], align 2
+}

test/Frontend/float16.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -ast-dump -fnative-half-type %s | FileCheck %s --check-prefix=CHECK-NATIVE
+
+/*  Various contexts where type _Float16 can appear. */
+
+/*  Namespace */
+namespace {
+  _Float16 f1n;
+  _Float16 f2n = 33.f16;
+  _Float16 arr1n[10];
+  _Float16 arr2n[] = { 1.2, 3.0, 3.e4 };
+  const volatile _Float16 func1n(const _Float16 &arg) {
+    return arg + f2n + arr1n[4] - arr2n[1];
+  }
+}
+
+//CHECK: |-NamespaceDecl
+//CHECK: | |-VarDecl {{.*}} f1n '_Float16'
+//CHECK: | |-VarDecl {{.*}} f2n '_Float16' cinit
+//CHECK: | | `-FloatingLiteral {{.*}} '_Float16' 3.300000e+01
+//CHECK: | |-VarDecl {{.*}} arr1n '_Float16 [10]'
+//CHECK: | |-VarDecl {{.*}} arr2n '_Float16 [3]' cinit
+//CHECK: | | `-InitListExpr {{.*}} '_Float16 [3]'
+//CHECK: | |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: | |   | `-FloatingLiteral {{.*}} 'double' 1.200000e+00
+//CHECK: | |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: | |   | `-FloatingLiteral {{.*}} 'double' 3.000000e+00
+//CHECK: | |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: | |     `-FloatingLiteral {{.*}} 'double' 3.000000e+04
+//CHECK: | `-FunctionDecl {{.*}} func1n 'const volatile _Float16 (const _Float16 &)'
+
+/* File */
+_Float16 f1f;
+_Float16 f2f = 32.4;
+_Float16 arr1f[10];
+_Float16 arr2f[] = { -1.2, -3.0, -3.e4 };
+_Float16 func1f(_Float16 arg);
+
+//CHECK: |-VarDecl {{.*}} f1f '_Float16'
+//CHECK: |-VarDecl {{.*}} f2f '_Float16' cinit
+//CHECK: | `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: |   `-FloatingLiteral {{.*}} 'double' 3.240000e+01
+//CHECK: |-VarDecl {{.*}} arr1f '_Float16 [10]'
+//CHECK: |-VarDecl {{.*}} arr2f '_Float16 [3]' cinit
+//CHECK: | `-InitListExpr {{.*}} '_Float16 [3]'
+//CHECK: |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: |   | `-UnaryOperator {{.*}} 'double' prefix '-'
+//CHECK: |   |   `-FloatingLiteral {{.*}} 'double' 1.200000e+00
+//CHECK: |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: |   | `-UnaryOperator {{.*}} 'double' prefix '-'
+//CHECK: |   |   `-FloatingLiteral {{.*}} 'double' 3.000000e+00
+//CHECK: |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK: |     `-UnaryOperator {{.*}} 'double' prefix '-'
+//CHECK: |       `-FloatingLiteral {{.*}} 'double' 3.000000e+04
+//CHECK: |-FunctionDecl {{.*}} func1f '_Float16 (_Float16)'
+//CHECK: | `-ParmVarDecl {{.*}} arg '_Float16'
+
+
+// Mixing __fp16 and Float16 types:
+// The _Float16 type is first converted to __fp16 type and then the operation
+// is completed as if both operands were of __fp16 type.
+
+__fp16 B = -0.1;
+auto C = -1.0f16 + B;
+
+// When we do *not* have native half types, we expect __fp16 to be promoted to
+// float, and consequently also _Float16 promotions to float:
+
+//CHECK: -VarDecl {{.*}} used B '__fp16' cinit
+//CHECK: | `-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
+//CHECK: |   `-UnaryOperator {{.*}} 'double' prefix '-'
+//CHECK: |     `-FloatingLiteral {{.*}} 'double' 1.000000e-01
+//CHECK: |-VarDecl {{.*}} C 'float':'float' cinit
+//CHECK: | `-BinaryOperator {{.*}} 'float' '+'
+//CHECK: |   |-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK: |   | `-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK: |   |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK: |   `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK: |     `-ImplicitCastExpr {{.*}} '__fp16' <LValueToRValue>
+//CHECK: |       `-DeclRefExpr {{.*}} '__fp16' lvalue Var 0x{{.*}} 'B' '__fp16'
+
+// When do have native half types, we expect to see promotions XXXXX:
+
+//CHECK-NATIVE: |-VarDecl {{.*}} used B '__fp16' cinit
+//CHECK-NATIVE: | `-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
+//CHECK-NATIVE: |   `-UnaryOperator {{.*}} 'double' prefix '-'
+//CHECK-NATIVE: |     `-FloatingLiteral {{.*}} 'double' 1.000000e-01
+//CHECK-NATIVE: |-VarDecl {{.*}} C '__fp16':'__fp16' cinit
+//CHECK-NATIVE: | `-BinaryOperator {{.*}} '__fp16' '+'
+//CHECK-NATIVE: |   |-ImplicitCastExpr {{.*}} '__fp16' <FloatingCast>
+//CHECK-NATIVE: |   | `-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK-NATIVE: |   |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NATIVE: |   `-ImplicitCastExpr {{.*}} '__fp16' <LValueToRValue>
+//CHECK-NATIVE: |     `-DeclRefExpr {{.*}} '__fp16' lvalue Var 0x{{.*}} 'B' '__fp16'
+
+
+/* Class */
+
+class C1 {
+  _Float16 f1c;
+  static const _Float16 f2c;
+  volatile _Float16 f3c;
+public:
+  C1(_Float16 arg) : f1c(arg), f3c(arg) { }
+  _Float16 func1c(_Float16 arg ) {
+    return f1c + arg;
+  }
+  static _Float16 func2c(_Float16 arg) {
+    return arg * C1::f2c;
+  }
+};
+
+//CHECK: |-CXXRecordDecl {{.*}} referenced class C1 definition
+//CHECK: | |-CXXRecordDecl {{.*}} implicit referenced class C1
+//CHECK: | |-FieldDecl {{.*}} referenced f1c '_Float16'
+//CHECK: | |-VarDecl {{.*}} used f2c 'const _Float16' static
+//CHECK: | |-FieldDecl {{.*}} f3c 'volatile _Float16'
+//CHECK: | |-AccessSpecDecl
+//CHECK: | |-CXXConstructorDecl {{.*}} used C1 'void (_Float16)'
+//CHECK: | | |-ParmVarDecl {{.*}} used arg '_Float16'
+//CHECK: | | |-CXXCtorInitializer Field {{.*}} 'f1c' '_Float16'
+//CHECK: | | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
+//CHECK: | | |-CXXCtorInitializer Field {{.*}} 'f3c' 'volatile _Float16'
+//CHECK: | | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
+//CHECK: | | `-CompoundStmt
+//CHECK: | |-CXXMethodDecl {{.*}} used func1c '_Float16 (_Float16)'
+//CHECK: | | |-ParmVarDecl {{.*}} used arg '_Float16'
+//CHECK: | | `-CompoundStmt
+//CHECK: | |   `-ReturnStmt
+//CHECK: | |     `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK: | |       |-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | |       | `-MemberExpr {{.*}} '_Float16' lvalue ->f1c 0x{{.*}}
+//CHECK: | |       |   `-CXXThisExpr {{.*}} 'class C1 *' this
+//CHECK: | |       `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | |         `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
+//CHECK: | |-CXXMethodDecl {{.*}} used func2c '_Float16 (_Float16)' static
+//CHECK: | | |-ParmVarDecl {{.*}} used arg '_Float16'
+//CHECK: | | `-CompoundStmt
+//CHECK: | |   `-ReturnStmt
+//CHECK: | |     `-BinaryOperator {{.*}} '_Float16' '*'
+//CHECK: | |       |-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | |       | `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'
+//CHECK: | |       `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK: | |         `-DeclRefExpr {{.*}} 'const _Float16' lvalue Var 0x{{.*}} 'f2c' 'const _Float16'
+
+
+/*  Template */
+
+template <class C> C func1t(C arg) {
+  return arg * 2.f16;
+}
+
+//CHECK: |-FunctionTemplateDecl {{.*}}  func1t
+//CHECK: | |-TemplateTypeParmDecl  {{.*}} C
+//CHECK: | |-FunctionDecl {{.*}} func1t 'C (C)'
+//CHECK: | | |-ParmVarDecl {{.*}} referenced arg 'C'
+//CHECK: | | `-CompoundStmt
+//CHECK: | |   `-ReturnStmt
+//CHECK: | |     `-BinaryOperator {{.*}} '<dependent type>' '*'
+//CHECK: | |       |-DeclRefExpr {{.*}} 'C' lvalue ParmVar {{.*}} 'arg' 'C'
+//CHECK: | |       `-FloatingLiteral {{.*}} '_Float16' 2.000000e+00
+//CHECK: | `-FunctionDecl {{.*}} used func1t '_Float16 (_Float16)'
+//CHECK: |   |-TemplateArgument type '_Float16'
+//CHECK: |   |-ParmVarDecl {{.*}} used arg '_Float16':'_Float16'
+//CHECK: |   `-CompoundStmt
+//CHECK: |     `-ReturnStmt
+//CHECK: |       `-BinaryOperator {{.*}} '_Float16' '*'
+//CHECK: |         |-ImplicitCastExpr {{.*}} '_Float16':'_Float16' <LValueToRValue>
+//CHECK: |         | `-DeclRefExpr {{.*}} '_Float16':'_Float16' lvalue ParmVar {{.*}} 'arg' '_Float16':'_Float16'
+//CHECK: |         `-FloatingLiteral {{.*}} '_Float16' 2.000000e+00
+
+
+template <class C> struct S1 {
+  C mem1;
+};
+
+//CHECK: |-ClassTemplateDecl {{.*}} S1
+//CHECK: | |-TemplateTypeParmDecl {{.*}} referenced class depth 0 index 0 C
+//CHECK: | |-CXXRecordDecl {{.*}} struct S1 definition
+//CHECK: | | |-CXXRecordDecl {{.*}} implicit struct S1
+//CHECK: | | `-FieldDecl {{.*}} mem1 'C'
+//CHECK: | `-ClassTemplateSpecialization {{.*}} 'S1'
+
+template <> struct S1<_Float16> {
+  _Float16 mem2;
+};
+
+
+/* Local */
+
+extern int printf (const char *__restrict __format, ...);
+
+int main(void) {
+  _Float16 f1l = 1e3f16;
+//CHECK:     |-DeclStmt
+//CHECK-NEXT:| `-VarDecl {{.*}} used f1l '_Float16' cinit
+//CHECK-NEXT:|   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+03
+
+  _Float16 f2l = -0.f16;
+//CHECK:     | `-VarDecl {{.*}} used f2l '_Float16' cinit
+//CHECK:     |   `-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK:     |     `-FloatingLiteral {{.*}} '_Float16' 0.000000e+00
+
+  _Float16 f3l = 1.000976562;
+//CHECK:     | `-VarDecl {{.*}} used f3l '_Float16' cinit
+//CHECK:     |   `-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
+//CHECK:     |     `-FloatingLiteral {{.*}} 'double' 1.000977e+00
+
+  C1 c1(f1l);
+//CHECK:     | `-VarDecl{{.*}} used c1 'class C1' callinit
+//CHECK:     |   `-CXXConstructExpr {{.*}} 'class C1' 'void (_Float16)'
+//CHECK:     |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var 0x{{.*}} 'f1l' '_Float16'
+
+  S1<_Float16> s1 = { 132.f16 };
+//CHECK:     |-DeclStmt
+//CHECK:     | `-VarDecl {{.*}} used s1 'S1<_Float16>':'struct S1<_Float16>' cinit
+//CHECK:     |   `-InitListExpr {{.*}} 'S1<_Float16>':'struct S1<_Float16>'
+//CHECK:     |     `-FloatingLiteral {{.*}} '_Float16' 1.320000e+02
+
+  _Float16 f4l = func1n(f1l)  + func1f(f2l) + c1.func1c(f3l) + c1.func2c(f1l) +
+    func1t(f1l) + s1.mem2 - f1n + f2n;
+//CHECK:     |-DeclStmt
+//CHECK:     | `-VarDecl {{.*}} used f4l '_Float16' cinit
+//CHECK:     |   `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     |-BinaryOperator {{.*}} '_Float16' '-'
+//CHECK:     |     | |-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     | | |-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     | | | |-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     | | | | |-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     | | | | | |-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK:     |     | | | | | | |-CallExpr {{.*}} '_Float16'
+//CHECK:     |     | | | | | | | |-ImplicitCastExpr {{.*}}  'const volatile _Float16 (*)(const _Float16 &)' <FunctionToPointerDecay>
+//CHECK:     |     | | | | | | | | `-DeclRefExpr {{.*}} 'const volatile _Float16 (const _Float16 &)' lvalue Function {{.*}} 'func1n' 'const volatile _Float16 (const _Float16 &)'
+//CHECK:     |     | | | | | | | `-ImplicitCastExpr {{.*}} 'const _Float16' lvalue <NoOp>
+//CHECK:     |     | | | | | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
+//CHECK:     |     | | | | | | `-CallExpr {{.*}} '_Float16'
+//CHECK:     |     | | | | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
+//CHECK:     |     | | | | | |   | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1f' '_Float16 (_Float16)'
+//CHECK:     |     | | | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     | | | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2l' '_Float16'
+//CHECK:     |     | | | | | `-CXXMemberCallExpr {{.*}} '_Float16'
+//CHECK:     |     | | | | |   |-MemberExpr {{.*}} '<bound member function type>' .func1c {{.*}}
+//CHECK:     |     | | | | |   | `-DeclRefExpr {{.*}} 'class C1' lvalue Var {{.*}} 'c1' 'class C1'
+//CHECK:     |     | | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     | | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
+//CHECK:     |     | | | | `-CallExpr {{.*}} '_Float16'
+//CHECK:     |     | | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
+//CHECK:     |     | | | |   | `-MemberExpr {{.*}} '_Float16 (_Float16)' lvalue .func2c {{.*}}
+//CHECK:     |     | | | |   |   `-DeclRefExpr {{.*}} 'class C1' lvalue Var {{.*}} 'c1' 'class C1'
+//CHECK:     |     | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
+//CHECK:     |     | | | `-CallExpr {{.*}} '_Float16':'_Float16'
+//CHECK:     |     | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
+//CHECK:     |     | | |   | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
+//CHECK:     |     | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
+//CHECK:     |     | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     | |   `-MemberExpr {{.*}} '_Float16' lvalue .mem2 {{.*}}
+//CHECK:     |     | |     `-DeclRefExpr {{.*}} 'S1<_Float16>':'struct S1<_Float16>' lvalue Var {{.*}} 's1' 'S1<_Float16>':'struct S1<_Float16>'
+//CHECK:     |     | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |     |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1n' '_Float16'
+//CHECK:     |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
+
+  auto f5l = -1.f16, *f6l = &f2l, f7l = func1t(f3l);
+//CHECK:     |-DeclStmt {{.*}}
+//CHECK:     | |-VarDecl {{.*}} f5l '_Float16':'_Float16' cinit
+//CHECK:     | | `-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK:     | |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK:     | |-VarDecl {{.*}} f6l '_Float16 *' cinit
+//CHECK:     | | `-UnaryOperator {{.*}} '_Float16 *' prefix '&'
+//CHECK:     | |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2l' '_Float16'
+//CHECK:     | `-VarDecl {{.*}} f7l '_Float16':'_Float16' cinit
+//CHECK:     |   `-CallExpr {{.*}} '_Float16':'_Float16'
+//CHECK:     |     |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
+//CHECK:     |     | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
+//CHECK:     |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK:     |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
+
+  _Float16 f8l = f4l++;
+//CHECK:     |-DeclStmt {{.*}}
+//CHECK:     | `-VarDecl {{.*}} f8l '_Float16' cinit
+//CHECK:     |   `-UnaryOperator {{.*}} '_Float16' postfix '++'
+//CHECK:     |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f4l' '_Float16'
+
+  _Float16 arr1l[] = { -1.f16, -0.f16, -11.f16 };
+//CHECK:     |-DeclStmt {{.*}}
+//CHECK:       `-VarDecl {{.*}} arr1l '_Float16 [3]' cinit
+//CHECK:         `-InitListExpr {{.*}} '_Float16 [3]'
+//CHECK:           |-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK:           | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK:           |-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK:           | `-FloatingLiteral {{.*}} '_Float16' 0.000000e+00
+//CHECK:           `-UnaryOperator {{.*}} '_Float16' prefix '-'
+//CHECK:             `-FloatingLiteral {{.*}} '_Float16' 1.100000e+01
+}

test/Lexer/half-literal.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
 float a = 1.0h; // expected-error{{invalid suffix 'h' on floating constant}}
 float b = 1.0H; // expected-error{{invalid suffix 'H' on floating constant}}
+
+_Float16 c = 1.f166; // expected-error{{invalid suffix 'f166' on floating constant}}
+_Float16 d = 1.f1;   // expected-error{{invalid suffix 'f1' on floating constant}}

tools/libclang/CXType.cpp

switch (BT->getKind()) {
     BTCASE(Int);
     BTCASE(Long);
     BTCASE(LongLong);
     BTCASE(Int128);
     BTCASE(Half);
     BTCASE(Float);
     BTCASE(Double);
     BTCASE(LongDouble);
+    BTCASE(Float16);
     BTCASE(Float128);
     BTCASE(NullPtr);
     BTCASE(Overload);
     BTCASE(Dependent);
     BTCASE(ObjCId);
     BTCASE(ObjCClass);
     BTCASE(ObjCSel);
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) BTCASE(Id);
#define TKIND(X) case CXType_##X: s = ""  #X  ""; break
   switch (K) {
     TKIND(Invalid);
     TKIND(Unexposed);
     TKIND(Void);
     TKIND(Bool);
     TKIND(Char_U);
     TKIND(UChar);
     TKIND(Char16);
-    TKIND(Char32);  
+    TKIND(Char32);
     TKIND(UShort);
     TKIND(UInt);
     TKIND(ULong);
     TKIND(ULongLong);
     TKIND(UInt128);
     TKIND(Char_S);
     TKIND(SChar);
     case CXType_WChar: s = "WChar"; break;
     TKIND(Short);
     TKIND(Int);
     TKIND(Long);
     TKIND(LongLong);
     TKIND(Int128);
     TKIND(Half);
     TKIND(Float);
     TKIND(Double);
     TKIND(LongDouble);
+    TKIND(Float16);
     TKIND(Float128);
     TKIND(NullPtr);
     TKIND(Overload);
     TKIND(Dependent);
     TKIND(ObjCId);
     TKIND(ObjCClass);
     TKIND(ObjCSel);
     TKIND(Complex);