test/OpenMP/target_teams_map_messages.cpp

   1 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 200 %s -Wno-openmp-target
   2
   3 // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 200 %s -Wno-openmp-target
   4 // RUN: %clang_cc1 -DCCODE -verify -fopenmp -ferror-limit 200 -x c %s -Wno-openmp-target
   5 #ifdef CCODE
   6 void foo(int arg) {
   7   const int n = 0;
   8
   9   double marr[10][10][10];
  10
  11   #pragma omp target teams map(marr[2][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
  12   {}
  13   #pragma omp target teams map(marr[:][0:][:])
  14   {}
  15   #pragma omp target teams map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}}
  16   {}
  17   #pragma omp target teams map(marr[:][n:][:])
  18   {}
  19 }
  20 #else
  21 template <typename T, int I>
  22 struct SA {
  23   static int ss;
  24   #pragma omp threadprivate(ss) // expected-note {{defined as threadprivate or thread local}}
  25   float a;
  26   int b[12];
  27   float *c;
  28   T d;
  29   float e[I];
  30   T *f;
  31   void func(int arg) {
  32     #pragma omp target teams map(arg,a,d)
  33     {}
  34     #pragma omp target teams map(arg[2:2],a,d) // expected-error {{subscripted value is not an array or pointer}}
  35     {}
  36     #pragma omp target teams map(arg,a*2) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
  37     {}
  38     #pragma omp target teams map(arg,(c+1)[2]) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
  39     {}
  40     #pragma omp target teams map(arg,a[:2],d) // expected-error {{subscripted value is not an array or pointer}}
  41     {}
  42     #pragma omp target teams map(arg,a,d[:2]) // expected-error {{subscripted value is not an array or pointer}}
  43     {}
  44
  45     #pragma omp target teams map(to:ss) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
  46     {}
  47
  48     #pragma omp target teams map(to:b,e)
  49     {}
  50     #pragma omp target teams map(to:b,e) map(to:b) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
  51     {}
  52     #pragma omp target teams map(to:b[:2],e)
  53     {}
  54     #pragma omp target teams map(to:b,e[:])
  55     {}
  56     #pragma omp target teams map(b[-1:]) // expected-error {{array section must be a subset of the original array}}
  57     {}
  58     #pragma omp target teams map(b[:-1]) // expected-error {{section length is evaluated to a negative value -1}}
  59     {}
  60
  61     #pragma omp target teams map(always, tofrom: c,f)
  62     {}
  63     #pragma omp target teams map(always, tofrom: c[1:2],f)
  64     {}
  65     #pragma omp target teams map(always, tofrom: c,f[1:2])
  66     {}
  67     #pragma omp target teams map(always, tofrom: c[:],f)   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
  68     {}
  69     #pragma omp target teams map(always, tofrom: c,f[:])   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
  70     {}
  71     return;
  72   }
  73 };
  74
  75 struct SB {
  76   unsigned A;
  77   unsigned B;
  78   float Arr[100];
  79   float *Ptr;
  80   float *foo() {
  81     return &Arr[0];
  82   }
  83 };
  84
  85 struct SC {
  86   unsigned A : 2;
  87   unsigned B : 3;
  88   unsigned C;
  89   unsigned D;
  90   float Arr[100];
  91   SB S;
  92   SB ArrS[100];
  93   SB *PtrS;
  94   SB *&RPtrS;
  95   float *Ptr;
  96
  97   SC(SB *&_RPtrS) : RPtrS(_RPtrS) {}
  98 };
  99
 100 union SD {
 101   unsigned A;
 102   float B;
 103 };
 104
 105 void SAclient(int arg) {
 106   SA<int,123> s;
 107   s.func(arg); // expected-note {{in instantiation of member function}}
 108   double marr[10][10][10];
 109   double marr2[5][10][1];
 110   double mvla[5][arg][10];
 111   double ***mptr;
 112   const int n = 0;
 113   const int m = 1;
 114   double mvla2[5][arg][m+n+10];
 115
 116   SB *p;
 117
 118   SD u;
 119   SC r(p),t(p);
 120   #pragma omp target teams map(r)
 121   {}
 122   #pragma omp target teams map(marr[2][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
 123   {}
 124   #pragma omp target teams map(marr[:][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
 125   {}
 126   #pragma omp target teams map(marr[2][3][0:2])
 127   {}
 128   #pragma omp target teams map(marr[:][:][:])
 129   {}
 130   #pragma omp target teams map(marr[:2][:][:])
 131   {}
 132   #pragma omp target teams map(marr[arg:][:][:])
 133   {}
 134   #pragma omp target teams map(marr[arg:])
 135   {}
 136   #pragma omp target teams map(marr[arg:][:arg][:]) // correct if arg is the size of dimension 2
 137   {}
 138   #pragma omp target teams map(marr[:arg][:])
 139   {}
 140   #pragma omp target teams map(marr[:arg][n:])
 141   {}
 142   #pragma omp target teams map(marr[:][:arg][n:]) // correct if arg is the size of  dimension 2
 143   {}
 144   #pragma omp target teams map(marr[:][:m][n:]) // expected-error {{array section does not specify contiguous storage}}
 145   {}
 146   #pragma omp target teams map(marr[n:m][:arg][n:])
 147   {}
 148   #pragma omp target teams map(marr[:2][:1][:]) // expected-error {{array section does not specify contiguous storage}}
 149   {}
 150   #pragma omp target teams map(marr[:2][1:][:]) // expected-error {{array section does not specify contiguous storage}}
 151   {}
 152   #pragma omp target teams map(marr[:2][:][:1]) // expected-error {{array section does not specify contiguous storage}}
 153   {}
 154   #pragma omp target teams map(marr[:2][:][1:]) // expected-error {{array section does not specify contiguous storage}}
 155   {}
 156   #pragma omp target teams map(marr[:1][:2][:])
 157   {}
 158   #pragma omp target teams map(marr[:1][0][:])
 159   {}
 160   #pragma omp target teams map(marr[:arg][:2][:]) // correct if arg is 1
 161   {}
 162   #pragma omp target teams map(marr[:1][3:1][:2])
 163   {}
 164   #pragma omp target teams map(marr[:1][3:arg][:2]) // correct if arg is 1
 165   {}
 166   #pragma omp target teams map(marr[:1][3:2][:2]) // expected-error {{array section does not specify contiguous storage}}
 167   {}
 168   #pragma omp target teams map(marr[:2][:10][:])
 169   {}
 170   #pragma omp target teams map(marr[:2][:][:5+5])
 171   {}
 172   #pragma omp target teams map(marr[:2][2+2-4:][0:5+5])
 173   {}
 174
 175   #pragma omp target teams map(marr[:1][:2][0]) // expected-error {{array section does not specify contiguous storage}}
 176   {}
 177   #pragma omp target teams map(marr2[:1][:2][0])
 178   {}
 179
 180   #pragma omp target teams map(mvla[:1][:][0]) // correct if the size of dimension 2 is 1.
 181   {}
 182   #pragma omp target teams map(mvla[:2][:arg][:]) // correct if arg is the size of dimension 2.
 183   {}
 184   #pragma omp target teams map(mvla[:1][:2][0]) // expected-error {{array section does not specify contiguous storage}}
 185    {}
 186   #pragma omp target teams map(mvla[1][2:arg][:])
 187   {}
 188   #pragma omp target teams map(mvla[:1][:][:])
 189   {}
 190   #pragma omp target teams map(mvla2[:1][:2][:11])
 191   {}
 192   #pragma omp target teams map(mvla2[:1][:2][:10]) // expected-error {{array section does not specify contiguous storage}}
 193   {}
 194
 195   #pragma omp target teams map(mptr[:2][2+2-4:1][0:5+5]) // expected-error {{array section does not specify contiguous storage}}
 196   {}
 197   #pragma omp target teams map(mptr[:1][:2-1][2:4-3])
 198   {}
 199   #pragma omp target teams map(mptr[:1][:arg][2:4-3]) // correct if arg is 1.
 200   {}
 201   #pragma omp target teams map(mptr[:1][:2-1][0:2])
 202   {}
 203   #pragma omp target teams map(mptr[:1][:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
 204   {}
 205   #pragma omp target teams map(mptr[:1][:][0:2]) // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
 206   {}
 207   #pragma omp target teams map(mptr[:2][:1][0:2]) // expected-error {{array section does not specify contiguous storage}}
 208   {}
 209
 210   #pragma omp target teams map(r.ArrS[0].B)
 211   {}
 212   #pragma omp target teams map(r.ArrS[:1].B) // expected-error {{OpenMP array section is not allowed here}}
 213   {}
 214   #pragma omp target teams map(r.ArrS[:arg].B) // expected-error {{OpenMP array section is not allowed here}}
 215   {}
 216   #pragma omp target teams map(r.ArrS[0].Arr[1:23])
 217   {}
 218   #pragma omp target teams map(r.ArrS[0].Arr[1:arg])
 219   {}
 220   #pragma omp target teams map(r.ArrS[0].Arr[arg:23])
 221   {}
 222   #pragma omp target teams map(r.ArrS[0].Error) // expected-error {{no member named 'Error' in 'SB'}}
 223   {}
 224   #pragma omp target teams map(r.ArrS[0].A, r.ArrS[1].A) // expected-error {{multiple array elements associated with the same variable are not allowed in map clauses of the same construct}} expected-note {{used here}}
 225   {}
 226   #pragma omp target teams map(r.ArrS[0].A, t.ArrS[1].A)
 227   {}
 228   #pragma omp target teams map(r.PtrS[0], r.PtrS->B) // expected-error {{same pointer dereferenced in multiple different ways in map clause expressions}} expected-note {{used here}}
 229   {}
 230   #pragma omp target teams map(r.PtrS, r.PtrS->B) // expected-error {{pointer cannot be mapped along with a section derived from itself}} expected-note {{used here}}
 231   {}
 232   #pragma omp target teams map(r.PtrS->A, r.PtrS->B)
 233   {}
 234   #pragma omp target teams map(r.RPtrS[0], r.RPtrS->B) // expected-error {{same pointer dereferenced in multiple different ways in map clause expressions}} expected-note {{used here}}
 235   {}
 236   #pragma omp target teams map(r.RPtrS, r.RPtrS->B) // expected-error {{pointer cannot be mapped along with a section derived from itself}} expected-note {{used here}}
 237   {}
 238   #pragma omp target teams map(r.RPtrS->A, r.RPtrS->B)
 239   {}
 240   #pragma omp target teams map(r.S.Arr[:12])
 241   {}
 242   #pragma omp target teams map(r.S.foo()[:12]) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
 243   {}
 244   #pragma omp target teams map(r.C, r.D)
 245   {}
 246   #pragma omp target teams map(r.C, r.C) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
 247   {}
 248   #pragma omp target teams map(r.C) map(r.C) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
 249   {}
 250   #pragma omp target teams map(r.C, r.S)  // this would be an error only caught at runtime - Sema would have to make sure there is not way for the missing data between fields to be mapped somewhere else.
 251   {}
 252   #pragma omp target teams map(r, r.S)  // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
 253   {}
 254   #pragma omp target teams map(r.C, t.C)
 255   {}
 256   #pragma omp target teams map(r.A)   // expected-error {{bit fields cannot be used to specify storage in a 'map' clause}}
 257   {}
 258   #pragma omp target teams map(r.Arr)
 259   {}
 260   #pragma omp target teams map(r.Arr[3:5])
 261   {}
 262   #pragma omp target teams map(r.Ptr[3:5])
 263   {}
 264   #pragma omp target teams map(r.ArrS[3:5].A)   // expected-error {{OpenMP array section is not allowed here}}
 265   {}
 266   #pragma omp target teams map(r.ArrS[3:5].Arr[6:7])   // expected-error {{OpenMP array section is not allowed here}}
 267   {}
 268   #pragma omp target teams map(r.ArrS[3].Arr[6:7])
 269   {}
 270   #pragma omp target teams map(r.S.Arr[4:5])
 271   {}
 272   #pragma omp target teams map(r.S.Ptr[4:5])
 273   {}
 274   #pragma omp target teams map(r.S.Ptr[:])  // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
 275   {}
 276   #pragma omp target teams map((p+1)->A)  // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
 277   {}
 278   #pragma omp target teams map(u.B)  // expected-error {{mapping of union members is not allowed}}
 279   {}
 280
 281   #pragma omp target data map(to: r.C) //expected-note {{used here}}
 282   {
 283     #pragma omp target teams map(r.D)  // expected-error {{original storage of expression in data environment is shared but data environment do not fully contain mapped expression storage}}
 284     {}
 285   }
 286
 287   #pragma omp target data map(to: t.Ptr) //expected-note {{used here}}
 288   {
 289     #pragma omp target teams map(t.Ptr[:23])  // expected-error {{pointer cannot be mapped along with a section derived from itself}}
 290     {}
 291   }
 292
 293   #pragma omp target data map(to: t.C, t.D)
 294   {
 295   #pragma omp target data map(to: t.C)
 296   {
 297     #pragma omp target teams map(t.D)
 298     {}
 299   }
 300   }
 301
 302   #pragma omp target data map(to: t)
 303   {
 304   #pragma omp target data map(to: t.C)
 305   {
 306     #pragma omp target teams map(t.D)
 307     {}
 308   }
 309   }
 310 }
 311 void foo() {
 312 }
 313
 314 bool foobool(int argc) {
 315   return argc;
 316 }
 317
 318 struct S1; // expected-note 2 {{declared here}}
 319 extern S1 a;
 320 class S2 {
 321   mutable int a;
 322 public:
 323   S2():a(0) { }
 324   S2(S2 &s2):a(s2.a) { }
 325   static float S2s;
 326   static const float S2sc;
 327 };
 328 const float S2::S2sc = 0;
 329 const S2 b;
 330 const S2 ba[5];
 331 class S3 {
 332   int a;
 333 public:
 334   S3():a(0) { }
 335   S3(S3 &s3):a(s3.a) { }
 336 };
 337 const S3 c;
 338 const S3 ca[5];
 339 extern const int f;
 340 class S4 {
 341   int a;
 342   S4();
 343   S4(const S4 &s4);
 344 public:
 345   S4(int v):a(v) { }
 346 };
 347 class S5 {
 348   int a;
 349   S5():a(0) {}
 350   S5(const S5 &s5):a(s5.a) { }
 351 public:
 352   S5(int v):a(v) { }
 353 };
 354
 355 template <class T>
 356 struct S6;
 357
 358 template<>
 359 struct S6<int>
 360 {
 361    virtual void foo();
 362 };
 363
 364 S3 h;
 365 #pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
 366
 367 typedef int from;
 368
 369 template <typename T, int I> // expected-note {{declared here}}
 370 T tmain(T argc) {
 371   const T d = 5;
 372   const T da[5] = { 0 };
 373   S4 e(4);
 374   S5 g(5);
 375   T i, t[20];
 376   T &j = i;
 377   T *k = &j;
 378   T x;
 379   T y;
 380   T to, tofrom, always;
 381   const T (&l)[5] = da;
 382 #pragma omp target teams map // expected-error {{expected '(' after 'map'}}
 383   {}
 384 #pragma omp target teams map( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}}
 385   {}
 386 #pragma omp target teams map() // expected-error {{expected expression}}
 387   {}
 388 #pragma omp target teams map(alloc) // expected-error {{use of undeclared identifier 'alloc'}}
 389   {}
 390 #pragma omp target teams map(to argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected ',' or ')' in 'map' clause}}
 391   {}
 392 #pragma omp target teams map(to:) // expected-error {{expected expression}}
 393   {}
 394 #pragma omp target teams map(from: argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
 395   {}
 396 #pragma omp target teams map(x: y) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
 397   {}
 398 #pragma omp target teams map(x)
 399   foo();
 400 #pragma omp target teams map(tofrom: t[:I])
 401   foo();
 402 #pragma omp target teams map(T: a) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}} expected-error {{incomplete type 'S1' where a complete type is required}}
 403   foo();
 404 #pragma omp target teams map(T) // expected-error {{'T' does not refer to a value}}
 405   foo();
 406 #pragma omp target teams map(I) // expected-error 2 {{expected expression containing only member accesses and/or array sections based on named variables}}
 407   foo();
 408 #pragma omp target teams map(S2::S2s)
 409   foo();
 410 #pragma omp target teams map(S2::S2sc)
 411   foo();
 412 #pragma omp target teams map(x)
 413   foo();
 414 #pragma omp target teams map(to: x)
 415   foo();
 416 #pragma omp target teams map(to: to)
 417   foo();
 418 #pragma omp target teams map(to)
 419   foo();
 420 #pragma omp target teams map(to, x)
 421   foo();
 422
 423 #pragma omp target data map(to x) // expected-error {{expected ',' or ')' in 'map' clause}}
 424 #pragma omp target data map(tofrom: argc > 0 ? x : y) // expected-error 2 {{expected expression containing only member accesses and/or array sections based on named variables}}
 425 #pragma omp target data map(argc)
 426 #pragma omp target data map(S1) // expected-error {{'S1' does not refer to a value}}
 427 #pragma omp target data map(a, b, c, d, f) // expected-error {{incomplete type 'S1' where a complete type is required}}
 428 #pragma omp target data map(ba)
 429 #pragma omp target data map(ca)
 430 #pragma omp target data map(da)
 431 #pragma omp target data map(S2::S2s)
 432 #pragma omp target data map(S2::S2sc)
 433 #pragma omp target data map(e, g)
 434 #pragma omp target data map(h) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
 435 #pragma omp target data map(k) map(k) // expected-error 2 {{variable already marked as mapped in current construct}} expected-note 2 {{used here}}
 436 #pragma omp target teams map(k), map(k[:5]) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}} expected-note 2 {{used here}}
 437   foo();
 438
 439 #pragma omp target data map(da)
 440 #pragma omp target teams map(da[:4])
 441   foo();
 442
 443 #pragma omp target data map(k, j, l) // expected-note 2 {{used here}}
 444 #pragma omp target data map(k[:4]) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}}
 445 #pragma omp target data map(j)
 446 #pragma omp target teams map(l) map(l[:5]) // expected-error 2 {{variable already marked as mapped in current construct}} expected-note 2 {{used here}}
 447   foo();
 448
 449 #pragma omp target data map(k[:4], j, l[:5]) // expected-note 2 {{used here}}
 450 #pragma omp target data map(k) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}}
 451 #pragma omp target data map(j)
 452 #pragma omp target teams map(l)
 453   foo();
 454
 455 #pragma omp target data map(always, tofrom: x)
 456 #pragma omp target data map(always: x) // expected-error {{missing map type}}
 457 #pragma omp target data map(tofrom, always: x) // expected-error {{incorrect map type modifier, expected 'always'}} expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
 458 #pragma omp target data map(always, tofrom: always, tofrom, x)
 459 #pragma omp target teams map(tofrom j) // expected-error {{expected ',' or ')' in 'map' clause}}
 460   foo();
 461   return 0;
 462 }
 463
 464 int main(int argc, char **argv) {
 465   const int d = 5;
 466   const int da[5] = { 0 };
 467   S4 e(4);
 468   S5 g(5);
 469   int i;
 470   int &j = i;
 471   int *k = &j;
 472   S6<int> m;
 473   int x;
 474   int y;
 475   int to, tofrom, always;
 476   const int (&l)[5] = da;
 477 #pragma omp target data map // expected-error {{expected '(' after 'map'}} expected-error {{expected at least one 'map' or 'use_device_ptr' clause for '#pragma omp target data'}}
 478 #pragma omp target data map( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}}
 479 #pragma omp target data map() // expected-error {{expected expression}}
 480 #pragma omp target data map(alloc) // expected-error {{use of undeclared identifier 'alloc'}}
 481 #pragma omp target data map(to argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected ',' or ')' in 'map' clause}}
 482 #pragma omp target data map(to:) // expected-error {{expected expression}}
 483 #pragma omp target data map(from: argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
 484 #pragma omp target data map(x: y) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
 485 #pragma omp target teams map(x)
 486   foo();
 487
 488 #pragma omp target teams map(to: x)
 489   foo();
 490 #pragma omp target teams map(to: to)
 491   foo();
 492 #pragma omp target teams map(to)
 493   foo();
 494 #pragma omp target teams map(to, x)
 495   foo();
 496
 497 #pragma omp target data map(to x) // expected-error {{expected ',' or ')' in 'map' clause}}
 498 #pragma omp target data map(tofrom: argc > 0 ? argv[1] : argv[2]) // expected-error {{xpected expression containing only member accesses and/or array sections based on named variables}}
 499 #pragma omp target data map(argc)
 500 #pragma omp target data map(S1) // expected-error {{'S1' does not refer to a value}}
 501 #pragma omp target data map(a, b, c, d, f) // expected-error {{incomplete type 'S1' where a complete type is required}}
 502 #pragma omp target data map(argv[1])
 503 #pragma omp target data map(ba)
 504 #pragma omp target data map(ca)
 505 #pragma omp target data map(da)
 506 #pragma omp target data map(S2::S2s)
 507 #pragma omp target data map(S2::S2sc)
 508 #pragma omp target data map(e, g)
 509 #pragma omp target data map(h) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
 510 #pragma omp target data map(k), map(k) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
 511 #pragma omp target teams map(k), map(k[:5]) // expected-error {{pointer cannot be mapped along with a section derived from itself}} expected-note {{used here}}
 512   foo();
 513
 514 #pragma omp target data map(da)
 515 #pragma omp target teams map(da[:4])
 516   foo();
 517
 518 #pragma omp target data map(k, j, l) // expected-note {{used here}}
 519 #pragma omp target data map(k[:4]) // expected-error {{pointer cannot be mapped along with a section derived from itself}}
 520 #pragma omp target data map(j)
 521 #pragma omp target teams map(l) map(l[:5]) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
 522   foo();
 523
 524 #pragma omp target data map(k[:4], j, l[:5]) // expected-note {{used here}}
 525 #pragma omp target data map(k) // expected-error {{pointer cannot be mapped along with a section derived from itself}}
 526 #pragma omp target data map(j)
 527 #pragma omp target teams map(l)
 528   foo();
 529
 530 #pragma omp target data map(always, tofrom: x)
 531 #pragma omp target data map(always: x) // expected-error {{missing map type}}
 532 #pragma omp target data map(tofrom, always: x) // expected-error {{incorrect map type modifier, expected 'always'}} expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
 533 #pragma omp target data map(always, tofrom: always, tofrom, x)
 534 #pragma omp target teams map(tofrom j) // expected-error {{expected ',' or ')' in 'map' clause}}
 535   foo();
 536
 537 #pragma omp target teams private(j) map(j) // expected-error {{private variable cannot be in a map clause in '#pragma omp target teams' directive}}  expected-note {{defined as private}}
 538   {}
 539
 540 #pragma omp target teams firstprivate(j) map(j)  // expected-error {{firstprivate variable cannot be in a map clause in '#pragma omp target teams' directive}} expected-note {{defined as firstprivate}}
 541   {}
 542
 543 #pragma omp target teams map(m)
 544   {}
 545
 546   return tmain<int, 3>(argc)+tmain<from, 4>(argc); // expected-note {{in instantiation of function template specialization 'tmain<int, 3>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<int, 4>' requested here}}
 547 }
 548 #endif