[OpenCL] Add Sema checks for OpenCL 2.0

[pxli168]

Summary

Add Sema checks for opencl 2.0 new features: Block, pipe, atomic etc. Also fix some old Sema check like pointer to image.
This patch is based on bader's patch in SPIRV-1.0 branch.

[pekka.jaaskelainen]

lib/Sema/SemaExpr.cpp

6298

[pekka.jaaskelainen]

lib/Sema/SemaDecl.cpp

5733

Is this intentionally included in the patch?

6759

Ditto. Better not commit disabled code in the repository.

7305

Ditto.

lib/Sema/SemaExpr.cpp

6295

-28

[pxli168]

lib/Sema/SemaDecl.cpp

5733

My mistake, just want to check if this works. But find it is handled by something else.

6759

Removed

lib/Sema/SemaExpr.cpp

6295

Fixed

6298

Intend to do this in order to get both err diag for both LHS and RHS.

[pxli168]

Remove some unused codes and add inline comment.

[Anastasia]

Also generally it's much nicer to have small logically isolated changes committed. I can see how you could partition this change into into pipe, blocks and images.

include/clang/Basic/DiagnosticSemaKinds.td

593

Can you explain why you are adding this and not relying on standard C behavior? Any reference to spec or complete example would be helpful!

7666

I think it's best to merge this with err_atomic_init_constant diagnostic. You can have {assigned|initialize} in the text and pass which value to select in the code handling the error.

I would also rename it directly to: err_opencl_atomic_init_constant

lib/Sema/SemaDecl.cpp

5724

is CL check really needed since we are accepting pipes only in CL2.0?

5735

Dead code here?

6745

this seems to be redundant considering the check above.

6760

Dead code!

7302

I feel like exporting the full diff might be a good idea here. A lot of small framents hard to understand.

"To get a full diff, use one of the following commands (or just use Arcanist to upload your patch):

git diff -U999999 other-branch
svn diff --diff-cmd=diff -x -U999999"

7308

Why this change?

11466

Can you remove "spir-" from here?

lib/Sema/SemaExpr.cpp

6299

Can we produce the diagnostic here and let checkBlockType only return true or false?

10094

Remove one -, add space after

lib/Sema/SemaInit.cpp

6138

I guess you mean s6.13.11.1?

6139

Not clear about the macro. Could you be more generic here i.e. write about initialization is generally disallowed.

6143

It would be sufficient to check: TyQualifiers.getAddressSpace() == LangAS::opencl_global

6145

Not sure about the InitializedEntity::EK_Variable check. What happens if it's removed?

6145

Do we need to check if it's a top level declaration and not enclosed in any function?

Also we seem to allow this currently:
kernel void foo(){ global int x;}

I am not sure it's correct.

6147

this variable decl can be avoided

test/CodeGenOpenCL/opencl_types.cl

39

Why removing this here?

test/SemaOpenCL/invalid-decl.cl

11

can we merge with some image tests?

14

this can be moved to pipe test?

19

Can we just do normal initialization without the macro?

Also please move this into test/Parser/opencl-atomics-cl20.cl to have them all in one place!

[pxli168]

include/clang/Basic/DiagnosticSemaKinds.td

593

I think this no declarator is just for bit-field in C. And OpenCL C does not support the bit-field I think we need not to support that.
If you think it is useless I think we can remove it then.

7666

It seems that this two are very different and need a big select. Then it seems two maybe OK.

lib/Sema/SemaDecl.cpp

5724

It seems all other check for OpenCL goes this way. I don't know if we just check OpenCL version will cause any error.

6718

agree. I will remove it.

lib/Sema/SemaExpr.cpp

6299

But how can we know if LHS or RHS is Block, or they both are?

10095

Fixed

lib/Sema/SemaInit.cpp

6138

yes, thank you!

6147

I just follow the surrounding code style.

test/CodeGenOpenCL/opencl_types.cl

39

As you can see, it used pointer of image type which I just added a semacheck for it.

test/SemaOpenCL/invalid-decl.cl

12

I will find some place to put these test in.

20

It seems strange to put sema test cases in Parser, just let them be together then.

[pxli168]

FIxed bugs and relocate the test cases.
Upload the full diff.

[Anastasia]

include/clang/Basic/DiagnosticSemaKinds.td

593

I just can't understand the intention here. Could you give any code example or reference to spec?

7666

I have a feeling that line numbers are broken now in this review due to patch reupload.

