replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "[OpenCL] Enabling the usage of CLK_NULL_QUEUE as compare operand." 

This reverts commit r290171. It triggers a bunch of warnings, because
the new enumerator isn't handled in all switches. We want a warning-free
build.

Replied on the commit with more details.

llvm-svn: 290173
This commit is contained in:
Daniel Jasper 2016-12-20 10:05:04 +00:00
parent 4be5d67443
commit 9068938eb0
14 changed files with 1 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
clang/include/clang/AST/OperationKinds.def
View File

@ -321,9 +321,6 @@ 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 pointer to a different address space.
CAST_OPERATION(AddressSpaceConversion)

5
clang/include/clang/Sema/Initialization.h
View File

@ -751,8 +751,6 @@ public:
SK_StdInitializerListConstructorCall,
/// \brief Initialize an OpenCL sampler from an integer.
SK_OCLSamplerInit,
/// \brief Initialize queue_t from 0.
SK_OCLZeroQueue,
/// \brief Passing zero to a function where OpenCL event_t is expected.
SK_OCLZeroEvent
};
@ -1150,9 +1148,6 @@ public:
/// constant.
void AddOCLZeroEventStep(QualType T);
/// \brief Add a step to initialize an OpenCL queue_t from 0.
void AddOCLZeroQueueStep(QualType T);
/// \brief 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);

1
clang/include/clang/Sema/Overload.h
View File

@ -83,7 +83,6 @@ namespace clang {
ICK_TransparentUnionConversion, ///< Transparent Union Conversions
ICK_Writeback_Conversion, ///< Objective-C ARC writeback conversion
ICK_Zero_Event_Conversion, ///< Zero constant to event (OpenCL1.2 6.12.10)
ICK_Zero_Queue_Conversion, ///< Zero constant to queue
ICK_C_Only_Conversion, ///< Conversions allowed in C, but not C++
ICK_Incompatible_Pointer_Conversion, ///< C-only conversion between pointers
/// with incompatible types

2
clang/lib/AST/ExprConstant.cpp
View File

@ -8340,7 +8340,6 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
case CK_IntegralComplexToFloatingComplex:
case CK_BuiltinFnToFnPtr:
case CK_ZeroToOCLEvent:
case CK_ZeroToOCLQueue:
case CK_NonAtomicToAtomic:
case CK_AddressSpaceConversion:
case CK_IntToOCLSampler:
@ -8838,7 +8837,6 @@ bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
case CK_CopyAndAutoreleaseBlockObject:
case CK_BuiltinFnToFnPtr:
case CK_ZeroToOCLEvent:
case CK_ZeroToOCLQueue:
case CK_NonAtomicToAtomic:
case CK_AddressSpaceConversion:
case CK_IntToOCLSampler:

1
clang/lib/CodeGen/CGExprAgg.cpp
View File

@ -751,7 +751,6 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
case CK_CopyAndAutoreleaseBlockObject:
case CK_BuiltinFnToFnPtr:
case CK_ZeroToOCLEvent:
case CK_ZeroToOCLQueue:
case CK_AddressSpaceConversion:
case CK_IntToOCLSampler:
llvm_unreachable("cast kind invalid for aggregate types");

1
clang/lib/CodeGen/CGExprComplex.cpp
View File

@ -480,7 +480,6 @@ ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
case CK_CopyAndAutoreleaseBlockObject:
case CK_BuiltinFnToFnPtr:
case CK_ZeroToOCLEvent:
case CK_ZeroToOCLQueue:
case CK_AddressSpaceConversion:
case CK_IntToOCLSampler:
llvm_unreachable("invalid cast kind for complex value");

5
clang/lib/CodeGen/CGExprScalar.cpp
View File

@ -1593,11 +1593,6 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
return llvm::Constant::getNullValue(ConvertType(DestTy));
}
case CK_ZeroToOCLQueue: {
assert(DestTy->isQueueT() && "CK_ZeroToOCLQueue cast on non queue_t type");
return llvm::Constant::getNullValue(ConvertType(DestTy));
}
case CK_IntToOCLSampler:
return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);

12
clang/lib/Sema/SemaExpr.cpp
View File

@ -9635,18 +9635,6 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return ResultTy;
}
if (getLangOpts().OpenCLVersion >= 200) {
if (LHSIsNull && RHSType->isQueueT()) {
LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
return ResultTy;
}
if (LHSType->isQueueT() && RHSIsNull) {
RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
return ResultTy;
}
}
return InvalidOperands(Loc, LHS, RHS);
}

6
clang/lib/Sema/SemaExprCXX.cpp
View File

@ -3878,12 +3878,6 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
From->getValueKind()).get();
break;
case ICK_Zero_Queue_Conversion:
From = ImpCastExprToType(From, ToType,
CK_ZeroToOCLQueue,
From->getValueKind()).get();
break;
case ICK_Lvalue_To_Rvalue:
case ICK_Array_To_Pointer:
case ICK_Function_To_Pointer:

41
clang/lib/Sema/SemaInit.cpp
View File

