[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
This revision was automatically updated to reflect the committed changes.
Closed by commit rGe95ee300c053: [SYCL] Prohibit arithmetic operations for
incompatible pointers (authored by bader).
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
Files:
clang/include/clang/AST/Type.h
clang/lib/Sema/SemaCast.cpp
clang/lib/Sema/SemaExpr.cpp
clang/test/Sema/address_spaces.c
clang/test/SemaCXX/address-space-arithmetic.cpp
Index: clang/test/SemaCXX/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/SemaCXX/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type ('__private int *' and '__local int *') which are pointers to non-overlapping address spaces}}
+}
Index: clang/test/Sema/address_spaces.c
===
--- clang/test/Sema/address_spaces.c
+++ clang/test/Sema/address_spaces.c
@@ -74,6 +74,10 @@
return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
}
+char *sub(_AS1 char *x, _AS2 char *y) {
+ return x - y; // expected-error {{arithmetic operation with operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
+}
+
struct SomeStruct {
int a;
long b;
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,10 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
-const PointerType *lhsPtr = LHSExpr->getType()->castAs();
-const PointerType *rhsPtr = RHSExpr->getType()->castAs();
-if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
+ if (isLHSPointer && isRHSPointer) {
+if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
S.Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
@@ -11444,8 +11442,7 @@
if (LCanPointeeTy != RCanPointeeTy) {
// Treat NULL constant as a special case in OpenCL.
if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
-const PointerType *LHSPtr = LHSType->castAs();
-if (!LHSPtr->isAddressSpaceOverlapping(*RHSType->castAs())) {
+if (!LCanPointeeTy.isAddressSpaceOverlapping(RCanPointeeTy)) {
Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSType << RHSType << 0 /* comparison */
Index: clang/lib/Sema/SemaCast.cpp
===
--- clang/lib/Sema/SemaCast.cpp
+++ clang/lib/Sema/SemaCast.cpp
@@ -2391,7 +2391,7 @@
return TC_NotApplicable;
auto SrcPointeeType = SrcPtrType->getPointeeType();
auto DestPointeeType = DestPtrType->getPointeeType();
- if (!DestPtrType->isAddressSpaceOverlapping(*SrcPtrType)) {
+ if (!DestPointeeType.isAddressSpaceOverlapping(SrcPointeeType)) {
msg = diag::err_bad_cxx_cast_addr_space_mismatch;
return TC_Failed;
}
@@ -2434,9 +2434,9 @@
const PointerType *SrcPPtr = cast(SrcPtr);
QualType DestPPointee = DestPPtr->getPointeeType();
QualType SrcPPointee = SrcPPtr->getPointeeType();
- if (Nested ? DestPPointee.getAddressSpace() !=
- SrcPPointee.getAddressSpace()
- : !DestPPtr->isAddressSpaceOverlapping(*SrcPPtr)) {
+ if (Nested
+ ? DestPPointee.getAddressSpace() != SrcPPointee.getAddressSpace()
+ : !DestPPointee.isAddressSpaceOverlapping(SrcPPointee)) {
Self.Diag(OpRange.getBegin(), DiagID)
<< SrcType << DestType << Sema::AA_Casting
<< SrcExpr.get()->getSourceRange();
Index: clang/include/clang/AST/Type.h
===
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -1064,6 +1064,21 @@
/// Return the address space of this type.
inline LangAS getAddressSpace() const;
+ /// Returns true if address space qualifiers overlap with T address space
+ /// qualifiers.
+ /// OpenCL C defines conversion rules for pointers to different address spaces
+ /// and notion of overlapping address spaces.
+ /// CL1.1 or CL1.2:
+ /// address spaces overlap iff they are they same.
+ /// OpenCL C v2.0 s6.5.5 adds:
+ ///
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader updated this revision to Diff 265579.
bader marked an inline comment as done.
bader added a comment.
Fix formatting in clang/test/Sema/address_spaces.c
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
Files:
clang/include/clang/AST/Type.h
clang/lib/Sema/SemaCast.cpp
clang/lib/Sema/SemaExpr.cpp
clang/test/Sema/address_spaces.c
clang/test/SemaCXX/address-space-arithmetic.cpp
Index: clang/test/SemaCXX/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/SemaCXX/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type ('__private int *' and '__local int *') which are pointers to non-overlapping address spaces}}
+}
Index: clang/test/Sema/address_spaces.c
===
--- clang/test/Sema/address_spaces.c
+++ clang/test/Sema/address_spaces.c
@@ -74,6 +74,10 @@
return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
}
+char *sub(_AS1 char *x, _AS2 char *y) {
+ return x - y; // expected-error {{arithmetic operation with operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
+}
+
struct SomeStruct {
int a;
long b;
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,10 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
-const PointerType *lhsPtr = LHSExpr->getType()->castAs();
-const PointerType *rhsPtr = RHSExpr->getType()->castAs();
-if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
+ if (isLHSPointer && isRHSPointer) {
+if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
S.Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
@@ -11444,8 +11442,7 @@
if (LCanPointeeTy != RCanPointeeTy) {
// Treat NULL constant as a special case in OpenCL.
if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
-const PointerType *LHSPtr = LHSType->castAs();
-if (!LHSPtr->isAddressSpaceOverlapping(*RHSType->castAs())) {
+if (!LCanPointeeTy.isAddressSpaceOverlapping(RCanPointeeTy)) {
Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSType << RHSType << 0 /* comparison */
Index: clang/lib/Sema/SemaCast.cpp
===
--- clang/lib/Sema/SemaCast.cpp
+++ clang/lib/Sema/SemaCast.cpp
@@ -2391,7 +2391,7 @@
return TC_NotApplicable;
auto SrcPointeeType = SrcPtrType->getPointeeType();
auto DestPointeeType = DestPtrType->getPointeeType();
- if (!DestPtrType->isAddressSpaceOverlapping(*SrcPtrType)) {
+ if (!DestPointeeType.isAddressSpaceOverlapping(SrcPointeeType)) {
msg = diag::err_bad_cxx_cast_addr_space_mismatch;
return TC_Failed;
}
@@ -2434,9 +2434,9 @@
const PointerType *SrcPPtr = cast(SrcPtr);
QualType DestPPointee = DestPPtr->getPointeeType();
QualType SrcPPointee = SrcPPtr->getPointeeType();
- if (Nested ? DestPPointee.getAddressSpace() !=
- SrcPPointee.getAddressSpace()
- : !DestPPtr->isAddressSpaceOverlapping(*SrcPPtr)) {
+ if (Nested
+ ? DestPPointee.getAddressSpace() != SrcPPointee.getAddressSpace()
+ : !DestPPointee.isAddressSpaceOverlapping(SrcPPointee)) {
Self.Diag(OpRange.getBegin(), DiagID)
<< SrcType << DestType << Sema::AA_Casting
<< SrcExpr.get()->getSourceRange();
Index: clang/include/clang/AST/Type.h
===
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -1064,6 +1064,21 @@
/// Return the address space of this type.
inline LangAS getAddressSpace() const;
+ /// Returns true if address space qualifiers overlap with T address space
+ /// qualifiers.
+ /// OpenCL C defines conversion rules for pointers to different address spaces
+ /// and notion of overlapping address spaces.
+ /// CL1.1 or CL1.2:
+ /// address spaces overlap iff they are they same.
+ /// OpenCL C v2.0 s6.5.5 adds:
+ /// __generic overlaps with any
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
rjmccall accepted this revision.
rjmccall added a comment.
This revision is now accepted and ready to land.
LGTM
Comment at: clang/include/clang/AST/Type.h:1069
+ /// qualifiers.
+ bool isAddressSpaceOverlapping(const QualType ) const {
+Qualifiers Q = getQualifiers();
bader wrote:
> rjmccall wrote:
> > It's idiomatic to take `QualType` by value rather than `const &`.
> >
> > Can you rewrite the `PointerType` method to delegate to this? Assuming it
> > isn't completely dead, that is.
> It isn't completely dead, but there were just a few uses of the `PointerType`
> method, so I've updated all of them to avoid code duplication in two classes.
Even better, thanks.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader marked 2 inline comments as done.
bader added inline comments.
Comment at: clang/include/clang/AST/Type.h:1069
+ /// qualifiers.
+ bool isAddressSpaceOverlapping(const QualType ) const {
+Qualifiers Q = getQualifiers();
rjmccall wrote:
> It's idiomatic to take `QualType` by value rather than `const &`.
>
> Can you rewrite the `PointerType` method to delegate to this? Assuming it
> isn't completely dead, that is.
It isn't completely dead, but there were just a few uses of the `PointerType`
method, so I've updated all of them to avoid code duplication in two classes.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader updated this revision to Diff 265547.
bader added a comment.
- Added C test case with address_space attribute.
- Move isAddressSpaceOverlapping from PointerType to QualType.
- Move C++ test case to clang/test/SemaCXX
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
Files:
clang/include/clang/AST/Type.h
clang/lib/Sema/SemaCast.cpp
clang/lib/Sema/SemaExpr.cpp
clang/test/Sema/address_spaces.c
clang/test/SemaCXX/address-space-arithmetic.cpp
Index: clang/test/SemaCXX/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/SemaCXX/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type ('__private int *' and '__local int *') which are pointers to non-overlapping address spaces}}
+}
Index: clang/test/Sema/address_spaces.c
===
--- clang/test/Sema/address_spaces.c
+++ clang/test/Sema/address_spaces.c
@@ -74,6 +74,10 @@
return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
}
+char* sub(_AS1 char *x, _AS2 char *y) {
+ return x - y; // expected-error {{arithmetic operation with operands of type ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
+}
+
struct SomeStruct {
int a;
long b;
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,10 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
-const PointerType *lhsPtr = LHSExpr->getType()->castAs();
-const PointerType *rhsPtr = RHSExpr->getType()->castAs();
-if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
+ if (isLHSPointer && isRHSPointer) {
+if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
S.Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
@@ -11444,8 +11442,7 @@
if (LCanPointeeTy != RCanPointeeTy) {
// Treat NULL constant as a special case in OpenCL.
if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
-const PointerType *LHSPtr = LHSType->castAs();
-if (!LHSPtr->isAddressSpaceOverlapping(*RHSType->castAs())) {
+if (!LCanPointeeTy.isAddressSpaceOverlapping(RCanPointeeTy)) {
Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSType << RHSType << 0 /* comparison */
Index: clang/lib/Sema/SemaCast.cpp
===
--- clang/lib/Sema/SemaCast.cpp
+++ clang/lib/Sema/SemaCast.cpp
@@ -2391,7 +2391,7 @@
return TC_NotApplicable;
auto SrcPointeeType = SrcPtrType->getPointeeType();
auto DestPointeeType = DestPtrType->getPointeeType();
- if (!DestPtrType->isAddressSpaceOverlapping(*SrcPtrType)) {
+ if (!DestPointeeType.isAddressSpaceOverlapping(SrcPointeeType)) {
msg = diag::err_bad_cxx_cast_addr_space_mismatch;
return TC_Failed;
}
@@ -2434,9 +2434,9 @@
const PointerType *SrcPPtr = cast(SrcPtr);
QualType DestPPointee = DestPPtr->getPointeeType();
QualType SrcPPointee = SrcPPtr->getPointeeType();
- if (Nested ? DestPPointee.getAddressSpace() !=
- SrcPPointee.getAddressSpace()
- : !DestPPtr->isAddressSpaceOverlapping(*SrcPPtr)) {
+ if (Nested
+ ? DestPPointee.getAddressSpace() != SrcPPointee.getAddressSpace()
+ : !DestPPointee.isAddressSpaceOverlapping(SrcPPointee)) {
Self.Diag(OpRange.getBegin(), DiagID)
<< SrcType << DestType << Sema::AA_Casting
<< SrcExpr.get()->getSourceRange();
Index: clang/include/clang/AST/Type.h
===
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -1064,6 +1064,21 @@
/// Return the address space of this type.
inline LangAS getAddressSpace() const;
+ /// Returns true if address space qualifiers overlap with T address space
+ /// qualifiers.
+ /// OpenCL C defines conversion rules for pointers to different address spaces
+ /// and notion of overlapping address spaces.
+ /// CL1.1 or CL1.2:
+ /// address spaces overlap iff they are they same.
+ ///
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
rjmccall added a comment.
Please add a C test case just using the address_space attribute.
Comment at: clang/include/clang/AST/Type.h:1069
+ /// qualifiers.
+ bool isAddressSpaceOverlapping(const QualType ) const {
+Qualifiers Q = getQualifiers();
It's idiomatic to take `QualType` by value rather than `const &`.
Can you rewrite the `PointerType` method to delegate to this? Assuming it
isn't completely dead, that is.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader marked 2 inline comments as done. bader added a comment. Thanks for the review. I've enabled the diagnostics for all the modes. I also applied the refactoring suggested by @rjmccall. Hopefully I understand it correctly. Repository: rG LLVM Github Monorepo CHANGES SINCE LAST ACTION https://reviews.llvm.org/D80317/new/ https://reviews.llvm.org/D80317 ___ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader updated this revision to Diff 265487.
bader added a comment.
Enable diagnostics for non-OpenCL modes and applied refactoring proposed by
John.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
Files:
clang/include/clang/AST/Type.h
clang/lib/Sema/SemaExpr.cpp
clang/test/Sema/address-space-arithmetic.cpp
Index: clang/test/Sema/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/Sema/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type
('__private int *' and '__local int *') which are pointers to }}
+}
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,10 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
-const PointerType *lhsPtr = LHSExpr->getType()->castAs();
-const PointerType *rhsPtr = RHSExpr->getType()->castAs();
-if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
+ if (isLHSPointer && isRHSPointer) {
+if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
S.Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
Index: clang/include/clang/AST/Type.h
===
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -1064,6 +1064,15 @@
/// Return the address space of this type.
inline LangAS getAddressSpace() const;
+ /// Returns true if address space qualifiers overlap with T address space
+ /// qualifiers.
+ bool isAddressSpaceOverlapping(const QualType ) const {
+Qualifiers Q = getQualifiers();
+Qualifiers TQ = T.getQualifiers();
+// Address spaces overlap if at least one of them is a superset of another
+return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
+ }
+
/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;
Index: clang/test/Sema/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/Sema/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type ('__private int *' and '__local int *') which are pointers to }}
+}
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,10 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
-const PointerType *lhsPtr = LHSExpr->getType()->castAs();
-const PointerType *rhsPtr = RHSExpr->getType()->castAs();
-if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
+ if (isLHSPointer && isRHSPointer) {
+if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
S.Diag(Loc,
diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
<< LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
Index: clang/include/clang/AST/Type.h
===
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -1064,6 +1064,15 @@
/// Return the address space of this type.
inline LangAS getAddressSpace() const;
+ /// Returns true if address space qualifiers overlap with T address space
+ /// qualifiers.
+ bool isAddressSpaceOverlapping(const QualType ) const {
+Qualifiers Q = getQualifiers();
+Qualifiers TQ = T.getQualifiers();
+// Address spaces overlap if at least one of them is a superset of another
+return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
+ }
+
/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
rjmccall added inline comments.
Comment at: clang/lib/Sema/SemaExpr.cpp:10090
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
Anastasia wrote:
> bader wrote:
> > Alternative approach would be to remove `S.getLangOpts().OpenCL` to enable
> > this check for all modes.
> >
> > @Anastasia, do you know if it's safe to do?
> If I look at embedded C (ISO/IEC TR 18037) s5.3 rules that we are following
> largely in Clang I believe this is a universal rule!
>
> Especially looking at the followong statement:
>
> > Clause 6.5.6 - Additive operators, add another constraint paragraph:
> > For subtraction, if the two operands are pointers into different address
> > spaces, the address spaces must overlap.
>
> So I think that it should apply to at least OpenCL, C and C++. I am
> surprised though that this has not been fixed yet.
>
> I am CCing @rjmccall and @jeroen.dobbelaere in case they have any more
> insights on this.
>
Yes, I agree, this should apply in all modes.
You should able to restructure the `isAddressSpaceOverlapping` function so that
it can work directly on the address spaces of `LHSPointeeTy` and
`RHSPointeeTy`; the code will be both cleaner and faster.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
Anastasia added subscribers: jeroen.dobbelaere, rjmccall.
Anastasia added inline comments.
Comment at: clang/lib/Sema/SemaExpr.cpp:10090
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
bader wrote:
> Alternative approach would be to remove `S.getLangOpts().OpenCL` to enable
> this check for all modes.
>
> @Anastasia, do you know if it's safe to do?
If I look at embedded C (ISO/IEC TR 18037) s5.3 rules that we are following
largely in Clang I believe this is a universal rule!
Especially looking at the followong statement:
> Clause 6.5.6 - Additive operators, add another constraint paragraph:
> For subtraction, if the two operands are pointers into different address
> spaces, the address spaces must overlap.
So I think that it should apply to at least OpenCL, C and C++. I am surprised
though that this has not been fixed yet.
I am CCing @rjmccall and @jeroen.dobbelaere in case they have any more insights
on this.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader created this revision.
bader added a reviewer: Anastasia.
Herald added subscribers: cfe-commits, ebevhan, yaxunl.
Herald added a project: clang.
bader marked an inline comment as done.
bader added inline comments.
Comment at: clang/lib/Sema/SemaExpr.cpp:10090
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
Alternative approach would be to remove `S.getLangOpts().OpenCL` to enable this
check for all modes.
@Anastasia, do you know if it's safe to do?
This change enables OpenCL diagnostics for the pointers annotated with
address space attribute SYCL mode.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D80317
Files:
clang/lib/Sema/SemaExpr.cpp
clang/test/SemaSYCL/address-space-arithmetic.cpp
Index: clang/test/SemaSYCL/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/SemaSYCL/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type
('__private int *' and '__local int *') which are pointers to }}
+}
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,7 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
const PointerType *lhsPtr = LHSExpr->getType()->castAs();
const PointerType *rhsPtr = RHSExpr->getType()->castAs();
if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
Index: clang/test/SemaSYCL/address-space-arithmetic.cpp
===
--- /dev/null
+++ clang/test/SemaSYCL/address-space-arithmetic.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -verify %s
+
+int *foo(__attribute__((opencl_private)) int *p,
+ __attribute__((opencl_local)) int *l) {
+ return p - l; // expected-error {{arithmetic operation with operands of type ('__private int *' and '__local int *') which are pointers to }}
+}
Index: clang/lib/Sema/SemaExpr.cpp
===
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10087,7 +10087,8 @@
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
const PointerType *lhsPtr = LHSExpr->getType()->castAs();
const PointerType *rhsPtr = RHSExpr->getType()->castAs();
if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D80317: [SYCL] Prohibit arithmetic operations for incompatible pointers
bader marked an inline comment as done.
bader added inline comments.
Comment at: clang/lib/Sema/SemaExpr.cpp:10090
// if both are pointers check if operation is valid wrt address spaces
- if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
+ if ((S.getLangOpts().OpenCL || S.getLangOpts().SYCLIsDevice) &&
+ isLHSPointer && isRHSPointer) {
Alternative approach would be to remove `S.getLangOpts().OpenCL` to enable this
check for all modes.
@Anastasia, do you know if it's safe to do?
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D80317/new/
https://reviews.llvm.org/D80317
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