Please, see the comment on the line 7670.

7670

Could you do something like:

def err_atomic_init_constant : Error<
  "atomic variable can only be %select{assigned|initialised}0 to a compile time constant"
  " in the declaration statement in the program scope">;

7673

in OpenCL

7674

Could we combine err_opencl_invalid_block_array and err_opencl_pointer_to_image saying something like:

"Declaring a %select{pointer|array}0 of type %1 is not allowed in OpenCL"

7675

array of block type is ...

7677

in OpenCL

lib/Sema/SemaDecl.cpp

5724

Some of them have to be. For example for C types that we use differently in CL. But for CL only types do we need to check additionally that it's CL? Do we not know it already?

lib/Sema/SemaExpr.cpp

6251

a block type

6299

I am not sure what the question is?

I think using block in a condition should be disallowed. Could you add this to testing as well?

6316

Could you remove this comment?

7550

I am not clear about the purpose of this change.

10061

Block -> block

10115

The code above seems to do similar. Could we combine into one function/diagnostic?

lib/Sema/SemaInit.cpp

6139

I don't think we need to copy the spec text here. I would like to see some explanation of the code actually.

Could you write something like: "Non-program scope atomic variables can't be initialized."

6147

Seems pointless though!

6155

Should you check if it's a program scope variable? Or alternatively we could disallow non-pointer variables with global AS, which should have already been done already.

test/CodeGenOpenCL/opencl_types.cl

39

I see. Would it reduce test coverage? Was it potentially testing the mangling of image types?

I think it's best to change the code instead of completely removing it. May be just remove * so it will be parsed. We seem not to have any test for mangling the images.

test/Parser/opencl-atomics-cl20.cl

71

Why using a macro here? It seems to complicate the test without adding any functionality.

test/SemaOpenCL/invalid-decl.cl

6

Yes, I think having it in parser is wrong. Not sure why it's there. You can move it if you wish. Otherwise, I will do afterwards.

[pxli168]

include/clang/Basic/DiagnosticSemaKinds.td

593

I will try,

7670

Seems good. But that error message was from spec, this will change it.

7674

OK, it will save few lines.

lib/Sema/SemaDecl.cpp

5724

Yes, but it seems all old code write in that way. I just follow the style.

lib/Sema/SemaExpr.cpp

6299

I don't see any thing talk about the block and condition. Spec only tells about block and selection.

6316

OK. but the "|" may seems strange. I just want to explain it.

7550

That seems some dead experiment. ):

10115

Yes, they are. But they live in different function test for operand "&" and "*" and maybe it is hard to merge them together. I have uploaded the full diff as you asked and uou can expand the code to see they are in two function check for the two unary operators.

lib/Sema/SemaInit.cpp

6139

But the example said there can be program scope atomic that only in global address space.

This macro can only be used to initialize atomic objects that are declared in program scope in the global address space

The quote from spec said so.

6155

It seems so. I will have a try.

test/CodeGenOpenCL/opencl_types.cl

39

Thank you advice, if may test for the mangling.
But the name bad make me the think it is a useless test so I just remove it.

I will change them into no-pointer type.

test/Parser/opencl-atomics-cl20.cl

71

Because the the init type maybe different and then have another error.

I will have a test for this semacheck as I said above.

test/SemaOpenCL/invalid-decl.cl

6

Keep them be together, and easy to move to right place then.

[Anastasia]

include/clang/Basic/DiagnosticSemaKinds.td

7670

You can pick the wording you like. I personally find this one better!

7674

And more importantly won't populate diagnostics.

lib/Sema/SemaDecl.cpp

5724

Ok, I think an improvement to the old code is always welcome!

lib/Sema/SemaExpr.cpp

6299

Ok, in that case there is nothing left to do here I guess.

6316

Doesn't seem strange to me.

10115

Yes, it's not a problem that they are in different functions. Could this code be encapsulated in a function, let's say

checkBlockType(...)

and be called from multiple places?

lib/Sema/SemaInit.cpp

6139

Yes, so copying spec into code is not the goal. Let's try to make it shorter and still have the same meaning!

test/Parser/opencl-atomics-cl20.cl

71

The macro is removed by the preprocessor and it's empty here anyways.

You are not adding a builtin macro ATOMIC_VAR_INIT to Clang.

This test can look a lot cleaner (without doing any macro expansion):
atomic_int guide = 42;

[Anastasia]

lib/Sema/SemaDecl.cpp