@ -3077,7 +3077,6 @@ void InitializationSequence::Step::Destroy() {
case SK_StdInitializerListConstructorCall:
case SK_OCLSamplerInit:
case SK_OCLZeroEvent:
case SK_OCLZeroQueue:
break;
case SK_ConversionSequence:
@ -3366,13 +3365,6 @@ void InitializationSequence::AddOCLZeroEventStep(QualType T) {
Steps.push_back(S);
}
void InitializationSequence::AddOCLZeroQueueStep(QualType T) {
Step S;
S.Kind = SK_OCLZeroQueue;
S.Type = T;
Steps.push_back(S);
}
void InitializationSequence::RewrapReferenceInitList(QualType T,
InitListExpr *Syntactic) {
assert(Syntactic->getNumInits() == 1 &&
@ -5038,20 +5030,6 @@ static bool TryOCLZeroEventInitialization(Sema &S,
return true;
}
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.AddOCLZeroQueueStep(DestType);
return true;
}
InitializationSequence::InitializationSequence(Sema &S,
const InitializedEntity &Entity,
const InitializationKind &Kind,
@ -5314,9 +5292,6 @@ void InitializationSequence::InitializeFrom(Sema &S,
if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
return;
if (TryOCLZeroQueueInitialization(S, *this, DestType, Initializer))
return;
// Handle initialization in C
AddCAssignmentStep(DestType);
MaybeProduceObjCObject(S, *this, Entity);
@ -6554,8 +6529,7 @@ InitializationSequence::Perform(Sema &S,
case SK_ProduceObjCObject:
case SK_StdInitializerList:
case SK_OCLSamplerInit:
case SK_OCLZeroEvent:
case SK_OCLZeroQueue: {
case SK_OCLZeroEvent: {
assert(Args.size() == 1);
CurInit = Args[0];
if (!CurInit.get()) return ExprError();
@ -7239,15 +7213,6 @@ InitializationSequence::Perform(Sema &S,
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,
CurInit.get()->getValueKind());
break;
}
}
}
@ -8076,10 +8041,6 @@ void InitializationSequence::dump(raw_ostream &OS) const {
case SK_OCLZeroEvent:
OS << "OpenCL event_t from zero";
break;
case SK_OCLZeroQueue:
OS << "OpenCL queue_t from zero";
break;
}
OS << " [" << S->Type.getAsString() << ']';

6
clang/lib/Sema/SemaOverload.cpp
View File

@ -1785,11 +1785,6 @@ static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
SCS.Second = ICK_Zero_Event_Conversion;
FromType = ToType;
} else if (ToType->isQueueT() &&
From->isIntegerConstantExpr(S.getASTContext()) &&
(From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
SCS.Second = ICK_Zero_Queue_Conversion;
FromType = ToType;
} else {
// No second conversion required.
SCS.Second = ICK_Identity;
@ -5167,7 +5162,6 @@ static bool CheckConvertedConstantConversions(Sema &S,
case ICK_Function_Conversion:
case ICK_Integral_Promotion:
case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
case ICK_Zero_Queue_Conversion:
return true;
case ICK_Boolean_Conversion:

18
clang/test/CodeGenOpenCL/null_queue.cl
View File

@ -1,18 +0,0 @@
// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -emit-llvm %s -o - | FileCheck %s
extern queue_t get_default_queue();
bool compare() {
return 0 == get_default_queue() &&
get_default_queue() == 0;
// CHECK: icmp eq %opencl.queue_t* null, %{{.*}}
// CHECK: icmp eq %opencl.queue_t* %{{.*}}, null
}
void func(queue_t q);
void init() {
queue_t q = 0;
func(0);
// CHECK: store %opencl.queue_t* null, %opencl.queue_t** %q
// CHECK: call void @func(%opencl.queue_t* null)
}

12
clang/test/SemaOpenCL/null_queue.cl
View File

@ -1,12 +0,0 @@
// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
extern queue_t get_default_queue();
bool compare() {
return 1 == get_default_queue() && // expected-error{{invalid operands to binary expression ('int' and 'queue_t')}}
get_default_queue() == 1; // expected-error{{invalid operands to binary expression ('queue_t' and 'int')}}
}
void init() {
queue_t q1 = 1; // expected-error{{initializing 'queue_t' with an expression of incompatible type 'int'}}
queue_t q = 0;
}

12
clang/test/SemaOpenCL/queue_t_overload.cl
View File

@ -1,12 +0,0 @@
// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
void __attribute__((overloadable)) foo(queue_t, __local char *); // expected-note {{candidate function not viable: no known conversion from 'int' to 'queue_t' for 1st argument}} // expected-note {{candidate function}}
void __attribute__((overloadable)) foo(queue_t, __local float *); // expected-note {{candidate function not viable: no known conversion from 'int' to 'queue_t' for 1st argument}} // expected-note {{candidate function}}
void kernel ker(__local char *src1, __local float *src2, __global int *src3) {
queue_t q;
foo(q, src1);
foo(0, src2);
foo(q, src3); // expected-error {{call to 'foo' is ambiguous}}
foo(1, src3); // expected-error {{no matching function for call to 'foo'}}
}