gcc/c-family/c-omp.c

   1 /* This file contains routines to construct GNU OpenMP constructs,
   2    called from parsing in the C and C++ front ends.
   3
   4    Copyright (C) 2005-2014 Free Software Foundation, Inc.
   5    Contributed by Richard Henderson <rth@redhat.com>,
   6                   Diego Novillo <dnovillo@redhat.com>.
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 3, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tree.h"
  28 #include "c-common.h"
  29 #include "c-pragma.h"
  30 #include "gimple-expr.h"
  31 #include "langhooks.h"
  32
  33
  34 /* Complete a #pragma omp master construct.  STMT is the structured-block
  35    that follows the pragma.  LOC is the l*/
  36
  37 tree
  38 c_finish_omp_master (location_t loc, tree stmt)
  39 {
  40   tree t = add_stmt (build1 (OMP_MASTER, void_type_node, stmt));
  41   SET_EXPR_LOCATION (t, loc);
  42   return t;
  43 }
  44
  45 /* Complete a #pragma omp taskgroup construct.  STMT is the structured-block
  46    that follows the pragma.  LOC is the l*/
  47
  48 tree
  49 c_finish_omp_taskgroup (location_t loc, tree stmt)
  50 {
  51   tree t = add_stmt (build1 (OMP_TASKGROUP, void_type_node, stmt));
  52   SET_EXPR_LOCATION (t, loc);
  53   return t;
  54 }
  55
  56 /* Complete a #pragma omp critical construct.  STMT is the structured-block
  57    that follows the pragma, NAME is the identifier in the pragma, or null
  58    if it was omitted.  LOC is the location of the #pragma.  */
  59
  60 tree
  61 c_finish_omp_critical (location_t loc, tree body, tree name)
  62 {
  63   tree stmt = make_node (OMP_CRITICAL);
  64   TREE_TYPE (stmt) = void_type_node;
  65   OMP_CRITICAL_BODY (stmt) = body;
  66   OMP_CRITICAL_NAME (stmt) = name;
  67   SET_EXPR_LOCATION (stmt, loc);
  68   return add_stmt (stmt);
  69 }
  70
  71 /* Complete a #pragma omp ordered construct.  STMT is the structured-block
  72    that follows the pragma.  LOC is the location of the #pragma.  */
  73
  74 tree
  75 c_finish_omp_ordered (location_t loc, tree stmt)
  76 {
  77   tree t = build1 (OMP_ORDERED, void_type_node, stmt);
  78   SET_EXPR_LOCATION (t, loc);
  79   return add_stmt (t);
  80 }
  81
  82
  83 /* Complete a #pragma omp barrier construct.  LOC is the location of
  84    the #pragma.  */
  85
  86 void
  87 c_finish_omp_barrier (location_t loc)
  88 {
  89   tree x;
  90
  91   x = builtin_decl_explicit (BUILT_IN_GOMP_BARRIER);
  92   x = build_call_expr_loc (loc, x, 0);
  93   add_stmt (x);
  94 }
  95
  96
  97 /* Complete a #pragma omp taskwait construct.  LOC is the location of the
  98    pragma.  */
  99
 100 void
 101 c_finish_omp_taskwait (location_t loc)
 102 {
 103   tree x;
 104
 105   x = builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT);
 106   x = build_call_expr_loc (loc, x, 0);
 107   add_stmt (x);
 108 }
 109
 110
 111 /* Complete a #pragma omp taskyield construct.  LOC is the location of the
 112    pragma.  */
 113
 114 void
 115 c_finish_omp_taskyield (location_t loc)
 116 {
 117   tree x;
 118
 119   x = builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD);
 120   x = build_call_expr_loc (loc, x, 0);
 121   add_stmt (x);
 122 }
 123
 124
 125 /* Complete a #pragma omp atomic construct.  For CODE OMP_ATOMIC
 126    the expression to be implemented atomically is LHS opcode= RHS.
 127    For OMP_ATOMIC_READ V = LHS, for OMP_ATOMIC_CAPTURE_{NEW,OLD} LHS
 128    opcode= RHS with the new or old content of LHS returned.
 129    LOC is the location of the atomic statement.  The value returned
 130    is either error_mark_node (if the construct was erroneous) or an
 131    OMP_ATOMIC* node which should be added to the current statement
 132    tree with add_stmt.  */
 133
 134 tree
 135 c_finish_omp_atomic (location_t loc, enum tree_code code,
 136                      enum tree_code opcode, tree lhs, tree rhs,
 137                      tree v, tree lhs1, tree rhs1, bool swapped, bool seq_cst)
 138 {
 139   tree x, type, addr, pre = NULL_TREE;
 140
 141   if (lhs == error_mark_node || rhs == error_mark_node
 142       || v == error_mark_node || lhs1 == error_mark_node
 143       || rhs1 == error_mark_node)
 144     return error_mark_node;
 145
 146   /* ??? According to one reading of the OpenMP spec, complex type are
 147      supported, but there are no atomic stores for any architecture.
 148      But at least icc 9.0 doesn't support complex types here either.
 149      And lets not even talk about vector types...  */
 150   type = TREE_TYPE (lhs);
 151   if (!INTEGRAL_TYPE_P (type)
 152       && !POINTER_TYPE_P (type)
 153       && !SCALAR_FLOAT_TYPE_P (type))
 154     {
 155       error_at (loc, "invalid expression type for %<#pragma omp atomic%>");
 156       return error_mark_node;
 157     }
 158
 159   /* ??? Validate that rhs does not overlap lhs.  */
 160
 161   /* Take and save the address of the lhs.  From then on we'll reference it
 162      via indirection.  */
 163   addr = build_unary_op (loc, ADDR_EXPR, lhs, 0);
 164   if (addr == error_mark_node)
 165     return error_mark_node;
 166   addr = save_expr (addr);
 167   if (TREE_CODE (addr) != SAVE_EXPR
 168       && (TREE_CODE (addr) != ADDR_EXPR
 169           || TREE_CODE (TREE_OPERAND (addr, 0)) != VAR_DECL))
 170     {
 171       /* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize
 172          it even after unsharing function body.  */
 173       tree var = create_tmp_var_raw (TREE_TYPE (addr), NULL);
 174       DECL_CONTEXT (var) = current_function_decl;
 175       addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL);
 176     }
 177   lhs = build_indirect_ref (loc, addr, RO_NULL);
 178
 179   if (code == OMP_ATOMIC_READ)
 180     {
 181       x = build1 (OMP_ATOMIC_READ, type, addr);
 182       SET_EXPR_LOCATION (x, loc);
 183       OMP_ATOMIC_SEQ_CST (x) = seq_cst;
 184       return build_modify_expr (loc, v, NULL_TREE, NOP_EXPR,
 185                                 loc, x, NULL_TREE);
 186     }
 187
 188   /* There are lots of warnings, errors, and conversions that need to happen
 189      in the course of interpreting a statement.  Use the normal mechanisms
 190      to do this, and then take it apart again.  */
 191   if (swapped)
 192     {
 193       rhs = build2_loc (loc, opcode, TREE_TYPE (lhs), rhs, lhs);
 194       opcode = NOP_EXPR;
 195     }
 196   bool save = in_late_binary_op;
 197   in_late_binary_op = true;
 198   x = build_modify_expr (loc, lhs, NULL_TREE, opcode, loc, rhs, NULL_TREE);
 199   in_late_binary_op = save;
 200   if (x == error_mark_node)
 201     return error_mark_node;
 202   if (TREE_CODE (x) == COMPOUND_EXPR)
 203     {
 204       pre = TREE_OPERAND (x, 0);
 205       gcc_assert (TREE_CODE (pre) == SAVE_EXPR);
 206       x = TREE_OPERAND (x, 1);
 207     }
 208   gcc_assert (TREE_CODE (x) == MODIFY_EXPR);
 209   rhs = TREE_OPERAND (x, 1);
 210
 211   /* Punt the actual generation of atomic operations to common code.  */
 212   if (code == OMP_ATOMIC)
 213     type = void_type_node;
 214   x = build2 (code, type, addr, rhs);
 215   SET_EXPR_LOCATION (x, loc);
 216   OMP_ATOMIC_SEQ_CST (x) = seq_cst;
 217
 218   /* Generally it is hard to prove lhs1 and lhs are the same memory
 219      location, just diagnose different variables.  */
 220   if (rhs1
 221       && TREE_CODE (rhs1) == VAR_DECL
 222       && TREE_CODE (lhs) == VAR_DECL
 223       && rhs1 != lhs)
 224     {
 225       if (code == OMP_ATOMIC)
 226         error_at (loc, "%<#pragma omp atomic update%> uses two different variables for memory");
 227       else
 228         error_at (loc, "%<#pragma omp atomic capture%> uses two different variables for memory");
 229       return error_mark_node;
 230     }
 231
 232   if (code != OMP_ATOMIC)
 233     {
 234       /* Generally it is hard to prove lhs1 and lhs are the same memory
 235          location, just diagnose different variables.  */
 236       if (lhs1 && TREE_CODE (lhs1) == VAR_DECL && TREE_CODE (lhs) == VAR_DECL)
 237         {
 238           if (lhs1 != lhs)
 239             {
 240               error_at (loc, "%<#pragma omp atomic capture%> uses two different variables for memory");
 241               return error_mark_node;
 242             }
 243         }
 244       x = build_modify_expr (loc, v, NULL_TREE, NOP_EXPR,
 245                              loc, x, NULL_TREE);
 246       if (rhs1 && rhs1 != lhs)
 247         {
 248           tree rhs1addr = build_unary_op (loc, ADDR_EXPR, rhs1, 0);
 249           if (rhs1addr == error_mark_node)
 250             return error_mark_node;
 251           x = omit_one_operand_loc (loc, type, x, rhs1addr);
 252         }
 253       if (lhs1 && lhs1 != lhs)
 254         {
 255           tree lhs1addr = build_unary_op (loc, ADDR_EXPR, lhs1, 0);
 256           if (lhs1addr == error_mark_node)
 257             return error_mark_node;
 258           if (code == OMP_ATOMIC_CAPTURE_OLD)
 259             x = omit_one_operand_loc (loc, type, x, lhs1addr);
 260           else
 261             {
 262               x = save_expr (x);
 263               x = omit_two_operands_loc (loc, type, x, x, lhs1addr);
 264             }
 265         }
 266     }
 267   else if (rhs1 && rhs1 != lhs)
 268     {
 269       tree rhs1addr = build_unary_op (loc, ADDR_EXPR, rhs1, 0);
 270       if (rhs1addr == error_mark_node)
 271         return error_mark_node;
 272       x = omit_one_operand_loc (loc, type, x, rhs1addr);
 273     }
 274
 275   if (pre)
 276     x = omit_one_operand_loc (loc, type, x, pre);
 277   return x;
 278 }
 279
 280
 281 /* Complete a #pragma omp flush construct.  We don't do anything with
 282    the variable list that the syntax allows.  LOC is the location of
 283    the #pragma.  */
 284
 285 void
 286 c_finish_omp_flush (location_t loc)
 287 {
 288   tree x;
 289
 290   x = builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE);
 291   x = build_call_expr_loc (loc, x, 0);
 292   add_stmt (x);
 293 }
 294
 295
 296 /* Check and canonicalize #pragma omp for increment expression.
 297    Helper function for c_finish_omp_for.  */
 298
 299 static tree
 300 check_omp_for_incr_expr (location_t loc, tree exp, tree decl)
 301 {
 302   tree t;
 303
 304   if (!INTEGRAL_TYPE_P (TREE_TYPE (exp))
 305       || TYPE_PRECISION (TREE_TYPE (exp)) < TYPE_PRECISION (TREE_TYPE (decl)))
 306     return error_mark_node;
 307
 308   if (exp == decl)
 309     return build_int_cst (TREE_TYPE (exp), 0);
 310
 311   switch (TREE_CODE (exp))
 312     {
 313     CASE_CONVERT:
 314       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
 315       if (t != error_mark_node)
 316         return fold_convert_loc (loc, TREE_TYPE (exp), t);
 317       break;
 318     case MINUS_EXPR:
 319       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
 320       if (t != error_mark_node)
 321         return fold_build2_loc (loc, MINUS_EXPR,
 322                             TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
 323       break;
 324     case PLUS_EXPR:
 325       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
 326       if (t != error_mark_node)
 327         return fold_build2_loc (loc, PLUS_EXPR,
 328                             TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
 329       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 1), decl);
 330       if (t != error_mark_node)
 331         return fold_build2_loc (loc, PLUS_EXPR,
 332                             TREE_TYPE (exp), TREE_OPERAND (exp, 0), t);
 333       break;
 334     case COMPOUND_EXPR:
 335       {
 336         /* cp_build_modify_expr forces preevaluation of the RHS to make
 337            sure that it is evaluated before the lvalue-rvalue conversion
 338            is applied to the LHS.  Reconstruct the original expression.  */
 339         tree op0 = TREE_OPERAND (exp, 0);
 340         if (TREE_CODE (op0) == TARGET_EXPR
 341             && !VOID_TYPE_P (TREE_TYPE (op0)))
 342           {
 343             tree op1 = TREE_OPERAND (exp, 1);
 344             tree temp = TARGET_EXPR_SLOT (op0);
 345             if (TREE_CODE_CLASS (TREE_CODE (op1)) == tcc_binary
 346                 && TREE_OPERAND (op1, 1) == temp)
 347               {
 348                 op1 = copy_node (op1);
 349                 TREE_OPERAND (op1, 1) = TARGET_EXPR_INITIAL (op0);
 350                 return check_omp_for_incr_expr (loc, op1, decl);
 351               }
 352           }
 353         break;
 354       }
 355     default:
 356       break;
 357     }
 358
 359   return error_mark_node;
 360 }
 361
 362 /* If the OMP_FOR increment expression in INCR is of pointer type,
 363    canonicalize it into an expression handled by gimplify_omp_for()
 364    and return it.  DECL is the iteration variable.  */
 365
 366 static tree
 367 c_omp_for_incr_canonicalize_ptr (location_t loc, tree decl, tree incr)
 368 {
 369   if (POINTER_TYPE_P (TREE_TYPE (decl))
 370       && TREE_OPERAND (incr, 1))
 371     {
 372       tree t = fold_convert_loc (loc,
 373                                  sizetype, TREE_OPERAND (incr, 1));
 374
 375       if (TREE_CODE (incr) == POSTDECREMENT_EXPR
 376           || TREE_CODE (incr) == PREDECREMENT_EXPR)
 377         t = fold_build1_loc (loc, NEGATE_EXPR, sizetype, t);
 378       t = fold_build_pointer_plus (decl, t);
 379       incr = build2 (MODIFY_EXPR, void_type_node, decl, t);
 380     }
 381   return incr;
 382 }
 383
 384 /* Validate and emit code for the OpenMP directive #pragma omp for.
 385    DECLV is a vector of iteration variables, for each collapsed loop.
 386    INITV, CONDV and INCRV are vectors containing initialization
 387    expressions, controlling predicates and increment expressions.
 388    BODY is the body of the loop and PRE_BODY statements that go before
 389    the loop.  */
 390
 391 tree
 392 c_finish_omp_for (location_t locus, enum tree_code code, tree declv,
 393                   tree initv, tree condv, tree incrv, tree body, tree pre_body)
 394 {
 395   location_t elocus;
 396   bool fail = false;
 397   int i;
 398
 399   if (code == CILK_SIMD
 400       && !c_check_cilk_loop (locus, TREE_VEC_ELT (declv, 0)))
 401     fail = true;
 402
 403   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (initv));
 404   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (condv));
 405   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (incrv));
 406   for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
 407     {
 408       tree decl = TREE_VEC_ELT (declv, i);
 409       tree init = TREE_VEC_ELT (initv, i);
 410       tree cond = TREE_VEC_ELT (condv, i);
 411       tree incr = TREE_VEC_ELT (incrv, i);
 412
 413       elocus = locus;
 414       if (EXPR_HAS_LOCATION (init))
 415         elocus = EXPR_LOCATION (init);
 416
 417       /* Validate the iteration variable.  */
 418       if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))
 419           && TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE)
 420         {
 421           error_at (elocus, "invalid type for iteration variable %qE", decl);
 422           fail = true;
 423         }
 424
 425       /* In the case of "for (int i = 0...)", init will be a decl.  It should
 426          have a DECL_INITIAL that we can turn into an assignment.  */
 427       if (init == decl)
 428         {
 429           elocus = DECL_SOURCE_LOCATION (decl);
 430
 431           init = DECL_INITIAL (decl);
 432           if (init == NULL)
 433             {
 434               error_at (elocus, "%qE is not initialized", decl);
 435               init = integer_zero_node;
 436               fail = true;
 437             }
 438
 439           init = build_modify_expr (elocus, decl, NULL_TREE, NOP_EXPR,
 440                                     /* FIXME diagnostics: This should
 441                                        be the location of the INIT.  */
 442                                     elocus,
 443                                     init,
 444                                     NULL_TREE);
 445         }
 446       if (init != error_mark_node)
 447         {
 448           gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
 449           gcc_assert (TREE_OPERAND (init, 0) == decl);
 450         }
 451
 452       if (cond == NULL_TREE)
 453         {
 454           error_at (elocus, "missing controlling predicate");
 455           fail = true;
 456         }
 457       else
 458         {
 459           bool cond_ok = false;
 460
 461           if (EXPR_HAS_LOCATION (cond))
 462             elocus = EXPR_LOCATION (cond);
 463
 464           if (TREE_CODE (cond) == LT_EXPR
 465               || TREE_CODE (cond) == LE_EXPR
 466               || TREE_CODE (cond) == GT_EXPR
 467               || TREE_CODE (cond) == GE_EXPR
 468               || TREE_CODE (cond) == NE_EXPR
 469               || TREE_CODE (cond) == EQ_EXPR)
 470             {
 471               tree op0 = TREE_OPERAND (cond, 0);
 472               tree op1 = TREE_OPERAND (cond, 1);
 473
 474               /* 2.5.1.  The comparison in the condition is computed in
 475                  the type of DECL, otherwise the behavior is undefined.
 476
 477                  For example:
 478                  long n; int i;
 479                  i < n;
 480
 481                  according to ISO will be evaluated as:
 482                  (long)i < n;
 483
 484                  We want to force:
 485                  i < (int)n;  */
 486               if (TREE_CODE (op0) == NOP_EXPR
 487                   && decl == TREE_OPERAND (op0, 0))
 488                 {
 489                   TREE_OPERAND (cond, 0) = TREE_OPERAND (op0, 0);
 490                   TREE_OPERAND (cond, 1)
 491                     = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
 492                                    TREE_OPERAND (cond, 1));
 493                 }
 494               else if (TREE_CODE (op1) == NOP_EXPR
 495                        && decl == TREE_OPERAND (op1, 0))
 496                 {
 497                   TREE_OPERAND (cond, 1) = TREE_OPERAND (op1, 0);
 498                   TREE_OPERAND (cond, 0)
 499                     = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
 500                                    TREE_OPERAND (cond, 0));
 501                 }
 502
 503               if (decl == TREE_OPERAND (cond, 0))
 504                 cond_ok = true;
 505               else if (decl == TREE_OPERAND (cond, 1))
 506                 {
 507                   TREE_SET_CODE (cond,
 508                                  swap_tree_comparison (TREE_CODE (cond)));
 509                   TREE_OPERAND (cond, 1) = TREE_OPERAND (cond, 0);
 510                   TREE_OPERAND (cond, 0) = decl;
 511                   cond_ok = true;
 512                 }
 513
 514               if (TREE_CODE (cond) == NE_EXPR
 515                   || TREE_CODE (cond) == EQ_EXPR)
 516                 {
 517                   if (!INTEGRAL_TYPE_P (TREE_TYPE (decl)))
 518                     cond_ok = false;
 519                   else if (operand_equal_p (TREE_OPERAND (cond, 1),
 520                                             TYPE_MIN_VALUE (TREE_TYPE (decl)),
 521                                             0))
 522                     TREE_SET_CODE (cond, TREE_CODE (cond) == NE_EXPR
 523                                          ? GT_EXPR : LE_EXPR);
 524                   else if (operand_equal_p (TREE_OPERAND (cond, 1),
 525                                             TYPE_MAX_VALUE (TREE_TYPE (decl)),
 526                                             0))
 527                     TREE_SET_CODE (cond, TREE_CODE (cond) == NE_EXPR
 528                                          ? LT_EXPR : GE_EXPR);
 529                   else if (code != CILK_SIMD)
 530                     cond_ok = false;
 531                 }
 532             }
 533
 534           if (!cond_ok)
 535             {
 536               error_at (elocus, "invalid controlling predicate");
 537               fail = true;
 538             }
 539         }
 540
 541       if (incr == NULL_TREE)
 542         {
 543           error_at (elocus, "missing increment expression");
 544           fail = true;
 545         }
 546       else
 547         {
 548           bool incr_ok = false;
 549
 550           if (EXPR_HAS_LOCATION (incr))
 551             elocus = EXPR_LOCATION (incr);
 552
 553           /* Check all the valid increment expressions: v++, v--, ++v, --v,
 554              v = v + incr, v = incr + v and v = v - incr.  */
 555           switch (TREE_CODE (incr))
 556             {
 557             case POSTINCREMENT_EXPR:
 558             case PREINCREMENT_EXPR:
 559             case POSTDECREMENT_EXPR:
 560             case PREDECREMENT_EXPR:
 561               if (TREE_OPERAND (incr, 0) != decl)
 562                 break;
 563
 564               incr_ok = true;
 565               incr = c_omp_for_incr_canonicalize_ptr (elocus, decl, incr);
 566               break;
 567
 568             case COMPOUND_EXPR:
 569               if (TREE_CODE (TREE_OPERAND (incr, 0)) != SAVE_EXPR
 570                   || TREE_CODE (TREE_OPERAND (incr, 1)) != MODIFY_EXPR)
 571                 break;
 572               incr = TREE_OPERAND (incr, 1);
 573               /* FALLTHRU */
 574             case MODIFY_EXPR:
 575               if (TREE_OPERAND (incr, 0) != decl)
 576                 break;
 577               if (TREE_OPERAND (incr, 1) == decl)
 578                 break;
 579               if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
 580                   && (TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl
 581                       || TREE_OPERAND (TREE_OPERAND (incr, 1), 1) == decl))
 582                 incr_ok = true;
 583               else if ((TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR
 584                         || (TREE_CODE (TREE_OPERAND (incr, 1))
 585                             == POINTER_PLUS_EXPR))
 586                        && TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl)
 587                 incr_ok = true;
 588               else
 589                 {
 590                   tree t = check_omp_for_incr_expr (elocus,
 591                                                     TREE_OPERAND (incr, 1),
 592                                                     decl);
 593                   if (t != error_mark_node)
 594                     {
 595                       incr_ok = true;
 596                       t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
 597                       incr = build2 (MODIFY_EXPR, void_type_node, decl, t);
 598                     }
 599                 }
 600               break;
 601
 602             default:
 603               break;
 604             }
 605           if (!incr_ok)
 606             {
 607               error_at (elocus, "invalid increment expression");
 608               fail = true;
 609             }
 610         }
 611
 612       TREE_VEC_ELT (initv, i) = init;
 613       TREE_VEC_ELT (incrv, i) = incr;
 614     }
 615
 616   if (fail)
 617     return NULL;
 618   else
 619     {
 620       tree t = make_node (code);
 621
 622       TREE_TYPE (t) = void_type_node;
 623       OMP_FOR_INIT (t) = initv;
 624       OMP_FOR_COND (t) = condv;
 625       OMP_FOR_INCR (t) = incrv;
 626       OMP_FOR_BODY (t) = body;
 627       OMP_FOR_PRE_BODY (t) = pre_body;
 628
 629       SET_EXPR_LOCATION (t, locus);
 630       return add_stmt (t);
 631     }
 632 }
 633
 634 /* Right now we have 14 different combined constructs, this
 635    function attempts to split or duplicate clauses for combined
 636    constructs.  CODE is the innermost construct in the combined construct,
 637    and MASK allows to determine which constructs are combined together,
 638    as every construct has at least one clause that no other construct
 639    has (except for OMP_SECTIONS, but that can be only combined with parallel).
 640    Combined constructs are:
 641    #pragma omp parallel for
 642    #pragma omp parallel sections
 643    #pragma omp parallel for simd
 644    #pragma omp for simd
 645    #pragma omp distribute simd
 646    #pragma omp distribute parallel for
 647    #pragma omp distribute parallel for simd
 648    #pragma omp teams distribute
 649    #pragma omp teams distribute parallel for
 650    #pragma omp teams distribute parallel for simd
 651    #pragma omp target teams
 652    #pragma omp target teams distribute
 653    #pragma omp target teams distribute parallel for
 654    #pragma omp target teams distribute parallel for simd  */
 655
 656 void
 657 c_omp_split_clauses (location_t loc, enum tree_code code,
 658                      omp_clause_mask mask, tree clauses, tree *cclauses)
 659 {
 660   tree next, c;
 661   enum c_omp_clause_split s;
 662   int i;
 663
 664   for (i = 0; i < C_OMP_CLAUSE_SPLIT_COUNT; i++)
 665     cclauses[i] = NULL;
 666   /* Add implicit nowait clause on
 667      #pragma omp parallel {for,for simd,sections}.  */
 668   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
 669     switch (code)
 670       {
 671       case OMP_FOR:
 672       case OMP_SIMD:
 673         cclauses[C_OMP_CLAUSE_SPLIT_FOR]
 674           = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
 675         break;
 676       case OMP_SECTIONS:
 677         cclauses[C_OMP_CLAUSE_SPLIT_SECTIONS]
 678           = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
 679         break;
 680       default:
 681         break;
 682       }
 683
 684   for (; clauses ; clauses = next)
 685     {
 686       next = OMP_CLAUSE_CHAIN (clauses);
 687
 688       switch (OMP_CLAUSE_CODE (clauses))
 689         {
 690         /* First the clauses that are unique to some constructs.  */
 691         case OMP_CLAUSE_DEVICE:
 692         case OMP_CLAUSE_MAP:
 693           s = C_OMP_CLAUSE_SPLIT_TARGET;
 694           break;
 695         case OMP_CLAUSE_NUM_TEAMS:
 696         case OMP_CLAUSE_THREAD_LIMIT:
 697           s = C_OMP_CLAUSE_SPLIT_TEAMS;
 698           break;
 699         case OMP_CLAUSE_DIST_SCHEDULE:
 700           s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
 701           break;
 702         case OMP_CLAUSE_COPYIN:
 703         case OMP_CLAUSE_NUM_THREADS:
 704         case OMP_CLAUSE_PROC_BIND:
 705           s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 706           break;
 707         case OMP_CLAUSE_ORDERED:
 708         case OMP_CLAUSE_SCHEDULE:
 709         case OMP_CLAUSE_NOWAIT:
 710           s = C_OMP_CLAUSE_SPLIT_FOR;
 711           break;
 712         case OMP_CLAUSE_SAFELEN:
 713         case OMP_CLAUSE_LINEAR:
 714         case OMP_CLAUSE_ALIGNED:
 715           s = C_OMP_CLAUSE_SPLIT_SIMD;
 716           break;
 717         /* Duplicate this to all of distribute, for and simd.  */
 718         case OMP_CLAUSE_COLLAPSE:
 719           if (code == OMP_SIMD)
 720             {
 721               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 722                                     OMP_CLAUSE_COLLAPSE);
 723               OMP_CLAUSE_COLLAPSE_EXPR (c)
 724                 = OMP_CLAUSE_COLLAPSE_EXPR (clauses);
 725               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
 726               cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
 727             }
 728           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
 729             {
 730               if ((mask & (OMP_CLAUSE_MASK_1
 731                            << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
 732                 {
 733                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 734                                         OMP_CLAUSE_COLLAPSE);
 735                   OMP_CLAUSE_COLLAPSE_EXPR (c)
 736                     = OMP_CLAUSE_COLLAPSE_EXPR (clauses);
 737                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
 738                   cclauses[C_OMP_CLAUSE_SPLIT_FOR] = c;
 739                   s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
 740                 }
 741               else
 742                 s = C_OMP_CLAUSE_SPLIT_FOR;
 743             }
 744           else
 745             s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
 746           break;
 747         /* Private clause is supported on all constructs but target,
 748            it is enough to put it on the innermost one.  For
 749            #pragma omp {for,sections} put it on parallel though,
 750            as that's what we did for OpenMP 3.1.  */
 751         case OMP_CLAUSE_PRIVATE:
 752           switch (code)
 753             {
 754             case OMP_SIMD: s = C_OMP_CLAUSE_SPLIT_SIMD; break;
 755             case OMP_FOR: case OMP_SECTIONS:
 756             case OMP_PARALLEL: s = C_OMP_CLAUSE_SPLIT_PARALLEL; break;
 757             case OMP_DISTRIBUTE: s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE; break;
 758             case OMP_TEAMS: s = C_OMP_CLAUSE_SPLIT_TEAMS; break;
 759             default: gcc_unreachable ();
 760             }
 761           break;
 762         /* Firstprivate clause is supported on all constructs but
 763            target and simd.  Put it on the outermost of those and
 764            duplicate on parallel.  */
 765         case OMP_CLAUSE_FIRSTPRIVATE:
 766           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 767               != 0)
 768             {
 769               if ((mask & ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS)
 770                            | (OMP_CLAUSE_MASK_1
 771                               << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE))) != 0)
 772                 {
 773                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 774                                         OMP_CLAUSE_FIRSTPRIVATE);
 775                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
 776                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
 777                   cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] = c;
 778                   if ((mask & (OMP_CLAUSE_MASK_1
 779                                << PRAGMA_OMP_CLAUSE_NUM_TEAMS)) != 0)
 780                     s = C_OMP_CLAUSE_SPLIT_TEAMS;
 781                   else
 782                     s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
 783                 }
 784               else
 785                 /* This must be
 786                    #pragma omp parallel{, for{, simd}, sections}.  */
 787                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 788             }
 789           else if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
 790                    != 0)
 791             {
 792               /* This must be #pragma omp {,target }teams distribute.  */
 793               gcc_assert (code == OMP_DISTRIBUTE);
 794               s = C_OMP_CLAUSE_SPLIT_TEAMS;
 795             }
 796           else if ((mask & (OMP_CLAUSE_MASK_1
 797                             << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
 798             {
 799               /* This must be #pragma omp distribute simd.  */
 800               gcc_assert (code == OMP_SIMD);
 801               s = C_OMP_CLAUSE_SPLIT_TEAMS;
 802             }
 803           else
 804             {
 805               /* This must be #pragma omp for simd.  */
 806               gcc_assert (code == OMP_SIMD);
 807               s = C_OMP_CLAUSE_SPLIT_FOR;
 808             }
 809           break;
 810         /* Lastprivate is allowed on for, sections and simd.  In
 811            parallel {for{, simd},sections} we actually want to put it on
 812            parallel rather than for or sections.  */
 813         case OMP_CLAUSE_LASTPRIVATE:
 814           if (code == OMP_FOR || code == OMP_SECTIONS)
 815             {
 816               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 817                   != 0)
 818                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 819               else
 820                 s = C_OMP_CLAUSE_SPLIT_FOR;
 821               break;
 822             }
 823           gcc_assert (code == OMP_SIMD);
 824           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
 825             {
 826               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 827                                     OMP_CLAUSE_LASTPRIVATE);
 828               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
 829               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 830                   != 0)
 831                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 832               else
 833                 s = C_OMP_CLAUSE_SPLIT_FOR;
 834               OMP_CLAUSE_CHAIN (c) = cclauses[s];
 835               cclauses[s] = c;
 836             }
 837           s = C_OMP_CLAUSE_SPLIT_SIMD;
 838           break;
 839         /* Shared and default clauses are allowed on private and teams.  */
 840         case OMP_CLAUSE_SHARED:
 841         case OMP_CLAUSE_DEFAULT:
 842           if (code == OMP_TEAMS)
 843             {
 844               s = C_OMP_CLAUSE_SPLIT_TEAMS;
 845               break;
 846             }
 847           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
 848               != 0)
 849             {
 850               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 851                                     OMP_CLAUSE_CODE (clauses));
 852               if (OMP_CLAUSE_CODE (clauses) == OMP_CLAUSE_SHARED)
 853                 OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
 854               else
 855                 OMP_CLAUSE_DEFAULT_KIND (c)
 856                   = OMP_CLAUSE_DEFAULT_KIND (clauses);
 857               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
 858               cclauses[C_OMP_CLAUSE_SPLIT_TEAMS] = c;
 859
 860             }
 861           s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 862           break;
 863         /* Reduction is allowed on simd, for, parallel, sections and teams.
 864            Duplicate it on all of them, but omit on for or sections if
 865            parallel is present.  */
 866         case OMP_CLAUSE_REDUCTION:
 867           if (code == OMP_SIMD)
 868             {
 869               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 870                                     OMP_CLAUSE_REDUCTION);
 871               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
 872               OMP_CLAUSE_REDUCTION_CODE (c)
 873                 = OMP_CLAUSE_REDUCTION_CODE (clauses);
 874               OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
 875                 = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
 876               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
 877               cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
 878             }
 879           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
 880             {
 881               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
 882                   != 0)
 883                 {
 884                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
 885                                         OMP_CLAUSE_REDUCTION);
 886                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
 887                   OMP_CLAUSE_REDUCTION_CODE (c)
 888                     = OMP_CLAUSE_REDUCTION_CODE (clauses);
 889                   OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
 890                     = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
 891                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
 892                   cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] = c;
 893                   s = C_OMP_CLAUSE_SPLIT_TEAMS;
 894                 }
 895               else if ((mask & (OMP_CLAUSE_MASK_1
 896                                 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
 897                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 898               else
 899                 s = C_OMP_CLAUSE_SPLIT_FOR;
 900             }
 901           else if (code == OMP_SECTIONS)
 902             s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 903           else
 904             s = C_OMP_CLAUSE_SPLIT_TEAMS;
 905           break;
 906         case OMP_CLAUSE_IF:
 907           /* FIXME: This is currently being discussed.  */
 908           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 909               != 0)
 910             s = C_OMP_CLAUSE_SPLIT_PARALLEL;
 911           else
 912             s = C_OMP_CLAUSE_SPLIT_TARGET;
 913           break;
 914         default:
 915           gcc_unreachable ();
 916         }
 917       OMP_CLAUSE_CHAIN (clauses) = cclauses[s];
 918       cclauses[s] = clauses;
 919     }
 920 }
 921
 922
 923 /* qsort callback to compare #pragma omp declare simd clauses.  */
 924
 925 static int
 926 c_omp_declare_simd_clause_cmp (const void *p, const void *q)
 927 {
 928   tree a = *(const tree *) p;
 929   tree b = *(const tree *) q;
 930   if (OMP_CLAUSE_CODE (a) != OMP_CLAUSE_CODE (b))
 931     {
 932       if (OMP_CLAUSE_CODE (a) > OMP_CLAUSE_CODE (b))
 933         return -1;
 934       return 1;
 935     }
 936   if (OMP_CLAUSE_CODE (a) != OMP_CLAUSE_SIMDLEN
 937       && OMP_CLAUSE_CODE (a) != OMP_CLAUSE_INBRANCH
 938       && OMP_CLAUSE_CODE (a) != OMP_CLAUSE_NOTINBRANCH)
 939     {
 940       int c = tree_to_shwi (OMP_CLAUSE_DECL (a));
 941       int d = tree_to_shwi (OMP_CLAUSE_DECL (b));
 942       if (c < d)
 943         return 1;
 944       if (c > d)
 945         return -1;
 946     }
 947   return 0;
 948 }
 949
 950 /* Change PARM_DECLs in OMP_CLAUSE_DECL of #pragma omp declare simd
 951    CLAUSES on FNDECL into argument indexes and sort them.  */
 952
 953 tree
 954 c_omp_declare_simd_clauses_to_numbers (tree parms, tree clauses)
 955 {
 956   tree c;
 957   vec<tree> clvec = vNULL;
 958
 959   for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
 960     {
 961       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_SIMDLEN
 962           && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_INBRANCH
 963           && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_NOTINBRANCH)
 964         {
 965           tree decl = OMP_CLAUSE_DECL (c);
 966           tree arg;
 967           int idx;
 968           for (arg = parms, idx = 0; arg;
 969                arg = TREE_CHAIN (arg), idx++)
 970             if (arg == decl)
 971               break;
 972           if (arg == NULL_TREE)
 973             {
 974               error_at (OMP_CLAUSE_LOCATION (c),
 975                         "%qD is not an function argument", decl);
 976               continue;
 977             }
 978           OMP_CLAUSE_DECL (c) = build_int_cst (integer_type_node, idx);
 979         }
 980       clvec.safe_push (c);
 981     }
 982   if (!clvec.is_empty ())
 983     {
 984       unsigned int len = clvec.length (), i;
 985       clvec.qsort (c_omp_declare_simd_clause_cmp);
 986       clauses = clvec[0];
 987       for (i = 0; i < len; i++)
 988         OMP_CLAUSE_CHAIN (clvec[i]) = (i < len - 1) ? clvec[i + 1] : NULL_TREE;
 989     }
 990   clvec.release ();
 991   return clauses;
 992 }
 993
 994 /* Change argument indexes in CLAUSES of FNDECL back to PARM_DECLs.  */
 995
 996 void
 997 c_omp_declare_simd_clauses_to_decls (tree fndecl, tree clauses)
 998 {
 999   tree c;
1000
1001   for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
1002     if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_SIMDLEN
1003         && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_INBRANCH
1004         && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_NOTINBRANCH)
1005       {
1006         int idx = tree_to_shwi (OMP_CLAUSE_DECL (c)), i;
1007         tree arg;
1008         for (arg = DECL_ARGUMENTS (fndecl), i = 0; arg;
1009              arg = TREE_CHAIN (arg), i++)
1010           if (i == idx)
1011             break;
1012         gcc_assert (arg);
1013         OMP_CLAUSE_DECL (c) = arg;
1014       }
1015 }
1016
1017 /* True if OpenMP sharing attribute of DECL is predetermined.  */
1018
1019 enum omp_clause_default_kind
1020 c_omp_predetermined_sharing (tree decl)
1021 {
1022   /* Variables with const-qualified type having no mutable member
1023      are predetermined shared.  */
1024   if (TREE_READONLY (decl))
1025     return OMP_CLAUSE_DEFAULT_SHARED;
1026
1027   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1028 }