7255

I think this should be removed?

7279

Is there a test for this?

[Anastasia]

Xiuli, do you still plan to continue here?

I was just thinking if it would make sense to re-upload the review since the line numbers got broken due to full diff.

Also it would be nice to partition to several independent commits/reviews. Let's say:

• Blocks diagnostics
• invalid types: images, pipes
• Misc: atomics and implicit declaration

Or you could split the last one into two as well.

What do you think?

include/clang/Basic/DiagnosticSemaKinds.td

593

Do you still plan to have it? We can discuss in a separate review if you wish to be able to proceed here.

[pxli168]

I will separate this patch into small ones.

lib/Sema/SemaDecl.cpp

5724

OK, I think we can try here to see if it will bring some errors.

7279

I will add one.

[pxli168]

Rebase for partition

include/clang/Basic/DiagnosticSemaKinds.td

 def warn_main_redefined : Warning<"variable named 'main' with external linkage "
     "has undefined behavior">, InGroup<Main>;
 def ext_main_used : Extension<
   "ISO C++ does not allow 'main' to be used by a program">, InGroup<Main>;
 
 /// parser diagnostics
 def ext_no_declarators : ExtWarn<"declaration does not declare anything">,
   InGroup<MissingDeclarations>;
+def err_no_declarators : Error<"declaration does not declare anything">;
 def ext_typedef_without_a_name : ExtWarn<"typedef requires a name">,
   InGroup<MissingDeclarations>;
 def err_typedef_not_identifier : Error<"typedef name must be an identifier">;
 def err_typedef_changes_linkage : Error<"unsupported: typedef changes linkage"
   " of anonymous type, but linkage was already computed">;
 def note_typedef_changes_linkage : Note<"use a tag name here to establish "
   "linkage prior to definition">;
 def err_statically_allocated_object : Error<
   "interface type cannot be statically allocated">;
def err_opencl_return_value_with_address_space : Error<
   "return value cannot be qualified with address space">;
 def err_opencl_constant_no_init : Error<
   "variable in constant address space must be initialized">;
 def err_atomic_init_constant : Error<
   "atomic variable can only be assigned to a compile time constant"
   " in the declaration statement in the program scope">;
 def err_opencl_implicit_vector_conversion : Error<
   "implicit conversions between vector types (%0 and %1) are not permitted">;
+def err_opencl_implicit_function_decl : Error<
+  "implicit declaration of function %0 is invalid in OpenCL">;
+def err_opencl_dereferencing : Error<
+  "dereferencing pointer of type %0 is not allowed in OpenCL">;
+def err_opencl_pointer_to_image : Error<
+  "pointer to image is invalid in OpenCL">;
+def err_opencl_type_can_only_be_used_as_function_parameter : Error <
+  "%0 can only be used as a function parameter">;
+def err_opencl_atomic_init_addressspace : Error<
+  "initialization of atomic variables is restricted to variables in global address space in opencl">;
+def err_opencl_block_proto_variadic : Error<
+  "invalid block prototype, variadic arguments are not allowed in opencl">;
+def err_opencl_invalid_block_array : Error<
+  "array of block is invalid in OpenCL">;
+def err_opencl_ternary_with_block : Error<
+  "blocks cannot be used as expressions in ternary expressions in opencl">;
+
 
 // OpenCL Section 6.8.g
 def err_opencl_unknown_type_specifier : Error<
   "OpenCL does not support the '%0' %select{type qualifier|storage class specifier}1">;
 
 } // end of sema category
 
 let CategoryName = "OpenMP Issue" in {

lib/Sema/SemaDecl.cpp

Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
   //   A declaration [...] shall declare at least a declarator [...], a tag,
   //   or the members of an enumeration.
   // C++ [dcl.dcl]p3:
   //   [If there are no declarators], and except for the declaration of an
   //   unnamed bit-field, the decl-specifier-seq shall introduce one or more
   //   names into the program, or shall redeclare a name introduced by a
   //   previous declaration.
   if (!DeclaresAnything) {
+    // OpenCL C doesn't support bit-field, so declaration with no declarator
+    // has no use.
+    if (getLangOpts().OpenCL) {
+      Diag(DS.getLocStart(), diag::err_no_declarators) << DS.getSourceRange();
+      return 0;
+    }
     // In C, we allow this as a (popular) extension / bug. Don't bother
     // producing further diagnostics for redundant qualifiers after this.
     Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
     return TagD;
   }
 
   // C++ [dcl.stc]p1:
   //   If a storage-class-specifier appears in a decl-specifier-seq, [...] the

 NamedDecl *
 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                               TypeSourceInfo *TInfo, LookupResult &Previous,
                               MultiTemplateParamsArg TemplateParamLists,
                               bool &AddToScope) {
   QualType R = TInfo->getType();
   DeclarationName Name = GetNameForDeclarator(D).getName();
 
+  // OpenCL v2.0 s6.9.b
+  // An image type can only be used as a type of a function argument.
+  if (getLangOpts().OpenCL && R->isImageType()) {
+    Diag(D.getIdentifierLoc(),
+         diag::err_opencl_type_can_only_be_used_as_function_parameter)
+        << "image";
+    D.setInvalidType();
+    return nullptr;
+  }
+
+  // OpenCL v2.0 s6.13.16.1
+  // Pipes can only be passed as arguments to a function.
+  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200 &&
+      R->isPipeType()) {
+    Diag(D.getIdentifierLoc(),
+         diag::err_opencl_type_can_only_be_used_as_function_parameter)
+        << "pipe";
+    D.setInvalidType();
+    return nullptr;
+  }
+
   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
 
   // dllimport globals without explicit storage class are treated as extern. We
   // have to change the storage class this early to get the right DeclContext.
   if (SC == SC_None && !DC->isRecord() &&
       hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
       !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
     SC = SC_Extern;
 
   DeclContext *OriginalDC = DC;
   bool IsLocalExternDecl = SC == SC_Extern &&
                            adjustContextForLocalExternDecl(DC);
void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
   }
 
   if (NewVD->isConstexpr() && !T->isDependentType() &&
       RequireLiteralType(NewVD->getLocation(), T,
                          diag::err_constexpr_var_non_literal)) {
     NewVD->setInvalidDecl();
     return;
   }
