[OpenCL] Support half precision floating point type literal

[yaxunl]

Summary

OpenCL allows half precision floating point type literals with suffices h or H when cl_khr_fp16 extension is enabled. This change supports that.

Differential Revision: http://reviews.llvm.org/D16865

[pxli168]

lib/Sema/SemaCast.cpp

2397 ↗

(On Diff #46816)

In the context there is a SrcType you can just use it as you used below.

test/Lexer/opencl-half-literal.cl

5 ↗

(On Diff #46816)

Did the tests need the constant here?
I think constant is address space in OpenCL, maybe you could remove them.

[yaxunl]

test/Lexer/opencl-half-literal.cl

5 ↗

(On Diff #46816)

In OpenCL 1.2 and below program scope variable must be in constant address space.
I tried to remove the constant and I got error:
opencl-half-literal.cl Line 5: program scope variable must reside in constant address space

[yaxunl]

Revised as Xiuli Suggested.

[yaxunl]

re-update diff. Accidentally dropped a line in test/SemaOpenCL/half.cl in the last update.

[Anastasia]

I think a reference to Spec section would be nice somewhere either in code or test.

Thanks!

lib/Lex/LiteralSupport.cpp

578 ↗

(On Diff #46905)

I think the full diff would have been better here. Otherwise, too many fragments without context around makes it hard to review.

test/Lexer/opencl-half-literal.cl

6 ↗

(On Diff #46905)

That's right, we can only declare program scope variables in a constant AS in OpenCL earlier than v2.0. So it's fine.

[yaxunl]

Add reference to OpenCL extension spec in comments.
Update with full diff.

[pxli168]

LGTM!
Thanks.

[Anastasia]

test/Lexer/opencl-half-literal.cl

10 ↗

(On Diff #46943)

Could we disable cl_khr_fp16 here and check that we get an error when using half literals.

[yaxunl]

Revised according to Anastasia's comments.

I got difficulty diagnosing half literal as lexical error since the preprocessor and lexer do not know whether OpenCL extension cl_khr_fp16 is enabled or not, so I diagnose half literal used without cl_khr_fp16 enabled as semantic error and added tests to SemaOpenCL.

Also I removed diagnostic for casting from half type since it is unnecessary. If half type value is created when cl_khr_fp16 is not enabled, it will be diagnosed before the cast expression is reached.

[Anastasia]

@pekka, do you have any additional comments here? I believe we are about to complete this work.

Thanks!

lib/Lex/LiteralSupport.cpp

559 ↗

(On Diff #47238)

. missing

561 ↗

(On Diff #47238)

. missing

test/SemaOpenCL/half.cl

49 ↗

(On Diff #47238)

I think you already test this in line 4?

[yaxunl]

test/SemaOpenCL/half.cl

49 ↗

(On Diff #47238)

I want to check after cl_khr_fp16 is enabled then disabled the behavior is expected. Do you think this is unnecessary?

[yaxunl]

Revised as Anastasia suggested.

Changed comments.
Removed unnecessary tests.

[pekka.jaaskelainen]

Can you add a test that tries to use half precision constants in non OpenCL C mode? Otherwise LGTM.

[yaxunl]

Added a test for half literal in non-OpenCL language as Pekka suggested.

[Anastasia]

LGTM!

[pekka.jaaskelainen]

LGTM!

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_float_overflow : Warning<
   "magnitude of floating-point constant too large for type %0; maximum is %1">,
    InGroup<LiteralRange>;
 def warn_float_underflow : Warning<
   "magnitude of floating-point constant too small for type %0; minimum is %1">,
   InGroup<LiteralRange>;
 def warn_double_const_requires_fp64 : Warning<
   "double precision constant requires cl_khr_fp64, casting to single precision">;
+def err_half_const_requires_fp16 : Error<
+  "half precision constant requires cl_khr_fp16">;
 
 // C99 variable-length arrays
 def ext_vla : Extension<"variable length arrays are a C99 feature">,
   InGroup<VLAExtension>;
 def warn_vla_used : Warning<"variable length array used">,
   InGroup<VLA>, DefaultIgnore;
 def err_vla_non_pod : Error<"variable length array of non-POD element type %0">;
 def err_vla_in_sfinae : Error<

cfe/trunk/include/clang/Lex/LiteralSupport.h

 public:
   NumericLiteralParser(StringRef TokSpelling,
                        SourceLocation TokLoc,
                        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
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
   bool isIntegerLiteral() const {
     return !saw_period && !saw_exponent;
   }
   bool isFloatingLiteral() const {

cfe/trunk/lib/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
 
   s = DigitsBegin = ThisTokBegin;
   saw_exponent = false;
   saw_period = false;
   saw_ud_suffix = false;
   isLong = false;
   isUnsigned = false;
   isLongLong = false;
+  isHalf = false;
   isFloat = false;
   isImaginary = false;
   MicrosoftInteger = 0;
   hadError = false;
 
   if (*s == '0') { // parse radix
     ParseNumberStartingWithZero(TokLoc);
     if (hadError)
NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   // integer constant.
   bool isFPConstant = isFloatingLiteral();
   const char *ImaginarySuffixLoc = nullptr;
 
   // Loop over all of the characters of the suffix.  If we see something bad,
   // we break out of the loop.
   for (; s != ThisTokEnd; ++s) {
     switch (*s) {
+    case 'h':      // FP Suffix for "half".
+    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 (isFloat || isLong) break; // FF, LF invalid.
+      if (isHalf || isFloat || isLong) break; // HF, FF, LF invalid.
       isFloat = true;
       continue;  // Success.
     case 'u':
     case 'U':
       if (isFPConstant) break;  // Error for floating constant.
       if (isUnsigned) break;    // Cannot be repeated.
       isUnsigned = true;
       continue;  // Success.
     case 'l':
     case 'L':
       if (isLong || isLongLong) break;  // Cannot be repeated.
-      if (isFloat) break;               // LF invalid.
+      if (isHalf || isFloat) break;     // LH, LF invalid.
 
       // Check for long long.  The L's need to be adjacent and the same case.
       if (s[1] == s[0]) {
         assert(s + 1 < ThisTokEnd && "didn't maximally munch?");
         if (isFPConstant) break;        // long long invalid for floats.
         isLongLong = true;
         ++s;  // Eat both of them.
       } else {
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;
+      isHalf = false;
       isImaginary = false;
       MicrosoftInteger = 0;
 
       saw_ud_suffix = true;
       return;
     }
 
     // Report an error if there are any.

cfe/trunk/lib/Sema/SemaExpr.cpp

case LOLR_StringTemplate:
       llvm_unreachable("unexpected literal operator lookup result");
     }
   }
 
   Expr *Res;
 
   if (Literal.isFloatingLiteral()) {
     QualType Ty;
-    if (Literal.isFloat)
+    if (Literal.isHalf){
+      if (getOpenCLOptions().cl_khr_fp16)
+        Ty = Context.HalfTy;
+      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.DoubleTy;
     else
       Ty = Context.LongDoubleTy;
 
     Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
 

cfe/trunk/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}}

cfe/trunk/test/Lexer/opencl-half-literal.cl

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+constant half a = 1.0h; 
+constant half aa = 1.0H;
+constant half b = 1.0hh; // expected-error{{invalid suffix 'hh' on floating constant}}
+constant half c = 1.0fh; // expected-error{{invalid suffix 'fh' on floating constant}}
+constant half d = 1.0lh; // expected-error{{invalid suffix 'lh' on floating constant}}
+constant half e = 1.0hf; // expected-error{{invalid suffix 'hf' on floating constant}}

cfe/trunk/test/SemaOpenCL/half.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -Wno-unused-value
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : disable
+constant float f = 1.0h; // expected-error{{half precision constant requires cl_khr_fp16}}
 
 half half_disabled(half *p, // expected-error{{declaring function return value of type 'half' is not allowed}}
                    half h)  // expected-error{{declaring function parameter of type 'half' is not allowed}}
 {
   half a[2]; // expected-error{{declaring variable of type 'half [2]' is not allowed}}
   half b;    // expected-error{{declaring variable of type 'half' is not allowed}}
   *p; // expected-error{{loading directly from pointer to type 'half' is not allowed}}
   p[1]; // expected-error{{loading directly from pointer to type 'half' is not allowed}}
 
   float c = 1.0f;
   b = (half) c;  // expected-error{{casting to type 'half' is not allowed}}
+  c = (float) 1.0h;  // expected-error{{half precision constant requires cl_khr_fp16}}
+  b = 1.0h; // expected-error{{half precision constant requires cl_khr_fp16}}
 
   half *allowed = &p[1];
   half *allowed2 = &*p;
   half *allowed3 = p + 1;
 
   return h;
 }
 
 // Exactly the same as above but with the cl_khr_fp16 extension enabled.
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
+constant half a = 1.0h;
 half half_enabled(half *p, half h)
 {
   half a[2];
   half b;
   *p;
   p[1];
 
   float c = 1.0f;
   b = (half) c;
+  c = (float) 1.0h;
+  b = 1.0h;
 
   half *allowed = &p[1];
   half *allowed2 = &*p;
   half *allowed3 = p + 1;
 
   return h;
 }