[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

600

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

7700

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.

7704

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">;

7707

in OpenCL

7708

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"

7709

array of block type is ...

7711

in OpenCL

lib/Sema/SemaDecl.cpp

5739

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

6429

a block type

6477

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?

6494

Could you remove this comment?

7727

I am not clear about the purpose of this change.

10239

Block -> block

10293

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

7

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

600

I will try,

7704

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

7708

OK, it will save few lines.

lib/Sema/SemaDecl.cpp

5739

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

lib/Sema/SemaExpr.cpp

6477

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

6494

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

7727

That seems some dead experiment. ):

10293

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

7

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

[Anastasia]

include/clang/Basic/DiagnosticSemaKinds.td

7704

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

7708

And more importantly won't populate diagnostics.

lib/Sema/SemaDecl.cpp

5739

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

lib/Sema/SemaExpr.cpp

6477

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

6494

Doesn't seem strange to me.

10293

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

7279–7285

I think this should be removed?

7303

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

600

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

5739

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

7303

I will add one.

[pxli168]

Rebase for partition

include/clang/Basic/DiagnosticSemaKinds.td

def warn_main_one_arg : Warning<"only one parameter on 'main' declaration">,
     InGroup<Main>;
 def err_main_arg_wrong : Error<"%select{first|second|third|fourth}0 "
     "parameter of 'main' (%select{argument count|argument array|environment|"
     "platform-specific data}0) must be of type %1">;
 def err_main_global_variable :
     Error<"main cannot be declared as global variable">;
 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_bad_kernel_param_type : Error<
   "%0 cannot be used as the type of a kernel parameter">;
 def err_record_with_pointers_kernel_param : Error<
   "%select{struct|union}0 kernel parameters may not contain pointers">;
 def note_within_field_of_type : Note<
   "within field of type %0 declared here">;
 def note_illegal_field_declared_here : Note<
   "field of illegal %select{type|pointer type}0 %1 declared here">;
 def err_event_t_global_var : Error<
   "the event_t type cannot be used to declare a program scope variable">;
 def err_event_t_struct_field : Error<
   "the event_t type cannot be used to declare a structure or union field">;
 def err_event_t_addr_space_qual : Error<
   "the event_t type can only be used with __private address space qualifier">;
 def err_expected_kernel_void_return_type : Error<
   "kernel must have void return type">;
 def err_sampler_argument_required : Error<
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 v2.0 s6.13.6 -- Builtin Pipe Functions
 def err_opencl_builtin_pipe_first_arg : Error<
   "first argument to %0 must be a pipe type">;
 def err_opencl_builtin_pipe_arg_num : Error<
     "invalid number of arguments to function: %0">;
 def err_opencl_builtin_pipe_invalid_arg : Error<
   "invalid argument type to function %0 (expecting %1)">;

lib/Sema/SemaDecl.cpp

Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
   //   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))
if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
         << T;
       NewVD->setInvalidDecl();
       return;
     }
   }
 
   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
     NewVD->setInvalidDecl();
     return;
   }
 
   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_vm);
     NewVD->setInvalidDecl();
     return;
   }
 
   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);
 
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) {
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'

 
 /// When we finish delayed parsing of an attribute, we must attach it to the
 /// relevant Decl.
 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
                                        ParsedAttributes &Attrs) {
   // Always attach attributes to the underlying decl.
   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
     D = TD->getTemplatedDecl();
   ProcessDeclAttributeList(S, D, Attrs.getList());  
   
   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
     if (Method->isStatic())
       checkThisInStaticMemberFunctionAttributes(Method);
 }
 
 
 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
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.

lib/Sema/SemaExpr.cpp

if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
     return QualType();
   }
 
   // If both types are identical, no conversion is needed.
   if (LHSType == RHSType)
     return LHSType;
 
   // Now handle "real" floating types (i.e. float, double, long double).
   if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
     return handleFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                  /*IsCompAssign = */ false);
 
   // Finally, we have two differing integer types.
   return handleIntegerConversion<doIntegralCast, doIntegralCast>
   (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
 }
 
 /// \brief Convert scalar operands to a vector that matches the
 ///        condition in length.
 ///
 /// Used when handling the OpenCL conditional operator where the
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,
   // 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 (getLangOpts().C99) {
     if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
       if (uOp->getOpcode() == UO_Deref)
         // Per C99 6.5.3.2, the address of a deref always returns a valid result
         // (assuming the deref expression is valid).
         return uOp->getSubExpr()->getType();
     }
     // Technically, there should be a check for array subscript
     // expressions here, but the result of one is always an lvalue anyway.
   }
   ValueDecl *dcl = getPrimaryDecl(op);
 
   if (auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
     if (!checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                            op->getLocStart()))
       return QualType();
 
   Expr::LValueClassification lval = op->ClassifyLValue(Context);
   unsigned AddressOfError = AO_No_Error;
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();
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
 
   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}}
+}