+
+  // OpenCL v2.0 s6.12.5 - The following Blocks features are currently not
+  // supported in OpenCL C: Blocks with variadic arguments.
+  if (getLangOpts().OpenCL && LangOpts.OpenCLVersion >= 200 &&
+      T->isBlockPointerType()) {
+    const BlockPointerType *BlkTy = T->getAs<BlockPointerType>();
+    assert(BlkTy && "Not a block pointer.");
+
+    const FunctionProtoType *FTy =
+        BlkTy->getPointeeType()->getAs<FunctionProtoType>();
+
+    if (FTy->isVariadic()) {
+      Diag(NewVD->getLocation(), diag::err_opencl_block_proto_variadic)
+          << T << NewVD->getSourceRange();
+      NewVD->setInvalidDecl();
+      return;
+    }
+  }
 }
 
 /// \brief Perform semantic checking on a newly-created variable
 /// declaration.
 ///
 /// This routine performs all of the type-checking required for a
 /// variable declaration once it has been built. It is used both to
 /// check variables after they have been parsed and their declarators
 /// have been translated into a declaration, and to check variables
 /// that have been instantiated from a template.
 ///
 /// Sets NewVD->isInvalidDecl() if an error was encountered.
 ///
 /// Returns true if the variable declaration is a redeclaration.
 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
   CheckVariableDeclarationType(NewVD);
 
   // If the decl is already known invalid, don't check it.
   if (NewVD->isInvalidDecl())
     return false;
 
   // If we did not find anything by this name, look for a non-visible
   // extern "C" declaration with the same name.
   if (Previous.empty() &&
       checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
     Previous.setShadowed();
 
   if (!Previous.empty()) {
     MergeVarDecl(NewVD, Previous);
     return true;
   }
   return false;
 }
 
 namespace {
 struct FindOverriddenMethod {
   Sema *S;
   CXXMethodDecl *Method;
 
   /// Member lookup function that determines whether a given C++
   /// method overrides a method in a base class, to be used with
enum OpenCLParamType {
   RecordKernelParam
 };
 
 static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
   if (PT->isPointerType()) {
     QualType PointeeType = PT->getPointeeType();
     if (PointeeType->isPointerType())
       return PtrPtrKernelParam;
-    return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
-                                              : PtrKernelParam;
+    // Now generice address space is added, we need to handle like this
+    unsigned addrSpace = PointeeType.getAddressSpace();
+    return (addrSpace != LangAS::opencl_global &&
+            addrSpace != LangAS::opencl_constant &&
+            addrSpace != LangAS::opencl_local)
+               ? PrivatePtrKernelParam
   }
 
   // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
   // be used as builtin types.
 
   if (PT->isImageType())
     return PtrKernelParam;
 
   if (PT->isBooleanType())
     return InvalidKernelParam;
 
   if (PT->isEventT())
     return InvalidKernelParam;
 
   if (PT->isHalfType())
     return InvalidKernelParam;
 
+  if (PT->isReserveIDT())
+    return InvalidKernelParam;
+
   if (PT->isRecordType())
     return RecordKernelParam;
 
   return ValidKernelParam;
 }
 
 static void checkIsValidOpenCLKernelParameter(
   Sema &S,
   Declarator &D,
   ParmVarDecl *Param,
   llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
   QualType PT = Param->getType();
 
   // Cache the valid types we encounter to avoid rechecking structs that are
   // used again
   if (ValidTypes.count(PT.getTypePtr()))
     return;
 
   switch (getOpenCLKernelParameterType(PT)) {
   case PtrPtrKernelParam:
     // OpenCL v1.2 s6.9.a:
     // A kernel function argument cannot be declared as a
     // pointer to a pointer type.
     S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
     D.setInvalidType();
     return;
 
   case PrivatePtrKernelParam:
     // OpenCL v1.2 s6.9.a:
     // A kernel function argument cannot be declared as a
     // pointer to the private address space.
     S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
     D.setInvalidType();
     return;
 
if (T.getAddressSpace() != 0) {
     // OpenCL allows function arguments declared to be an array of a type
     // to be qualified with an address space.
     if (!(getLangOpts().OpenCL && T->isArrayType())) {
       Diag(NameLoc, diag::err_arg_with_address_space);
       New->setInvalidDecl();
     }
   }   
 
+  // OpenCL v2.0 s6.9b2 - An image type cannot be used to declare a variable, a
+  // structure or union field, an array of images, a pointer to an image, or the
+  // return type of a function.
+  if (getLangOpts().OpenCL && T->isPointerType() &&
+      T->getPointeeType()->isImageType()) {
+    Diag(NameLoc, diag::err_opencl_pointer_to_image);
+    New->setInvalidDecl();
+  }
+
   return New;
 }
 
 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
                                            SourceLocation LocAfterDecls) {
   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
 
   // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
     Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
     return ExternCPrev;
   }
 
   // Extension in C99.  Legal in C90, but warn about it.
   unsigned diag_id;
   if (II.getName().startswith("__builtin_"))
     diag_id = diag::warn_builtin_unknown;
+  else if (getLangOpts().OpenCL)
+    // OpenCL function need to be called with prototype, so we don't allow
+    // implicit function declarations in OpenCL
+    diag_id = diag::err_opencl_implicit_function_decl;
   else if (getLangOpts().C99)
     diag_id = diag::ext_implicit_function_decl;
   else
     diag_id = diag::warn_implicit_function_decl;
   Diag(Loc, diag_id) << &II;
 
   // Because typo correction is expensive, only do it if the implicit
   // function declaration is going to be treated as an error.
D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
                                              /*ESpecRange=*/SourceRange(),
                                              /*Exceptions=*/nullptr,
                                              /*ExceptionRanges=*/nullptr,
                                              /*NumExceptions=*/0,
                                              /*NoexceptExpr=*/nullptr,
                                              /*ExceptionSpecTokens=*/nullptr,
                                              Loc, Loc, D),
                 DS.getAttributes(),
                 SourceLocation());
   D.SetIdentifier(&II, Loc);
 
   // Insert this function into translation-unit scope.
 
   DeclContext *PrevDC = CurContext;
   CurContext = Context.getTranslationUnitDecl();
 
   FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));

