[OpenCL] Improving OpenCL function pointer error checking to catch lone function designator

[neil.hickey]

Summary

An undecorated function designator implies taking the address of a function, which is illegal in OpenCL. Implementing a check for this earlier to allow the error to be reported even in the presence of other more obvious errors.

[Eugene.Zelenko]

Committed in rL256838.

include/clang/Basic/DiagnosticParseKinds.td

 // OpenCL EXTENSION pragma (OpenCL 1.1 [9.1])
 def warn_pragma_expected_colon : Warning<
   "missing ':' after %0 - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_enable_disable : Warning<
   "expected 'enable' or 'disable' - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_unknown_extension : Warning<
   "unknown OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>;
 
+// OpenCL error
+def err_opencl_taking_function_address_parser : Error<
+  "taking address of function is not allowed">;
+
 // OpenMP support.
 def warn_pragma_omp_ignored : Warning<
   "unexpected '#pragma omp ...' in program">, InGroup<SourceUsesOpenMP>, DefaultIgnore;
 def warn_omp_extra_tokens_at_eol : Warning<
   "extra tokens at the end of '#pragma omp %0' are ignored">,
   InGroup<ExtraTokens>;
 def warn_pragma_expected_colon_r_paren : Warning<
   "missing ':' or ')' after %0 - ignoring">, InGroup<IgnoredPragmas>;

lib/Parse/ParseExpr.cpp

if (getLangOpts().ObjC1) {
       break;
     }
     // FALL THROUGH.
   default:
     NotCastExpr = true;
     return ExprError();
   }
 
+  // check to see whether Res is a function designator only. If it is and we
+  // are compiling for OpenCL, we need to return an error as this implies
+  // that the address of the function is being taken, which is illegal in CL
+
   // These can be followed by postfix-expr pieces.
-  return ParsePostfixExpressionSuffix(Res);
+  Res = ParsePostfixExpressionSuffix(Res);
+  Expr *PostfixExpr = Res.get();
+  if (PostfixExpr) {
+    QualType Ty = PostfixExpr->getType();
+    if (!Ty.isNull() && Ty->isFunctionType() && getLangOpts().OpenCL) {
+      Diag(PostfixExpr->getExprLoc(),
+           diag::err_opencl_taking_function_address_parser);
+      return ExprError();
+    }
+  }
+
+  return Res;
 }
 
 /// \brief Once the leading part of a postfix-expression is parsed, this
 /// method parses any suffixes that apply.
 ///
 /// \verbatim
 ///       postfix-expression: [C99 6.5.2]
 ///         primary-expression

test/SemaOpenCL/cond.cl

char3 ntest11(char2 C, char3 X, char Y)
   return C ? X : Y; // expected-error {{vector condition type 'char2' (vector of 2 'char' values) and result type 'char3' (vector of 3 'char' values) do not have the same number of elements}}
 }
 
 int foo1(int);
 int foo2(int);
 
 unsigned int ntest12(int2 C)
 {
-  return (unsigned int)(C ? foo1 : foo2); // expected-error {{taking address of function is not allowed}}
+  return (unsigned int)(C ? foo1 : foo2); // expected-error {{taking address of function is not allowed}} expected-error {{taking address of function is not allowed}}
 }

test/SemaOpenCL/func_ptr.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
 
 void foo(void*);
 
 void bar()
 {
   // declaring a function pointer is an error
   void (*fptr)(int); // expected-error{{pointers to functions are not allowed}}
 
   // taking the address of a function is an error
   foo((void*)foo); // expected-error{{taking address of function is not allowed}}
   foo(&foo); // expected-error{{taking address of function is not allowed}}
 
+  // initializing an array with the address of functions is an error
+  void* vptrarr[2] = {foo, &foo}; // expected-error{{taking address of function is not allowed}} expected-error{{taking address of function is not allowed}}
+
   // just calling a function is correct
   foo(0);
 }