[packages/llvm/llvm-7.0] actually add the intel OpenCL patches
jajcus
jajcus at pld-linux.org
Mon Jul 1 16:03:03 CEST 2019
commit 18b8fe9c33ca219e1dcece96ed3abf814938ced3
Author: Jacek Konieczny <j.konieczny at eggsoft.pl>
Date: Mon Jul 1 16:02:32 2019 +0200
actually add the intel OpenCL patches
0001-Add-cl_intel_planar_yuv-extension.patch | 69 +
0002-Unify-ZeroToOCL-cast-types.patch | 426 ++++++
...support-of-cl_intel_device_side_avc_motio.patch | 1604 ++++++++++++++++++++
...x-diagnostics-on-OpenCL-access-qualifiers.patch | 161 ++
...invalid-address-space-generation-for-clk_.patch | 70 +
5 files changed, 2330 insertions(+)
---
diff --git a/0001-Add-cl_intel_planar_yuv-extension.patch b/0001-Add-cl_intel_planar_yuv-extension.patch
new file mode 100644
index 0000000..bca15bf
--- /dev/null
+++ b/0001-Add-cl_intel_planar_yuv-extension.patch
@@ -0,0 +1,69 @@
+From d003e9124a41cd8fc208f6bcad5d4065e1e8ff74 Mon Sep 17 00:00:00 2001
+From: Andrew Savonichev <andrew.savonichev at intel.com>
+Date: Tue, 23 Oct 2018 16:13:16 +0000
+Subject: [PATCH 1/4] Add cl_intel_planar_yuv extension
+
+Just adding a preprocessor #define for the extension.
+
+Patch by Alexey Sotkin and Dmitry Sidorov
+
+Phabricator review: https://reviews.llvm.org/D51402
+
+git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@345044 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Headers/opencl-c.h | 8 ++++++++
+ test/Headers/opencl-c-header.cl | 17 +++++++++++++++--
+ 2 files changed, 23 insertions(+), 2 deletions(-)
+
+diff --git a/lib/Headers/opencl-c.h b/lib/Headers/opencl-c.h
+index e481c79..5525830 100644
+--- a/lib/Headers/opencl-c.h
++++ b/lib/Headers/opencl-c.h
+@@ -22,6 +22,14 @@
+ #endif //cl_khr_3d_image_writes
+ #endif //__OPENCL_C_VERSION__ < CL_VERSION_2_0
+
++#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
++#ifndef cl_intel_planar_yuv
++#define cl_intel_planar_yuv
++#endif // cl_intel_planar_yuv
++#pragma OPENCL EXTENSION cl_intel_planar_yuv : begin
++#pragma OPENCL EXTENSION cl_intel_planar_yuv : end
++#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
++
+ #define __ovld __attribute__((overloadable))
+ #define __conv __attribute__((convergent))
+
+diff --git a/test/Headers/opencl-c-header.cl b/test/Headers/opencl-c-header.cl
+index 2c28be1..d344f37 100644
+--- a/test/Headers/opencl-c-header.cl
++++ b/test/Headers/opencl-c-header.cl
+@@ -1,5 +1,6 @@
+-// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s| FileCheck %s
+-// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -cl-std=CL1.1| FileCheck %s
++// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify | FileCheck %s
++// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.1| FileCheck %s
++// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.2| FileCheck %s
+
+ // Test including the default header as a module.
+ // The module should be compiled only once and loaded from cache afterwards.
+@@ -71,4 +72,16 @@ void test_image3dwo(write_only image3d_t img) {
+ }
+ #endif //__OPENCL_C_VERSION__
+
++// Verify that non-builtin cl_intel_planar_yuv extension is defined from
++// OpenCL 1.2 onwards.
++#if (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
++// expected-no-diagnostics
++#ifndef cl_intel_planar_yuv
++#error "Missing cl_intel_planar_yuv define"
++#endif
++#else //__OPENCL_C_VERSION__
++// expected-warning at +2{{unknown OpenCL extension 'cl_intel_planar_yuv' - ignoring}}
++#endif //__OPENCL_C_VERSION__
++#pragma OPENCL EXTENSION cl_intel_planar_yuv : enable
++
+ // CHECK-MOD: Reading modules
+--
+1.8.3.1
+
diff --git a/0002-Unify-ZeroToOCL-cast-types.patch b/0002-Unify-ZeroToOCL-cast-types.patch
new file mode 100644
index 0000000..23b4f91
--- /dev/null
+++ b/0002-Unify-ZeroToOCL-cast-types.patch
@@ -0,0 +1,426 @@
+From 642bf06efbdc007b6508f2d4f9fa111243316898 Mon Sep 17 00:00:00 2001
+From: Andrew Savonichev <andrew.savonichev at intel.com>
+Date: Tue, 23 Oct 2018 15:19:20 +0000
+Subject: [PATCH 2/4] Unify ZeroToOCL* cast types
+
+Reviewers: Anastasia, yaxunl
+
+Reviewed By: Anastasia
+
+Subscribers: asavonic, cfe-commits
+
+Differential Revision: https://reviews.llvm.org/D52654
+
+Change-Id: I42503b38f90c8d0339ab98cd4b11ec703dbca892
+git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@345038 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/clang/AST/OperationKinds.def | 8 +--
+ include/clang/Sema/Initialization.h | 16 ++----
+ lib/AST/Expr.cpp | 3 +-
+ lib/AST/ExprConstant.cpp | 6 +-
+ lib/CodeGen/CGExpr.cpp | 6 +-
+ lib/CodeGen/CGExprAgg.cpp | 3 +-
+ lib/CodeGen/CGExprComplex.cpp | 3 +-
+ lib/CodeGen/CGExprConstant.cpp | 3 +-
+ lib/CodeGen/CGExprScalar.cpp | 10 +---
+ lib/Edit/RewriteObjCFoundationAPI.cpp | 3 +-
+ lib/Sema/SemaCast.cpp | 2 +-
+ lib/Sema/SemaExprCXX.cpp | 7 +--
+ lib/Sema/SemaInit.cpp | 97 +++++++++++----------------------
+ lib/StaticAnalyzer/Core/ExprEngineC.cpp | 3 +-
+ 14 files changed, 55 insertions(+), 115 deletions(-)
+
+diff --git a/include/clang/AST/OperationKinds.def b/include/clang/AST/OperationKinds.def
+index e2d65d8..d499a71 100644
+--- a/include/clang/AST/OperationKinds.def
++++ b/include/clang/AST/OperationKinds.def
+@@ -318,11 +318,9 @@ CAST_OPERATION(CopyAndAutoreleaseBlockObject)
+ // callee of a call expression.
+ CAST_OPERATION(BuiltinFnToFnPtr)
+
+-// Convert a zero value for OpenCL event_t initialization.
+-CAST_OPERATION(ZeroToOCLEvent)
+-
+-// Convert a zero value for OpenCL queue_t initialization.
+-CAST_OPERATION(ZeroToOCLQueue)
++// Convert a zero value for OpenCL opaque types initialization (event_t,
++// queue_t, etc.)
++CAST_OPERATION(ZeroToOCLOpaqueType)
+
+ // Convert a pointer to a different address space.
+ CAST_OPERATION(AddressSpaceConversion)
+diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h
+index 8582e97..65468e2 100644
+--- a/include/clang/Sema/Initialization.h
++++ b/include/clang/Sema/Initialization.h
+@@ -892,11 +892,8 @@ public:
+ /// Initialize an OpenCL sampler from an integer.
+ SK_OCLSamplerInit,
+
+- /// Initialize queue_t from 0.
+- SK_OCLZeroQueue,
+-
+- /// Passing zero to a function where OpenCL event_t is expected.
+- SK_OCLZeroEvent
++ /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero
++ SK_OCLZeroOpaqueType
+ };
+
+ /// A single step in the initialization sequence.
+@@ -1333,12 +1330,9 @@ public:
+ /// constant.
+ void AddOCLSamplerInitStep(QualType T);
+
+- /// Add a step to initialize an OpenCL event_t from a NULL
+- /// constant.
+- void AddOCLZeroEventStep(QualType T);
+-
+- /// Add a step to initialize an OpenCL queue_t from 0.
+- void AddOCLZeroQueueStep(QualType T);
++ /// Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.)
++ /// from a zero constant.
++ void AddOCLZeroOpaqueTypeStep(QualType T);
+
+ /// Add steps to unwrap a initializer list for a reference around a
+ /// single element and rewrap it at the end.
+diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
+index 50cff15..babc580 100644
+--- a/lib/AST/Expr.cpp
++++ b/lib/AST/Expr.cpp
+@@ -1641,8 +1641,7 @@ bool CastExpr::CastConsistency() const {
+ case CK_ARCConsumeObject:
+ case CK_ARCReclaimReturnedObject:
+ case CK_ARCExtendBlockObject:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_IntToOCLSampler:
+ assert(!getType()->isBooleanType() && "unheralded conversion to bool");
+ goto CheckNoBasePath;
+diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
+index 25817b4..e743fc9 100644
+--- a/lib/AST/ExprConstant.cpp
++++ b/lib/AST/ExprConstant.cpp
+@@ -9386,8 +9386,7 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
+ case CK_IntegralComplexCast:
+ case CK_IntegralComplexToFloatingComplex:
+ case CK_BuiltinFnToFnPtr:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_NonAtomicToAtomic:
+ case CK_AddressSpaceConversion:
+ case CK_IntToOCLSampler:
+@@ -9921,8 +9920,7 @@ bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
+ case CK_ARCExtendBlockObject:
+ case CK_CopyAndAutoreleaseBlockObject:
+ case CK_BuiltinFnToFnPtr:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_NonAtomicToAtomic:
+ case CK_AddressSpaceConversion:
+ case CK_IntToOCLSampler:
+diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
+index 93a1859..46ae899 100644
+--- a/lib/CodeGen/CGExpr.cpp
++++ b/lib/CodeGen/CGExpr.cpp
+@@ -4224,10 +4224,8 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
+ return MakeAddrLValue(V, E->getType(), LV.getBaseInfo(),
+ CGM.getTBAAInfoForSubobject(LV, E->getType()));
+ }
+- case CK_ZeroToOCLQueue:
+- llvm_unreachable("NULL to OpenCL queue lvalue cast is not valid");
+- case CK_ZeroToOCLEvent:
+- llvm_unreachable("NULL to OpenCL event lvalue cast is not valid");
++ case CK_ZeroToOCLOpaqueType:
++ llvm_unreachable("NULL to OpenCL opaque type lvalue cast is not valid");
+ }
+
+ llvm_unreachable("Unhandled lvalue cast kind?");
+diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
+index 6264110..888eb18 100644
+--- a/lib/CodeGen/CGExprAgg.cpp
++++ b/lib/CodeGen/CGExprAgg.cpp
+@@ -847,8 +847,7 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
+ case CK_ARCExtendBlockObject:
+ case CK_CopyAndAutoreleaseBlockObject:
+ case CK_BuiltinFnToFnPtr:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_AddressSpaceConversion:
+ case CK_IntToOCLSampler:
+ llvm_unreachable("cast kind invalid for aggregate types");
+diff --git a/lib/CodeGen/CGExprComplex.cpp b/lib/CodeGen/CGExprComplex.cpp
+index fb17609..a465f61 100644
+--- a/lib/CodeGen/CGExprComplex.cpp
++++ b/lib/CodeGen/CGExprComplex.cpp
+@@ -505,8 +505,7 @@ ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
+ case CK_ARCExtendBlockObject:
+ case CK_CopyAndAutoreleaseBlockObject:
+ case CK_BuiltinFnToFnPtr:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_AddressSpaceConversion:
+ case CK_IntToOCLSampler:
+ llvm_unreachable("invalid cast kind for complex value");
+diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
+index 6876647..7f9f38a 100644
+--- a/lib/CodeGen/CGExprConstant.cpp
++++ b/lib/CodeGen/CGExprConstant.cpp
+@@ -869,8 +869,7 @@ public:
+ case CK_FloatingToIntegral:
+ case CK_FloatingToBoolean:
+ case CK_FloatingCast:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ return nullptr;
+ }
+ llvm_unreachable("Invalid CastKind");
+diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
+index c62588c..32eaff4 100644
+--- a/lib/CodeGen/CGExprScalar.cpp
++++ b/lib/CodeGen/CGExprScalar.cpp
+@@ -1920,13 +1920,9 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
+ CE->getExprLoc());
+ }
+
+- case CK_ZeroToOCLEvent: {
+- assert(DestTy->isEventT() && "CK_ZeroToOCLEvent cast on non-event type");
+- return llvm::Constant::getNullValue(ConvertType(DestTy));
+- }
+-
+- case CK_ZeroToOCLQueue: {
+- assert(DestTy->isQueueT() && "CK_ZeroToOCLQueue cast on non queue_t type");
++ case CK_ZeroToOCLOpaqueType: {
++ assert((DestTy->isEventT() || DestTy->isQueueT()) &&
++ "CK_ZeroToOCLEvent cast on non-event type");
+ return llvm::Constant::getNullValue(ConvertType(DestTy));
+ }
+
+diff --git a/lib/Edit/RewriteObjCFoundationAPI.cpp b/lib/Edit/RewriteObjCFoundationAPI.cpp
+index b53a70d..98af710 100644
+--- a/lib/Edit/RewriteObjCFoundationAPI.cpp
++++ b/lib/Edit/RewriteObjCFoundationAPI.cpp
+@@ -1079,8 +1079,7 @@ static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
+ case CK_NonAtomicToAtomic:
+ case CK_CopyAndAutoreleaseBlockObject:
+ case CK_BuiltinFnToFnPtr:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_IntToOCLSampler:
+ return false;
+
+diff --git a/lib/Sema/SemaCast.cpp b/lib/Sema/SemaCast.cpp
+index 57aac80..b86be43 100644
+--- a/lib/Sema/SemaCast.cpp
++++ b/lib/Sema/SemaCast.cpp
+@@ -2535,7 +2535,7 @@ void CastOperation::CheckCStyleCast() {
+ llvm::APSInt CastInt;
+ if (SrcExpr.get()->EvaluateAsInt(CastInt, Self.Context)) {
+ if (0 == CastInt) {
+- Kind = CK_ZeroToOCLEvent;
++ Kind = CK_ZeroToOCLOpaqueType;
+ return;
+ }
+ Self.Diag(OpRange.getBegin(),
+diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
+index c851a81..b3b319b 100644
+--- a/lib/Sema/SemaExprCXX.cpp
++++ b/lib/Sema/SemaExprCXX.cpp
+@@ -4229,14 +4229,9 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
+ }
+
+ case ICK_Zero_Event_Conversion:
+- From = ImpCastExprToType(From, ToType,
+- CK_ZeroToOCLEvent,
+- From->getValueKind()).get();
+- break;
+-
+ case ICK_Zero_Queue_Conversion:
+ From = ImpCastExprToType(From, ToType,
+- CK_ZeroToOCLQueue,
++ CK_ZeroToOCLOpaqueType,
+ From->getValueKind()).get();
+ break;
+
+diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
+index 5070996..5e81560 100644
+--- a/lib/Sema/SemaInit.cpp
++++ b/lib/Sema/SemaInit.cpp
+@@ -3172,8 +3172,7 @@ void InitializationSequence::Step::Destroy() {
+ case SK_StdInitializerList:
+ case SK_StdInitializerListConstructorCall:
+ case SK_OCLSamplerInit:
+- case SK_OCLZeroEvent:
+- case SK_OCLZeroQueue:
++ case SK_OCLZeroOpaqueType:
+ break;
+
+ case SK_ConversionSequence:
+@@ -3459,16 +3458,9 @@ void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
+ Steps.push_back(S);
+ }
+
+-void InitializationSequence::AddOCLZeroEventStep(QualType T) {
++void InitializationSequence::AddOCLZeroOpaqueTypeStep(QualType T) {
+ Step S;
+- S.Kind = SK_OCLZeroEvent;
+- S.Type = T;
+- Steps.push_back(S);
+-}
+-
+-void InitializationSequence::AddOCLZeroQueueStep(QualType T) {
+- Step S;
+- S.Kind = SK_OCLZeroQueue;
++ S.Kind = SK_OCLZeroOpaqueType;
+ S.Type = T;
+ Steps.push_back(S);
+ }
+@@ -5172,39 +5164,31 @@ static bool TryOCLSamplerInitialization(Sema &S,
+ return true;
+ }
+
+-//
+-// OpenCL 1.2 spec, s6.12.10
+-//
+-// The event argument can also be used to associate the
+-// async_work_group_copy with a previous async copy allowing
+-// an event to be shared by multiple async copies; otherwise
+-// event should be zero.
+-//
+-static bool TryOCLZeroEventInitialization(Sema &S,
+- InitializationSequence &Sequence,
+- QualType DestType,
+- Expr *Initializer) {
+- if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
+- !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
+- (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
++static bool TryOCLZeroOpaqueTypeInitialization(Sema &S,
++ InitializationSequence &Sequence,
++ QualType DestType,
++ Expr *Initializer) {
++ if (!S.getLangOpts().OpenCL)
+ return false;
+
+- Sequence.AddOCLZeroEventStep(DestType);
+- return true;
+-}
++ //
++ // OpenCL 1.2 spec, s6.12.10
++ //
++ // The event argument can also be used to associate the
++ // async_work_group_copy with a previous async copy allowing
++ // an event to be shared by multiple async copies; otherwise
++ // event should be zero.
++ //
++ if (DestType->isEventT() || DestType->isQueueT()) {
++ if (!Initializer->isIntegerConstantExpr(S.getASTContext()) ||
++ (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
++ return false;
+
+-static bool TryOCLZeroQueueInitialization(Sema &S,
+- InitializationSequence &Sequence,
+- QualType DestType,
+- Expr *Initializer) {
+- if (!S.getLangOpts().OpenCL || S.getLangOpts().OpenCLVersion < 200 ||
+- !DestType->isQueueT() ||
+- !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
+- (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
+- return false;
++ Sequence.AddOCLZeroOpaqueTypeStep(DestType);
++ return true;
++ }
+
+- Sequence.AddOCLZeroQueueStep(DestType);
+- return true;
++ return false;
+ }
+
+ InitializationSequence::InitializationSequence(Sema &S,
+@@ -5478,12 +5462,9 @@ void InitializationSequence::InitializeFrom(Sema &S,
+ if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
+ return;
+
+- if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
++ if (TryOCLZeroOpaqueTypeInitialization(S, *this, DestType, Initializer))
+ return;
+
+- if (TryOCLZeroQueueInitialization(S, *this, DestType, Initializer))
+- return;
+-
+ // Handle initialization in C
+ AddCAssignmentStep(DestType);
+ MaybeProduceObjCObject(S, *this, Entity);
+@@ -7304,8 +7285,7 @@ InitializationSequence::Perform(Sema &S,
+ case SK_ProduceObjCObject:
+ case SK_StdInitializerList:
+ case SK_OCLSamplerInit:
+- case SK_OCLZeroEvent:
+- case SK_OCLZeroQueue: {
++ case SK_OCLZeroOpaqueType: {
+ assert(Args.size() == 1);
+ CurInit = Args[0];
+ if (!CurInit.get()) return ExprError();
+@@ -7960,21 +7940,12 @@ InitializationSequence::Perform(Sema &S,
+ CK_IntToOCLSampler);
+ break;
+ }
+- case SK_OCLZeroEvent: {
+- assert(Step->Type->isEventT() &&
+- "Event initialization on non-event type.");
++ case SK_OCLZeroOpaqueType: {
++ assert((Step->Type->isEventT() || Step->Type->isQueueT()) &&
++ "Wrong type for initialization of OpenCL opaque type.");
+
+ CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
+- CK_ZeroToOCLEvent,
+- CurInit.get()->getValueKind());
+- break;
+- }
+- case SK_OCLZeroQueue: {
+- assert(Step->Type->isQueueT() &&
+- "Event initialization on non queue type.");
+-
+- CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
+- CK_ZeroToOCLQueue,
++ CK_ZeroToOCLOpaqueType,
+ CurInit.get()->getValueKind());
+ break;
+ }
+@@ -8857,12 +8828,8 @@ void InitializationSequence::dump(raw_ostream &OS) const {
+ OS << "OpenCL sampler_t from integer constant";
+ break;
+
+- case SK_OCLZeroEvent:
+- OS << "OpenCL event_t from zero";
+- break;
+-
+- case SK_OCLZeroQueue:
+- OS << "OpenCL queue_t from zero";
++ case SK_OCLZeroOpaqueType:
++ OS << "OpenCL opaque type from zero";
+ break;
+ }
+
+diff --git a/lib/StaticAnalyzer/Core/ExprEngineC.cpp b/lib/StaticAnalyzer/Core/ExprEngineC.cpp
+index 61b7a29..8ec3b9b 100644
+--- a/lib/StaticAnalyzer/Core/ExprEngineC.cpp
++++ b/lib/StaticAnalyzer/Core/ExprEngineC.cpp
+@@ -412,8 +412,7 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
+ case CK_BlockPointerToObjCPointerCast:
+ case CK_AnyPointerToBlockPointerCast:
+ case CK_ObjCObjectLValueCast:
+- case CK_ZeroToOCLEvent:
+- case CK_ZeroToOCLQueue:
++ case CK_ZeroToOCLOpaqueType:
+ case CK_IntToOCLSampler:
+ case CK_LValueBitCast: {
+ state =
+--
+1.8.3.1
+
diff --git a/0003-OpenCL-Add-support-of-cl_intel_device_side_avc_motio.patch b/0003-OpenCL-Add-support-of-cl_intel_device_side_avc_motio.patch
new file mode 100644
index 0000000..78e83ce
--- /dev/null
+++ b/0003-OpenCL-Add-support-of-cl_intel_device_side_avc_motio.patch
@@ -0,0 +1,1604 @@
+From 939eaef0875da8468d06017f91cd1a605584cd85 Mon Sep 17 00:00:00 2001
+From: Andrew Savonichev <andrew.savonichev at intel.com>
+Date: Thu, 8 Nov 2018 11:25:41 +0000
+Subject: [PATCH] [OpenCL] Add support of
+ cl_intel_device_side_avc_motion_estimation extension
+
+Summary:
+Documentation can be found at https://www.khronos.org/registry/OpenCL/extensions/intel/cl_intel_device_side_avc_motion_estimation.txt
+
+Patch by Kristina Bessonova
+
+Reviewers: Anastasia, yaxunl, shafik
+
+Reviewed By: Anastasia
+
+Subscribers: arphaman, sidorovd, AlexeySotkin, krisb, bader, asavonic, cfe-commits
+
+Differential Revision: https://reviews.llvm.org/D51484
+
+Change-Id: I852384a616cc1942f8b626dd61899e437da81ada
+git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@346392 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ include/clang-c/Index.h | 20 +-
+ include/clang/AST/ASTContext.h | 3 +
+ include/clang/AST/Type.h | 33 +-
+ include/clang/Basic/OpenCLExtensionTypes.def | 41 ++
+ include/clang/Basic/OpenCLExtensions.def | 1 +
+ include/clang/Sema/Initialization.h | 4 +
+ include/clang/Serialization/ASTBitCodes.h | 4 +
+ include/clang/module.modulemap | 1 +
+ lib/AST/ASTContext.cpp | 10 +
+ lib/AST/ASTImporter.cpp | 4 +
+ lib/AST/ExprConstant.cpp | 3 +
+ lib/AST/ItaniumMangle.cpp | 6 +
+ lib/AST/MicrosoftMangle.cpp | 5 +
+ lib/AST/NSAPI.cpp | 3 +
+ lib/AST/Type.cpp | 7 +
+ lib/AST/TypeLoc.cpp | 3 +
+ lib/Analysis/PrintfFormatString.cpp | 3 +
+ lib/CodeGen/CGDebugInfo.cpp | 4 +
+ lib/CodeGen/CGDebugInfo.h | 3 +
+ lib/CodeGen/CGExprScalar.cpp | 3 +-
+ lib/CodeGen/CGOpenCLRuntime.cpp | 5 +
+ lib/CodeGen/CodeGenTypes.cpp | 3 +
+ lib/CodeGen/ItaniumCXXABI.cpp | 3 +
+ lib/Headers/opencl-c.h | 631 +++++++++++++++++++++
+ lib/Index/USRGeneration.cpp | 3 +
+ lib/Sema/Sema.cpp | 4 +
+ lib/Sema/SemaExpr.cpp | 6 +
+ lib/Sema/SemaInit.cpp | 35 +-
+ lib/Serialization/ASTCommon.cpp | 5 +
+ lib/Serialization/ASTReader.cpp | 5 +
+ .../CodeGenOpenCL/intel-subgroups-avc-ext-types.cl | 81 +++
+ test/Headers/opencl-c-header.cl | 1 +
+ test/Index/opencl-types.cl | 8 +
+ test/SemaOpenCL/extension-version.cl | 9 +
+ test/SemaOpenCL/intel-subgroup-avc-ext-types.cl | 105 ++++
+ tools/libclang/CIndex.cpp | 3 +
+ tools/libclang/CXType.cpp | 4 +
+ 37 files changed, 1065 insertions(+), 7 deletions(-)
+ create mode 100644 include/clang/Basic/OpenCLExtensionTypes.def
+ create mode 100644 test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
+ create mode 100644 test/SemaOpenCL/intel-subgroup-avc-ext-types.cl
+
+diff --git a/include/clang-c/Index.h b/include/clang-c/Index.h
+index 65dada3..d4ddcf5 100644
+--- a/include/clang-c/Index.h
++++ b/include/clang-c/Index.h
+@@ -3266,7 +3266,25 @@ enum CXTypeKind {
+ CXType_OCLSampler = 157,
+ CXType_OCLEvent = 158,
+ CXType_OCLQueue = 159,
+- CXType_OCLReserveID = 160
++ CXType_OCLReserveID = 160,
++
++ CXType_ObjCObject = 161,
++ CXType_ObjCTypeParam = 162,
++ CXType_Attributed = 163,
++
++ CXType_OCLIntelSubgroupAVCMcePayload = 164,
++ CXType_OCLIntelSubgroupAVCImePayload = 165,
++ CXType_OCLIntelSubgroupAVCRefPayload = 166,
++ CXType_OCLIntelSubgroupAVCSicPayload = 167,
++ CXType_OCLIntelSubgroupAVCMceResult = 168,
++ CXType_OCLIntelSubgroupAVCImeResult = 169,
++ CXType_OCLIntelSubgroupAVCRefResult = 170,
++ CXType_OCLIntelSubgroupAVCSicResult = 171,
++ CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172,
++ CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173,
++ CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174,
++
++ CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175
+ };
+
+ /**
+diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
+index 6eb8618..1635659 100644
+--- a/include/clang/AST/ASTContext.h
++++ b/include/clang/AST/ASTContext.h
+@@ -1041,6 +1041,9 @@ public:
+ CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
+ CanQualType OCLQueueTy, OCLReserveIDTy;
+ CanQualType OMPArraySectionTy;
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ CanQualType Id##Ty;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+
+ // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
+ mutable QualType AutoDeductTy; // Deduction against 'auto'.
+diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
+index 9a8dd6f..5d6f4ad 100644
+--- a/include/clang/AST/Type.h
++++ b/include/clang/AST/Type.h
+@@ -1911,6 +1911,13 @@ public:
+ bool isQueueT() const; // OpenCL queue_t
+ bool isReserveIDT() const; // OpenCL reserve_id_t
+
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ bool is##Id##Type() const;
++#include "clang/Basic/OpenCLExtensionTypes.def"
++ // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
++ bool isOCLIntelSubgroupAVCType() const;
++ bool isOCLExtOpaqueType() const; // Any OpenCL extension type
++
+ bool isPipeType() const; // OpenCL pipe type
+ bool isOpenCLSpecificType() const; // Any OpenCL specific type
+
+@@ -2253,6 +2260,9 @@ public:
+ // OpenCL image types
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
+ #include "clang/Basic/OpenCLImageTypes.def"
++// OpenCL extension types
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ // All other builtin types
+ #define BUILTIN_TYPE(Id, SingletonId) Id,
+ #define LAST_BUILTIN_TYPE(Id) LastKind = Id
+@@ -6295,9 +6305,30 @@ inline bool Type::isPipeType() const {
+ return isa<PipeType>(CanonicalType);
+ }
+
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ inline bool Type::is##Id##Type() const { \
++ return isSpecificBuiltinType(BuiltinType::Id); \
++ }
++#include "clang/Basic/OpenCLExtensionTypes.def"
++
++inline bool Type::isOCLIntelSubgroupAVCType() const {
++#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
++ isOCLIntelSubgroupAVC##Id##Type() ||
++ return
++#include "clang/Basic/OpenCLExtensionTypes.def"
++ false; // end of boolean or operation
++}
++
++inline bool Type::isOCLExtOpaqueType() const {
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
++ return
++#include "clang/Basic/OpenCLExtensionTypes.def"
++ false; // end of boolean or operation
++}
++
+ inline bool Type::isOpenCLSpecificType() const {
+ return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
+- isQueueT() || isReserveIDT() || isPipeType();
++ isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
+ }
+
+ inline bool Type::isTemplateTypeParmType() const {
+diff --git a/include/clang/Basic/OpenCLExtensionTypes.def b/include/clang/Basic/OpenCLExtensionTypes.def
+new file mode 100644
+index 0000000..b72f7ef
+--- /dev/null
++++ b/include/clang/Basic/OpenCLExtensionTypes.def
+@@ -0,0 +1,41 @@
++//===-- OpenCLExtensionTypes.def - Metadata about BuiltinTypes ------*- C++ -*-===//
++//
++// The LLVM Compiler Infrastructure
++//
++// This file is distributed under the University of Illinois Open Source
++// License. See LICENSE.TXT for details.
++//
++//===----------------------------------------------------------------------===//
++// This file extends builtin types database with OpenCL extension types.
++// Custom code should define this macro:
++// EXT_OPAQUE_TYPE(Name, Id, Ext)
++
++#ifdef EXT_OPAQUE_TYPE
++
++#ifndef INTEL_SUBGROUP_AVC_TYPE
++#define INTEL_SUBGROUP_AVC_TYPE(Name, Id) \
++ EXT_OPAQUE_TYPE(intel_sub_group_avc_##Name, OCLIntelSubgroupAVC##Id, \
++ cl_intel_device_side_avc_motion_estimation)
++#endif
++
++#endif
++
++#ifdef INTEL_SUBGROUP_AVC_TYPE
++INTEL_SUBGROUP_AVC_TYPE(mce_payload_t, McePayload)
++INTEL_SUBGROUP_AVC_TYPE(ime_payload_t, ImePayload)
++INTEL_SUBGROUP_AVC_TYPE(ref_payload_t, RefPayload)
++INTEL_SUBGROUP_AVC_TYPE(sic_payload_t, SicPayload)
++INTEL_SUBGROUP_AVC_TYPE(mce_result_t, MceResult)
++INTEL_SUBGROUP_AVC_TYPE(ime_result_t, ImeResult)
++INTEL_SUBGROUP_AVC_TYPE(ref_result_t, RefResult)
++INTEL_SUBGROUP_AVC_TYPE(sic_result_t, SicResult)
++INTEL_SUBGROUP_AVC_TYPE(ime_result_single_reference_streamout_t, ImeResultSingleRefStreamout)
++INTEL_SUBGROUP_AVC_TYPE(ime_result_dual_reference_streamout_t, ImeResultDualRefStreamout)
++INTEL_SUBGROUP_AVC_TYPE(ime_single_reference_streamin_t, ImeSingleRefStreamin)
++INTEL_SUBGROUP_AVC_TYPE(ime_dual_reference_streamin_t, ImeDualRefStreamin)
++
++#undef INTEL_SUBGROUP_AVC_TYPE
++#endif // INTEL_SUBGROUP_AVC_TYPE
++
++#undef EXT_OPAQUE_TYPE
++
+diff --git a/include/clang/Basic/OpenCLExtensions.def b/include/clang/Basic/OpenCLExtensions.def
+index 13cb12e..5e7d2cb 100644
+--- a/include/clang/Basic/OpenCLExtensions.def
++++ b/include/clang/Basic/OpenCLExtensions.def
+@@ -85,6 +85,7 @@ OPENCLEXT_INTERNAL(cl_amd_media_ops2, 100, ~0U)
+ // Intel OpenCL extensions
+ OPENCLEXT_INTERNAL(cl_intel_subgroups, 120, ~0U)
+ OPENCLEXT_INTERNAL(cl_intel_subgroups_short, 120, ~0U)
++OPENCLEXT_INTERNAL(cl_intel_device_side_avc_motion_estimation, 120, ~0U)
+
+ #undef OPENCLEXT_INTERNAL
+
+diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h
+index 65468e2..092866a 100644
+--- a/include/clang/Sema/Initialization.h
++++ b/include/clang/Sema/Initialization.h
+@@ -1334,6 +1334,10 @@ public:
+ /// from a zero constant.
+ void AddOCLZeroOpaqueTypeStep(QualType T);
+
++ /// Add a step to initialize by zero types defined in the
++ /// cl_intel_device_side_avc_motion_estimation OpenCL extension
++ void AddOCLIntelSubgroupAVCZeroInitStep(QualType T);
++
+ /// Add steps to unwrap a initializer list for a reference around a
+ /// single element and rewrap it at the end.
+ void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
+diff --git a/include/clang/Serialization/ASTBitCodes.h b/include/clang/Serialization/ASTBitCodes.h
+index 430fc48..c3cc142 100644
+--- a/include/clang/Serialization/ASTBitCodes.h
++++ b/include/clang/Serialization/ASTBitCodes.h
+@@ -1015,6 +1015,10 @@ namespace serialization {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ PREDEF_TYPE_##Id##_ID,
+ #include "clang/Basic/OpenCLImageTypes.def"
++ /// \brief OpenCL extension types with auto numeration
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ PREDEF_TYPE_##Id##_ID,
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ };
+
+ /// The number of predefined type IDs that are reserved for
+diff --git a/include/clang/module.modulemap b/include/clang/module.modulemap
+index 8d525c5..aa89551 100644
+--- a/include/clang/module.modulemap
++++ b/include/clang/module.modulemap
+@@ -46,6 +46,7 @@ module Clang_Basic {
+ textual header "Basic/LangOptions.def"
+ textual header "Basic/OpenCLExtensions.def"
+ textual header "Basic/OpenCLImageTypes.def"
++ textual header "Basic/OpenCLExtensionTypes.def"
+ textual header "Basic/OpenMPKinds.def"
+ textual header "Basic/OperatorKinds.def"
+ textual header "Basic/Sanitizers.def"
+diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
+index c085f52..af80a52 100644
+--- a/lib/AST/ASTContext.cpp
++++ b/lib/AST/ASTContext.cpp
+@@ -1241,6 +1241,10 @@ void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
+ InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
+ InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
+ InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
++
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ InitBuiltinType(Id##Ty, BuiltinType::Id);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ }
+
+ // Builtin type for __objc_yes and __objc_no
+@@ -1892,6 +1896,9 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ AS = getTargetAddressSpace(
+ Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
+ Width = Target->getPointerWidth(AS);
+@@ -6471,6 +6478,9 @@ static char getObjCEncodingForPrimitiveKind(const ASTContext *C,
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+ case BuiltinType::OCLQueue:
+diff --git a/lib/AST/ASTImporter.cpp b/lib/AST/ASTImporter.cpp
+index b360b39..5ba2e0e 100644
+--- a/lib/AST/ASTImporter.cpp
++++ b/lib/AST/ASTImporter.cpp
+@@ -588,6 +588,10 @@ QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
+ case BuiltinType::Id: \
+ return Importer.getToContext().SingletonId;
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ return Importer.getToContext().Id##Ty;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ #define SHARED_SINGLETON_TYPE(Expansion)
+ #define BUILTIN_TYPE(Id, SingletonId) \
+ case BuiltinType::Id: return Importer.getToContext().SingletonId;
+diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
+index e743fc9..84c04b0 100644
+--- a/lib/AST/ExprConstant.cpp
++++ b/lib/AST/ExprConstant.cpp
+@@ -7448,6 +7448,9 @@ EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp
+index 2dc04f2..4826556 100644
+--- a/lib/AST/ItaniumMangle.cpp
++++ b/lib/AST/ItaniumMangle.cpp
+@@ -2654,6 +2654,12 @@ void CXXNameMangler::mangleType(const BuiltinType *T) {
+ case BuiltinType::OCLReserveID:
+ Out << "13ocl_reserveid";
+ break;
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ type_name = "ocl_" #ExtType; \
++ Out << type_name.size() << type_name; \
++ break;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ }
+ }
+
+diff --git a/lib/AST/MicrosoftMangle.cpp b/lib/AST/MicrosoftMangle.cpp
+index d5332ba..3aae4ce 100644
+--- a/lib/AST/MicrosoftMangle.cpp
++++ b/lib/AST/MicrosoftMangle.cpp
+@@ -1959,6 +1959,11 @@ void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
+ Out << "PA";
+ mangleArtificalTagType(TTK_Struct, "ocl_reserveid");
+ break;
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ mangleArtificalTagType(TTK_Struct, "ocl_" #ExtType); \
++ break;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+
+ case BuiltinType::NullPtr:
+ Out << "$$T";
+diff --git a/lib/AST/NSAPI.cpp b/lib/AST/NSAPI.cpp
+index 94ad87b..0e5ba89 100644
+--- a/lib/AST/NSAPI.cpp
++++ b/lib/AST/NSAPI.cpp
+@@ -475,6 +475,9 @@ NSAPI::getNSNumberFactoryMethodKind(QualType T) const {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
+index f79a597..5421679 100644
+--- a/lib/AST/Type.cpp
++++ b/lib/AST/Type.cpp
+@@ -2796,6 +2796,10 @@ StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
+ return "reserve_id_t";
+ case OMPArraySection:
+ return "<OpenMP array section type>";
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case Id: \
++ return #ExtType;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ }
+
+ llvm_unreachable("Invalid builtin type.");
+@@ -3796,6 +3800,9 @@ bool Type::canHaveNullability(bool ResultIfUnknown) const {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/AST/TypeLoc.cpp b/lib/AST/TypeLoc.cpp
+index e4fd6f1..edd297a 100644
+--- a/lib/AST/TypeLoc.cpp
++++ b/lib/AST/TypeLoc.cpp
+@@ -384,6 +384,9 @@ TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/Analysis/PrintfFormatString.cpp b/lib/Analysis/PrintfFormatString.cpp
+index dcb15c5..5567f7c 100644
+--- a/lib/Analysis/PrintfFormatString.cpp
++++ b/lib/Analysis/PrintfFormatString.cpp
+@@ -708,6 +708,9 @@ bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ #define SIGNED_TYPE(Id, SingletonId)
+ #define UNSIGNED_TYPE(Id, SingletonId)
+ #define FLOATING_TYPE(Id, SingletonId)
+diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp
+index 5be6fb3..eac817a 100644
+--- a/lib/CodeGen/CGDebugInfo.cpp
++++ b/lib/CodeGen/CGDebugInfo.cpp
+@@ -652,6 +652,10 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
+ return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
+ case BuiltinType::OCLReserveID:
+ return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+
+ case BuiltinType::UChar:
+ case BuiltinType::Char_U:
+diff --git a/lib/CodeGen/CGDebugInfo.h b/lib/CodeGen/CGDebugInfo.h
+index e632806..c892413 100644
+--- a/lib/CodeGen/CGDebugInfo.h
++++ b/lib/CodeGen/CGDebugInfo.h
+@@ -76,6 +76,9 @@ class CGDebugInfo {
+ llvm::DIType *OCLQueueDITy = nullptr;
+ llvm::DIType *OCLNDRangeDITy = nullptr;
+ llvm::DIType *OCLReserveIDDITy = nullptr;
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ llvm::DIType *Id##Ty = nullptr;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+
+ /// Cache of previously constructed Types.
+ llvm::DenseMap<const void *, llvm::TrackingMDRef> TypeCache;
+diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
+index 32eaff4..df5b614 100644
+--- a/lib/CodeGen/CGExprScalar.cpp
++++ b/lib/CodeGen/CGExprScalar.cpp
+@@ -1921,7 +1921,8 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
+ }
+
+ case CK_ZeroToOCLOpaqueType: {
+- assert((DestTy->isEventT() || DestTy->isQueueT()) &&
++ assert((DestTy->isEventT() || DestTy->isQueueT() ||
++ DestTy->isOCLIntelSubgroupAVCType()) &&
+ "CK_ZeroToOCLEvent cast on non-event type");
+ return llvm::Constant::getNullValue(ConvertType(DestTy));
+ }
+diff --git a/lib/CodeGen/CGOpenCLRuntime.cpp b/lib/CodeGen/CGOpenCLRuntime.cpp
+index 1da19a9..baa9178 100644
+--- a/lib/CodeGen/CGOpenCLRuntime.cpp
++++ b/lib/CodeGen/CGOpenCLRuntime.cpp
+@@ -62,6 +62,11 @@ llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {
+ case BuiltinType::OCLReserveID:
+ return llvm::PointerType::get(
+ llvm::StructType::create(Ctx, "opencl.reserve_id_t"), AddrSpc);
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ return llvm::PointerType::get( \
++ llvm::StructType::create(Ctx, "opencl." #ExtType), AddrSpc);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ }
+ }
+
+diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp
+index 1a1395e..2acf1ac 100644
+--- a/lib/CodeGen/CodeGenTypes.cpp
++++ b/lib/CodeGen/CodeGenTypes.cpp
+@@ -503,6 +503,9 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp
+index 00fff14..dc8792b 100644
+--- a/lib/CodeGen/ItaniumCXXABI.cpp
++++ b/lib/CodeGen/ItaniumCXXABI.cpp
+@@ -2808,6 +2808,9 @@ static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/lib/Headers/opencl-c.h b/lib/Headers/opencl-c.h
+index 5525830..98f997d 100644
+--- a/lib/Headers/opencl-c.h
++++ b/lib/Headers/opencl-c.h
+@@ -16201,6 +16201,637 @@ void __ovld __conv intel_sub_group_block_write_us4( __global ushort* p, u
+ void __ovld __conv intel_sub_group_block_write_us8( __global ushort* p, ushort8 data );
+ #endif // cl_intel_subgroups_short
+
++#ifdef cl_intel_device_side_avc_motion_estimation
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : begin
++
++#define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0
++#define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1
++#define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2
++#define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3
++
++#define CLK_AVC_ME_MINOR_8x8_INTEL 0x0
++#define CLK_AVC_ME_MINOR_8x4_INTEL 0x1
++#define CLK_AVC_ME_MINOR_4x8_INTEL 0x2
++#define CLK_AVC_ME_MINOR_4x4_INTEL 0x3
++
++#define CLK_AVC_ME_MAJOR_FORWARD_INTEL 0x0
++#define CLK_AVC_ME_MAJOR_BACKWARD_INTEL 0x1
++#define CLK_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2
++
++#define CLK_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0
++#define CLK_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E
++#define CLK_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D
++#define CLK_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B
++#define CLK_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77
++#define CLK_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F
++#define CLK_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F
++#define CLK_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F
++
++#define CLK_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0
++#define CLK_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1
++#define CLK_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2
++
++#define CLK_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0
++#define CLK_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1
++#define CLK_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2
++#define CLK_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3
++#define CLK_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4
++#define CLK_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5
++#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6
++#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7
++#define CLK_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8
++
++#define CLK_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0
++#define CLK_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2
++
++#define CLK_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0
++#define CLK_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1
++#define CLK_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3
++
++#define CLK_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0
++#define CLK_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1
++#define CLK_AVC_ME_COST_PRECISION_PEL_INTEL 0x2
++#define CLK_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3
++
++#define CLK_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10
++#define CLK_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15
++#define CLK_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20
++#define CLK_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B
++#define CLK_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30
++
++#define CLK_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0
++#define CLK_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2
++#define CLK_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4
++#define CLK_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8
++
++#define CLK_AVC_ME_INTRA_16x16_INTEL 0x0
++#define CLK_AVC_ME_INTRA_8x8_INTEL 0x1
++#define CLK_AVC_ME_INTRA_4x4_INTEL 0x2
++
++#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0
++#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000
++
++#define CLK_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL (0x1 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL (0x2 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL (0x3 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL (0x55 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL (0xAA << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL (0xFF << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL (0x1 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL (0x2 << 24)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL (0x1 << 26)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL (0x2 << 26)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL (0x1 << 28)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL (0x2 << 28)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL (0x1 << 30)
++#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL (0x2 << 30)
++
++#define CLK_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00
++#define CLK_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80
++
++#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_ALL_INTEL 0x0
++#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6
++#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5
++#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3
++
++#define CLK_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60
++#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10
++#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8
++#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4
++
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7
++#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8
++#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0
++#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1
++#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2
++#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3
++
++#define CLK_AVC_ME_FRAME_FORWARD_INTEL 0x1
++#define CLK_AVC_ME_FRAME_BACKWARD_INTEL 0x2
++#define CLK_AVC_ME_FRAME_DUAL_INTEL 0x3
++
++#define CLK_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0
++#define CLK_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1
++
++#define CLK_AVC_ME_INITIALIZE_INTEL 0x0
++
++#define CLK_AVC_IME_PAYLOAD_INITIALIZE_INTEL 0x0
++#define CLK_AVC_REF_PAYLOAD_INITIALIZE_INTEL 0x0
++#define CLK_AVC_SIC_PAYLOAD_INITIALIZE_INTEL 0x0
++
++#define CLK_AVC_IME_RESULT_INITIALIZE_INTEL 0x0
++#define CLK_AVC_REF_RESULT_INITIALIZE_INTEL 0x0
++#define CLK_AVC_SIC_RESULT_INITIALIZE_INTEL 0x0
++
++#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0
++#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0
++#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0
++#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0
++
++// MCE built-in functions
++uchar __ovld
++intel_sub_group_avc_mce_get_default_inter_base_multi_reference_penalty(
++ uchar slice_type, uchar qp);
++ulong __ovld intel_sub_group_avc_mce_get_default_inter_shape_penalty(
++ uchar slice_type, uchar qp);
++uchar __ovld intel_sub_group_avc_mce_get_default_inter_direction_penalty(
++ uchar slice_type, uchar qp);
++uint __ovld intel_sub_group_avc_mce_get_default_intra_luma_shape_penalty(
++ uchar slice_type, uchar qp);
++uint2 __ovld
++intel_sub_group_avc_mce_get_default_inter_motion_vector_cost_table(
++ uchar slice_type, uchar qp);
++uchar __ovld intel_sub_group_avc_mce_get_default_intra_luma_mode_penalty(
++ uchar slice_type, uchar qp);
++
++uint2 __ovld intel_sub_group_avc_mce_get_default_high_penalty_cost_table();
++uint2 __ovld intel_sub_group_avc_mce_get_default_medium_penalty_cost_table();
++uint2 __ovld intel_sub_group_avc_mce_get_default_low_penalty_cost_table();
++uint __ovld intel_sub_group_avc_mce_get_default_non_dc_luma_intra_penalty();
++uchar __ovld
++intel_sub_group_avc_mce_get_default_intra_chroma_mode_base_penalty();
++
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_inter_base_multi_reference_penalty(
++ uchar reference_base_penalty, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_inter_shape_penalty(
++ ulong packed_shape_penalty, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_inter_direction_penalty(
++ uchar direction_cost, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_motion_vector_cost_function(
++ ulong packed_cost_center_delta, uint2 packed_cost_table,
++ uchar cost_precision, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_ac_only_haar(
++ intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_source_interlaced_field_polarity(
++ uchar src_field_polarity, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_single_reference_interlaced_field_polarity(
++ uchar ref_field_polarity, intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_mce_set_dual_reference_interlaced_field_polarities(
++ uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
++ intel_sub_group_avc_mce_payload_t payload);
++
++ulong __ovld intel_sub_group_avc_mce_get_motion_vectors(
++ intel_sub_group_avc_mce_result_t result);
++ushort __ovld intel_sub_group_avc_mce_get_inter_distortions(
++ intel_sub_group_avc_mce_result_t result);
++ushort __ovld intel_sub_group_avc_mce_get_best_inter_distortion(
++ intel_sub_group_avc_mce_result_t result);
++uchar __ovld intel_sub_group_avc_mce_get_inter_major_shape(
++ intel_sub_group_avc_mce_result_t result);
++uchar __ovld intel_sub_group_avc_mce_get_inter_minor_shapes(
++ intel_sub_group_avc_mce_result_t result);
++uchar __ovld intel_sub_group_avc_mce_get_inter_directions(
++ intel_sub_group_avc_mce_result_t result);
++uchar __ovld intel_sub_group_avc_mce_get_inter_motion_vector_count(
++ intel_sub_group_avc_mce_result_t result);
++uint __ovld intel_sub_group_avc_mce_get_inter_reference_ids(
++ intel_sub_group_avc_mce_result_t result);
++uchar __ovld
++intel_sub_group_avc_mce_get_inter_reference_interlaced_field_polarities(
++ uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
++ intel_sub_group_avc_mce_result_t result);
++
++// IME built-in functions
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_initialize(
++ ushort2 src_coord, uchar partition_mask, uchar sad_adjustment);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_single_reference(
++ short2 ref_offset, uchar search_window_config,
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_dual_reference(
++ short2 fwd_ref_offset, short2 bwd_ref_offset, uchar search_window_config,
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_max_motion_vector_count(
++ uchar max_motion_vector_count, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_unidirectional_mix_disable(
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_early_search_termination_threshold(
++ uchar threshold, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_weighted_sad(
++ uint packed_sad_weights, intel_sub_group_avc_ime_payload_t payload);
++
++__attribute__((deprecated("If you use the latest Intel driver, please use "
++ "intel_sub_group_avc_ime_ref_window_size instead",
++ "intel_sub_group_avc_ime_ref_window_size")))
++ushort2 __ovld
++intel_sub_group_ime_ref_window_size(uchar search_window_config, char dual_ref);
++ushort2 __ovld intel_sub_group_avc_ime_ref_window_size(
++ uchar search_window_config, char dual_ref);
++short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset(
++ short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size,
++ ushort2 image_size);
++
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_evaluate_with_single_reference(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_evaluate_with_dual_reference(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld
++intel_sub_group_avc_ime_evaluate_with_single_reference_streamout(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld
++intel_sub_group_avc_ime_evaluate_with_dual_reference_streamout(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_evaluate_with_single_reference_streamin(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,
++ intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_evaluate_with_dual_reference_streamin(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ime_payload_t payload,
++ intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
++intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld
++intel_sub_group_avc_ime_evaluate_with_single_reference_streaminout(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload,
++ intel_sub_group_avc_ime_single_reference_streamin_t streamin_components);
++intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld
++intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ime_payload_t payload,
++ intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
++
++intel_sub_group_avc_ime_single_reference_streamin_t __ovld
++intel_sub_group_avc_ime_get_single_reference_streamin(
++ intel_sub_group_avc_ime_result_single_reference_streamout_t result);
++intel_sub_group_avc_ime_dual_reference_streamin_t __ovld
++intel_sub_group_avc_ime_get_dual_reference_streamin(
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t result);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_strip_single_reference_streamout(
++ intel_sub_group_avc_ime_result_single_reference_streamout_t result);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_ime_strip_dual_reference_streamout(
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t result);
++
++uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(
++ intel_sub_group_avc_ime_result_single_reference_streamout_t result,
++ uchar major_shape);
++ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(
++ intel_sub_group_avc_ime_result_single_reference_streamout_t result,
++ uchar major_shape);
++uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(
++ intel_sub_group_avc_ime_result_single_reference_streamout_t result,
++ uchar major_shape);
++uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors(
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
++ uchar major_shape, uchar direction);
++ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions(
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
++ uchar major_shape, uchar direction);
++uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids(
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t result,
++ uchar major_shape, uchar direction);
++
++uchar __ovld intel_sub_group_avc_ime_get_border_reached(
++ uchar image_select, intel_sub_group_avc_ime_result_t result);
++uchar __ovld intel_sub_group_avc_ime_get_truncated_search_indication(
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld
++intel_sub_group_avc_ime_get_unidirectional_early_search_termination(
++ intel_sub_group_avc_ime_result_t result);
++uint __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_motion_vector(
++ intel_sub_group_avc_ime_result_t result);
++ushort __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_distortion(
++ intel_sub_group_avc_ime_result_t result);
++
++// REF built-in functions
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_fme_initialize(
++ ushort2 src_coord, ulong motion_vectors, uchar major_shapes,
++ uchar minor_shapes, uchar directions, uchar pixel_resolution,
++ uchar sad_adjustment);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_bme_initialize(
++ ushort2 src_coord, ulong motion_vectors, uchar major_shapes,
++ uchar minor_shapes, uchar directions, uchar pixel_resolution,
++ uchar bidirectional_weight, uchar sad_adjustment);
++
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_bidirectional_mix_disable(
++ intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_bilinear_filter_enable(
++ intel_sub_group_avc_ref_payload_t payload);
++
++intel_sub_group_avc_ref_result_t __ovld
++intel_sub_group_avc_ref_evaluate_with_single_reference(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_ref_result_t __ovld
++intel_sub_group_avc_ref_evaluate_with_dual_reference(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_ref_result_t __ovld
++intel_sub_group_avc_ref_evaluate_with_multi_reference(
++ read_only image2d_t src_image, uint packed_reference_ids,
++ sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_ref_result_t __ovld
++intel_sub_group_avc_ref_evaluate_with_multi_reference(
++ read_only image2d_t src_image, uint packed_reference_ids,
++ uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
++ intel_sub_group_avc_ref_payload_t payload);
++
++// SIC built-in functions
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_initialize(
++ ushort2 src_coord);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_configure_skc(
++ uint skip_block_partition_type, uint skip_motion_vector_mask,
++ ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment,
++ intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_configure_ipe(
++ uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
++ uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
++ uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
++ uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_configure_ipe(
++ uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
++ uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
++ uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
++ ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel,
++ ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment,
++ intel_sub_group_avc_sic_payload_t payload);
++uint __ovld
++intel_sub_group_avc_sic_get_motion_vector_mask(
++ uint skip_block_partition_type, uchar direction);
++
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_intra_luma_shape_penalty(
++ uint packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_intra_luma_mode_cost_function(
++ uchar luma_mode_penalty, uint luma_packed_neighbor_modes,
++ uint luma_packed_non_dc_penalty, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_intra_chroma_mode_cost_function(
++ uchar chroma_mode_penalty, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_skc_bilinear_filter_enable(
++ intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_skc_forward_transform_enable(
++ ulong packed_sad_coefficients, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_block_based_raw_skip_sad(
++ uchar block_based_skip_type,
++ intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_sic_evaluate_ipe(
++ read_only image2d_t src_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_sic_evaluate_with_single_reference(
++ read_only image2d_t src_image, read_only image2d_t ref_image,
++ sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_sic_evaluate_with_dual_reference(
++ read_only image2d_t src_image, read_only image2d_t fwd_ref_image,
++ read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
++ intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_sic_evaluate_with_multi_reference(
++ read_only image2d_t src_image, uint packed_reference_ids,
++ sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_sic_evaluate_with_multi_reference(
++ read_only image2d_t src_image, uint packed_reference_ids,
++ uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
++ intel_sub_group_avc_sic_payload_t payload);
++
++uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape(
++ intel_sub_group_avc_sic_result_t result);
++ushort __ovld intel_sub_group_avc_sic_get_best_ipe_luma_distortion(
++ intel_sub_group_avc_sic_result_t result);
++ushort __ovld intel_sub_group_avc_sic_get_best_ipe_chroma_distortion(
++ intel_sub_group_avc_sic_result_t result);
++ulong __ovld intel_sub_group_avc_sic_get_packed_ipe_luma_modes(
++ intel_sub_group_avc_sic_result_t result);
++uchar __ovld intel_sub_group_avc_sic_get_ipe_chroma_mode(
++ intel_sub_group_avc_sic_result_t result);
++uint __ovld intel_sub_group_avc_sic_get_packed_skc_luma_count_threshold(
++ intel_sub_group_avc_sic_result_t result);
++ulong __ovld intel_sub_group_avc_sic_get_packed_skc_luma_sum_threshold(
++ intel_sub_group_avc_sic_result_t result);
++ushort __ovld intel_sub_group_avc_sic_get_inter_raw_sads(
++ intel_sub_group_avc_sic_result_t result);
++
++// Wrappers
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_inter_base_multi_reference_penalty(
++ uchar reference_base_penalty, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_inter_base_multi_reference_penalty(
++ uchar reference_base_penalty, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_inter_base_multi_reference_penalty(
++ uchar reference_base_penalty, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_inter_shape_penalty(
++ ulong packed_shape_cost, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_inter_shape_penalty(
++ ulong packed_shape_cost, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_inter_shape_penalty(
++ ulong packed_shape_cost, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_inter_direction_penalty(
++ uchar direction_cost, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_inter_direction_penalty(
++ uchar direction_cost, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_inter_direction_penalty(
++ uchar direction_cost, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_motion_vector_cost_function(
++ ulong packed_cost_center_delta, uint2 packed_cost_table,
++ uchar cost_precision, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_motion_vector_cost_function(
++ ulong packed_cost_center_delta, uint2 packed_cost_table,
++ uchar cost_precision, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_motion_vector_cost_function(
++ ulong packed_cost_center_delta, uint2 packed_cost_table,
++ uchar cost_precision, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_source_interlaced_field_polarity(
++ uchar src_field_polarity, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_source_interlaced_field_polarity(
++ uchar src_field_polarity, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_source_interlaced_field_polarity(
++ uchar src_field_polarity, intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_single_reference_interlaced_field_polarity(
++ uchar ref_field_polarity, intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_single_reference_interlaced_field_polarity(
++ uchar ref_field_polarity, intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_single_reference_interlaced_field_polarity(
++ uchar ref_field_polarity, intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_dual_reference_interlaced_field_polarities(
++ uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_dual_reference_interlaced_field_polarities(
++ uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
++ intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_dual_reference_interlaced_field_polarities(
++ uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity,
++ intel_sub_group_avc_sic_payload_t payload);
++
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_ime_set_ac_only_haar(
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_ref_set_ac_only_haar(
++ intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_sic_set_ac_only_haar(
++ intel_sub_group_avc_sic_payload_t payload);
++
++ulong __ovld intel_sub_group_avc_ime_get_motion_vectors(
++ intel_sub_group_avc_ime_result_t result);
++ulong __ovld intel_sub_group_avc_ref_get_motion_vectors(
++ intel_sub_group_avc_ref_result_t result);
++
++ushort __ovld intel_sub_group_avc_ime_get_inter_distortions(
++ intel_sub_group_avc_ime_result_t result);
++ushort __ovld intel_sub_group_avc_ref_get_inter_distortions(
++ intel_sub_group_avc_ref_result_t result);
++ushort __ovld intel_sub_group_avc_sic_get_inter_distortions(
++ intel_sub_group_avc_sic_result_t result);
++
++ushort __ovld intel_sub_group_avc_ime_get_best_inter_distortion(
++ intel_sub_group_avc_ime_result_t result);
++ushort __ovld intel_sub_group_avc_ref_get_best_inter_distortion(
++ intel_sub_group_avc_ref_result_t result);
++
++uchar __ovld intel_sub_group_avc_ime_get_inter_major_shape(
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld intel_sub_group_avc_ref_get_inter_major_shape(
++ intel_sub_group_avc_ref_result_t result);
++uchar __ovld intel_sub_group_avc_ime_get_inter_minor_shapes(
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld intel_sub_group_avc_ref_get_inter_minor_shapes(
++ intel_sub_group_avc_ref_result_t result);
++
++uchar __ovld intel_sub_group_avc_ime_get_inter_directions(
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld intel_sub_group_avc_ref_get_inter_directions(
++ intel_sub_group_avc_ref_result_t result);
++
++uchar __ovld intel_sub_group_avc_ime_get_inter_motion_vector_count(
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld intel_sub_group_avc_ref_get_inter_motion_vector_count(
++ intel_sub_group_avc_ref_result_t result);
++
++uint __ovld intel_sub_group_avc_ime_get_inter_reference_ids(
++ intel_sub_group_avc_ime_result_t result);
++uint __ovld intel_sub_group_avc_ref_get_inter_reference_ids(
++ intel_sub_group_avc_ref_result_t result);
++
++uchar __ovld
++intel_sub_group_avc_ime_get_inter_reference_interlaced_field_polarities(
++ uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
++ intel_sub_group_avc_ime_result_t result);
++uchar __ovld
++intel_sub_group_avc_ref_get_inter_reference_interlaced_field_polarities(
++ uint packed_reference_ids, uint packed_reference_parameter_field_polarities,
++ intel_sub_group_avc_ref_result_t result);
++
++// Type conversion functions
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_ime_convert_to_mce_payload(
++ intel_sub_group_avc_ime_payload_t payload);
++intel_sub_group_avc_ime_payload_t __ovld
++intel_sub_group_avc_mce_convert_to_ime_payload(
++ intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_ref_convert_to_mce_payload(
++ intel_sub_group_avc_ref_payload_t payload);
++intel_sub_group_avc_ref_payload_t __ovld
++intel_sub_group_avc_mce_convert_to_ref_payload(
++ intel_sub_group_avc_mce_payload_t payload);
++intel_sub_group_avc_mce_payload_t __ovld
++intel_sub_group_avc_sic_convert_to_mce_payload(
++ intel_sub_group_avc_sic_payload_t payload);
++intel_sub_group_avc_sic_payload_t __ovld
++intel_sub_group_avc_mce_convert_to_sic_payload(
++ intel_sub_group_avc_mce_payload_t payload);
++
++intel_sub_group_avc_mce_result_t __ovld
++intel_sub_group_avc_ime_convert_to_mce_result(
++ intel_sub_group_avc_ime_result_t result);
++intel_sub_group_avc_ime_result_t __ovld
++intel_sub_group_avc_mce_convert_to_ime_result(
++ intel_sub_group_avc_mce_result_t result);
++intel_sub_group_avc_mce_result_t __ovld
++intel_sub_group_avc_ref_convert_to_mce_result(
++ intel_sub_group_avc_ref_result_t result);
++intel_sub_group_avc_ref_result_t __ovld
++intel_sub_group_avc_mce_convert_to_ref_result(
++ intel_sub_group_avc_mce_result_t result);
++intel_sub_group_avc_mce_result_t __ovld
++intel_sub_group_avc_sic_convert_to_mce_result(
++ intel_sub_group_avc_sic_result_t result);
++intel_sub_group_avc_sic_result_t __ovld
++intel_sub_group_avc_mce_convert_to_sic_result(
++ intel_sub_group_avc_mce_result_t result);
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : end
++#endif // cl_intel_device_side_avc_motion_estimation
++
+ #ifdef cl_amd_media_ops
+ uint __ovld amd_bitalign(uint a, uint b, uint c);
+ uint2 __ovld amd_bitalign(uint2 a, uint2 b, uint2 c);
+diff --git a/lib/Index/USRGeneration.cpp b/lib/Index/USRGeneration.cpp
+index b128b69..3062982 100644
+--- a/lib/Index/USRGeneration.cpp
++++ b/lib/Index/USRGeneration.cpp
+@@ -704,6 +704,9 @@ void USRGenerator::VisitType(QualType T) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+ case BuiltinType::OCLQueue:
+diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
+index 49f3dec..df99459 100644
+--- a/lib/Sema/Sema.cpp
++++ b/lib/Sema/Sema.cpp
+@@ -320,6 +320,10 @@ void Sema::Initialize() {
+ #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
+ setOpenCLExtensionForType(Context.Id, Ext);
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ addImplicitTypedef(#ExtType, Context.Id##Ty); \
++ setOpenCLExtensionForType(Context.Id##Ty, #Ext);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ };
+
+ if (Context.getTargetInfo().hasBuiltinMSVaList()) {
+diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
+index 3dc6fb1..84617ec 100644
+--- a/lib/Sema/SemaExpr.cpp
++++ b/lib/Sema/SemaExpr.cpp
+@@ -5058,6 +5058,9 @@ static bool isPlaceholderToRemoveAsArg(QualType type) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ #define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
+ #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
+ #include "clang/AST/BuiltinTypes.def"
+@@ -16458,6 +16461,9 @@ ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ #define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
+ #define PLACEHOLDER_TYPE(Id, SingletonId)
+ #include "clang/AST/BuiltinTypes.def"
+diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
+index 5e81560..f0ff942 100644
+--- a/lib/Sema/SemaInit.cpp
++++ b/lib/Sema/SemaInit.cpp
+@@ -1166,6 +1166,10 @@ void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
+ SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
+ << DeclType;
+ hadError = true;
++ } else if (DeclType->isOCLIntelSubgroupAVCType()) {
++ // Checks for scalar type are sufficient for these types too.
++ CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
++ StructuredIndex);
+ } else {
+ if (!VerifyOnly)
+ SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
+@@ -5164,6 +5168,11 @@ static bool TryOCLSamplerInitialization(Sema &S,
+ return true;
+ }
+
++static bool IsZeroInitializer(Expr *Initializer, Sema &S) {
++ return Initializer->isIntegerConstantExpr(S.getASTContext()) &&
++ (Initializer->EvaluateKnownConstInt(S.getASTContext()) == 0);
++}
++
+ static bool TryOCLZeroOpaqueTypeInitialization(Sema &S,
+ InitializationSequence &Sequence,
+ QualType DestType,
+@@ -5180,8 +5189,23 @@ static bool TryOCLZeroOpaqueTypeInitialization(Sema &S,
+ // event should be zero.
+ //
+ if (DestType->isEventT() || DestType->isQueueT()) {
+- if (!Initializer->isIntegerConstantExpr(S.getASTContext()) ||
+- (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
++ if (!IsZeroInitializer(Initializer, S))
++ return false;
++
++ Sequence.AddOCLZeroOpaqueTypeStep(DestType);
++ return true;
++ }
++
++ // We should allow zero initialization for all types defined in the
++ // cl_intel_device_side_avc_motion_estimation extension, except
++ // intel_sub_group_avc_mce_payload_t and intel_sub_group_avc_mce_result_t.
++ if (S.getOpenCLOptions().isEnabled(
++ "cl_intel_device_side_avc_motion_estimation") &&
++ DestType->isOCLIntelSubgroupAVCType()) {
++ if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
++ DestType->isOCLIntelSubgroupAVCMceResultType())
++ return false;
++ if (!IsZeroInitializer(Initializer, S))
+ return false;
+
+ Sequence.AddOCLZeroOpaqueTypeStep(DestType);
+@@ -7924,7 +7948,9 @@ InitializationSequence::Perform(Sema &S,
+ // defined in SPIR spec v1.2 and also opencl-c.h
+ unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
+ unsigned FilterMode = (0x30 & SamplerValue) >> 4;
+- if (FilterMode != 1 && FilterMode != 2)
++ if (FilterMode != 1 && FilterMode != 2 &&
++ !S.getOpenCLOptions().isEnabled(
++ "cl_intel_device_side_avc_motion_estimation"))
+ S.Diag(Kind.getLocation(),
+ diag::warn_sampler_initializer_invalid_bits)
+ << "Filter Mode";
+@@ -7941,7 +7967,8 @@ InitializationSequence::Perform(Sema &S,
+ break;
+ }
+ case SK_OCLZeroOpaqueType: {
+- assert((Step->Type->isEventT() || Step->Type->isQueueT()) &&
++ assert((Step->Type->isEventT() || Step->Type->isQueueT() ||
++ Step->Type->isOCLIntelSubgroupAVCType()) &&
+ "Wrong type for initialization of OpenCL opaque type.");
+
+ CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
+diff --git a/lib/Serialization/ASTCommon.cpp b/lib/Serialization/ASTCommon.cpp
+index da48271..06fc930 100644
+--- a/lib/Serialization/ASTCommon.cpp
++++ b/lib/Serialization/ASTCommon.cpp
+@@ -213,6 +213,11 @@ serialization::TypeIdxFromBuiltin(const BuiltinType *BT) {
+ ID = PREDEF_TYPE_##Id##_ID; \
+ break;
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case BuiltinType::Id: \
++ ID = PREDEF_TYPE_##Id##_ID; \
++ break;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ ID = PREDEF_TYPE_SAMPLER_ID;
+ break;
+diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp
+index 723839f..0da79ac 100644
+--- a/lib/Serialization/ASTReader.cpp
++++ b/lib/Serialization/ASTReader.cpp
+@@ -6979,6 +6979,11 @@ QualType ASTReader::GetType(TypeID ID) {
+ T = Context.SingletonId; \
+ break;
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
++ case PREDEF_TYPE_##Id##_ID: \
++ T = Context.Id##Ty; \
++ break;
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case PREDEF_TYPE_SAMPLER_ID:
+ T = Context.OCLSamplerTy;
+ break;
+diff --git a/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl b/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
+new file mode 100644
+index 0000000..515f13f
+--- /dev/null
++++ b/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
+@@ -0,0 +1,81 @@
++// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -cl-ext=+cl_intel_device_side_avc_motion_estimation -emit-llvm -o - -O0 | FileCheck %s
++
++// CHECK: %opencl.intel_sub_group_avc_mce_payload_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ime_payload_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ref_payload_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_sic_payload_t = type opaque
++
++// CHECK: %opencl.intel_sub_group_avc_mce_result_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ime_result_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ref_result_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_sic_result_t = type opaque
++
++// CHECK: %opencl.intel_sub_group_avc_ime_result_single_reference_streamout_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ime_result_dual_reference_streamout_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ime_single_reference_streamin_t = type opaque
++// CHECK: %opencl.intel_sub_group_avc_ime_dual_reference_streamin_t = type opaque
++
++// CHECK: store %opencl.intel_sub_group_avc_ime_payload_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ref_payload_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_sic_payload_t* null,
++
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ref_result_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_sic_result_t* null,
++
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_single_reference_streamout_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_dual_reference_streamout_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_single_reference_streamin_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_dual_reference_streamin_t* null,
++//
++// CHECK: store %opencl.intel_sub_group_avc_ime_payload_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ref_payload_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_sic_payload_t* null,
++
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ref_result_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_sic_result_t* null,
++
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_single_reference_streamout_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_result_dual_reference_streamout_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_single_reference_streamin_t* null,
++// CHECK: store %opencl.intel_sub_group_avc_ime_dual_reference_streamin_t* null,
++
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : enable
++
++// Using 0x0 directly allows us not to include opencl-c.h header and not to
++// redefine all of these CLK_AVC_*_INTITIALIZE_INTEL macro. '0x0' value must
++// be in sync with ones defined in opencl-c.h
++
++void foo() {
++ intel_sub_group_avc_mce_payload_t payload_mce; // No literal initializer for mce types
++ intel_sub_group_avc_ime_payload_t payload_ime = 0x0;
++ intel_sub_group_avc_ref_payload_t payload_ref = 0x0;
++ intel_sub_group_avc_sic_payload_t payload_sic = 0x0;
++
++ intel_sub_group_avc_mce_result_t result_mce; // No literal initializer for mce types
++ intel_sub_group_avc_ime_result_t result_ime = 0x0;
++ intel_sub_group_avc_ref_result_t result_ref = 0x0;
++ intel_sub_group_avc_sic_result_t result_sic = 0x0;
++
++ intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout = 0x0;
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamout = 0x0;
++ intel_sub_group_avc_ime_single_reference_streamin_t sstreamin = 0x0;
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin = 0x0;
++
++ // Initialization with initializer list was supported in the first version
++ // of the extension. So we check for backward compatibility here.
++ intel_sub_group_avc_ime_payload_t payload_ime_list = {0};
++ intel_sub_group_avc_ref_payload_t payload_ref_list = {0};
++ intel_sub_group_avc_sic_payload_t payload_sic_list = {0};
++
++ intel_sub_group_avc_ime_result_t result_ime_list = {0};
++ intel_sub_group_avc_ref_result_t result_ref_list = {0};
++ intel_sub_group_avc_sic_result_t result_sic_list = {0};
++
++ intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout_list = {0};
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamout_list = {0};
++ intel_sub_group_avc_ime_single_reference_streamin_t sstreamin_list = {0};
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list = {0};
++}
++
+diff --git a/test/Headers/opencl-c-header.cl b/test/Headers/opencl-c-header.cl
+index d344f37..b26e61b 100644
+--- a/test/Headers/opencl-c-header.cl
++++ b/test/Headers/opencl-c-header.cl
+@@ -46,6 +46,7 @@
+
+ // Verify that called builtins occur in the generated IR.
+
++// CHECK-NOT: intel_sub_group_avc_mce_get_default_inter_base_multi_reference_penalty
+ // CHECK-NOT: ndrange_t
+ // CHECK20: ndrange_t
+ // CHECK: _Z16convert_char_rtec
+diff --git a/test/Index/opencl-types.cl b/test/Index/opencl-types.cl
+index d71893a..cda2dad 100644
+--- a/test/Index/opencl-types.cl
++++ b/test/Index/opencl-types.cl
+@@ -124,3 +124,11 @@ void kernel testMiscOpenCLTypes() {
+ // CHECK: VarDecl=scalarOCLEvent:118:15 (Definition) [type=clk_event_t] [typekind=Typedef] [canonicaltype=clk_event_t] [canonicaltypekind=Unexposed] [isPOD=1]
+ // CHECK: VarDecl=scalarOCLQueue:119:11 (Definition) [type=queue_t] [typekind=Typedef] [canonicaltype=queue_t] [canonicaltypekind=OCLQueue] [isPOD=1]
+ // CHECK: VarDecl=scalarOCLReserveID:120:16 (Definition) [type=reserve_id_t] [typekind=Typedef] [canonicaltype=reserve_id_t] [canonicaltypekind=OCLReserveID] [isPOD=1]
++
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : enable
++
++void kernel testExtOpenCLTypes() {
++ intel_sub_group_avc_mce_payload_t mce_payload;
++}
++
++// CHECK: VarDecl=mce_payload:131:37 (Definition){{( \(invalid\))?}} [type=intel_sub_group_avc_mce_payload_t] [typekind=Typedef] [canonicaltype=intel_sub_group_avc_mce_payload_t] [canonicaltypekind=OCLIntelSubgroupAVCMcePayload] [isPOD=1]
+diff --git a/test/SemaOpenCL/extension-version.cl b/test/SemaOpenCL/extension-version.cl
+index 714e4c2..64a2841 100644
+--- a/test/SemaOpenCL/extension-version.cl
++++ b/test/SemaOpenCL/extension-version.cl
+@@ -300,3 +300,12 @@
+ #endif
+ #pragma OPENCL EXTENSION cl_intel_subgroups_short : enable
+
++#if (__OPENCL_C_VERSION__ >= 120)
++#ifndef cl_intel_device_side_avc_motion_estimation
++#error "Missing cl_intel_device_side_avc_motion_estimation define"
++#endif
++#else
++// expected-warning at +2{{unsupported OpenCL extension 'cl_intel_device_side_avc_motion_estimation' - ignoring}}
++#endif
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : enable
++
+diff --git a/test/SemaOpenCL/intel-subgroup-avc-ext-types.cl b/test/SemaOpenCL/intel-subgroup-avc-ext-types.cl
+new file mode 100644
+index 0000000..3392e80
+--- /dev/null
++++ b/test/SemaOpenCL/intel-subgroup-avc-ext-types.cl
+@@ -0,0 +1,105 @@
++// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -cl-ext=+cl_intel_device_side_avc_motion_estimation -fsyntax-only -verify %s
++
++#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : enable
++
++// All intel_sub_group_avc_* types can only be used as argument or return value
++// of built-in functions defined in the extension.
++// But there are also additional initialization rules:
++// * All types except intel_sub_group_avc_mce_* types can be initialized with
++// the corresponding initializer macro defined in opencl-c.h
++// Currently all these macroses are defined as 0x0
++// * In previous versions of the extension these macroses was defined as {0},
++// so initialization with initializer list containing one integer equal to
++// zero should also work
++
++struct st{};
++// negative test cases for initializers
++void foo(char c, float f, void* v, struct st ss) {
++ intel_sub_group_avc_mce_payload_t payload_mce = 0; // No zero initializer for mce types
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_mce_payload_t' with an expression of incompatible type 'int'}}
++ intel_sub_group_avc_ime_payload_t payload_ime = 1; // No literal initializer for *payload_t types
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ime_payload_t' with an expression of incompatible type 'int'}}
++ intel_sub_group_avc_ref_payload_t payload_ref = f;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ref_payload_t' with an expression of incompatible type 'float'}}
++ intel_sub_group_avc_sic_payload_t payload_sic = ss;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_sic_payload_t' with an expression of incompatible type 'struct st'}}
++
++ intel_sub_group_avc_mce_result_t result_mce = 0; // No zero initializer for mce types
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_mce_result_t' with an expression of incompatible type 'int'}}
++ intel_sub_group_avc_ime_result_t result_ime = 1; // No literal initializer for *result_t types
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ime_result_t' with an expression of incompatible type 'int'}}
++ intel_sub_group_avc_ref_result_t result_ref = f;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ref_result_t' with an expression of incompatible type 'float'}}
++ intel_sub_group_avc_sic_result_t result_sic = ss;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_sic_result_t' with an expression of incompatible type 'struct st'}}
++
++ intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout = v;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ime_result_single_reference_streamout_t' with an expression of incompatible type 'void *'}}
++
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamin_list = {0x0, 0x1};
++ // expected-warning at -1 {{excess elements in struct initializer}}
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list2 = {};
++ // expected-error at -1 {{scalar initializer cannot be empty}}
++ intel_sub_group_avc_ime_single_reference_streamin_t dstreamin_list3 = {c};
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ime_single_reference_streamin_t' with an expression of incompatible type 'char'}}
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list4 = {1};
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ime_dual_reference_streamin_t' with an expression of incompatible type 'int'}}
++}
++
++// negative tests for initializers and assignment
++void far() {
++ intel_sub_group_avc_mce_payload_t payload_mce;
++ intel_sub_group_avc_mce_payload_t payload_mce2 = payload_mce;
++
++ intel_sub_group_avc_ime_payload_t payload_ime;
++ intel_sub_group_avc_ref_payload_t payload_ref = payload_ime;
++ // expected-error at -1 {{initializing 'intel_sub_group_avc_ref_payload_t' with an expression of incompatible type 'intel_sub_group_avc_ime_payload_t'}}
++
++ intel_sub_group_avc_sic_result_t result_sic;
++ intel_sub_group_avc_ime_result_t result_ime;
++ result_sic = result_ime;
++ // expected-error at -1 {{assigning to 'intel_sub_group_avc_sic_result_t' from incompatible type 'intel_sub_group_avc_ime_result_t'}}
++}
++
++// Using 0x0 directly allows us not to include opencl-c.h header and not to
++// redefine all of these CLK_AVC_*_INTITIALIZE_INTEL macro. '0x0' value must
++// be in sync with ones defined in opencl-c.h
++
++// positive test cases
++void bar() {
++ const sampler_t vme_sampler = 0x0;
++
++ intel_sub_group_avc_mce_payload_t payload_mce; // No literal initializer for mce types
++ intel_sub_group_avc_ime_payload_t payload_ime = 0x0;
++ intel_sub_group_avc_ref_payload_t payload_ref = 0x0;
++ intel_sub_group_avc_sic_payload_t payload_sic = 0x0;
++
++ intel_sub_group_avc_mce_result_t result_mce; // No literal initializer for mce types
++ intel_sub_group_avc_ime_result_t result_ime = 0x0;
++ intel_sub_group_avc_ref_result_t result_ref = 0x0;
++ intel_sub_group_avc_sic_result_t result_sic = 0x0;
++
++ intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout = 0x0;
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamout = 0x0;
++ intel_sub_group_avc_ime_single_reference_streamin_t sstreamin = 0x0;
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin = 0x0;
++
++ // It is allowed to assign variables of the same types
++ intel_sub_group_avc_mce_payload_t pauload_mce2 = payload_mce;
++
++ // Initialization with initializer list was supported in the first version
++ // of the extension. So we check for backward compatibility here.
++ intel_sub_group_avc_ime_payload_t payload_ime_list = {0};
++ intel_sub_group_avc_ref_payload_t payload_ref_list = {0};
++ intel_sub_group_avc_sic_payload_t payload_sic_list = {0};
++
++ intel_sub_group_avc_ime_result_t result_ime_list = {0};
++ intel_sub_group_avc_ref_result_t result_ref_list = {0};
++ intel_sub_group_avc_sic_result_t result_sic_list = {0};
++
++ intel_sub_group_avc_ime_result_single_reference_streamout_t sstreamout_list = {0};
++ intel_sub_group_avc_ime_result_dual_reference_streamout_t dstreamout_list = {0};
++ intel_sub_group_avc_ime_single_reference_streamin_t sstreamin_list = {0};
++ intel_sub_group_avc_ime_dual_reference_streamin_t dstreamin_list = {0};
++}
++
+diff --git a/tools/libclang/CIndex.cpp b/tools/libclang/CIndex.cpp
+index 499d9ab..857f73f 100644
+--- a/tools/libclang/CIndex.cpp
++++ b/tools/libclang/CIndex.cpp
+@@ -1519,6 +1519,9 @@ bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
+ #include "clang/Basic/OpenCLImageTypes.def"
++#define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) \
++ case BuiltinType::Id:
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ case BuiltinType::OCLSampler:
+ case BuiltinType::OCLEvent:
+ case BuiltinType::OCLClkEvent:
+diff --git a/tools/libclang/CXType.cpp b/tools/libclang/CXType.cpp
+index 7c0f307..95f2487 100644
+--- a/tools/libclang/CXType.cpp
++++ b/tools/libclang/CXType.cpp
+@@ -70,6 +70,8 @@ static CXTypeKind GetBuiltinTypeKind(const BuiltinType *BT) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) BTCASE(Id);
+ #include "clang/Basic/OpenCLImageTypes.def"
+ #undef IMAGE_TYPE
++#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) BTCASE(Id);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ BTCASE(OCLSampler);
+ BTCASE(OCLEvent);
+ BTCASE(OCLQueue);
+@@ -590,6 +592,8 @@ CXString clang_getTypeKindSpelling(enum CXTypeKind K) {
+ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) TKIND(Id);
+ #include "clang/Basic/OpenCLImageTypes.def"
+ #undef IMAGE_TYPE
++#define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) TKIND(Id);
++#include "clang/Basic/OpenCLExtensionTypes.def"
+ TKIND(OCLSampler);
+ TKIND(OCLEvent);
+ TKIND(OCLQueue);
+--
+1.8.3.1
+
diff --git a/0004-OpenCL-Relax-diagnostics-on-OpenCL-access-qualifiers.patch b/0004-OpenCL-Relax-diagnostics-on-OpenCL-access-qualifiers.patch
new file mode 100644
index 0000000..254164a
--- /dev/null
+++ b/0004-OpenCL-Relax-diagnostics-on-OpenCL-access-qualifiers.patch
@@ -0,0 +1,161 @@
+From 7f183c37f13d34b9c9a7eac845421ac706d220d6 Mon Sep 17 00:00:00 2001
+From: Andrew Savonichev <andrew.savonichev at intel.com>
+Date: Thu, 6 Sep 2018 15:10:26 +0000
+Subject: [PATCH] [OpenCL] Relax diagnostics on OpenCL access qualifiers
+
+Summary:
+Emit warning for multiple access qualifiers if they do not conflict.
+
+Patch by Alexey Bader
+
+Reviewers: Anastasia, yaxunl
+
+Reviewed By: Anastasia
+
+Subscribers: asavonic, bader, cfe-commits
+
+Differential Revision: https://reviews.llvm.org/D51302
+
+git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@341553 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/Sema/SemaDeclAttr.cpp | 14 ++++++++----
+ lib/Sema/SemaType.cpp | 45 +++++++++++++++++++++++++++----------
+ test/SemaOpenCL/access-qualifier.cl | 33 ++++++++++++++++++++++++++-
+ 3 files changed, 75 insertions(+), 17 deletions(-)
+
+diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
+index 77deed6..9bea321 100644
+--- a/lib/Sema/SemaDeclAttr.cpp
++++ b/lib/Sema/SemaDeclAttr.cpp
+@@ -5912,10 +5912,16 @@ static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+
+ // Check if there is only one access qualifier.
+ if (D->hasAttr<OpenCLAccessAttr>()) {
+- S.Diag(AL.getLoc(), diag::err_opencl_multiple_access_qualifiers)
+- << D->getSourceRange();
+- D->setInvalidDecl(true);
+- return;
++ if (D->getAttr<OpenCLAccessAttr>()->getSemanticSpelling() ==
++ AL.getSemanticSpelling()) {
++ S.Diag(AL.getLoc(), diag::warn_duplicate_declspec)
++ << AL.getName()->getName() << AL.getRange();
++ } else {
++ S.Diag(AL.getLoc(), diag::err_opencl_multiple_access_qualifiers)
++ << D->getSourceRange();
++ D->setInvalidDecl(true);
++ return;
++ }
+ }
+
+ // OpenCL v2.0 s6.6 - read_write can be used for image types to specify that an
+diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
+index 284d34b..bc0d42a 100644
+--- a/lib/Sema/SemaType.cpp
++++ b/lib/Sema/SemaType.cpp
+@@ -7085,22 +7085,43 @@ static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr,
+ }
+
+ if (const TypedefType* TypedefTy = CurType->getAs<TypedefType>()) {
+- QualType PointeeTy = TypedefTy->desugar();
+- S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers);
++ QualType BaseTy = TypedefTy->desugar();
+
+ std::string PrevAccessQual;
+- switch (cast<BuiltinType>(PointeeTy.getTypePtr())->getKind()) {
+- #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+- case BuiltinType::Id: \
+- PrevAccessQual = #Access; \
+- break;
+- #include "clang/Basic/OpenCLImageTypes.def"
+- default:
+- assert(0 && "Unable to find corresponding image type.");
++ if (BaseTy->isPipeType()) {
++ if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
++ OpenCLAccessAttr *Attr =
++ TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
++ PrevAccessQual = Attr->getSpelling();
++ } else {
++ PrevAccessQual = "read_only";
++ }
++ } else if (const BuiltinType* ImgType = BaseTy->getAs<BuiltinType>()) {
++
++ switch (ImgType->getKind()) {
++ #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
++ case BuiltinType::Id: \
++ PrevAccessQual = #Access; \
++ break;
++ #include "clang/Basic/OpenCLImageTypes.def"
++ default:
++ llvm_unreachable("Unable to find corresponding image type.");
++ }
++ } else {
++ llvm_unreachable("unexpected type");
++ }
++ StringRef AttrName = Attr.getName()->getName();
++ if (PrevAccessQual == AttrName.ltrim("_")) {
++ // Duplicated qualifiers
++ S.Diag(Attr.getLoc(), diag::warn_duplicate_declspec)
++ << AttrName << Attr.getRange();
++ } else {
++ // Contradicting qualifiers
++ S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers);
+ }
+
+- S.Diag(TypedefTy->getDecl()->getLocStart(),
+- diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
++ S.Diag(TypedefTy->getDecl()->getBeginLoc(),
++ diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
+ } else if (CurType->isPipeType()) {
+ if (Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
+ QualType ElemType = CurType->getAs<PipeType>()->getElementType();
+diff --git a/test/SemaOpenCL/access-qualifier.cl b/test/SemaOpenCL/access-qualifier.cl
+index 35e838b..3d337ee 100644
+--- a/test/SemaOpenCL/access-qualifier.cl
++++ b/test/SemaOpenCL/access-qualifier.cl
+@@ -60,7 +60,7 @@ kernel void k10(read_only Int img){} // expected-error {{access qualifier can on
+
+ kernel void k11(read_only write_only image1d_t i){} // expected-error{{multiple access qualifiers}}
+
+-kernel void k12(read_only read_only image1d_t i){} // expected-error{{multiple access qualifiers}}
++kernel void k12(read_only read_only image1d_t i){} // expected-warning {{duplicate 'read_only' declaration specifier}}
+
+ #if __OPENCL_C_VERSION__ >= 200
+ kernel void k13(read_write pipe int i){} // expected-error{{access qualifier 'read_write' can not be used for 'read_only pipe int'}}
+@@ -78,3 +78,34 @@ kernel void k14(read_only pipe int p) {
+ #if __OPENCL_C_VERSION__ < 200
+ kernel void test_image3d_wo(write_only image3d_t img) {} // expected-error {{use of type '__write_only image3d_t' requires cl_khr_3d_image_writes extension to be enabled}}
+ #endif
++
++#if __OPENCL_C_VERSION__ >= 200
++kernel void read_write_twice_typedef(read_write img1d_rw i){} // expected-warning {{duplicate 'read_write' declaration specifier}}
++// expected-note at -74 {{previously declared 'read_write' here}}
++
++kernel void pipe_ro_twice(read_only read_only pipe int i){} // expected-warning{{duplicate 'read_only' declaration specifier}}
++// Conflicting access qualifiers
++kernel void pipe_ro_twice_tw(read_write read_only read_only pipe int i){} // expected-error{{multiple access qualifiers}}
++// expected-warning at -1 {{duplicate 'read_only' declaration specifier}}
++kernel void pipe_ro_wo(read_only write_only pipe int i){} // expected-error{{multiple access qualifiers}}
++
++typedef read_only pipe int ROPipeInt;
++kernel void pipe_ro_twice_typedef(read_only ROPipeInt i){} // expected-warning{{duplicate 'read_only' declaration specifier}}
++// expected-note at -2 {{previously declared 'read_only' here}}
++
++kernel void pass_ro_typedef_to_wo(ROPipeInt p) {
++ myPipeWrite(p); // expected-error {{passing 'ROPipeInt' (aka 'read_only pipe int') to parameter of incompatible type 'write_only pipe int'}}
++ // expected-note at -26 {{passing argument to parameter here}}
++}
++#endif
++
++kernel void read_only_twice_typedef(__read_only img1d_ro i){} // expected-warning {{duplicate '__read_only' declaration specifier}}
++// expected-note at -96 {{previously declared 'read_only' here}}
++
++kernel void read_only_twice_default(read_only img1d_ro_default img){} // expected-warning {{duplicate 'read_only' declaration specifier}}
++// expected-note at -102 {{previously declared 'read_only' here}}
++
++kernel void image_wo_twice(write_only __write_only image1d_t i){} // expected-warning {{duplicate 'write_only' declaration specifier}}
++kernel void image_wo_twice_typedef(write_only img1d_wo i){} // expected-warning {{duplicate 'write_only' declaration specifier}}
++// expected-note at -104 {{previously declared 'write_only' here}}
++
+--
+2.7.4
+
diff --git a/0005-OpenCL-Fix-invalid-address-space-generation-for-clk_.patch b/0005-OpenCL-Fix-invalid-address-space-generation-for-clk_.patch
new file mode 100644
index 0000000..2848025
--- /dev/null
+++ b/0005-OpenCL-Fix-invalid-address-space-generation-for-clk_.patch
@@ -0,0 +1,70 @@
+From c7ee1afbc6399023296cddeab2b53ed55a123de4 Mon Sep 17 00:00:00 2001
+From: Alexey Sotkin <alexey.sotkin at intel.com>
+Date: Wed, 14 Nov 2018 09:40:05 +0000
+Subject: [PATCH] [OpenCL] Fix invalid address space generation for clk_event_t
+
+Summary:
+Addrspace(32) was generated when putting 0 in clk_event_t * event_ret
+parameter for enqueue_kernel function.
+
+Patch by Viktoria Maksimova
+
+Reviewers: Anastasia, yaxunl, AlexeySotkin
+
+Reviewed By: Anastasia, AlexeySotkin
+
+Subscribers: cfe-commits
+
+Differential Revision: https://reviews.llvm.org/D53809
+
+git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@346838 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ lib/CodeGen/CGBuiltin.cpp | 4 +++-
+ test/CodeGenOpenCL/cl20-device-side-enqueue.cl | 9 ++++++++-
+ 2 files changed, 11 insertions(+), 2 deletions(-)
+
+diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
+index 0770c20..cd074af 100644
+--- a/lib/CodeGen/CGBuiltin.cpp
++++ b/lib/CodeGen/CGBuiltin.cpp
+@@ -3400,7 +3400,9 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
+ llvm::Value *ClkEvent = EmitScalarExpr(E->getArg(5));
+ // Convert to generic address space.
+ EventList = Builder.CreatePointerCast(EventList, EventPtrTy);
+- ClkEvent = Builder.CreatePointerCast(ClkEvent, EventPtrTy);
++ ClkEvent = ClkEvent->getType()->isIntegerTy()
++ ? Builder.CreateBitOrPointerCast(ClkEvent, EventPtrTy)
++ : Builder.CreatePointerCast(ClkEvent, EventPtrTy);
+ auto Info =
+ CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(6));
+ llvm::Value *Kernel =
+diff --git a/test/CodeGenOpenCL/cl20-device-side-enqueue.cl b/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
+index d74a1df..120a426 100644
+--- a/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
++++ b/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
+@@ -79,6 +79,13 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
+ a[i] = b[i];
+ });
+
++ // COMMON-LABEL: call i32 @__enqueue_kernel_basic_events
++ // COMMON-SAME: (%opencl.queue_t{{.*}}* {{%[0-9]+}}, i32 {{%[0-9]+}}, %struct.ndrange_t* {{.*}}, i32 1, %opencl.clk_event_t{{.*}}* addrspace(4)* {{%[0-9]+}}, %opencl.clk_event_t{{.*}}* addrspace(4)* null,
++ enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, 0,
++ ^(void) {
++ return;
++ });
++
+ // Emits global block literal [[BLG1]] and block kernel [[INVGK1]].
+ // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
+ // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
+@@ -336,7 +343,7 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
+ // COMMON: define internal spir_kernel void [[INVGK5]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
+ // COMMON: define internal spir_kernel void [[INVGK6]](i8 addrspace(4)*, i8 addrspace(3)*, i8 addrspace(3)*, i8 addrspace(3)*) #{{[0-9]+}} {
+ // COMMON: entry:
+-// COMMON: call void @__device_side_enqueue_block_invoke_8(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3)
++// COMMON: call void @__device_side_enqueue_block_invoke_9(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3)
+ // COMMON: ret void
+ // COMMON: }
+ // COMMON: define internal spir_kernel void [[INVGK7]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
+--
+1.8.3.1
+
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/llvm.git/commitdiff/18b8fe9c33ca219e1dcece96ed3abf814938ced3
More information about the pld-cvs-commit
mailing list