lib/Sema/SemaExpr.cpp

if (checkVectorResult(S, CondTy, VecResTy, QuestionLoc))
       return QualType();
     return VecResTy;
   }
 
   // Both operands are scalar.
   return OpenCLConvertScalarsToVectors(S, LHS, RHS, CondTy, QuestionLoc);
 }
 
+/// \brief Return true if the Expr is block type
+static bool checkBlockType(Sema &S, const Expr *E) {
+  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
+    QualType Ty = CE->getCallee()->getType();
+    if (Ty->isBlockPointerType()) {
+      S.Diag(E->getExprLoc(), diag::err_opencl_ternary_with_block);
+      return true;
+    }
+  }
+  return false;
+}
+
 /// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
 /// In that case, LHS = cond.
 /// C99 6.5.15
 QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
                                         ExprResult &RHS, ExprValueKind &VK,
                                         ExprObjectKind &OK,
                                         SourceLocation QuestionLoc) {
 
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
   // different to merit its own checker.
   if (getLangOpts().OpenCL && Cond.get()->getType()->isVectorType())
     return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);
 
   // First, check the condition.
   Cond = UsualUnaryConversions(Cond.get());
   if (Cond.isInvalid())
     return QualType();
   if (checkCondition(*this, Cond.get(), QuestionLoc))
     return QualType();
 
   // Now check the two expressions.
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
     return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
                                /*AllowBothBool*/true,
                                /*AllowBoolConversions*/false);
 
   QualType ResTy = UsualArithmeticConversions(LHS, RHS);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
 
