r314650 - Dependent Address Space Support Test File

[NAKAMURA Takumi via cfe-commits]

On Mon, Oct 2, 2017 at 3:33 PM Andrew Gozillon via cfe-commits <
cfe-commits at lists.llvm.org> wrote:

> Author: agozillon
> Date: Sun Oct  1 23:31:25 2017
> New Revision: 314650
>
> URL: http://llvm.org/viewvc/llvm-project?rev=314650&view=rev
> Log:
> Dependent Address Space Support Test File
>
> Adding regression test for Dependent Address Spaces in relation to
> https://reviews.llvm.org/D33666 I forgot to svn add the test file
> before commiting the prior changes. I appologies.
>
>
> Added:
>     cfe/trunk/test/SemaTemplate/address_space-dependent.cpp
>
> Added: cfe/trunk/test/SemaTemplate/address_space-dependent.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaTemplate/address_space-dependent.cpp?rev=314650&view=auto
>
> ==============================================================================
> --- cfe/trunk/test/SemaTemplate/address_space-dependent.cpp (added)
> +++ cfe/trunk/test/SemaTemplate/address_space-dependent.cpp Sun Oct  1
> 23:31:25 2017
> @@ -0,0 +1,119 @@
> +// RUN: %clang_cc1 -x c++ -std=c++14 -fsyntax-only -verify %s
> +
> +template <int I, int J, int K>
> +void car() {
> +  int __attribute__((address_space(I))) __attribute__((address_space(J)))
> * Y;  // expected-error {{multiple address spaces specified for type}}
> +  int *__attribute__((address_space(I)))
> __attribute__((address_space(J))) * Z; // expected-error {{multiple address
> spaces specified for type}}
> +
> +  __attribute__((address_space(I))) int local;        // expected-error
> {{automatic variable qualified with an address space}}
> +  __attribute__((address_space(J))) int array[5];     // expected-error
> {{automatic variable qualified with an address space}}
> +  __attribute__((address_space(I))) int arrarr[5][5]; // expected-error
> {{automatic variable qualified with an address space}}
> +
> +  __attribute__((address_space(J))) * x; // expected-error {{C++ requires
> a type specifier for all declarations}}
> +
> +  __attribute__((address_space(I))) float *B;
> +
> +  typedef __attribute__((address_space(J))) int AS2Int;
> +  struct HasASFields {
> +    AS2Int typedef_as_field; // expected-error {{field may not be
> qualified with an address space}}
> +  };
> +
> +  struct _st {
> +    int x, y;
> +  } s __attribute((address_space(I))) = {1, 1};
> +}
> +
> +template <int I>
> +struct HasASTemplateFields {
> +  __attribute__((address_space(I))) int as_field; // expected-error
> {{field may not be qualified with an address space}}
> +};
> +
> +template <int I, int J>
> +void foo(__attribute__((address_space(I))) float *a, // expected-note
> {{candidate template ignored: substitution failure [with I = 1, J = 2]:
> parameter may not be qualified with an address space}}
> +         __attribute__((address_space(J))) float b) {
> +  *a = 5.0f + b;
> +}
> +
> +template void foo<1, 2>(float *, float); // expected-error {{explicit
> instantiation of 'foo' does not refer to a function template, variable
> template, member function, member class, or static data member}}
> +
> +template <int I>
> +void neg() {
> +  __attribute__((address_space(I))) int *bounds; // expected-error
> {{address space is negative}}
> +}
> +
> +template <long int I>
> +void toBig() {
> +  __attribute__((address_space(I))) int *bounds; // expected-error
> {{address space is larger than the maximum supported (8388599)}}
> +}
> +
> +template <long int I>
> +void correct() {
> +  __attribute__((address_space(I))) int *bounds;
> +}
> +
> +template <int I, int J>
> +char *cmp(__attribute__((address_space(I))) char *x,
> __attribute__((address_space(J))) char *y) {
> +  return x < y ? x : y; // expected-error {{comparison of distinct
> pointer types ('__attribute__((address_space(1))) char *' and
> '__attribute__((address_space(2))) char *')}}
> +}
> +
> +typedef void ft(void);
> +
> +template <int I>
> +struct fooFunction {
> +  __attribute__((address_space(I))) void **const base = 0;
> +
> +  void *get_0(void) {
> +    return base[0]; // expected-error {{cannot initialize return object
> of type 'void *' with an lvalue of type '__attribute__((address_space(1)))
> void *}}
> +  }
> +
> +  __attribute__((address_space(I))) ft qf; // expected-error {{function
> type may not be qualified with an address space}}
> +  __attribute__((address_space(I))) char *test3_val;
> +
> +  void test3(void) {
> +    extern void test3_helper(char *p); // expected-note {{passing
> argument to parameter 'p' here}}
> +    test3_helper(test3_val);           // expected-error {{cannot
> initialize a parameter of type 'char *' with an lvalue of type
> '__attribute__((address_space(1))) char *'}}
> +  }
> +};
> +
> +template <typename T, int N>
> +int GetAddressSpaceValue(T __attribute__((address_space(N))) * p) {
> +  return N;
> +}
> +
> +template <unsigned A> int __attribute__((address_space(A)))
> *same_template();
> +template <unsigned B> int __attribute__((address_space(B)))
> *same_template();
> +void test_same_template() { (void) same_template<0>(); }
> +
> +template <unsigned A> int __attribute__((address_space(A)))
> *different_template(); // expected-note {{candidate function [with A = 0]}}
> +template <unsigned B> int __attribute__((address_space(B+1)))
> *different_template(); // expected-note {{candidate function [with B = 0]}}
> +void test_different_template() { (void) different_template<0>(); } //
> expected-error {{call to 'different_template' is ambiguous}}
> +
> +template <typename T> struct partial_spec_deduce_as;
> +template <typename T, unsigned AS>
> +struct partial_spec_deduce_as <__attribute__((address_space(AS))) T *> {
> +   static const unsigned value = AS;
> +};
> +
> +int main() {
> +  int __attribute__((address_space(1))) * p1;
> +  int p = GetAddressSpaceValue(p1);
> +
> +  car<1, 2, 3>(); // expected-note {{in instantiation of function
> template specialization 'car<1, 2, 3>' requested here}}
> +  HasASTemplateFields<1> HASTF;
> +  neg<-1>(); // expected-note {{in instantiation of function template
> specialization 'neg<-1>' requested here}}
> +  correct<0x7FFFF7>();
> +  toBig<4294967500>(); // expected-note {{in instantiation of function
> template specialization 'toBig<4294967500>' requested here}}
>

It exceeds if long is 32-bit.
Reproducible with %clang_cc1 -triple i686-unknown-unknown


> +
> +  __attribute__((address_space(1))) char *x;
> +  __attribute__((address_space(2))) char *y;
> +  cmp<1, 2>(x, y); // expected-note {{in instantiation of function
> template specialization 'cmp<1, 2>' requested here}}
> +
> +  fooFunction<1> ff;
> +  ff.get_0(); // expected-note {{in instantiation of member function
> 'fooFunction<1>::get_0' requested here}}
> +  ff.qf();
> +  ff.test3(); // expected-note {{in instantiation of member function
> 'fooFunction<1>::test3' requested here}}
> +
> +  static_assert(partial_spec_deduce_as<int
> __attribute__((address_space(3))) *>::value == 3, "address space value has
> been incorrectly deduced");
> +
> +  return 0;
> +}
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20171002/2e83a0d6/attachment-0001.html>