+  // OpenCL v2.0 s6.12.5 - To support these behaviors, additional
+  // restrictions in addition to the above feature restrictions are: Blocks
+  // cannot be used as expressions of the ternary selection operator (?:).
+  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200) {
+    // should output error for both LHS and RHS, use | instead ||
+    if (checkBlockType(*this, LHS.get()) | checkBlockType(*this, RHS.get()))
+      return QualType();
+  }
+
   // If both operands have arithmetic type, do the usual arithmetic conversions
   // to find a common type: C99 6.5.15p3,5.
   if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
     LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
     RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
 
     return ResTy;
   }

 /// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
 /// for float->int.
 ///
 /// \param scalar - if non-null, actually perform the conversions
 /// \return true if the operation fails (but without diagnosing the failure)
 static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
                                      QualType scalarTy,
                                      QualType vectorEltTy,
-                                     QualType vectorTy) {
+                                     QualType vectorTy,
+                                     SourceLocation Loc) {
   // The conversion to apply to the scalar before splatting it,
   // if necessary.
   CastKind scalarCast = CK_Invalid;
   
   if (vectorEltTy->isIntegralType(S.Context)) {
     if (!scalarTy->isIntegralType(S.Context))
       return true;
     if (S.getLangOpts().OpenCL &&
if (!IsCompAssign &&
       return RHSType;
     }
   }
 
   // If there's an ext-vector type and a scalar, try to convert the scalar to
   // the vector element type and splat.
   if (!RHSVecType && isa<ExtVectorType>(LHSVecType)) {
     if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
-                                  LHSVecType->getElementType(), LHSType))
+                                  LHSVecType->getElementType(), LHSType, Loc))
       return LHSType;
   }
   if (!LHSVecType && isa<ExtVectorType>(RHSVecType)) {
     if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
                                   LHSType, RHSVecType->getElementType(),
-                                  RHSType))
+                                  RHSType, Loc))
       return RHSType;
   }
 
   // If we're allowing lax vector conversions, only the total (data) size
   // needs to be the same.
   // FIXME: Should we really be allowing this?
   // FIXME: We really just pick the LHS type arbitrarily?
   if (isLaxVectorConversion(RHSType, LHSType)) {
if (lval == Expr::LV_IncompleteVoidType) {
     // allow it in cases which are otherwise valid.
     // Example: "extern void x; void* y = &x;".
     Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
   }
 
   // If the operand has type "type", the result has type "pointer to type".
   if (op->getType()->isObjCObjectType())
     return Context.getObjCObjectPointerType(op->getType());
+
+  // OpenCL v2.0 s6.12.5 - The unary operators (* and &) cannot be used with a
+  // Block
+  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200) {
+    if (OrigOp.get()->getType()->isBlockPointerType()) {
+      Diag(OpLoc, diag::err_typecheck_unary_expr) << OrigOp.get()->getType()
+                                                  << op->getSourceRange();
+      return QualType();
+    }
+  }
+
   return Context.getPointerType(op->getType());
 }
 
 static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
   const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
   if (!DRE)
     return;
   const Decl *D = DRE->getDecl();
   if (!D)
     return;
   const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
   if (!Param)
     return;
   if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
     if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
       return;
   if (FunctionScopeInfo *FD = S.getCurFunction())
     if (!FD->ModifiedNonNullParams.count(Param))
       FD->ModifiedNonNullParams.insert(Param);
 }
 
 /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
                                         SourceLocation OpLoc) {
   if (Op->isTypeDependent())
     return S.Context.DependentTy;
 
   ExprResult ConvResult = S.UsualUnaryConversions(Op);
   if (ConvResult.isInvalid())
     return QualType();
   Op = ConvResult.get();
   QualType OpTy = Op->getType();
   QualType Result;
 
   if (isa<CXXReinterpretCastExpr>(Op)) {
     QualType OpOrigType = Op->IgnoreParenCasts()->getType();
     S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
                                      Op->getSourceRange());
   }
 
   if (const PointerType *PT = OpTy->getAs<PointerType>())
+  {
     Result = PT->getPointeeType();
+    // OpenCL v2.0 s6.12.5 - The unary operators (* and &) cannot be used with a
+    // Block.
+    if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion >= 200 &&
+        Result->isBlockPointerType()) {
+      S.Diag(OpLoc, diag::err_opencl_dereferencing) << OpTy
+                                                    << Op->getSourceRange();
+      return QualType();
+    }
+  }
   else if (const ObjCObjectPointerType *OPT =
              OpTy->getAs<ObjCObjectPointerType>())
     Result = OPT->getPointeeType();
   else {
     ExprResult PR = S.CheckPlaceholderExpr(Op);
     if (PR.isInvalid()) return QualType();
     if (PR.get() != Op)
       return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);

lib/Sema/SemaInit.cpp

if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
     // Produce a C++98 compatibility warning if we are initializing a reference
     // from an initializer list. For parameters, we produce a better warning
     // elsewhere.
     Expr *Init = Args[0];
     S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
       << Init->getSourceRange();
   }
 
+  // OpenCL v2.0 s6.13.11.1 - The ATOMIC_VAR_INIT macro expands to a token
+  // sequence suitable for initializing an atomic object of a type that is
+  // initialization-compatible with value. An atomic object with automatic
+  // storage duration that is not explicitly initialized using ATOMIC_VAR_INIT
+  // is initially in an indeterminate state; however, the default (zero)
+  // initialization for objects with static storage duration is guaranteed to
+  // produce a valid state.
+  // #define ATOMIC_VAR_INIT(C value)
+  // This macro can only be used to initialize atomic objects that are declared
+  // in program scope in the global address space.
+  // Examples:
+  // global atomic_int guide = ATOMIC_VAR_INIT(42);
+  if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion >= 200 &&
+      Entity.getType()->isAtomicType()) {
+    Qualifiers TyQualifiers = Entity.getType().getQualifiers();
+    bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+                       TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+    if (!HasGlobalAS && Entity.getKind() == InitializedEntity::EK_Variable &&
+        Args.size() > 0) {
+      Expr *Init = Args[0];
+      S.Diag(Init->getLocStart(), diag::err_opencl_atomic_init_addressspace)
+          << SourceRange(Entity.getDecl()->getLocStart(), Init->getLocEnd());
+      return ExprError();
+    }
+  }
+
   // Diagnose cases where we initialize a pointer to an array temporary, and the
   // pointer obviously outlives the temporary.
   if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
       Entity.getType()->isPointerType() &&
       InitializedEntityOutlivesFullExpression(Entity)) {
     Expr *Init = Args[0];
     Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
     if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)

lib/Sema/SemaType.cpp

if (T->isVariableArrayType()) {
                                   : diag::ext_c99_array_usage) << ASM;
   }
 
   if (T->isVariableArrayType()) {
     // Warn about VLAs for -Wvla.
     Diag(Loc, diag::warn_vla_used);
   }
 
+  // OpenCL v2.0 s6.12.5 - The following Blocks features are currently not
+  // supported in OpenCL C: Arrays of Blocks.
+  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200 &&
+      Context.getBaseElementType(T)->isBlockPointerType()) {
+    Diag(Loc, diag::err_opencl_invalid_block_array);
+    return QualType();
+  }
+
   return T;
 }
 
 /// \brief Build an ext-vector type.
 ///
 /// Run the required checks for the extended vector type.
 QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
                                   SourceLocation AttrLoc) {

test/CodeGenOpenCL/opencl_types.cl

// CHECK: alloca i32
   event_t evt;
 // CHECK: alloca %opencl.event_t*
 // CHECK: store i32 5,
   fnc4smp(smp);
 // CHECK: call {{.*}}void @fnc4smp(i32
   fnc4smp(glb_smp);
 // CHECK: call {{.*}}void @fnc4smp(i32
 }
-
-void __attribute__((overloadable)) bad1(image1d_t *b, image2d_t *c, image2d_t *d) {}
-// CHECK-LABEL: @{{_Z4bad1P11ocl_image1dP11ocl_image2dS2_|"\\01\?bad1@@\$\$J0YAXPE?APAUocl_image1d@@PE?APAUocl_image2d@@1@Z"}}

test/Parser/opencl-atomics-cl20.cl

 // expected-error-re@-30 {{use of type 'atomic_uintptr_t' (aka '_Atomic({{.+}})') requires cl_khr_int64_extended_atomics extension to be enabled}}
 // expected-error-re@-30 {{use of type 'atomic_size_t' (aka '_Atomic({{.+}})') requires cl_khr_int64_base_atomics extension to be enabled}}
 // expected-error-re@-31 {{use of type 'atomic_size_t' (aka '_Atomic({{.+}})') requires cl_khr_int64_extended_atomics extension to be enabled}}
 // expected-error-re@-31 {{use of type 'atomic_ptrdiff_t' (aka '_Atomic({{.+}})') requires cl_khr_int64_base_atomics extension to be enabled}}
 // expected-error-re@-32 {{use of type 'atomic_ptrdiff_t' (aka '_Atomic({{.+}})') requires cl_khr_int64_extended_atomics extension to be enabled}}
 #endif
 
 #ifdef CL20
+#define ATOMIC_VAR_INIT
 void foo(atomic_int * ptr) {}
 void atomic_ops_test() {
   atomic_int i;
   foo(&i);
 // OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic types.
   i++; // expected-error {{invalid argument type 'atomic_int' (aka '_Atomic(int)') to unary expression}}
   i = 1; // expected-error {{atomic variable can only be assigned to a compile time constant in the declaration statement in the program scope}}
   i += 1; // expected-error {{invalid operands to binary expression ('atomic_int' (aka '_Atomic(int)') and 'int')}}
   i = i + i; // expected-error {{invalid operands to binary expression ('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
 }
+void atomic_init_test() {
+    atomic_int guide = ATOMIC_VAR_INIT(42); // expected-error {{initialization of atomic variables is restricted to variables in global address space in opencl}}
+}
 #endif

test/SemaOpenCL/invalid-block.cl

+// RUN: %clang_cc1 -verify -fblocks -cl-std=CL2.0 %s
+
+int (^BlkVariadic)(int, ...) = ^int(int I, ...) { // expected-error {{invalid block prototype, variadic arguments are not allowed}}
+  return 0;
+};
+
+typedef int (^BlkInt)(int);
+void f1(int i) {
+  BlkInt B1 = ^int(int I) {return 1;};
+  BlkInt B2 = ^int(int I) {return 2;};
+  BlkInt Arr[] = {B1, B2}; // expected-error {{array of block is invalid in OpenCL}}
+  int tmp = i ? B1(i)      // expected-error {{blocks cannot be used as expressions in ternary expressions}}
+              : B2(i);     // expected-error {{blocks cannot be used as expressions in ternary expressions}}
+}
+
+void f2(BlkInt *BlockPtr) {
+  BlkInt B = ^int(int I) {return 1;};
+  BlkInt *P = &B; // expected-error {{invalid argument type 'BlkInt' (aka 'int (^)(int)') to unary expression}}
+  B = *BlockPtr;  // expected-error {{dereferencing pointer of type '__generic BlkInt *' (aka 'int (^__generic *)(int)') is not allowed}}
+}
+

test/SemaOpenCL/invalid-decl.cl

+// RUN: %clang_cc1 -verify -cl-std=CL2.0 %s 
+int; // expected-error {{declaration does not declare anything}}
+
+void test1(){
+  myfun(); // expected-error {{implicit declaration of function 'myfun' is invalid in OpenCL}}
+}

test/SemaOpenCL/invalid-image.cl

+// RUN: %clang_cc1 -verify %s
+
+void test1(image1d_t *i){} // expected-error {{pointer to image is invalid in OpenCL}}
+
+void test2() {
+  image1d_t i; // expected-error {{image can only be used as a function parameter}}
+}

test/SemaOpenCL/invalid-pipes-cl2.0.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
 
 void test1(pipe int *p){// expected-error {{pipes packet types cannot be of reference type}}
 }
 void test2(pipe p){// expected-error {{missing actual type specifier for pipe}}
 }
 void test3(int pipe p){// expected-error {{cannot combine with previous 'int' declaration specifier}}
 }
+void test4() {
+  pipe int p; // expected-error {{pipe can only be used as a function parameter}}
+}