LCOV - code coverage report
Current view: top level - gcc/c-family - c-omp.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1126 1184 95.1 %
Date: 2020-03-28 11:57:23 Functions: 28 28 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* This file contains routines to construct OpenACC and OpenMP constructs,
       2                 :            :    called from parsing in the C and C++ front ends.
       3                 :            : 
       4                 :            :    Copyright (C) 2005-2020 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 "options.h"
      28                 :            : #include "c-common.h"
      29                 :            : #include "gimple-expr.h"
      30                 :            : #include "c-pragma.h"
      31                 :            : #include "stringpool.h"
      32                 :            : #include "omp-general.h"
      33                 :            : #include "gomp-constants.h"
      34                 :            : #include "memmodel.h"
      35                 :            : #include "attribs.h"
      36                 :            : #include "gimplify.h"
      37                 :            : 
      38                 :            : 
      39                 :            : /* Complete a #pragma oacc wait construct.  LOC is the location of
      40                 :            :    the #pragma.  */
      41                 :            : 
      42                 :            : tree
      43                 :        217 : c_finish_oacc_wait (location_t loc, tree parms, tree clauses)
      44                 :            : {
      45                 :        217 :   const int nparms = list_length (parms);
      46                 :        217 :   tree stmt, t;
      47                 :        217 :   vec<tree, va_gc> *args;
      48                 :            : 
      49                 :        217 :   vec_alloc (args, nparms + 2);
      50                 :        217 :   stmt = builtin_decl_explicit (BUILT_IN_GOACC_WAIT);
      51                 :            : 
      52                 :        217 :   if (omp_find_clause (clauses, OMP_CLAUSE_ASYNC))
      53                 :         29 :     t = OMP_CLAUSE_ASYNC_EXPR (clauses);
      54                 :            :   else
      55                 :        188 :     t = build_int_cst (integer_type_node, GOMP_ASYNC_SYNC);
      56                 :            : 
      57                 :        217 :   args->quick_push (t);
      58                 :        217 :   args->quick_push (build_int_cst (integer_type_node, nparms));
      59                 :            : 
      60                 :        337 :   for (t = parms; t; t = TREE_CHAIN (t))
      61                 :            :     {
      62                 :        120 :       if (TREE_CODE (OMP_CLAUSE_WAIT_EXPR (t)) == INTEGER_CST)
      63                 :         42 :         args->quick_push (build_int_cst (integer_type_node,
      64                 :         42 :                         TREE_INT_CST_LOW (OMP_CLAUSE_WAIT_EXPR (t))));
      65                 :            :       else
      66                 :        198 :         args->quick_push (OMP_CLAUSE_WAIT_EXPR (t));
      67                 :            :     }
      68                 :            : 
      69                 :        217 :   stmt = build_call_expr_loc_vec (loc, stmt, args);
      70                 :            : 
      71                 :        217 :   vec_free (args);
      72                 :            : 
      73                 :        217 :   return stmt;
      74                 :            : }
      75                 :            : 
      76                 :            : /* Complete a #pragma omp master construct.  STMT is the structured-block
      77                 :            :    that follows the pragma.  LOC is the location of the #pragma.  */
      78                 :            : 
      79                 :            : tree
      80                 :        412 : c_finish_omp_master (location_t loc, tree stmt)
      81                 :            : {
      82                 :        412 :   tree t = add_stmt (build1 (OMP_MASTER, void_type_node, stmt));
      83                 :        412 :   SET_EXPR_LOCATION (t, loc);
      84                 :        412 :   return t;
      85                 :            : }
      86                 :            : 
      87                 :            : /* Complete a #pragma omp taskgroup construct.  BODY is the structured-block
      88                 :            :    that follows the pragma.  LOC is the location of the #pragma.  */
      89                 :            : 
      90                 :            : tree
      91                 :        223 : c_finish_omp_taskgroup (location_t loc, tree body, tree clauses)
      92                 :            : {
      93                 :        223 :   tree stmt = make_node (OMP_TASKGROUP);
      94                 :        223 :   TREE_TYPE (stmt) = void_type_node;
      95                 :        223 :   OMP_TASKGROUP_BODY (stmt) = body;
      96                 :        223 :   OMP_TASKGROUP_CLAUSES (stmt) = clauses;
      97                 :        223 :   SET_EXPR_LOCATION (stmt, loc);
      98                 :        223 :   return add_stmt (stmt);
      99                 :            : }
     100                 :            : 
     101                 :            : /* Complete a #pragma omp critical construct.  BODY is the structured-block
     102                 :            :    that follows the pragma, NAME is the identifier in the pragma, or null
     103                 :            :    if it was omitted.  LOC is the location of the #pragma.  */
     104                 :            : 
     105                 :            : tree
     106                 :        355 : c_finish_omp_critical (location_t loc, tree body, tree name, tree clauses)
     107                 :            : {
     108                 :        355 :   tree stmt = make_node (OMP_CRITICAL);
     109                 :        355 :   TREE_TYPE (stmt) = void_type_node;
     110                 :        355 :   OMP_CRITICAL_BODY (stmt) = body;
     111                 :        355 :   OMP_CRITICAL_NAME (stmt) = name;
     112                 :        355 :   OMP_CRITICAL_CLAUSES (stmt) = clauses;
     113                 :        355 :   SET_EXPR_LOCATION (stmt, loc);
     114                 :        355 :   return add_stmt (stmt);
     115                 :            : }
     116                 :            : 
     117                 :            : /* Complete a #pragma omp ordered construct.  STMT is the structured-block
     118                 :            :    that follows the pragma.  LOC is the location of the #pragma.  */
     119                 :            : 
     120                 :            : tree
     121                 :       1155 : c_finish_omp_ordered (location_t loc, tree clauses, tree stmt)
     122                 :            : {
     123                 :       1155 :   tree t = make_node (OMP_ORDERED);
     124                 :       1155 :   TREE_TYPE (t) = void_type_node;
     125                 :       1155 :   OMP_ORDERED_BODY (t) = stmt;
     126                 :       1155 :   if (!flag_openmp      /* flag_openmp_simd */
     127                 :       1205 :       && (OMP_CLAUSE_CODE (clauses) != OMP_CLAUSE_SIMD
     128                 :         50 :           || OMP_CLAUSE_CHAIN (clauses)))
     129                 :          5 :     clauses = build_omp_clause (loc, OMP_CLAUSE_SIMD);
     130                 :       1155 :   OMP_ORDERED_CLAUSES (t) = clauses;
     131                 :       1155 :   SET_EXPR_LOCATION (t, loc);
     132                 :       1155 :   return add_stmt (t);
     133                 :            : }
     134                 :            : 
     135                 :            : 
     136                 :            : /* Complete a #pragma omp barrier construct.  LOC is the location of
     137                 :            :    the #pragma.  */
     138                 :            : 
     139                 :            : void
     140                 :        297 : c_finish_omp_barrier (location_t loc)
     141                 :            : {
     142                 :        297 :   tree x;
     143                 :            : 
     144                 :        297 :   x = builtin_decl_explicit (BUILT_IN_GOMP_BARRIER);
     145                 :        297 :   x = build_call_expr_loc (loc, x, 0);
     146                 :        297 :   add_stmt (x);
     147                 :        297 : }
     148                 :            : 
     149                 :            : 
     150                 :            : /* Complete a #pragma omp taskwait construct.  LOC is the location of the
     151                 :            :    pragma.  */
     152                 :            : 
     153                 :            : void
     154                 :         37 : c_finish_omp_taskwait (location_t loc)
     155                 :            : {
     156                 :         37 :   tree x;
     157                 :            : 
     158                 :         37 :   x = builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT);
     159                 :         37 :   x = build_call_expr_loc (loc, x, 0);
     160                 :         37 :   add_stmt (x);
     161                 :         37 : }
     162                 :            : 
     163                 :            : 
     164                 :            : /* Complete a #pragma omp taskyield construct.  LOC is the location of the
     165                 :            :    pragma.  */
     166                 :            : 
     167                 :            : void
     168                 :          2 : c_finish_omp_taskyield (location_t loc)
     169                 :            : {
     170                 :          2 :   tree x;
     171                 :            : 
     172                 :          2 :   x = builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD);
     173                 :          2 :   x = build_call_expr_loc (loc, x, 0);
     174                 :          2 :   add_stmt (x);
     175                 :          2 : }
     176                 :            : 
     177                 :            : 
     178                 :            : /* Complete a #pragma omp atomic construct.  For CODE OMP_ATOMIC
     179                 :            :    the expression to be implemented atomically is LHS opcode= RHS. 
     180                 :            :    For OMP_ATOMIC_READ V = LHS, for OMP_ATOMIC_CAPTURE_{NEW,OLD} LHS
     181                 :            :    opcode= RHS with the new or old content of LHS returned.
     182                 :            :    LOC is the location of the atomic statement.  The value returned
     183                 :            :    is either error_mark_node (if the construct was erroneous) or an
     184                 :            :    OMP_ATOMIC* node which should be added to the current statement
     185                 :            :    tree with add_stmt.  If TEST is set, avoid calling save_expr
     186                 :            :    or create_tmp_var*.  */
     187                 :            : 
     188                 :            : tree
     189                 :       3395 : c_finish_omp_atomic (location_t loc, enum tree_code code,
     190                 :            :                      enum tree_code opcode, tree lhs, tree rhs,
     191                 :            :                      tree v, tree lhs1, tree rhs1, bool swapped,
     192                 :            :                      enum omp_memory_order memory_order, bool test)
     193                 :            : {
     194                 :       3395 :   tree x, type, addr, pre = NULL_TREE;
     195                 :       3395 :   HOST_WIDE_INT bitpos = 0, bitsize = 0;
     196                 :            : 
     197                 :       3395 :   if (lhs == error_mark_node || rhs == error_mark_node
     198                 :       3395 :       || v == error_mark_node || lhs1 == error_mark_node
     199                 :       3395 :       || rhs1 == error_mark_node)
     200                 :            :     return error_mark_node;
     201                 :            : 
     202                 :            :   /* ??? According to one reading of the OpenMP spec, complex type are
     203                 :            :      supported, but there are no atomic stores for any architecture.
     204                 :            :      But at least icc 9.0 doesn't support complex types here either.
     205                 :            :      And lets not even talk about vector types...  */
     206                 :       3395 :   type = TREE_TYPE (lhs);
     207                 :       3395 :   if (!INTEGRAL_TYPE_P (type)
     208                 :        386 :       && !POINTER_TYPE_P (type)
     209                 :        379 :       && !SCALAR_FLOAT_TYPE_P (type))
     210                 :            :     {
     211                 :          4 :       error_at (loc, "invalid expression type for %<#pragma omp atomic%>");
     212                 :          4 :       return error_mark_node;
     213                 :            :     }
     214                 :       3391 :   if (TYPE_ATOMIC (type))
     215                 :            :     {
     216                 :          8 :       error_at (loc, "%<_Atomic%> expression in %<#pragma omp atomic%>");
     217                 :          8 :       return error_mark_node;
     218                 :            :     }
     219                 :            : 
     220                 :       3383 :   if (opcode == RDIV_EXPR)
     221                 :          0 :     opcode = TRUNC_DIV_EXPR;
     222                 :            : 
     223                 :            :   /* ??? Validate that rhs does not overlap lhs.  */
     224                 :       3383 :   tree blhs = NULL;
     225                 :       3383 :   if (TREE_CODE (lhs) == COMPONENT_REF
     226                 :         59 :       && TREE_CODE (TREE_OPERAND (lhs, 1)) == FIELD_DECL
     227                 :         59 :       && DECL_C_BIT_FIELD (TREE_OPERAND (lhs, 1))
     228                 :       3421 :       && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (lhs, 1)))
     229                 :            :     {
     230                 :         38 :       tree field = TREE_OPERAND (lhs, 1);
     231                 :         38 :       tree repr = DECL_BIT_FIELD_REPRESENTATIVE (field);
     232                 :         38 :       if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field))
     233                 :         76 :           && tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr)))
     234                 :         38 :         bitpos = (tree_to_uhwi (DECL_FIELD_OFFSET (field))
     235                 :         38 :                   - tree_to_uhwi (DECL_FIELD_OFFSET (repr))) * BITS_PER_UNIT;
     236                 :            :       else
     237                 :            :         bitpos = 0;
     238                 :         38 :       bitpos += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field))
     239                 :         38 :                  - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
     240                 :         38 :       gcc_assert (tree_fits_shwi_p (DECL_SIZE (field)));
     241                 :         38 :       bitsize = tree_to_shwi (DECL_SIZE (field));
     242                 :         38 :       blhs = lhs;
     243                 :         38 :       type = TREE_TYPE (repr);
     244                 :         38 :       lhs = build3 (COMPONENT_REF, TREE_TYPE (repr), TREE_OPERAND (lhs, 0),
     245                 :         38 :                     repr, TREE_OPERAND (lhs, 2));
     246                 :            :     }
     247                 :            : 
     248                 :            :   /* Take and save the address of the lhs.  From then on we'll reference it
     249                 :            :      via indirection.  */
     250                 :       3383 :   addr = build_unary_op (loc, ADDR_EXPR, lhs, false);
     251                 :       3383 :   if (addr == error_mark_node)
     252                 :            :     return error_mark_node;
     253                 :       3373 :   if (!test)
     254                 :       3325 :     addr = save_expr (addr);
     255                 :       3373 :   if (!test
     256                 :       3325 :       && TREE_CODE (addr) != SAVE_EXPR
     257                 :       6180 :       && (TREE_CODE (addr) != ADDR_EXPR
     258                 :       2795 :           || !VAR_P (TREE_OPERAND (addr, 0))))
     259                 :            :     {
     260                 :            :       /* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize
     261                 :            :          it even after unsharing function body.  */
     262                 :        115 :       tree var = create_tmp_var_raw (TREE_TYPE (addr));
     263                 :        115 :       DECL_CONTEXT (var) = current_function_decl;
     264                 :        115 :       addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL);
     265                 :            :     }
     266                 :       3373 :   tree orig_lhs = lhs;
     267                 :       3373 :   lhs = build_indirect_ref (loc, addr, RO_NULL);
     268                 :       3373 :   tree new_lhs = lhs;
     269                 :            : 
     270                 :       3373 :   if (code == OMP_ATOMIC_READ)
     271                 :            :     {
     272                 :        350 :       x = build1 (OMP_ATOMIC_READ, type, addr);
     273                 :        350 :       SET_EXPR_LOCATION (x, loc);
     274                 :        350 :       OMP_ATOMIC_MEMORY_ORDER (x) = memory_order;
     275                 :        350 :       if (blhs)
     276                 :          4 :         x = build3_loc (loc, BIT_FIELD_REF, TREE_TYPE (blhs), x,
     277                 :            :                         bitsize_int (bitsize), bitsize_int (bitpos));
     278                 :        350 :       return build_modify_expr (loc, v, NULL_TREE, NOP_EXPR,
     279                 :        350 :                                 loc, x, NULL_TREE);
     280                 :            :     }
     281                 :            : 
     282                 :            :   /* There are lots of warnings, errors, and conversions that need to happen
     283                 :            :      in the course of interpreting a statement.  Use the normal mechanisms
     284                 :            :      to do this, and then take it apart again.  */
     285                 :       3023 :   if (blhs)
     286                 :            :     {
     287                 :         36 :       lhs = build3_loc (loc, BIT_FIELD_REF, TREE_TYPE (blhs), lhs,
     288                 :            :                         bitsize_int (bitsize), bitsize_int (bitpos));
     289                 :         36 :       if (swapped)
     290                 :          0 :         rhs = build_binary_op (loc, opcode, rhs, lhs, true);
     291                 :         36 :       else if (opcode != NOP_EXPR)
     292                 :         29 :         rhs = build_binary_op (loc, opcode, lhs, rhs, true);
     293                 :            :       opcode = NOP_EXPR;
     294                 :            :     }
     295                 :       2987 :   else if (swapped)
     296                 :            :     {
     297                 :        100 :       rhs = build_binary_op (loc, opcode, rhs, lhs, true);
     298                 :        100 :       opcode = NOP_EXPR;
     299                 :            :     }
     300                 :       3023 :   bool save = in_late_binary_op;
     301                 :       3023 :   in_late_binary_op = true;
     302                 :       6010 :   x = build_modify_expr (loc, blhs ? blhs : lhs, NULL_TREE, opcode,
     303                 :            :                          loc, rhs, NULL_TREE);
     304                 :       3023 :   in_late_binary_op = save;
     305                 :       3023 :   if (x == error_mark_node)
     306                 :            :     return error_mark_node;
     307                 :       3002 :   if (TREE_CODE (x) == COMPOUND_EXPR)
     308                 :            :     {
     309                 :         14 :       pre = TREE_OPERAND (x, 0);
     310                 :         14 :       gcc_assert (TREE_CODE (pre) == SAVE_EXPR || tree_invariant_p (pre));
     311                 :         14 :       x = TREE_OPERAND (x, 1);
     312                 :            :     }
     313                 :       3002 :   gcc_assert (TREE_CODE (x) == MODIFY_EXPR);
     314                 :       3002 :   rhs = TREE_OPERAND (x, 1);
     315                 :            : 
     316                 :       3002 :   if (blhs)
     317                 :         72 :     rhs = build3_loc (loc, BIT_INSERT_EXPR, type, new_lhs,
     318                 :            :                       rhs, bitsize_int (bitpos));
     319                 :            : 
     320                 :            :   /* Punt the actual generation of atomic operations to common code.  */
     321                 :       3002 :   if (code == OMP_ATOMIC)
     322                 :       2247 :     type = void_type_node;
     323                 :       3002 :   x = build2 (code, type, addr, rhs);
     324                 :       3002 :   SET_EXPR_LOCATION (x, loc);
     325                 :       3002 :   OMP_ATOMIC_MEMORY_ORDER (x) = memory_order;
     326                 :            : 
     327                 :            :   /* Generally it is hard to prove lhs1 and lhs are the same memory
     328                 :            :      location, just diagnose different variables.  */
     329                 :       3002 :   if (rhs1
     330                 :        693 :       && VAR_P (rhs1)
     331                 :        188 :       && VAR_P (orig_lhs)
     332                 :        188 :       && rhs1 != orig_lhs
     333                 :        188 :       && !test)
     334                 :            :     {
     335                 :          0 :       if (code == OMP_ATOMIC)
     336                 :          0 :         error_at (loc, "%<#pragma omp atomic update%> uses two different "
     337                 :            :                        "variables for memory");
     338                 :            :       else
     339                 :          0 :         error_at (loc, "%<#pragma omp atomic capture%> uses two different "
     340                 :            :                        "variables for memory");
     341                 :          0 :       return error_mark_node;
     342                 :            :     }
     343                 :            : 
     344                 :       3002 :   if (lhs1
     345                 :       3002 :       && lhs1 != orig_lhs
     346                 :        290 :       && TREE_CODE (lhs1) == COMPONENT_REF
     347                 :         14 :       && TREE_CODE (TREE_OPERAND (lhs1, 1)) == FIELD_DECL
     348                 :         14 :       && DECL_C_BIT_FIELD (TREE_OPERAND (lhs1, 1))
     349                 :       3016 :       && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (lhs1, 1)))
     350                 :            :     {
     351                 :         14 :       tree field = TREE_OPERAND (lhs1, 1);
     352                 :         14 :       tree repr = DECL_BIT_FIELD_REPRESENTATIVE (field);
     353                 :         14 :       lhs1 = build3 (COMPONENT_REF, TREE_TYPE (repr), TREE_OPERAND (lhs1, 0),
     354                 :         14 :                      repr, TREE_OPERAND (lhs1, 2));
     355                 :            :     }
     356                 :       3002 :   if (rhs1
     357                 :       3002 :       && rhs1 != orig_lhs
     358                 :        505 :       && TREE_CODE (rhs1) == COMPONENT_REF
     359                 :         18 :       && TREE_CODE (TREE_OPERAND (rhs1, 1)) == FIELD_DECL
     360                 :         18 :       && DECL_C_BIT_FIELD (TREE_OPERAND (rhs1, 1))
     361                 :       3020 :       && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (rhs1, 1)))
     362                 :            :     {
     363                 :         18 :       tree field = TREE_OPERAND (rhs1, 1);
     364                 :         18 :       tree repr = DECL_BIT_FIELD_REPRESENTATIVE (field);
     365                 :         18 :       rhs1 = build3 (COMPONENT_REF, TREE_TYPE (repr), TREE_OPERAND (rhs1, 0),
     366                 :         18 :                      repr, TREE_OPERAND (rhs1, 2));
     367                 :            :     }
     368                 :            : 
     369                 :       3002 :   if (code != OMP_ATOMIC)
     370                 :            :     {
     371                 :            :       /* Generally it is hard to prove lhs1 and lhs are the same memory
     372                 :            :          location, just diagnose different variables.  */
     373                 :        755 :       if (lhs1 && VAR_P (lhs1) && VAR_P (orig_lhs))
     374                 :            :         {
     375                 :        147 :           if (lhs1 != orig_lhs && !test)
     376                 :            :             {
     377                 :          0 :               error_at (loc, "%<#pragma omp atomic capture%> uses two "
     378                 :            :                              "different variables for memory");
     379                 :          0 :               return error_mark_node;
     380                 :            :             }
     381                 :            :         }
     382                 :        755 :       if (blhs)
     383                 :            :         {
     384                 :         23 :           x = build3_loc (loc, BIT_FIELD_REF, TREE_TYPE (blhs), x,
     385                 :            :                           bitsize_int (bitsize), bitsize_int (bitpos));
     386                 :         23 :           type = TREE_TYPE (blhs);
     387                 :            :         }
     388                 :        755 :       x = build_modify_expr (loc, v, NULL_TREE, NOP_EXPR,
     389                 :            :                              loc, x, NULL_TREE);
     390                 :        755 :       if (rhs1 && rhs1 != orig_lhs)
     391                 :            :         {
     392                 :        229 :           tree rhs1addr = build_unary_op (loc, ADDR_EXPR, rhs1, false);
     393                 :        229 :           if (rhs1addr == error_mark_node)
     394                 :            :             return error_mark_node;
     395                 :        229 :           x = omit_one_operand_loc (loc, type, x, rhs1addr);
     396                 :            :         }
     397                 :        755 :       if (lhs1 && lhs1 != orig_lhs)
     398                 :            :         {
     399                 :        290 :           tree lhs1addr = build_unary_op (loc, ADDR_EXPR, lhs1, false);
     400                 :        290 :           if (lhs1addr == error_mark_node)
     401                 :            :             return error_mark_node;
     402                 :        289 :           if (code == OMP_ATOMIC_CAPTURE_OLD)
     403                 :        191 :             x = omit_one_operand_loc (loc, type, x, lhs1addr);
     404                 :            :           else
     405                 :            :             {
     406                 :         98 :               if (!test)
     407                 :         98 :                 x = save_expr (x);
     408                 :         98 :               x = omit_two_operands_loc (loc, type, x, x, lhs1addr);
     409                 :            :             }
     410                 :            :         }
     411                 :            :     }
     412                 :       2247 :   else if (rhs1 && rhs1 != orig_lhs)
     413                 :            :     {
     414                 :        276 :       tree rhs1addr = build_unary_op (loc, ADDR_EXPR, rhs1, false);
     415                 :        276 :       if (rhs1addr == error_mark_node)
     416                 :            :         return error_mark_node;
     417                 :        276 :       x = omit_one_operand_loc (loc, type, x, rhs1addr);
     418                 :            :     }
     419                 :            : 
     420                 :       3001 :   if (pre)
     421                 :         14 :     x = omit_one_operand_loc (loc, type, x, pre);
     422                 :            :   return x;
     423                 :            : }
     424                 :            : 
     425                 :            : 
     426                 :            : /* Return true if TYPE is the implementation's omp_depend_t.  */
     427                 :            : 
     428                 :            : bool
     429                 :       1025 : c_omp_depend_t_p (tree type)
     430                 :            : {
     431                 :       1025 :   type = TYPE_MAIN_VARIANT (type);
     432                 :       1025 :   return (TREE_CODE (type) == RECORD_TYPE
     433                 :        388 :           && TYPE_NAME (type)
     434                 :        388 :           && ((TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
     435                 :        388 :                ? DECL_NAME (TYPE_NAME (type)) : TYPE_NAME (type))
     436                 :        388 :               == get_identifier ("omp_depend_t"))
     437                 :        365 :           && (!TYPE_CONTEXT (type)
     438                 :        316 :               || TREE_CODE (TYPE_CONTEXT (type)) == TRANSLATION_UNIT_DECL)
     439                 :        365 :           && COMPLETE_TYPE_P (type)
     440                 :        365 :           && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
     441                 :       1390 :           && !compare_tree_int (TYPE_SIZE (type),
     442                 :        365 :                                 2 * tree_to_uhwi (TYPE_SIZE (ptr_type_node))));
     443                 :            : }
     444                 :            : 
     445                 :            : 
     446                 :            : /* Complete a #pragma omp depobj construct.  LOC is the location of the
     447                 :            :    #pragma.  */
     448                 :            : 
     449                 :            : void
     450                 :        312 : c_finish_omp_depobj (location_t loc, tree depobj,
     451                 :            :                      enum omp_clause_depend_kind kind, tree clause)
     452                 :            : {
     453                 :        312 :   tree t = NULL_TREE;
     454                 :        615 :   if (!error_operand_p (depobj))
     455                 :            :     {
     456                 :        303 :       if (!c_omp_depend_t_p (TREE_TYPE (depobj)))
     457                 :            :         {
     458                 :         27 :           error_at (EXPR_LOC_OR_LOC (depobj, loc),
     459                 :            :                     "type of %<depobj%> expression is not %<omp_depend_t%>");
     460                 :         27 :           depobj = error_mark_node;
     461                 :            :         }
     462                 :        276 :       else if (TYPE_READONLY (TREE_TYPE (depobj)))
     463                 :            :         {
     464                 :          9 :           error_at (EXPR_LOC_OR_LOC (depobj, loc),
     465                 :            :                     "%<const%> qualified %<depobj%> expression");
     466                 :          9 :           depobj = error_mark_node;
     467                 :            :         }
     468                 :            :     }
     469                 :            :   else
     470                 :            :     depobj = error_mark_node;
     471                 :            : 
     472                 :        312 :   if (clause == error_mark_node)
     473                 :        312 :     return;
     474                 :            : 
     475                 :        263 :   if (clause)
     476                 :            :     {
     477                 :        147 :       gcc_assert (TREE_CODE (clause) == OMP_CLAUSE
     478                 :            :                   && OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_DEPEND);
     479                 :        147 :       if (OMP_CLAUSE_CHAIN (clause))
     480                 :          9 :         error_at (OMP_CLAUSE_LOCATION (clause),
     481                 :            :                   "more than one locator in %<depend%> clause on %<depobj%> "
     482                 :            :                   "construct");
     483                 :        147 :       switch (OMP_CLAUSE_DEPEND_KIND (clause))
     484                 :            :         {
     485                 :          9 :         case OMP_CLAUSE_DEPEND_DEPOBJ:
     486                 :          9 :           error_at (OMP_CLAUSE_LOCATION (clause),
     487                 :            :                     "%<depobj%> dependence type specified in %<depend%> "
     488                 :            :                     "clause on %<depobj%> construct");
     489                 :          9 :           return;
     490                 :         18 :         case OMP_CLAUSE_DEPEND_SOURCE:
     491                 :         18 :         case OMP_CLAUSE_DEPEND_SINK:
     492                 :         54 :           error_at (OMP_CLAUSE_LOCATION (clause),
     493                 :            :                     "%<depend(%s)%> is only allowed in %<omp ordered%>",
     494                 :         18 :                     OMP_CLAUSE_DEPEND_KIND (clause) == OMP_CLAUSE_DEPEND_SOURCE
     495                 :            :                     ? "source" : "sink");
     496                 :         18 :           return;
     497                 :        120 :         case OMP_CLAUSE_DEPEND_IN:
     498                 :        120 :         case OMP_CLAUSE_DEPEND_OUT:
     499                 :        120 :         case OMP_CLAUSE_DEPEND_INOUT:
     500                 :        120 :         case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
     501                 :        120 :           kind = OMP_CLAUSE_DEPEND_KIND (clause);
     502                 :        120 :           t = OMP_CLAUSE_DECL (clause);
     503                 :        120 :           gcc_assert (t);
     504                 :        120 :           if (TREE_CODE (t) == TREE_LIST
     505                 :          9 :               && TREE_PURPOSE (t)
     506                 :        129 :               && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC)
     507                 :            :             {
     508                 :          9 :               error_at (OMP_CLAUSE_LOCATION (clause),
     509                 :            :                         "%<iterator%> modifier may not be specified on "
     510                 :            :                         "%<depobj%> construct");
     511                 :          9 :               return;
     512                 :            :             }
     513                 :        111 :           if (TREE_CODE (t) == COMPOUND_EXPR)
     514                 :            :             {
     515                 :          0 :               tree t1 = build_fold_addr_expr (TREE_OPERAND (t, 1));
     516                 :          0 :               t = build2 (COMPOUND_EXPR, TREE_TYPE (t1), TREE_OPERAND (t, 0),
     517                 :            :                           t1);
     518                 :            :             }
     519                 :            :           else
     520                 :        111 :             t = build_fold_addr_expr (t);
     521                 :            :           break;
     522                 :          0 :         default:
     523                 :          0 :           gcc_unreachable ();
     524                 :            :         }
     525                 :            :     }
     526                 :            :   else
     527                 :        116 :     gcc_assert (kind != OMP_CLAUSE_DEPEND_SOURCE);
     528                 :            : 
     529                 :        227 :   if (depobj == error_mark_node)
     530                 :            :     return;
     531                 :            : 
     532                 :        182 :   depobj = build_fold_addr_expr_loc (EXPR_LOC_OR_LOC (depobj, loc), depobj);
     533                 :        182 :   tree dtype
     534                 :        182 :     = build_pointer_type_for_mode (ptr_type_node, TYPE_MODE (ptr_type_node),
     535                 :            :                                    true);
     536                 :        182 :   depobj = fold_convert (dtype, depobj);
     537                 :        182 :   tree r;
     538                 :        182 :   if (clause)
     539                 :            :     {
     540                 :         93 :       depobj = save_expr (depobj);
     541                 :         93 :       r = build_indirect_ref (loc, depobj, RO_UNARY_STAR);
     542                 :         93 :       add_stmt (build2 (MODIFY_EXPR, void_type_node, r, t));
     543                 :            :     }
     544                 :        182 :   int k;
     545                 :        182 :   switch (kind)
     546                 :            :     {
     547                 :            :     case OMP_CLAUSE_DEPEND_IN:
     548                 :            :       k = GOMP_DEPEND_IN;
     549                 :            :       break;
     550                 :          9 :     case OMP_CLAUSE_DEPEND_OUT:
     551                 :          9 :       k = GOMP_DEPEND_OUT;
     552                 :          9 :       break;
     553                 :         24 :     case OMP_CLAUSE_DEPEND_INOUT:
     554                 :         24 :       k = GOMP_DEPEND_INOUT;
     555                 :         24 :       break;
     556                 :         13 :     case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
     557                 :         13 :       k = GOMP_DEPEND_MUTEXINOUTSET;
     558                 :         13 :       break;
     559                 :         62 :     case OMP_CLAUSE_DEPEND_LAST:
     560                 :         62 :       k = -1;
     561                 :         62 :       break;
     562                 :          0 :     default:
     563                 :          0 :       gcc_unreachable ();
     564                 :            :     }
     565                 :        182 :   t = build_int_cst (ptr_type_node, k);
     566                 :        182 :   depobj = build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (depobj), depobj,
     567                 :        182 :                        TYPE_SIZE_UNIT (ptr_type_node));
     568                 :        182 :   r = build_indirect_ref (loc, depobj, RO_UNARY_STAR);
     569                 :        182 :   add_stmt (build2 (MODIFY_EXPR, void_type_node, r, t));
     570                 :            : }
     571                 :            : 
     572                 :            : 
     573                 :            : /* Complete a #pragma omp flush construct.  We don't do anything with
     574                 :            :    the variable list that the syntax allows.  LOC is the location of
     575                 :            :    the #pragma.  */
     576                 :            : 
     577                 :            : void
     578                 :         29 : c_finish_omp_flush (location_t loc, int mo)
     579                 :            : {
     580                 :         29 :   tree x;
     581                 :            : 
     582                 :         29 :   if (mo == MEMMODEL_LAST)
     583                 :            :     {
     584                 :         20 :       x = builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE);
     585                 :         20 :       x = build_call_expr_loc (loc, x, 0);
     586                 :            :     }
     587                 :            :   else
     588                 :            :     {
     589                 :          9 :       x = builtin_decl_explicit (BUILT_IN_ATOMIC_THREAD_FENCE);
     590                 :          9 :       x = build_call_expr_loc (loc, x, 1,
     591                 :            :                                build_int_cst (integer_type_node, mo));
     592                 :            :     }
     593                 :         29 :   add_stmt (x);
     594                 :         29 : }
     595                 :            : 
     596                 :            : 
     597                 :            : /* Check and canonicalize OMP_FOR increment expression.
     598                 :            :    Helper function for c_finish_omp_for.  */
     599                 :            : 
     600                 :            : static tree
     601                 :        653 : check_omp_for_incr_expr (location_t loc, tree exp, tree decl)
     602                 :            : {
     603                 :        753 :   tree t;
     604                 :            : 
     605                 :       1506 :   if (!INTEGRAL_TYPE_P (TREE_TYPE (exp))
     606                 :       1506 :       || TYPE_PRECISION (TREE_TYPE (exp)) < TYPE_PRECISION (TREE_TYPE (decl)))
     607                 :          0 :     return error_mark_node;
     608                 :            : 
     609                 :        753 :   if (exp == decl)
     610                 :        190 :     return build_int_cst (TREE_TYPE (exp), 0);
     611                 :            : 
     612                 :        563 :   switch (TREE_CODE (exp))
     613                 :            :     {
     614                 :        199 :     CASE_CONVERT:
     615                 :        199 :       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
     616                 :        199 :       if (t != error_mark_node)
     617                 :        172 :         return fold_convert_loc (loc, TREE_TYPE (exp), t);
     618                 :            :       break;
     619                 :         20 :     case MINUS_EXPR:
     620                 :         20 :       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
     621                 :         20 :       if (t != error_mark_node)
     622                 :         20 :         return fold_build2_loc (loc, MINUS_EXPR,
     623                 :         40 :                                 TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
     624                 :            :       break;
     625                 :        191 :     case PLUS_EXPR:
     626                 :        191 :       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
     627                 :        191 :       if (t != error_mark_node)
     628                 :        152 :         return fold_build2_loc (loc, PLUS_EXPR,
     629                 :        304 :                                 TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
     630                 :         39 :       t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 1), decl);
     631                 :         39 :       if (t != error_mark_node)
     632                 :         29 :         return fold_build2_loc (loc, PLUS_EXPR,
     633                 :         58 :                                 TREE_TYPE (exp), TREE_OPERAND (exp, 0), t);
     634                 :            :       break;
     635                 :        100 :     case COMPOUND_EXPR:
     636                 :        100 :       {
     637                 :            :         /* cp_build_modify_expr forces preevaluation of the RHS to make
     638                 :            :            sure that it is evaluated before the lvalue-rvalue conversion
     639                 :            :            is applied to the LHS.  Reconstruct the original expression.  */
     640                 :        100 :         tree op0 = TREE_OPERAND (exp, 0);
     641                 :        100 :         if (TREE_CODE (op0) == TARGET_EXPR
     642                 :        200 :             && !VOID_TYPE_P (TREE_TYPE (op0)))
     643                 :            :           {
     644                 :        100 :             tree op1 = TREE_OPERAND (exp, 1);
     645                 :        100 :             tree temp = TARGET_EXPR_SLOT (op0);
     646                 :        100 :             if (BINARY_CLASS_P (op1)
     647                 :        100 :                 && TREE_OPERAND (op1, 1) == temp)
     648                 :            :               {
     649                 :        100 :                 op1 = copy_node (op1);
     650                 :        100 :                 TREE_OPERAND (op1, 1) = TARGET_EXPR_INITIAL (op0);
     651                 :        100 :                 return check_omp_for_incr_expr (loc, op1, decl);
     652                 :            :               }
     653                 :            :           }
     654                 :            :         break;
     655                 :            :       }
     656                 :            :     default:
     657                 :            :       break;
     658                 :            :     }
     659                 :            : 
     660                 :         90 :   return error_mark_node;
     661                 :            : }
     662                 :            : 
     663                 :            : /* If the OMP_FOR increment expression in INCR is of pointer type,
     664                 :            :    canonicalize it into an expression handled by gimplify_omp_for()
     665                 :            :    and return it.  DECL is the iteration variable.  */
     666                 :            : 
     667                 :            : static tree
     668                 :      24073 : c_omp_for_incr_canonicalize_ptr (location_t loc, tree decl, tree incr)
     669                 :            : {
     670                 :      46334 :   if (POINTER_TYPE_P (TREE_TYPE (decl))
     671                 :      24073 :       && TREE_OPERAND (incr, 1))
     672                 :            :     {
     673                 :       1799 :       tree t = fold_convert_loc (loc,
     674                 :       1799 :                                  sizetype, TREE_OPERAND (incr, 1));
     675                 :            : 
     676                 :       1799 :       if (TREE_CODE (incr) == POSTDECREMENT_EXPR
     677                 :       1780 :           || TREE_CODE (incr) == PREDECREMENT_EXPR)
     678                 :        569 :         t = fold_build1_loc (loc, NEGATE_EXPR, sizetype, t);
     679                 :       1799 :       t = fold_build_pointer_plus (decl, t);
     680                 :       1799 :       incr = build2 (MODIFY_EXPR, void_type_node, decl, t);
     681                 :            :     }
     682                 :      24073 :   return incr;
     683                 :            : }
     684                 :            : 
     685                 :            : /* Validate and generate OMP_FOR.
     686                 :            :    DECLV is a vector of iteration variables, for each collapsed loop.
     687                 :            : 
     688                 :            :    ORIG_DECLV, if non-NULL, is a vector with the original iteration
     689                 :            :    variables (prior to any transformations, by say, C++ iterators).
     690                 :            : 
     691                 :            :    INITV, CONDV and INCRV are vectors containing initialization
     692                 :            :    expressions, controlling predicates and increment expressions.
     693                 :            :    BODY is the body of the loop and PRE_BODY statements that go before
     694                 :            :    the loop.  */
     695                 :            : 
     696                 :            : tree
     697                 :      24194 : c_finish_omp_for (location_t locus, enum tree_code code, tree declv,
     698                 :            :                   tree orig_declv, tree initv, tree condv, tree incrv,
     699                 :            :                   tree body, tree pre_body, bool final_p)
     700                 :            : {
     701                 :      24194 :   location_t elocus;
     702                 :      24194 :   bool fail = false;
     703                 :      24194 :   int i;
     704                 :            : 
     705                 :      24194 :   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (initv));
     706                 :      24194 :   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (condv));
     707                 :      24194 :   gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (incrv));
     708                 :      57736 :   for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
     709                 :            :     {
     710                 :      33542 :       tree decl = TREE_VEC_ELT (declv, i);
     711                 :      33542 :       tree init = TREE_VEC_ELT (initv, i);
     712                 :      33542 :       tree cond = TREE_VEC_ELT (condv, i);
     713                 :      33542 :       tree incr = TREE_VEC_ELT (incrv, i);
     714                 :            : 
     715                 :      33542 :       elocus = locus;
     716                 :      33542 :       if (EXPR_HAS_LOCATION (init))
     717                 :      29705 :         elocus = EXPR_LOCATION (init);
     718                 :            : 
     719                 :            :       /* Validate the iteration variable.  */
     720                 :      67084 :       if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))
     721                 :      36184 :           && TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE)
     722                 :            :         {
     723                 :          1 :           error_at (elocus, "invalid type for iteration variable %qE", decl);
     724                 :          1 :           fail = true;
     725                 :            :         }
     726                 :      33541 :       else if (TYPE_ATOMIC (TREE_TYPE (decl)))
     727                 :            :         {
     728                 :         16 :           error_at (elocus, "%<_Atomic%> iteration variable %qE", decl);
     729                 :         16 :           fail = true;
     730                 :            :           /* _Atomic iterator confuses stuff too much, so we risk ICE
     731                 :            :              trying to diagnose it further.  */
     732                 :         16 :           continue;
     733                 :            :         }
     734                 :            : 
     735                 :            :       /* In the case of "for (int i = 0...)", init will be a decl.  It should
     736                 :            :          have a DECL_INITIAL that we can turn into an assignment.  */
     737                 :      33526 :       if (init == decl)
     738                 :            :         {
     739                 :       3009 :           elocus = DECL_SOURCE_LOCATION (decl);
     740                 :            : 
     741                 :       3009 :           init = DECL_INITIAL (decl);
     742                 :       3009 :           if (init == NULL)
     743                 :            :             {
     744                 :          0 :               error_at (elocus, "%qE is not initialized", decl);
     745                 :          0 :               init = integer_zero_node;
     746                 :          0 :               fail = true;
     747                 :            :             }
     748                 :       3009 :           DECL_INITIAL (decl) = NULL_TREE;
     749                 :            : 
     750                 :       3009 :           init = build_modify_expr (elocus, decl, NULL_TREE, NOP_EXPR,
     751                 :            :                                     /* FIXME diagnostics: This should
     752                 :            :                                        be the location of the INIT.  */
     753                 :            :                                     elocus,
     754                 :            :                                     init,
     755                 :            :                                     NULL_TREE);
     756                 :            :         }
     757                 :      33526 :       if (init != error_mark_node)
     758                 :            :         {
     759                 :      33526 :           gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
     760                 :      33526 :           gcc_assert (TREE_OPERAND (init, 0) == decl);
     761                 :            :         }
     762                 :            : 
     763                 :      33526 :       if (cond == NULL_TREE)
     764                 :            :         {
     765                 :          2 :           error_at (elocus, "missing controlling predicate");
     766                 :          2 :           fail = true;
     767                 :            :         }
     768                 :            :       else
     769                 :            :         {
     770                 :      33524 :           bool cond_ok = false;
     771                 :            : 
     772                 :            :           /* E.g. C sizeof (vla) could add COMPOUND_EXPRs with
     773                 :            :              evaluation of the vla VAR_DECL.  We need to readd
     774                 :            :              them to the non-decl operand.  See PR45784.  */
     775                 :      33524 :           while (TREE_CODE (cond) == COMPOUND_EXPR)
     776                 :          0 :             cond = TREE_OPERAND (cond, 1);
     777                 :            : 
     778                 :      33524 :           if (EXPR_HAS_LOCATION (cond))
     779                 :      33411 :             elocus = EXPR_LOCATION (cond);
     780                 :            : 
     781                 :      33524 :           if (TREE_CODE (cond) == LT_EXPR
     782                 :            :               || TREE_CODE (cond) == LE_EXPR
     783                 :            :               || TREE_CODE (cond) == GT_EXPR
     784                 :      33524 :               || TREE_CODE (cond) == GE_EXPR
     785                 :       5224 :               || TREE_CODE (cond) == NE_EXPR
     786                 :         39 :               || TREE_CODE (cond) == EQ_EXPR)
     787                 :            :             {
     788                 :      33485 :               tree op0 = TREE_OPERAND (cond, 0);
     789                 :      33485 :               tree op1 = TREE_OPERAND (cond, 1);
     790                 :            : 
     791                 :            :               /* 2.5.1.  The comparison in the condition is computed in
     792                 :            :                  the type of DECL, otherwise the behavior is undefined.
     793                 :            : 
     794                 :            :                  For example:
     795                 :            :                  long n; int i;
     796                 :            :                  i < n;
     797                 :            : 
     798                 :            :                  according to ISO will be evaluated as:
     799                 :            :                  (long)i < n;
     800                 :            : 
     801                 :            :                  We want to force:
     802                 :            :                  i < (int)n;  */
     803                 :      33485 :               if (TREE_CODE (op0) == NOP_EXPR
     804                 :      33485 :                   && decl == TREE_OPERAND (op0, 0))
     805                 :            :                 {
     806                 :         57 :                   TREE_OPERAND (cond, 0) = TREE_OPERAND (op0, 0);
     807                 :        114 :                   TREE_OPERAND (cond, 1)
     808                 :         57 :                     = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
     809                 :         57 :                                    TREE_OPERAND (cond, 1));
     810                 :            :                 }
     811                 :      33428 :               else if (TREE_CODE (op1) == NOP_EXPR
     812                 :      33428 :                        && decl == TREE_OPERAND (op1, 0))
     813                 :            :                 {
     814                 :          5 :                   TREE_OPERAND (cond, 1) = TREE_OPERAND (op1, 0);
     815                 :         10 :                   TREE_OPERAND (cond, 0)
     816                 :          5 :                     = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
     817                 :          5 :                                    TREE_OPERAND (cond, 0));
     818                 :            :                 }
     819                 :            : 
     820                 :      33485 :               if (decl == TREE_OPERAND (cond, 0))
     821                 :            :                 cond_ok = true;
     822                 :        152 :               else if (decl == TREE_OPERAND (cond, 1))
     823                 :            :                 {
     824                 :        151 :                   TREE_SET_CODE (cond,
     825                 :            :                                  swap_tree_comparison (TREE_CODE (cond)));
     826                 :        151 :                   TREE_OPERAND (cond, 1) = TREE_OPERAND (cond, 0);
     827                 :        151 :                   TREE_OPERAND (cond, 0) = decl;
     828                 :        151 :                   cond_ok = true;
     829                 :            :                 }
     830                 :            : 
     831                 :      33485 :               if (TREE_CODE (cond) == NE_EXPR
     832                 :      33485 :                   || TREE_CODE (cond) == EQ_EXPR)
     833                 :            :                 {
     834                 :       5185 :                   if (!INTEGRAL_TYPE_P (TREE_TYPE (decl)))
     835                 :            :                     {
     836                 :        855 :                       if (code == OACC_LOOP || TREE_CODE (cond) == EQ_EXPR)
     837                 :            :                         cond_ok = false;
     838                 :            :                     }
     839                 :       8660 :                   else if (operand_equal_p (TREE_OPERAND (cond, 1),
     840                 :       4330 :                                             TYPE_MIN_VALUE (TREE_TYPE (decl)),
     841                 :            :                                             0))
     842                 :        222 :                     TREE_SET_CODE (cond, TREE_CODE (cond) == NE_EXPR
     843                 :            :                                          ? GT_EXPR : LE_EXPR);
     844                 :       8216 :                   else if (operand_equal_p (TREE_OPERAND (cond, 1),
     845                 :       4108 :                                             TYPE_MAX_VALUE (TREE_TYPE (decl)),
     846                 :            :                                             0))
     847                 :          6 :                     TREE_SET_CODE (cond, TREE_CODE (cond) == NE_EXPR
     848                 :            :                                          ? LT_EXPR : GE_EXPR);
     849                 :       4102 :                   else if (code == OACC_LOOP || TREE_CODE (cond) == EQ_EXPR)
     850                 :            :                     cond_ok = false;
     851                 :            :                 }
     852                 :            : 
     853                 :      33485 :               if (cond_ok && TREE_VEC_ELT (condv, i) != cond)
     854                 :            :                 {
     855                 :          0 :                   tree ce = NULL_TREE, *pce = &ce;
     856                 :          0 :                   tree type = TREE_TYPE (TREE_OPERAND (cond, 1));
     857                 :          0 :                   for (tree c = TREE_VEC_ELT (condv, i); c != cond;
     858                 :          0 :                        c = TREE_OPERAND (c, 1))
     859                 :            :                     {
     860                 :          0 :                       *pce = build2 (COMPOUND_EXPR, type, TREE_OPERAND (c, 0),
     861                 :          0 :                                      TREE_OPERAND (cond, 1));
     862                 :          0 :                       pce = &TREE_OPERAND (*pce, 1);
     863                 :            :                     }
     864                 :          0 :                   TREE_OPERAND (cond, 1) = ce;
     865                 :          0 :                   TREE_VEC_ELT (condv, i) = cond;
     866                 :            :                 }
     867                 :            :             }
     868                 :            : 
     869                 :      33485 :           if (!cond_ok)
     870                 :            :             {
     871                 :         40 :               error_at (elocus, "invalid controlling predicate");
     872                 :         40 :               fail = true;
     873                 :            :             }
     874                 :            :         }
     875                 :            : 
     876                 :      33526 :       if (incr == NULL_TREE)
     877                 :            :         {
     878                 :          0 :           error_at (elocus, "missing increment expression");
     879                 :          0 :           fail = true;
     880                 :            :         }
     881                 :            :       else
     882                 :            :         {
     883                 :      33526 :           bool incr_ok = false;
     884                 :            : 
     885                 :      33526 :           if (EXPR_HAS_LOCATION (incr))
     886                 :      32979 :             elocus = EXPR_LOCATION (incr);
     887                 :            : 
     888                 :            :           /* Check all the valid increment expressions: v++, v--, ++v, --v,
     889                 :            :              v = v + incr, v = incr + v and v = v - incr.  */
     890                 :      33526 :           switch (TREE_CODE (incr))
     891                 :            :             {
     892                 :      24080 :             case POSTINCREMENT_EXPR:
     893                 :      24080 :             case PREINCREMENT_EXPR:
     894                 :      24080 :             case POSTDECREMENT_EXPR:
     895                 :      24080 :             case PREDECREMENT_EXPR:
     896                 :      24080 :               if (TREE_OPERAND (incr, 0) != decl)
     897                 :            :                 break;
     898                 :            : 
     899                 :      24073 :               incr_ok = true;
     900                 :      24073 :               if (!fail
     901                 :      24042 :                   && TREE_CODE (cond) == NE_EXPR
     902                 :       3344 :                   && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
     903                 :        723 :                   && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))
     904                 :      24796 :                   && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))))
     905                 :            :                       != INTEGER_CST))
     906                 :            :                 {
     907                 :            :                   /* For pointer to VLA, transform != into < or >
     908                 :            :                      depending on whether incr is increment or decrement.  */
     909                 :          4 :                   if (TREE_CODE (incr) == PREINCREMENT_EXPR
     910                 :          4 :                       || TREE_CODE (incr) == POSTINCREMENT_EXPR)
     911                 :          2 :                     TREE_SET_CODE (cond, LT_EXPR);
     912                 :            :                   else
     913                 :          2 :                     TREE_SET_CODE (cond, GT_EXPR);
     914                 :            :                 }
     915                 :      24073 :               incr = c_omp_for_incr_canonicalize_ptr (elocus, decl, incr);
     916                 :      24073 :               break;
     917                 :            : 
     918                 :         16 :             case COMPOUND_EXPR:
     919                 :         16 :               if (TREE_CODE (TREE_OPERAND (incr, 0)) != SAVE_EXPR
     920                 :         16 :                   || TREE_CODE (TREE_OPERAND (incr, 1)) != MODIFY_EXPR)
     921                 :            :                 break;
     922                 :         10 :               incr = TREE_OPERAND (incr, 1);
     923                 :            :               /* FALLTHRU */
     924                 :       9426 :             case MODIFY_EXPR:
     925                 :       9426 :               if (TREE_OPERAND (incr, 0) != decl)
     926                 :            :                 break;
     927                 :       9426 :               if (TREE_OPERAND (incr, 1) == decl)
     928                 :            :                 break;
     929                 :       9426 :               if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
     930                 :       9426 :                   && (TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl
     931                 :        165 :                       || TREE_OPERAND (TREE_OPERAND (incr, 1), 1) == decl))
     932                 :            :                 incr_ok = true;
     933                 :       2039 :               else if ((TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR
     934                 :       1028 :                         || (TREE_CODE (TREE_OPERAND (incr, 1))
     935                 :            :                             == POINTER_PLUS_EXPR))
     936                 :       2867 :                        && TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl)
     937                 :            :                 incr_ok = true;
     938                 :            :               else
     939                 :            :                 {
     940                 :        204 :                   tree t = check_omp_for_incr_expr (elocus,
     941                 :        204 :                                                     TREE_OPERAND (incr, 1),
     942                 :            :                                                     decl);
     943                 :        204 :                   if (t != error_mark_node)
     944                 :            :                     {
     945                 :        190 :                       incr_ok = true;
     946                 :        190 :                       t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
     947                 :        190 :                       incr = build2 (MODIFY_EXPR, void_type_node, decl, t);
     948                 :            :                     }
     949                 :            :                 }
     950                 :       9426 :               if (!fail
     951                 :       9426 :                   && incr_ok
     952                 :       9405 :                   && TREE_CODE (cond) == NE_EXPR)
     953                 :            :                 {
     954                 :       1613 :                   tree i = TREE_OPERAND (incr, 1);
     955                 :       1613 :                   i = TREE_OPERAND (i, TREE_OPERAND (i, 0) == decl);
     956                 :       1613 :                   i = c_fully_fold (i, false, NULL);
     957                 :       1613 :                   if (!final_p
     958                 :          4 :                       && TREE_CODE (i) != INTEGER_CST)
     959                 :            :                     ;
     960                 :       1613 :                   else if (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
     961                 :            :                     {
     962                 :        132 :                       tree unit
     963                 :        132 :                         = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
     964                 :        132 :                       if (unit)
     965                 :            :                         {
     966                 :        132 :                           enum tree_code ccode = GT_EXPR;
     967                 :        132 :                           unit = c_fully_fold (unit, false, NULL);
     968                 :        132 :                           i = fold_convert (TREE_TYPE (unit), i);
     969                 :        132 :                           if (operand_equal_p (unit, i, 0))
     970                 :            :                             ccode = LT_EXPR;
     971                 :        111 :                           if (ccode == GT_EXPR)
     972                 :            :                             {
     973                 :        111 :                               i = fold_unary (NEGATE_EXPR, TREE_TYPE (i), i);
     974                 :        111 :                               if (i == NULL_TREE
     975                 :        111 :                                   || !operand_equal_p (unit, i, 0))
     976                 :            :                                 {
     977                 :         90 :                                   error_at (elocus,
     978                 :            :                                             "increment is not constant 1 or "
     979                 :            :                                             "-1 for %<!=%> condition");
     980                 :         90 :                                   fail = true;
     981                 :            :                                 }
     982                 :            :                             }
     983                 :        132 :                           if (TREE_CODE (unit) != INTEGER_CST)
     984                 :            :                             /* For pointer to VLA, transform != into < or >
     985                 :            :                                depending on whether the pointer is
     986                 :            :                                incremented or decremented in each
     987                 :            :                                iteration.  */
     988                 :         72 :                             TREE_SET_CODE (cond, ccode);
     989                 :            :                         }
     990                 :            :                     }
     991                 :            :                   else
     992                 :            :                     {
     993                 :       1481 :                       if (!integer_onep (i) && !integer_minus_onep (i))
     994                 :            :                         {
     995                 :        172 :                           error_at (elocus,
     996                 :            :                                     "increment is not constant 1 or -1 for"
     997                 :            :                                     " %<!=%> condition");
     998                 :        172 :                           fail = true;
     999                 :            :                         }
    1000                 :            :                     }
    1001                 :            :                 }
    1002                 :            :               break;
    1003                 :            : 
    1004                 :            :             default:
    1005                 :            :               break;
    1006                 :            :             }
    1007                 :      33526 :           if (!incr_ok)
    1008                 :            :             {
    1009                 :         41 :               error_at (elocus, "invalid increment expression");
    1010                 :         41 :               fail = true;
    1011                 :            :             }
    1012                 :            :         }
    1013                 :            : 
    1014                 :      33526 :       TREE_VEC_ELT (initv, i) = init;
    1015                 :      33526 :       TREE_VEC_ELT (incrv, i) = incr;
    1016                 :            :     }
    1017                 :            : 
    1018                 :      24194 :   if (fail)
    1019                 :            :     return NULL;
    1020                 :            :   else
    1021                 :            :     {
    1022                 :      23837 :       tree t = make_node (code);
    1023                 :            : 
    1024                 :      23837 :       TREE_TYPE (t) = void_type_node;
    1025                 :      47674 :       OMP_FOR_INIT (t) = initv;
    1026                 :      47674 :       OMP_FOR_COND (t) = condv;
    1027                 :      47674 :       OMP_FOR_INCR (t) = incrv;
    1028                 :      47674 :       OMP_FOR_BODY (t) = body;
    1029                 :      47674 :       OMP_FOR_PRE_BODY (t) = pre_body;
    1030                 :      47674 :       OMP_FOR_ORIG_DECLS (t) = orig_declv;
    1031                 :            : 
    1032                 :      23837 :       SET_EXPR_LOCATION (t, locus);
    1033                 :      23837 :       return t;
    1034                 :            :     }
    1035                 :            : }
    1036                 :            : 
    1037                 :            : /* Type for passing data in between c_omp_check_loop_iv and
    1038                 :            :    c_omp_check_loop_iv_r.  */
    1039                 :            : 
    1040                 :            : struct c_omp_check_loop_iv_data
    1041                 :            : {
    1042                 :            :   tree declv;
    1043                 :            :   bool fail;
    1044                 :            :   location_t stmt_loc;
    1045                 :            :   location_t expr_loc;
    1046                 :            :   int kind;
    1047                 :            :   walk_tree_lh lh;
    1048                 :            :   hash_set<tree> *ppset;
    1049                 :            : };
    1050                 :            : 
    1051                 :            : /* Helper function called via walk_tree, to diagnose uses
    1052                 :            :    of associated loop IVs inside of lb, b and incr expressions
    1053                 :            :    of OpenMP loops.  */
    1054                 :            :    
    1055                 :            : static tree
    1056                 :     106486 : c_omp_check_loop_iv_r (tree *tp, int *walk_subtrees, void *data)
    1057                 :            : {
    1058                 :     106486 :   struct c_omp_check_loop_iv_data *d
    1059                 :            :     = (struct c_omp_check_loop_iv_data *) data;
    1060                 :     106486 :   if (DECL_P (*tp))
    1061                 :            :     {
    1062                 :            :       int i;
    1063                 :      62601 :       for (i = 0; i < TREE_VEC_LENGTH (d->declv); i++)
    1064                 :      42822 :         if (*tp == TREE_VEC_ELT (d->declv, i)
    1065                 :      42142 :             || (TREE_CODE (TREE_VEC_ELT (d->declv, i)) == TREE_LIST
    1066                 :        935 :                 && *tp == TREE_PURPOSE (TREE_VEC_ELT (d->declv, i)))
    1067                 :      84872 :             || (TREE_CODE (TREE_VEC_ELT (d->declv, i)) == TREE_LIST
    1068                 :        843 :                 && TREE_CHAIN (TREE_VEC_ELT (d->declv, i))
    1069                 :        250 :                 && (TREE_CODE (TREE_CHAIN (TREE_VEC_ELT (d->declv, i)))
    1070                 :            :                     == TREE_VEC)
    1071                 :        250 :                 && *tp == TREE_VEC_ELT (TREE_CHAIN (TREE_VEC_ELT (d->declv,
    1072                 :            :                                                                   i)), 2)))
    1073                 :            :           {
    1074                 :        776 :             location_t loc = d->expr_loc;
    1075                 :        776 :             if (loc == UNKNOWN_LOCATION)
    1076                 :        227 :               loc = d->stmt_loc;
    1077                 :        776 :             switch (d->kind)
    1078                 :            :               {
    1079                 :        235 :               case 0:
    1080                 :        235 :                 error_at (loc, "initializer expression refers to "
    1081                 :            :                                "iteration variable %qD", *tp);
    1082                 :        235 :                 break;
    1083                 :        275 :               case 1:
    1084                 :        275 :                 error_at (loc, "condition expression refers to "
    1085                 :            :                                "iteration variable %qD", *tp);
    1086                 :        275 :                 break;
    1087                 :        266 :               case 2:
    1088                 :        266 :                 error_at (loc, "increment expression refers to "
    1089                 :            :                                "iteration variable %qD", *tp);
    1090                 :        266 :                 break;
    1091                 :            :               }
    1092                 :        776 :             d->fail = true;
    1093                 :            :           }
    1094                 :            :     }
    1095                 :            :   /* Don't walk dtors added by C++ wrap_cleanups_r.  */
    1096                 :      86707 :   else if (TREE_CODE (*tp) == TRY_CATCH_EXPR
    1097                 :      86707 :            && TRY_CATCH_IS_CLEANUP (*tp))
    1098                 :            :     {
    1099                 :         25 :       *walk_subtrees = 0;
    1100                 :         25 :       return walk_tree_1 (&TREE_OPERAND (*tp, 0), c_omp_check_loop_iv_r, data,
    1101                 :         25 :                           d->ppset, d->lh);
    1102                 :            :     }
    1103                 :            : 
    1104                 :            :   return NULL_TREE;
    1105                 :            : }
    1106                 :            : 
    1107                 :            : /* Diagnose invalid references to loop iterators in lb, b and incr
    1108                 :            :    expressions.  */
    1109                 :            : 
    1110                 :            : bool
    1111                 :      23837 : c_omp_check_loop_iv (tree stmt, tree declv, walk_tree_lh lh)
    1112                 :            : {
    1113                 :      23837 :   hash_set<tree> pset;
    1114                 :      23837 :   struct c_omp_check_loop_iv_data data;
    1115                 :      23837 :   int i;
    1116                 :            : 
    1117                 :      23837 :   data.declv = declv;
    1118                 :      23837 :   data.fail = false;
    1119                 :      23837 :   data.stmt_loc = EXPR_LOCATION (stmt);
    1120                 :      23837 :   data.lh = lh;
    1121                 :      23837 :   data.ppset = &pset;
    1122                 :     114034 :   for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (stmt)); i++)
    1123                 :            :     {
    1124                 :      33180 :       tree init = TREE_VEC_ELT (OMP_FOR_INIT (stmt), i);
    1125                 :      33180 :       gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
    1126                 :      33180 :       tree decl = TREE_OPERAND (init, 0);
    1127                 :      33180 :       tree cond = TREE_VEC_ELT (OMP_FOR_COND (stmt), i);
    1128                 :      33180 :       gcc_assert (COMPARISON_CLASS_P (cond));
    1129                 :      33180 :       gcc_assert (TREE_OPERAND (cond, 0) == decl);
    1130                 :      33180 :       tree incr = TREE_VEC_ELT (OMP_FOR_INCR (stmt), i);
    1131                 :      33180 :       data.expr_loc = EXPR_LOCATION (TREE_OPERAND (init, 1));
    1132                 :      33180 :       data.kind = 0;
    1133                 :      33180 :       walk_tree_1 (&TREE_OPERAND (init, 1),
    1134                 :            :                    c_omp_check_loop_iv_r, &data, &pset, lh);
    1135                 :            :       /* Don't warn for C++ random access iterators here, the
    1136                 :            :          expression then involves the subtraction and always refers
    1137                 :            :          to the original value.  The C++ FE needs to warn on those
    1138                 :            :          earlier.  */
    1139                 :      33180 :       if (decl == TREE_VEC_ELT (declv, i)
    1140                 :      33180 :           || (TREE_CODE (TREE_VEC_ELT (declv, i)) == TREE_LIST
    1141                 :        774 :               && decl == TREE_PURPOSE (TREE_VEC_ELT (declv, i))))
    1142                 :            :         {
    1143                 :      32406 :           data.expr_loc = EXPR_LOCATION (cond);
    1144                 :      32406 :           data.kind = 1;
    1145                 :      32406 :           walk_tree_1 (&TREE_OPERAND (cond, 1),
    1146                 :            :                        c_omp_check_loop_iv_r, &data, &pset, lh);
    1147                 :            :         }
    1148                 :      33180 :       if (TREE_CODE (incr) == MODIFY_EXPR)
    1149                 :            :         {
    1150                 :      10942 :           gcc_assert (TREE_OPERAND (incr, 0) == decl);
    1151                 :      10942 :           incr = TREE_OPERAND (incr, 1);
    1152                 :      10942 :           data.kind = 2;
    1153                 :      10942 :           if (TREE_CODE (incr) == PLUS_EXPR
    1154                 :      10942 :               && TREE_OPERAND (incr, 1) == decl)
    1155                 :            :             {
    1156                 :        174 :               data.expr_loc = EXPR_LOCATION (TREE_OPERAND (incr, 0));
    1157                 :        174 :               walk_tree_1 (&TREE_OPERAND (incr, 0),
    1158                 :            :                            c_omp_check_loop_iv_r, &data, &pset, lh);
    1159                 :            :             }
    1160                 :            :           else
    1161                 :            :             {
    1162                 :      10768 :               data.expr_loc = EXPR_LOCATION (TREE_OPERAND (incr, 1));
    1163                 :      10768 :               walk_tree_1 (&TREE_OPERAND (incr, 1),
    1164                 :            :                            c_omp_check_loop_iv_r, &data, &pset, lh);
    1165                 :            :             }
    1166                 :            :         }
    1167                 :            :     }
    1168                 :      23837 :   return !data.fail;
    1169                 :            : }
    1170                 :            : 
    1171                 :            : /* Similar, but allows to check the init or cond expressions individually.  */
    1172                 :            : 
    1173                 :            : bool
    1174                 :       1851 : c_omp_check_loop_iv_exprs (location_t stmt_loc, tree declv, tree decl,
    1175                 :            :                            tree init, tree cond, walk_tree_lh lh)
    1176                 :            : {
    1177                 :       1851 :   hash_set<tree> pset;
    1178                 :       1851 :   struct c_omp_check_loop_iv_data data;
    1179                 :            : 
    1180                 :       1851 :   data.declv = declv;
    1181                 :       1851 :   data.fail = false;
    1182                 :       1851 :   data.stmt_loc = stmt_loc;
    1183                 :       1851 :   data.lh = lh;
    1184                 :       1851 :   data.ppset = &pset;
    1185                 :       1851 :   if (init)
    1186                 :            :     {
    1187                 :       1031 :       data.expr_loc = EXPR_LOCATION (init);
    1188                 :       1031 :       data.kind = 0;
    1189                 :       1031 :       walk_tree_1 (&init,
    1190                 :            :                    c_omp_check_loop_iv_r, &data, &pset, lh);
    1191                 :            :     }
    1192                 :       1851 :   if (cond)
    1193                 :            :     {
    1194                 :        820 :       gcc_assert (COMPARISON_CLASS_P (cond));
    1195                 :        820 :       data.expr_loc = EXPR_LOCATION (init);
    1196                 :        820 :       data.kind = 1;
    1197                 :        820 :       if (TREE_OPERAND (cond, 0) == decl)
    1198                 :        820 :         walk_tree_1 (&TREE_OPERAND (cond, 1),
    1199                 :            :                      c_omp_check_loop_iv_r, &data, &pset, lh);
    1200                 :            :       else
    1201                 :          0 :         walk_tree_1 (&TREE_OPERAND (cond, 0),
    1202                 :            :                      c_omp_check_loop_iv_r, &data, &pset, lh);
    1203                 :            :     }
    1204                 :       1851 :   return !data.fail;
    1205                 :            : }
    1206                 :            : 
    1207                 :            : /* This function splits clauses for OpenACC combined loop
    1208                 :            :    constructs.  OpenACC combined loop constructs are:
    1209                 :            :    #pragma acc kernels loop
    1210                 :            :    #pragma acc parallel loop  */
    1211                 :            : 
    1212                 :            : tree
    1213                 :       1533 : c_oacc_split_loop_clauses (tree clauses, tree *not_loop_clauses,
    1214                 :            :                            bool is_parallel)
    1215                 :            : {
    1216                 :       1533 :   tree next, loop_clauses, nc;
    1217                 :            : 
    1218                 :       1533 :   loop_clauses = *not_loop_clauses = NULL_TREE;
    1219                 :       3125 :   for (; clauses ; clauses = next)
    1220                 :            :     {
    1221                 :       1592 :       next = OMP_CLAUSE_CHAIN (clauses);
    1222                 :            : 
    1223                 :       1592 :       switch (OMP_CLAUSE_CODE (clauses))
    1224                 :            :         {
    1225                 :            :           /* Loop clauses.  */
    1226                 :       1095 :         case OMP_CLAUSE_COLLAPSE:
    1227                 :       1095 :         case OMP_CLAUSE_TILE:
    1228                 :       1095 :         case OMP_CLAUSE_GANG:
    1229                 :       1095 :         case OMP_CLAUSE_WORKER:
    1230                 :       1095 :         case OMP_CLAUSE_VECTOR:
    1231                 :       1095 :         case OMP_CLAUSE_AUTO:
    1232                 :       1095 :         case OMP_CLAUSE_SEQ:
    1233                 :       1095 :         case OMP_CLAUSE_INDEPENDENT:
    1234                 :       1095 :         case OMP_CLAUSE_PRIVATE:
    1235                 :       1095 :           OMP_CLAUSE_CHAIN (clauses) = loop_clauses;
    1236                 :       1095 :           loop_clauses = clauses;
    1237                 :       1095 :           break;
    1238                 :            : 
    1239                 :            :           /* Reductions must be duplicated on both constructs.  */
    1240                 :         49 :         case OMP_CLAUSE_REDUCTION:
    1241                 :         49 :           if (is_parallel)
    1242                 :            :             {
    1243                 :         40 :               nc = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1244                 :            :                                      OMP_CLAUSE_REDUCTION);
    1245                 :         40 :               OMP_CLAUSE_DECL (nc) = OMP_CLAUSE_DECL (clauses);
    1246                 :         40 :               OMP_CLAUSE_REDUCTION_CODE (nc)
    1247                 :         40 :                 = OMP_CLAUSE_REDUCTION_CODE (clauses);
    1248                 :         40 :               OMP_CLAUSE_CHAIN (nc) = *not_loop_clauses;
    1249                 :         40 :               *not_loop_clauses = nc;
    1250                 :            :             }
    1251                 :            : 
    1252                 :         49 :           OMP_CLAUSE_CHAIN (clauses) = loop_clauses;
    1253                 :         49 :           loop_clauses = clauses;
    1254                 :         49 :           break;
    1255                 :            : 
    1256                 :            :           /* Parallel/kernels clauses.  */
    1257                 :        448 :         default:
    1258                 :        448 :           OMP_CLAUSE_CHAIN (clauses) = *not_loop_clauses;
    1259                 :        448 :           *not_loop_clauses = clauses;
    1260                 :        448 :           break;
    1261                 :            :         }
    1262                 :            :     }
    1263                 :            : 
    1264                 :       1533 :   return loop_clauses;
    1265                 :            : }
    1266                 :            : 
    1267                 :            : /* This function attempts to split or duplicate clauses for OpenMP
    1268                 :            :    combined/composite constructs.  Right now there are 30 different
    1269                 :            :    constructs.  CODE is the innermost construct in the combined construct,
    1270                 :            :    and MASK allows to determine which constructs are combined together,
    1271                 :            :    as every construct has at least one clause that no other construct
    1272                 :            :    has (except for OMP_SECTIONS, but that can be only combined with parallel,
    1273                 :            :    and OMP_MASTER, which doesn't have any clauses at all).
    1274                 :            :    OpenMP combined/composite constructs are:
    1275                 :            :    #pragma omp distribute parallel for
    1276                 :            :    #pragma omp distribute parallel for simd
    1277                 :            :    #pragma omp distribute simd
    1278                 :            :    #pragma omp for simd
    1279                 :            :    #pragma omp master taskloop
    1280                 :            :    #pragma omp master taskloop simd
    1281                 :            :    #pragma omp parallel for
    1282                 :            :    #pragma omp parallel for simd
    1283                 :            :    #pragma omp parallel loop
    1284                 :            :    #pragma omp parallel master
    1285                 :            :    #pragma omp parallel master taskloop
    1286                 :            :    #pragma omp parallel master taskloop simd
    1287                 :            :    #pragma omp parallel sections
    1288                 :            :    #pragma omp target parallel
    1289                 :            :    #pragma omp target parallel for
    1290                 :            :    #pragma omp target parallel for simd
    1291                 :            :    #pragma omp target parallel loop
    1292                 :            :    #pragma omp target teams
    1293                 :            :    #pragma omp target teams distribute
    1294                 :            :    #pragma omp target teams distribute parallel for
    1295                 :            :    #pragma omp target teams distribute parallel for simd
    1296                 :            :    #pragma omp target teams distribute simd
    1297                 :            :    #pragma omp target teams loop
    1298                 :            :    #pragma omp target simd
    1299                 :            :    #pragma omp taskloop simd
    1300                 :            :    #pragma omp teams distribute
    1301                 :            :    #pragma omp teams distribute parallel for
    1302                 :            :    #pragma omp teams distribute parallel for simd
    1303                 :            :    #pragma omp teams distribute simd
    1304                 :            :    #pragma omp teams loop  */
    1305                 :            : 
    1306                 :            : void
    1307                 :      10852 : c_omp_split_clauses (location_t loc, enum tree_code code,
    1308                 :            :                      omp_clause_mask mask, tree clauses, tree *cclauses)
    1309                 :            : {
    1310                 :      10852 :   tree next, c;
    1311                 :      10852 :   enum c_omp_clause_split s;
    1312                 :      10852 :   int i;
    1313                 :            : 
    1314                 :      75964 :   for (i = 0; i < C_OMP_CLAUSE_SPLIT_COUNT; i++)
    1315                 :      65112 :     cclauses[i] = NULL;
    1316                 :            :   /* Add implicit nowait clause on
    1317                 :            :      #pragma omp parallel {for,for simd,sections}.  */
    1318                 :      10852 :   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
    1319                 :       8637 :     switch (code)
    1320                 :            :       {
    1321                 :       8409 :       case OMP_FOR:
    1322                 :       8409 :       case OMP_SIMD:
    1323                 :      19227 :         if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
    1324                 :       8375 :           cclauses[C_OMP_CLAUSE_SPLIT_FOR]
    1325                 :       8375 :             = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
    1326                 :            :         break;
    1327                 :        123 :       case OMP_SECTIONS:
    1328                 :        123 :         cclauses[C_OMP_CLAUSE_SPLIT_SECTIONS]
    1329                 :        123 :           = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
    1330                 :        123 :         break;
    1331                 :            :       default:
    1332                 :            :         break;
    1333                 :            :       }
    1334                 :            : 
    1335                 :      32997 :   for (; clauses ; clauses = next)
    1336                 :            :     {
    1337                 :      22145 :       next = OMP_CLAUSE_CHAIN (clauses);
    1338                 :            : 
    1339                 :      22145 :       switch (OMP_CLAUSE_CODE (clauses))
    1340                 :            :         {
    1341                 :            :         /* First the clauses that are unique to some constructs.  */
    1342                 :            :         case OMP_CLAUSE_DEVICE:
    1343                 :            :         case OMP_CLAUSE_MAP:
    1344                 :            :         case OMP_CLAUSE_IS_DEVICE_PTR:
    1345                 :            :         case OMP_CLAUSE_DEFAULTMAP:
    1346                 :            :         case OMP_CLAUSE_DEPEND:
    1347                 :            :           s = C_OMP_CLAUSE_SPLIT_TARGET;
    1348                 :            :           break;
    1349                 :        512 :         case OMP_CLAUSE_NUM_TEAMS:
    1350                 :        512 :         case OMP_CLAUSE_THREAD_LIMIT:
    1351                 :        512 :           s = C_OMP_CLAUSE_SPLIT_TEAMS;
    1352                 :        512 :           break;
    1353                 :       3021 :         case OMP_CLAUSE_DIST_SCHEDULE:
    1354                 :       3021 :           s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1355                 :       3021 :           break;
    1356                 :        594 :         case OMP_CLAUSE_COPYIN:
    1357                 :        594 :         case OMP_CLAUSE_NUM_THREADS:
    1358                 :        594 :         case OMP_CLAUSE_PROC_BIND:
    1359                 :        594 :           s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1360                 :        594 :           break;
    1361                 :        130 :         case OMP_CLAUSE_ORDERED:
    1362                 :        130 :           s = C_OMP_CLAUSE_SPLIT_FOR;
    1363                 :        130 :           break;
    1364                 :       5828 :         case OMP_CLAUSE_SCHEDULE:
    1365                 :       5828 :           s = C_OMP_CLAUSE_SPLIT_FOR;
    1366                 :       5828 :           if (code != OMP_SIMD)
    1367                 :       2970 :             OMP_CLAUSE_SCHEDULE_SIMD (clauses) = 0;
    1368                 :            :           break;
    1369                 :        584 :         case OMP_CLAUSE_SAFELEN:
    1370                 :        584 :         case OMP_CLAUSE_SIMDLEN:
    1371                 :        584 :         case OMP_CLAUSE_ALIGNED:
    1372                 :        584 :         case OMP_CLAUSE_NONTEMPORAL:
    1373                 :        584 :           s = C_OMP_CLAUSE_SPLIT_SIMD;
    1374                 :        584 :           break;
    1375                 :        286 :         case OMP_CLAUSE_GRAINSIZE:
    1376                 :        286 :         case OMP_CLAUSE_NUM_TASKS:
    1377                 :        286 :         case OMP_CLAUSE_FINAL:
    1378                 :        286 :         case OMP_CLAUSE_UNTIED:
    1379                 :        286 :         case OMP_CLAUSE_MERGEABLE:
    1380                 :        286 :         case OMP_CLAUSE_NOGROUP:
    1381                 :        286 :         case OMP_CLAUSE_PRIORITY:
    1382                 :        286 :           s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1383                 :        286 :           break;
    1384                 :         24 :         case OMP_CLAUSE_BIND:
    1385                 :         24 :           s = C_OMP_CLAUSE_SPLIT_LOOP;
    1386                 :         24 :           break;
    1387                 :            :         /* Duplicate this to all of taskloop, distribute, for, simd and
    1388                 :            :            loop.  */
    1389                 :       3984 :         case OMP_CLAUSE_COLLAPSE:
    1390                 :       3984 :           if (code == OMP_SIMD)
    1391                 :            :             {
    1392                 :       2082 :               if ((mask & ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)
    1393                 :       2082 :                            | (OMP_CLAUSE_MASK_1
    1394                 :       2082 :                               << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)
    1395                 :       2082 :                            | (OMP_CLAUSE_MASK_1
    1396                 :       2082 :                               << PRAGMA_OMP_CLAUSE_NOGROUP))) != 0)
    1397                 :            :                 {
    1398                 :       2039 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1399                 :            :                                         OMP_CLAUSE_COLLAPSE);
    1400                 :       2039 :                   OMP_CLAUSE_COLLAPSE_EXPR (c)
    1401                 :       2039 :                     = OMP_CLAUSE_COLLAPSE_EXPR (clauses);
    1402                 :       2039 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
    1403                 :       2039 :                   cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
    1404                 :            :                 }
    1405                 :            :               else
    1406                 :            :                 {
    1407                 :            :                   /* This must be #pragma omp target simd */
    1408                 :            :                   s = C_OMP_CLAUSE_SPLIT_SIMD;
    1409                 :            :                   break;
    1410                 :            :                 }
    1411                 :            :             }
    1412                 :       3941 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
    1413                 :            :             {
    1414                 :       3346 :               if ((mask & (OMP_CLAUSE_MASK_1
    1415                 :       3346 :                            << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
    1416                 :            :                 {
    1417                 :       2393 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1418                 :            :                                         OMP_CLAUSE_COLLAPSE);
    1419                 :       2393 :                   OMP_CLAUSE_COLLAPSE_EXPR (c)
    1420                 :       2393 :                     = OMP_CLAUSE_COLLAPSE_EXPR (clauses);
    1421                 :       2393 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
    1422                 :       2393 :                   cclauses[C_OMP_CLAUSE_SPLIT_FOR] = c;
    1423                 :       2393 :                   s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1424                 :            :                 }
    1425                 :            :               else
    1426                 :            :                 s = C_OMP_CLAUSE_SPLIT_FOR;
    1427                 :            :             }
    1428                 :        595 :           else if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))
    1429                 :        595 :                    != 0)
    1430                 :            :             s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1431                 :        494 :           else if (code == OMP_LOOP)
    1432                 :            :             s = C_OMP_CLAUSE_SPLIT_LOOP;
    1433                 :            :           else
    1434                 :        450 :             s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1435                 :            :           break;
    1436                 :            :         /* Private clause is supported on all constructs but master,
    1437                 :            :            it is enough to put it on the innermost one other than master.  For
    1438                 :            :            #pragma omp {for,sections} put it on parallel though,
    1439                 :            :            as that's what we did for OpenMP 3.1.  */
    1440                 :        516 :         case OMP_CLAUSE_PRIVATE:
    1441                 :        516 :           switch (code)
    1442                 :            :             {
    1443                 :            :             case OMP_SIMD: s = C_OMP_CLAUSE_SPLIT_SIMD; break;
    1444                 :        163 :             case OMP_FOR: case OMP_SECTIONS:
    1445                 :        163 :             case OMP_PARALLEL: s = C_OMP_CLAUSE_SPLIT_PARALLEL; break;
    1446                 :         30 :             case OMP_DISTRIBUTE: s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE; break;
    1447                 :         30 :             case OMP_TEAMS: s = C_OMP_CLAUSE_SPLIT_TEAMS; break;
    1448                 :         12 :             case OMP_MASTER: s = C_OMP_CLAUSE_SPLIT_PARALLEL; break;
    1449                 :         20 :             case OMP_TASKLOOP: s = C_OMP_CLAUSE_SPLIT_TASKLOOP; break;
    1450                 :         44 :             case OMP_LOOP: s = C_OMP_CLAUSE_SPLIT_LOOP; break;
    1451                 :          0 :             default: gcc_unreachable ();
    1452                 :            :             }
    1453                 :            :           break;
    1454                 :            :         /* Firstprivate clause is supported on all constructs but
    1455                 :            :            simd, master and loop.  Put it on the outermost of those and
    1456                 :            :            duplicate on teams and parallel.  */
    1457                 :        794 :         case OMP_CLAUSE_FIRSTPRIVATE:
    1458                 :        794 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP))
    1459                 :        794 :               != 0)
    1460                 :            :             {
    1461                 :        167 :               if (code == OMP_SIMD
    1462                 :        167 :                   && (mask & ((OMP_CLAUSE_MASK_1
    1463                 :         66 :                                << PRAGMA_OMP_CLAUSE_NUM_THREADS)
    1464                 :         66 :                               | (OMP_CLAUSE_MASK_1
    1465                 :         66 :                                  << PRAGMA_OMP_CLAUSE_NUM_TEAMS))) == 0)
    1466                 :            :                 {
    1467                 :            :                   /* This must be #pragma omp target simd.  */
    1468                 :            :                   s = C_OMP_CLAUSE_SPLIT_TARGET;
    1469                 :            :                   break;
    1470                 :            :                 }
    1471                 :        162 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1472                 :            :                                     OMP_CLAUSE_FIRSTPRIVATE);
    1473                 :        162 :               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1474                 :        162 :               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
    1475                 :        162 :               cclauses[C_OMP_CLAUSE_SPLIT_TARGET] = c;
    1476                 :            :             }
    1477                 :        789 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
    1478                 :        789 :               != 0)
    1479                 :            :             {
    1480                 :        525 :               if ((mask & ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS)
    1481                 :        525 :                            | (OMP_CLAUSE_MASK_1
    1482                 :        525 :                               << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE))) != 0)
    1483                 :            :                 {
    1484                 :        262 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1485                 :            :                                         OMP_CLAUSE_FIRSTPRIVATE);
    1486                 :        262 :                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1487                 :        262 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
    1488                 :        262 :                   cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] = c;
    1489                 :        262 :                   if ((mask & (OMP_CLAUSE_MASK_1
    1490                 :        262 :                                << PRAGMA_OMP_CLAUSE_NUM_TEAMS)) != 0)
    1491                 :            :                     s = C_OMP_CLAUSE_SPLIT_TEAMS;
    1492                 :            :                   else
    1493                 :            :                     s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1494                 :            :                 }
    1495                 :        263 :               else if ((mask & (OMP_CLAUSE_MASK_1
    1496                 :        263 :                                 << PRAGMA_OMP_CLAUSE_NOGROUP)) != 0)
    1497                 :            :                 /* This must be
    1498                 :            :                    #pragma omp parallel master taskloop{, simd}.  */
    1499                 :            :                 s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1500                 :            :               else
    1501                 :            :                 /* This must be
    1502                 :            :                    #pragma omp parallel{, for{, simd}, sections,loop}
    1503                 :            :                    or
    1504                 :            :                    #pragma omp target parallel.  */
    1505                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1506                 :            :             }
    1507                 :        264 :           else if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
    1508                 :        264 :                    != 0)
    1509                 :            :             {
    1510                 :            :               /* This must be one of
    1511                 :            :                  #pragma omp {,target }teams {distribute,loop}
    1512                 :            :                  #pragma omp target teams
    1513                 :            :                  #pragma omp {,target }teams distribute simd.  */
    1514                 :        147 :               gcc_assert (code == OMP_DISTRIBUTE
    1515                 :            :                           || code == OMP_LOOP
    1516                 :            :                           || code == OMP_TEAMS
    1517                 :            :                           || code == OMP_SIMD);
    1518                 :            :               s = C_OMP_CLAUSE_SPLIT_TEAMS;
    1519                 :            :             }
    1520                 :        117 :           else if ((mask & (OMP_CLAUSE_MASK_1
    1521                 :        117 :                             << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
    1522                 :            :             {
    1523                 :            :               /* This must be #pragma omp distribute simd.  */
    1524                 :         54 :               gcc_assert (code == OMP_SIMD);
    1525                 :            :               s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1526                 :            :             }
    1527                 :         63 :           else if ((mask & (OMP_CLAUSE_MASK_1
    1528                 :         63 :                             << PRAGMA_OMP_CLAUSE_NOGROUP)) != 0)
    1529                 :            :             {
    1530                 :            :               /* This must be #pragma omp {,{,parallel }master }taskloop simd
    1531                 :            :                  or
    1532                 :            :                  #pragma omp {,parallel }master taskloop.  */
    1533                 :         54 :               gcc_assert (code == OMP_SIMD || code == OMP_TASKLOOP);
    1534                 :            :               s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1535                 :            :             }
    1536                 :            :           else
    1537                 :            :             {
    1538                 :            :               /* This must be #pragma omp for simd.  */
    1539                 :          9 :               gcc_assert (code == OMP_SIMD);
    1540                 :            :               s = C_OMP_CLAUSE_SPLIT_FOR;
    1541                 :            :             }
    1542                 :            :           break;
    1543                 :            :         /* Lastprivate is allowed on distribute, for, sections, taskloop, loop
    1544                 :            :            and simd.  In parallel {for{, simd},sections} we actually want to
    1545                 :            :            put it on parallel rather than for or sections.  */
    1546                 :        949 :         case OMP_CLAUSE_LASTPRIVATE:
    1547                 :        949 :           if (code == OMP_DISTRIBUTE)
    1548                 :            :             {
    1549                 :            :               s = C_OMP_CLAUSE_SPLIT_DISTRIBUTE;
    1550                 :            :               break;
    1551                 :            :             }
    1552                 :        949 :           if ((mask & (OMP_CLAUSE_MASK_1
    1553                 :        949 :                        << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
    1554                 :            :             {
    1555                 :        272 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1556                 :            :                                     OMP_CLAUSE_LASTPRIVATE);
    1557                 :        272 :               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1558                 :        272 :               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
    1559                 :        272 :               OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c)
    1560                 :        272 :                 = OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clauses);
    1561                 :        272 :               cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE] = c;
    1562                 :            :             }
    1563                 :        949 :           if (code == OMP_FOR || code == OMP_SECTIONS)
    1564                 :            :             {
    1565                 :        528 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
    1566                 :        528 :                   != 0)
    1567                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1568                 :            :               else
    1569                 :            :                 s = C_OMP_CLAUSE_SPLIT_FOR;
    1570                 :            :               break;
    1571                 :            :             }
    1572                 :        421 :           if (code == OMP_TASKLOOP)
    1573                 :            :             {
    1574                 :            :               s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1575                 :            :               break;
    1576                 :            :             }
    1577                 :        393 :           if (code == OMP_LOOP)
    1578                 :            :             {
    1579                 :            :               s = C_OMP_CLAUSE_SPLIT_LOOP;
    1580                 :            :               break;
    1581                 :            :             }
    1582                 :        325 :           gcc_assert (code == OMP_SIMD);
    1583                 :        325 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
    1584                 :            :             {
    1585                 :        191 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1586                 :            :                                     OMP_CLAUSE_LASTPRIVATE);
    1587                 :        191 :               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1588                 :        191 :               OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c)
    1589                 :        191 :                 = OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clauses);
    1590                 :        191 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
    1591                 :        191 :                   != 0)
    1592                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1593                 :            :               else
    1594                 :            :                 s = C_OMP_CLAUSE_SPLIT_FOR;
    1595                 :        191 :               OMP_CLAUSE_CHAIN (c) = cclauses[s];
    1596                 :        191 :               cclauses[s] = c;
    1597                 :            :             }
    1598                 :        325 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP)) != 0)
    1599                 :            :             {
    1600                 :         50 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1601                 :            :                                     OMP_CLAUSE_LASTPRIVATE);
    1602                 :         50 :               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1603                 :         50 :               OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c)
    1604                 :         50 :                 = OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clauses);
    1605                 :         50 :               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
    1606                 :         50 :               cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP] = c;
    1607                 :            :             }
    1608                 :            :           s = C_OMP_CLAUSE_SPLIT_SIMD;
    1609                 :            :           break;
    1610                 :            :         /* Shared and default clauses are allowed on parallel, teams and
    1611                 :            :            taskloop.  */
    1612                 :       1416 :         case OMP_CLAUSE_SHARED:
    1613                 :       1416 :         case OMP_CLAUSE_DEFAULT:
    1614                 :       1416 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))
    1615                 :       1416 :               != 0)
    1616                 :            :             {
    1617                 :        186 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
    1618                 :        186 :                   != 0)
    1619                 :            :                 {
    1620                 :         55 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1621                 :         55 :                                         OMP_CLAUSE_CODE (clauses));
    1622                 :         55 :                   if (OMP_CLAUSE_CODE (clauses) == OMP_CLAUSE_SHARED)
    1623                 :         20 :                     OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1624                 :            :                   else
    1625                 :         35 :                     OMP_CLAUSE_DEFAULT_KIND (c)
    1626                 :         70 :                       = OMP_CLAUSE_DEFAULT_KIND (clauses);
    1627                 :         55 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
    1628                 :         55 :                   cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] = c;
    1629                 :            :                 }
    1630                 :            :               s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1631                 :            :               break;
    1632                 :            :             }
    1633                 :       1230 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
    1634                 :       1230 :               != 0)
    1635                 :            :             {
    1636                 :        621 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS))
    1637                 :        621 :                   == 0)
    1638                 :            :                 {
    1639                 :            :                   s = C_OMP_CLAUSE_SPLIT_TEAMS;
    1640                 :            :                   break;
    1641                 :            :                 }
    1642                 :        300 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1643                 :        300 :                                     OMP_CLAUSE_CODE (clauses));
    1644                 :        300 :               if (OMP_CLAUSE_CODE (clauses) == OMP_CLAUSE_SHARED)
    1645                 :        190 :                 OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1646                 :            :               else
    1647                 :        110 :                 OMP_CLAUSE_DEFAULT_KIND (c)
    1648                 :        220 :                   = OMP_CLAUSE_DEFAULT_KIND (clauses);
    1649                 :        300 :               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
    1650                 :        300 :               cclauses[C_OMP_CLAUSE_SPLIT_TEAMS] = c;
    1651                 :            :             }
    1652                 :            :           s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1653                 :            :           break;
    1654                 :            :         /* order clauses are allowed on for, simd and loop.  */
    1655                 :        277 :         case OMP_CLAUSE_ORDER:
    1656                 :        277 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
    1657                 :            :             {
    1658                 :        177 :               if (code == OMP_SIMD)
    1659                 :            :                 {
    1660                 :        127 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1661                 :            :                                         OMP_CLAUSE_ORDER);
    1662                 :        127 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
    1663                 :        127 :                   cclauses[C_OMP_CLAUSE_SPLIT_FOR] = c;
    1664                 :        127 :                   s = C_OMP_CLAUSE_SPLIT_SIMD;
    1665                 :            :                 }
    1666                 :            :               else
    1667                 :            :                 s = C_OMP_CLAUSE_SPLIT_FOR;
    1668                 :            :             }
    1669                 :        100 :           else if (code == OMP_LOOP)
    1670                 :            :             s = C_OMP_CLAUSE_SPLIT_LOOP;
    1671                 :            :           else
    1672                 :         70 :             s = C_OMP_CLAUSE_SPLIT_SIMD;
    1673                 :            :           break;
    1674                 :            :         /* Reduction is allowed on simd, for, parallel, sections, taskloop,
    1675                 :            :            teams and loop.  Duplicate it on all of them, but omit on for or
    1676                 :            :            sections if parallel is present (unless inscan, in that case
    1677                 :            :            omit on parallel).  If taskloop or loop is combined with
    1678                 :            :            parallel, omit it on parallel.  */
    1679                 :       1398 :         case OMP_CLAUSE_REDUCTION:
    1680                 :       1398 :           if (OMP_CLAUSE_REDUCTION_TASK (clauses))
    1681                 :            :             {
    1682                 :         47 :               if (code == OMP_SIMD || code == OMP_LOOP)
    1683                 :            :                 {
    1684                 :         20 :                   error_at (OMP_CLAUSE_LOCATION (clauses),
    1685                 :            :                             "invalid %<task%> reduction modifier on construct "
    1686                 :            :                             "combined with %<simd%> or %<loop%>");
    1687                 :         20 :                   OMP_CLAUSE_REDUCTION_TASK (clauses) = 0;
    1688                 :            :                 }
    1689                 :         27 :               else if (code != OMP_SECTIONS
    1690                 :         20 :                        && (mask & (OMP_CLAUSE_MASK_1
    1691                 :         20 :                                    << PRAGMA_OMP_CLAUSE_NUM_THREADS)) == 0
    1692                 :         27 :                        && (mask & (OMP_CLAUSE_MASK_1
    1693                 :         27 :                                    << PRAGMA_OMP_CLAUSE_SCHEDULE)) == 0)
    1694                 :            :                 {
    1695                 :          5 :                   error_at (OMP_CLAUSE_LOCATION (clauses),
    1696                 :            :                             "invalid %<task%> reduction modifier on construct "
    1697                 :            :                             "not combined with %<parallel%>, %<for%> or "
    1698                 :            :                             "%<sections%>");
    1699                 :          5 :                   OMP_CLAUSE_REDUCTION_TASK (clauses) = 0;
    1700                 :            :                 }
    1701                 :            :             }
    1702                 :       1398 :           if (OMP_CLAUSE_REDUCTION_INSCAN (clauses)
    1703                 :       1553 :               && ((mask & ((OMP_CLAUSE_MASK_1
    1704                 :        155 :                             << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)
    1705                 :        155 :                            | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)))
    1706                 :       1398 :                   != 0))
    1707                 :            :             {
    1708                 :         15 :               error_at (OMP_CLAUSE_LOCATION (clauses),
    1709                 :            :                         "%<inscan%> %<reduction%> clause on construct other "
    1710                 :            :                         "than %<for%>, %<simd%>, %<for simd%>, "
    1711                 :            :                         "%<parallel for%>, %<parallel for simd%>");
    1712                 :         15 :               OMP_CLAUSE_REDUCTION_INSCAN (clauses) = 0;
    1713                 :            :             }
    1714                 :       1398 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
    1715                 :            :             {
    1716                 :        997 :               if (code == OMP_SIMD)
    1717                 :            :                 {
    1718                 :        264 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1719                 :            :                                         OMP_CLAUSE_REDUCTION);
    1720                 :        264 :                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1721                 :        264 :                   OMP_CLAUSE_REDUCTION_CODE (c)
    1722                 :        264 :                     = OMP_CLAUSE_REDUCTION_CODE (clauses);
    1723                 :        264 :                   OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
    1724                 :        264 :                     = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
    1725                 :        264 :                   OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
    1726                 :        264 :                     = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clauses);
    1727                 :        264 :                   OMP_CLAUSE_REDUCTION_INSCAN (c)
    1728                 :        264 :                     = OMP_CLAUSE_REDUCTION_INSCAN (clauses);
    1729                 :        264 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
    1730                 :        264 :                   cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
    1731                 :            :                 }
    1732                 :        997 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS))
    1733                 :        997 :                   != 0)
    1734                 :            :                 {
    1735                 :         90 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1736                 :            :                                         OMP_CLAUSE_REDUCTION);
    1737                 :         90 :                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1738                 :         90 :                   OMP_CLAUSE_REDUCTION_CODE (c)
    1739                 :         90 :                     = OMP_CLAUSE_REDUCTION_CODE (clauses);
    1740                 :         90 :                   OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
    1741                 :         90 :                     = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
    1742                 :         90 :                   OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
    1743                 :         90 :                     = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clauses);
    1744                 :         90 :                   OMP_CLAUSE_REDUCTION_INSCAN (c)
    1745                 :         90 :                     = OMP_CLAUSE_REDUCTION_INSCAN (clauses);
    1746                 :         90 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
    1747                 :         90 :                   cclauses[C_OMP_CLAUSE_SPLIT_TEAMS] = c;
    1748                 :         90 :                   s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1749                 :            :                 }
    1750                 :        907 :               else if ((mask & (OMP_CLAUSE_MASK_1
    1751                 :        998 :                                 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0
    1752                 :        840 :                        && !OMP_CLAUSE_REDUCTION_INSCAN (clauses))
    1753                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1754                 :            :               else
    1755                 :            :                 s = C_OMP_CLAUSE_SPLIT_FOR;
    1756                 :            :             }
    1757                 :        401 :           else if (code == OMP_SECTIONS
    1758                 :        401 :                    || code == OMP_PARALLEL
    1759                 :        351 :                    || code == OMP_MASTER)
    1760                 :            :             s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1761                 :        346 :           else if (code == OMP_TASKLOOP)
    1762                 :            :             s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1763                 :        316 :           else if (code == OMP_LOOP)
    1764                 :            :             s = C_OMP_CLAUSE_SPLIT_LOOP;
    1765                 :        212 :           else if (code == OMP_SIMD)
    1766                 :            :             {
    1767                 :        137 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))
    1768                 :        137 :                   != 0)
    1769                 :            :                 {
    1770                 :         67 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1771                 :            :                                         OMP_CLAUSE_REDUCTION);
    1772                 :         67 :                   OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1773                 :         67 :                   OMP_CLAUSE_REDUCTION_CODE (c)
    1774                 :         67 :                     = OMP_CLAUSE_REDUCTION_CODE (clauses);
    1775                 :         67 :                   OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
    1776                 :         67 :                     = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
    1777                 :         67 :                   OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
    1778                 :         67 :                     = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clauses);
    1779                 :         67 :                   OMP_CLAUSE_REDUCTION_INSCAN (c)
    1780                 :         67 :                     = OMP_CLAUSE_REDUCTION_INSCAN (clauses);
    1781                 :         67 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
    1782                 :         67 :                   cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP] = c;
    1783                 :            :                 }
    1784                 :            :               s = C_OMP_CLAUSE_SPLIT_SIMD;
    1785                 :            :             }
    1786                 :            :           else
    1787                 :            :             s = C_OMP_CLAUSE_SPLIT_TEAMS;
    1788                 :            :           break;
    1789                 :         34 :         case OMP_CLAUSE_IN_REDUCTION:
    1790                 :            :           /* in_reduction on taskloop simd becomes reduction on the simd
    1791                 :            :              and keeps being in_reduction on taskloop.  */
    1792                 :         34 :           if (code == OMP_SIMD)
    1793                 :            :             {
    1794                 :         24 :               c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1795                 :            :                                     OMP_CLAUSE_REDUCTION);
    1796                 :         24 :               OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clauses);
    1797                 :         24 :               OMP_CLAUSE_REDUCTION_CODE (c)
    1798                 :         24 :                 = OMP_CLAUSE_REDUCTION_CODE (clauses);
    1799                 :         24 :               OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
    1800                 :         24 :                 = OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
    1801                 :         24 :               OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
    1802                 :         24 :                 = OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clauses);
    1803                 :         24 :               OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
    1804                 :         24 :               cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
    1805                 :            :             }
    1806                 :            :           s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1807                 :            :           break;
    1808                 :        631 :         case OMP_CLAUSE_IF:
    1809                 :        631 :           if (OMP_CLAUSE_IF_MODIFIER (clauses) != ERROR_MARK)
    1810                 :            :             {
    1811                 :        366 :               s = C_OMP_CLAUSE_SPLIT_COUNT;
    1812                 :        366 :               switch (OMP_CLAUSE_IF_MODIFIER (clauses))
    1813                 :            :                 {
    1814                 :        135 :                 case OMP_PARALLEL:
    1815                 :        135 :                   if ((mask & (OMP_CLAUSE_MASK_1
    1816                 :        135 :                                << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
    1817                 :            :                     s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1818                 :            :                   break;
    1819                 :        101 :                 case OMP_SIMD:
    1820                 :        101 :                   if (code == OMP_SIMD)
    1821                 :            :                     s = C_OMP_CLAUSE_SPLIT_SIMD;
    1822                 :            :                   break;
    1823                 :         40 :                 case OMP_TASKLOOP:
    1824                 :         40 :                   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))
    1825                 :         40 :                       != 0)
    1826                 :            :                     s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1827                 :            :                   break;
    1828                 :         80 :                 case OMP_TARGET:
    1829                 :         80 :                   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP))
    1830                 :         80 :                       != 0)
    1831                 :            :                     s = C_OMP_CLAUSE_SPLIT_TARGET;
    1832                 :            :                   break;
    1833                 :            :                 default:
    1834                 :            :                   break;
    1835                 :            :                 }
    1836                 :            :               if (s != C_OMP_CLAUSE_SPLIT_COUNT)
    1837                 :            :                 break;
    1838                 :            :               /* Error-recovery here, invalid if-modifier specified, add the
    1839                 :            :                  clause to just one construct.  */
    1840                 :         10 :               if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) != 0)
    1841                 :            :                 s = C_OMP_CLAUSE_SPLIT_TARGET;
    1842                 :          5 :               else if ((mask & (OMP_CLAUSE_MASK_1
    1843                 :          5 :                                 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
    1844                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1845                 :          0 :               else if ((mask & (OMP_CLAUSE_MASK_1
    1846                 :          0 :                                 << PRAGMA_OMP_CLAUSE_NOGROUP)) != 0)
    1847                 :            :                 s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1848                 :          0 :               else if (code == OMP_SIMD)
    1849                 :            :                 s = C_OMP_CLAUSE_SPLIT_SIMD;
    1850                 :            :               else
    1851                 :          0 :                 gcc_unreachable ();
    1852                 :            :               break;
    1853                 :            :             }
    1854                 :            :           /* Otherwise, duplicate if clause to all constructs.  */
    1855                 :        265 :           if (code == OMP_SIMD)
    1856                 :            :             {
    1857                 :        130 :               if ((mask & ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)
    1858                 :        130 :                            | (OMP_CLAUSE_MASK_1
    1859                 :        130 :                               << PRAGMA_OMP_CLAUSE_NUM_THREADS)
    1860                 :        130 :                            | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP)))
    1861                 :        130 :                   != 0)
    1862                 :            :                 {
    1863                 :         95 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1864                 :            :                                         OMP_CLAUSE_IF);
    1865                 :         95 :                   OMP_CLAUSE_IF_MODIFIER (c)
    1866                 :         95 :                     = OMP_CLAUSE_IF_MODIFIER (clauses);
    1867                 :         95 :                   OMP_CLAUSE_IF_EXPR (c) = OMP_CLAUSE_IF_EXPR (clauses);
    1868                 :         95 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
    1869                 :         95 :                   cclauses[C_OMP_CLAUSE_SPLIT_SIMD] = c;
    1870                 :            :                 }
    1871                 :            :               else
    1872                 :            :                 {
    1873                 :            :                   s = C_OMP_CLAUSE_SPLIT_SIMD;
    1874                 :            :                   break;
    1875                 :            :                 }
    1876                 :            :             }
    1877                 :        230 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))
    1878                 :        230 :               != 0)
    1879                 :            :             {
    1880                 :         30 :               if ((mask & (OMP_CLAUSE_MASK_1
    1881                 :         30 :                            << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
    1882                 :            :                 {
    1883                 :         10 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1884                 :            :                                         OMP_CLAUSE_IF);
    1885                 :         10 :                   OMP_CLAUSE_IF_MODIFIER (c)
    1886                 :         10 :                     = OMP_CLAUSE_IF_MODIFIER (clauses);
    1887                 :         10 :                   OMP_CLAUSE_IF_EXPR (c) = OMP_CLAUSE_IF_EXPR (clauses);
    1888                 :         10 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
    1889                 :         10 :                   cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP] = c;
    1890                 :         10 :                   s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1891                 :            :                 }
    1892                 :            :               else
    1893                 :            :                 s = C_OMP_CLAUSE_SPLIT_TASKLOOP;
    1894                 :            :             }
    1895                 :        200 :           else if ((mask & (OMP_CLAUSE_MASK_1
    1896                 :        200 :                             << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
    1897                 :            :             {
    1898                 :        125 :               if ((mask & (OMP_CLAUSE_MASK_1
    1899                 :        125 :                            << PRAGMA_OMP_CLAUSE_MAP)) != 0)
    1900                 :            :                 {
    1901                 :         25 :                   c = build_omp_clause (OMP_CLAUSE_LOCATION (clauses),
    1902                 :            :                                         OMP_CLAUSE_IF);
    1903                 :         25 :                   OMP_CLAUSE_IF_MODIFIER (c)
    1904                 :         25 :                     = OMP_CLAUSE_IF_MODIFIER (clauses);
    1905                 :         25 :                   OMP_CLAUSE_IF_EXPR (c) = OMP_CLAUSE_IF_EXPR (clauses);
    1906                 :         25 :                   OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
    1907                 :         25 :                   cclauses[C_OMP_CLAUSE_SPLIT_TARGET] = c;
    1908                 :         25 :                   s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1909                 :            :                 }
    1910                 :            :               else
    1911                 :            :                 s = C_OMP_CLAUSE_SPLIT_PARALLEL;
    1912                 :            :             }
    1913                 :            :           else
    1914                 :            :             s = C_OMP_CLAUSE_SPLIT_TARGET;
    1915                 :            :           break;
    1916                 :        396 :         case OMP_CLAUSE_LINEAR:
    1917                 :            :           /* Linear clause is allowed on simd and for.  Put it on the
    1918                 :            :              innermost construct.  */
    1919                 :        396 :           if (code == OMP_SIMD)
    1920                 :            :             s = C_OMP_CLAUSE_SPLIT_SIMD;
    1921                 :            :           else
    1922                 :        114 :             s = C_OMP_CLAUSE_SPLIT_FOR;
    1923                 :            :           break;
    1924                 :         78 :         case OMP_CLAUSE_NOWAIT:
    1925                 :            :           /* Nowait clause is allowed on target, for and sections, but
    1926                 :            :              is not allowed on parallel for or parallel sections.  Therefore,
    1927                 :            :              put it on target construct if present, because that can only
    1928                 :            :              be combined with parallel for{, simd} and not with for{, simd},
    1929                 :            :              otherwise to the worksharing construct.  */
    1930                 :         78 :           if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP))
    1931                 :         78 :               != 0)
    1932                 :            :             s = C_OMP_CLAUSE_SPLIT_TARGET;
    1933                 :            :           else
    1934                 :            :             s = C_OMP_CLAUSE_SPLIT_FOR;
    1935                 :            :           break;
    1936                 :          0 :         default:
    1937                 :          0 :           gcc_unreachable ();
    1938                 :            :         }
    1939                 :      22145 :       OMP_CLAUSE_CHAIN (clauses) = cclauses[s];
    1940                 :      22145 :       cclauses[s] = clauses;
    1941                 :            :     }
    1942                 :            : 
    1943                 :      10852 :   if (!flag_checking)
    1944                 :            :     return;
    1945                 :            : 
    1946                 :      10852 :   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) == 0)
    1947                 :       8195 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_TARGET] == NULL_TREE);
    1948                 :      10852 :   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS)) == 0)
    1949                 :       6541 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_TEAMS] == NULL_TREE);
    1950                 :      10852 :   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) == 0)
    1951                 :       4494 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE] == NULL_TREE);
    1952                 :      10852 :   if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) == 0)
    1953                 :       2215 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] == NULL_TREE);
    1954                 :      10852 :   if ((mask & ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)
    1955                 :      10852 :                | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP))) == 0
    1956                 :       1619 :       && code != OMP_SECTIONS
    1957                 :       1619 :       && code != OMP_LOOP)
    1958                 :       1413 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_FOR] == NULL_TREE);
    1959                 :      10852 :   if (code != OMP_SIMD)
    1960                 :       5739 :     gcc_assert (cclauses[C_OMP_CLAUSE_SPLIT_SIMD] == NULL_TREE);
    1961                 :            : }
    1962                 :            : 
    1963                 :            : 
    1964                 :            : /* qsort callback to compare #pragma omp declare simd clauses.  */
    1965                 :            : 
    1966                 :            : static int
    1967                 :      11306 : c_omp_declare_simd_clause_cmp (const void *p, const void *q)
    1968                 :            : {
    1969                 :      11306 :   tree a = *(const tree *) p;
    1970                 :      11306 :   tree b = *(const tree *) q;
    1971                 :      11306 :   if (OMP_CLAUSE_CODE (a) != OMP_CLAUSE_CODE (b))
    1972                 :            :     {
    1973                 :       9629 :       if (OMP_CLAUSE_CODE (a) > OMP_CLAUSE_CODE (b))
    1974                 :            :         return -1;
    1975                 :       4023 :       return 1;
    1976                 :            :     }
    1977                 :       1677 :   if (OMP_CLAUSE_CODE (a) != OMP_CLAUSE_SIMDLEN
    1978                 :       1647 :       && OMP_CLAUSE_CODE (a) != OMP_CLAUSE_INBRANCH
    1979                 :       3324 :       && OMP_CLAUSE_CODE (a) != OMP_CLAUSE_NOTINBRANCH)
    1980                 :            :     {
    1981                 :       1647 :       int c = tree_to_shwi (OMP_CLAUSE_DECL (a));
    1982                 :       1647 :       int d = tree_to_shwi (OMP_CLAUSE_DECL (b));
    1983                 :       1647 :       if (c < d)
    1984                 :            :         return 1;
    1985                 :        760 :       if (c > d)
    1986                 :        760 :         return -1;
    1987                 :            :     }
    1988                 :            :   return 0;
    1989                 :            : }
    1990                 :            : 
    1991                 :            : /* Change PARM_DECLs in OMP_CLAUSE_DECL of #pragma omp declare simd
    1992                 :            :    CLAUSES on FNDECL into argument indexes and sort them.  */
    1993                 :            : 
    1994                 :            : tree
    1995                 :       1095 : c_omp_declare_simd_clauses_to_numbers (tree parms, tree clauses)
    1996                 :            : {
    1997                 :       1095 :   tree c;
    1998                 :       1095 :   vec<tree> clvec = vNULL;
    1999                 :            : 
    2000                 :       3687 :   for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
    2001                 :            :     {
    2002                 :       2592 :       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_SIMDLEN
    2003                 :       2189 :           && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_INBRANCH
    2004                 :       4699 :           && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_NOTINBRANCH)
    2005                 :            :         {
    2006                 :       1625 :           tree decl = OMP_CLAUSE_DECL (c);
    2007                 :       1625 :           tree arg;
    2008                 :       1625 :           int idx;
    2009                 :       6441 :           for (arg = parms, idx = 0; arg;
    2010                 :       2408 :                arg = TREE_CHAIN (arg), idx++)
    2011                 :       4025 :             if (arg == decl)
    2012                 :            :               break;
    2013                 :       1625 :           if (arg == NULL_TREE)
    2014                 :            :             {
    2015                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    2016                 :            :                         "%qD is not a function argument", decl);
    2017                 :       2592 :               continue;
    2018                 :            :             }
    2019                 :       1617 :           OMP_CLAUSE_DECL (c) = build_int_cst (integer_type_node, idx);
    2020                 :       1617 :           if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
    2021                 :       1617 :               && OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c))
    2022                 :            :             {
    2023                 :         37 :               decl = OMP_CLAUSE_LINEAR_STEP (c);
    2024                 :        201 :               for (arg = parms, idx = 0; arg;
    2025                 :         82 :                    arg = TREE_CHAIN (arg), idx++)
    2026                 :        119 :                 if (arg == decl)
    2027                 :            :                   break;
    2028                 :         37 :               if (arg == NULL_TREE)
    2029                 :            :                 {
    2030                 :          0 :                   error_at (OMP_CLAUSE_LOCATION (c),
    2031                 :            :                             "%qD is not a function argument", decl);
    2032                 :          0 :                   continue;
    2033                 :            :                 }
    2034                 :         37 :               OMP_CLAUSE_LINEAR_STEP (c)
    2035                 :         74 :                 = build_int_cst (integer_type_node, idx);
    2036                 :            :             }
    2037                 :            :         }
    2038                 :       2584 :       clvec.safe_push (c);
    2039                 :            :     }
    2040                 :       1095 :   if (!clvec.is_empty ())
    2041                 :            :     {
    2042                 :       1015 :       unsigned int len = clvec.length (), i;
    2043                 :       1015 :       clvec.qsort (c_omp_declare_simd_clause_cmp);
    2044                 :       1015 :       clauses = clvec[0];
    2045                 :       3599 :       for (i = 0; i < len; i++)
    2046                 :       2584 :         OMP_CLAUSE_CHAIN (clvec[i]) = (i < len - 1) ? clvec[i + 1] : NULL_TREE;
    2047                 :            :     }
    2048                 :            :   else
    2049                 :            :     clauses = NULL_TREE;
    2050                 :       1095 :   clvec.release ();
    2051                 :       1095 :   return clauses;
    2052                 :            : }
    2053                 :            : 
    2054                 :            : /* Change argument indexes in CLAUSES of FNDECL back to PARM_DECLs.  */
    2055                 :            : 
    2056                 :            : void
    2057                 :        136 : c_omp_declare_simd_clauses_to_decls (tree fndecl, tree clauses)
    2058                 :            : {
    2059                 :        136 :   tree c;
    2060                 :            : 
    2061                 :        508 :   for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
    2062                 :        372 :     if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_SIMDLEN
    2063                 :        324 :         && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_INBRANCH
    2064                 :        692 :         && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_NOTINBRANCH)
    2065                 :            :       {
    2066                 :        240 :         int idx = tree_to_shwi (OMP_CLAUSE_DECL (c)), i;
    2067                 :        240 :         tree arg;
    2068                 :        680 :         for (arg = DECL_ARGUMENTS (fndecl), i = 0; arg;
    2069                 :        220 :              arg = TREE_CHAIN (arg), i++)
    2070                 :        460 :           if (i == idx)
    2071                 :            :             break;
    2072                 :        240 :         gcc_assert (arg);
    2073                 :        240 :         OMP_CLAUSE_DECL (c) = arg;
    2074                 :        240 :         if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
    2075                 :        240 :             && OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c))
    2076                 :            :           {
    2077                 :          0 :             idx = tree_to_shwi (OMP_CLAUSE_LINEAR_STEP (c));
    2078                 :          0 :             for (arg = DECL_ARGUMENTS (fndecl), i = 0; arg;
    2079                 :          0 :                  arg = TREE_CHAIN (arg), i++)
    2080                 :          0 :               if (i == idx)
    2081                 :            :                 break;
    2082                 :          0 :             gcc_assert (arg);
    2083                 :          0 :             OMP_CLAUSE_LINEAR_STEP (c) = arg;
    2084                 :            :           }
    2085                 :            :       }
    2086                 :        136 : }
    2087                 :            : 
    2088                 :            : /* Return true for __func__ and similar function-local predefined
    2089                 :            :    variables (which are in OpenMP predetermined shared, allowed in
    2090                 :            :    shared/firstprivate clauses).  */
    2091                 :            : 
    2092                 :            : bool
    2093                 :      30073 : c_omp_predefined_variable (tree decl)
    2094                 :            : {
    2095                 :      30073 :   if (VAR_P (decl)
    2096                 :      21501 :       && DECL_ARTIFICIAL (decl)
    2097                 :        179 :       && TREE_READONLY (decl)
    2098                 :        179 :       && TREE_STATIC (decl)
    2099                 :        179 :       && DECL_NAME (decl)
    2100                 :      30252 :       && (DECL_NAME (decl) == ridpointers[RID_C99_FUNCTION_NAME]
    2101                 :        141 :           || DECL_NAME (decl) == ridpointers[RID_FUNCTION_NAME]
    2102                 :        111 :           || DECL_NAME (decl) == ridpointers[RID_PRETTY_FUNCTION_NAME]))
    2103                 :        102 :     return true;
    2104                 :            :   return false;
    2105                 :            : }
    2106                 :            : 
    2107                 :            : /* True if OpenMP sharing attribute of DECL is predetermined.  */
    2108                 :            : 
    2109                 :            : enum omp_clause_default_kind
    2110                 :      19807 : c_omp_predetermined_sharing (tree decl)
    2111                 :            : {
    2112                 :            :   /* Predetermine artificial variables holding integral values, those
    2113                 :            :      are usually result of gimplify_one_sizepos or SAVE_EXPR
    2114                 :            :      gimplification.  */
    2115                 :      19807 :   if (VAR_P (decl)
    2116                 :      11235 :       && DECL_ARTIFICIAL (decl)
    2117                 :      20197 :       && INTEGRAL_TYPE_P (TREE_TYPE (decl)))
    2118                 :            :     return OMP_CLAUSE_DEFAULT_SHARED;
    2119                 :            : 
    2120                 :      19451 :   if (c_omp_predefined_variable (decl))
    2121                 :         34 :     return OMP_CLAUSE_DEFAULT_SHARED;
    2122                 :            : 
    2123                 :            :   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
    2124                 :            : }
    2125                 :            : 
    2126                 :            : /* Diagnose errors in an OpenMP context selector, return CTX if
    2127                 :            :    it is correct or error_mark_node otherwise.  */
    2128                 :            : 
    2129                 :            : tree
    2130                 :       1336 : c_omp_check_context_selector (location_t loc, tree ctx)
    2131                 :            : {
    2132                 :            :   /* Each trait-set-selector-name can only be specified once.
    2133                 :            :      There are just 4 set names.  */
    2134                 :       2765 :   for (tree t1 = ctx; t1; t1 = TREE_CHAIN (t1))
    2135                 :       1612 :     for (tree t2 = TREE_CHAIN (t1); t2; t2 = TREE_CHAIN (t2))
    2136                 :        183 :       if (TREE_PURPOSE (t1) == TREE_PURPOSE (t2))
    2137                 :            :         {
    2138                 :         30 :           error_at (loc, "selector set %qs specified more than once",
    2139                 :         30 :                     IDENTIFIER_POINTER (TREE_PURPOSE (t1)));
    2140                 :         30 :           return error_mark_node;
    2141                 :            :         }
    2142                 :       2705 :   for (tree t = ctx; t; t = TREE_CHAIN (t))
    2143                 :            :     {
    2144                 :            :       /* Each trait-selector-name can only be specified once.  */
    2145                 :       1429 :       if (list_length (TREE_VALUE (t)) < 5)
    2146                 :            :         {
    2147                 :       3207 :           for (tree t1 = TREE_VALUE (t); t1; t1 = TREE_CHAIN (t1))
    2148                 :       2345 :             for (tree t2 = TREE_CHAIN (t1); t2; t2 = TREE_CHAIN (t2))
    2149                 :        557 :               if (TREE_PURPOSE (t1) == TREE_PURPOSE (t2))
    2150                 :            :                 {
    2151                 :         10 :                   error_at (loc,
    2152                 :            :                             "selector %qs specified more than once in set %qs",
    2153                 :         10 :                             IDENTIFIER_POINTER (TREE_PURPOSE (t1)),
    2154                 :         10 :                             IDENTIFIER_POINTER (TREE_PURPOSE (t)));
    2155                 :         30 :                   return error_mark_node;
    2156                 :            :                 }
    2157                 :            :         }
    2158                 :            :       else
    2159                 :            :         {
    2160                 :         15 :           hash_set<tree> pset;
    2161                 :         55 :           for (tree t1 = TREE_VALUE (t); t1; t1 = TREE_CHAIN (t1))
    2162                 :         50 :             if (pset.add (TREE_PURPOSE (t1)))
    2163                 :            :               {
    2164                 :          5 :                 error_at (loc,
    2165                 :            :                           "selector %qs specified more than once in set %qs",
    2166                 :          5 :                           IDENTIFIER_POINTER (TREE_PURPOSE (t1)),
    2167                 :          5 :                           IDENTIFIER_POINTER (TREE_PURPOSE (t)));
    2168                 :          5 :                 return error_mark_node;
    2169                 :            :               }
    2170                 :            :         }
    2171                 :            : 
    2172                 :       1414 :       static const char *const kind[] = {
    2173                 :            :         "host", "nohost", "cpu", "gpu", "fpga", "any", NULL };
    2174                 :       1414 :       static const char *const vendor[] = {
    2175                 :            :         "amd", "arm", "bsc", "cray", "fujitsu", "gnu", "ibm", "intel",
    2176                 :            :         "llvm", "nvidia", "pgi", "ti", "unknown", NULL };
    2177                 :       1414 :       static const char *const extension[] = { NULL };
    2178                 :       1414 :       static const char *const atomic_default_mem_order[] = {
    2179                 :            :         "seq_cst", "relaxed", "acq_rel", NULL };
    2180                 :       1414 :       struct known_properties { const char *set; const char *selector;
    2181                 :            :                                 const char *const *props; };
    2182                 :       1414 :       known_properties props[] = {
    2183                 :            :         { "device", "kind", kind },
    2184                 :            :         { "implementation", "vendor", vendor },
    2185                 :            :         { "implementation", "extension", extension },
    2186                 :            :         { "implementation", "atomic_default_mem_order",
    2187                 :            :           atomic_default_mem_order } };
    2188                 :       3207 :       for (tree t1 = TREE_VALUE (t); t1; t1 = TREE_CHAIN (t1))
    2189                 :       9025 :         for (unsigned i = 0; i < ARRAY_SIZE (props); i++)
    2190                 :       7232 :           if (!strcmp (IDENTIFIER_POINTER (TREE_PURPOSE (t1)),
    2191                 :            :                                            props[i].selector)
    2192                 :       7232 :               && !strcmp (IDENTIFIER_POINTER (TREE_PURPOSE (t)),
    2193                 :            :                                               props[i].set))
    2194                 :       1342 :             for (tree t2 = TREE_VALUE (t1); t2; t2 = TREE_CHAIN (t2))
    2195                 :       4068 :               for (unsigned j = 0; ; j++)
    2196                 :            :                 {
    2197                 :       4884 :                   if (props[i].props[j] == NULL)
    2198                 :            :                     {
    2199                 :        242 :                       if (TREE_PURPOSE (t2)
    2200                 :        242 :                           && !strcmp (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
    2201                 :            :                                       " score"))
    2202                 :            :                         break;
    2203                 :         77 :                       if (props[i].props == atomic_default_mem_order)
    2204                 :            :                         {
    2205                 :         15 :                           error_at (loc,
    2206                 :            :                                     "incorrect property %qs of %qs selector",
    2207                 :         15 :                                     IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
    2208                 :            :                                     "atomic_default_mem_order");
    2209                 :         15 :                           return error_mark_node;
    2210                 :            :                         }
    2211                 :         62 :                       else if (TREE_PURPOSE (t2))
    2212                 :         55 :                         warning_at (loc, 0,
    2213                 :            :                                     "unknown property %qs of %qs selector",
    2214                 :         55 :                                     IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
    2215                 :            :                                     props[i].selector);
    2216                 :            :                       else
    2217                 :          7 :                         warning_at (loc, 0,
    2218                 :            :                                     "unknown property %qE of %qs selector",
    2219                 :          7 :                                     TREE_VALUE (t2), props[i].selector);
    2220                 :            :                       break;
    2221                 :            :                     }
    2222                 :       4642 :                   else if (TREE_PURPOSE (t2) == NULL_TREE)
    2223                 :            :                     {
    2224                 :        580 :                       const char *str = TREE_STRING_POINTER (TREE_VALUE (t2));
    2225                 :        580 :                       if (!strcmp (str, props[i].props[j])
    2226                 :        580 :                           && ((size_t) TREE_STRING_LENGTH (TREE_VALUE (t2))
    2227                 :         98 :                               == strlen (str) + 1))
    2228                 :            :                         break;
    2229                 :            :                     }
    2230                 :       4062 :                   else if (!strcmp (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
    2231                 :            :                                     props[i].props[j]))
    2232                 :            :                     break;
    2233                 :       4068 :                 }
    2234                 :            :     }
    2235                 :            :   return ctx;
    2236                 :            : }
    2237                 :            : 
    2238                 :            : /* Register VARIANT as variant of some base function marked with
    2239                 :            :    #pragma omp declare variant.  CONSTRUCT is corresponding construct
    2240                 :            :    selector set.  */
    2241                 :            : 
    2242                 :            : void
    2243                 :       1102 : c_omp_mark_declare_variant (location_t loc, tree variant, tree construct)
    2244                 :            : {
    2245                 :       1102 :   tree attr = lookup_attribute ("omp declare variant variant",
    2246                 :       1102 :                                 DECL_ATTRIBUTES (variant));
    2247                 :       1102 :   if (attr == NULL_TREE)
    2248                 :            :     {
    2249                 :       1266 :       attr = tree_cons (get_identifier ("omp declare variant variant"),
    2250                 :            :                         unshare_expr (construct),
    2251                 :        633 :                         DECL_ATTRIBUTES (variant));
    2252                 :        633 :       DECL_ATTRIBUTES (variant) = attr;
    2253                 :        633 :       return;
    2254                 :            :     }
    2255                 :        469 :   if ((TREE_VALUE (attr) != NULL_TREE) != (construct != NULL_TREE)
    2256                 :        469 :       || (construct != NULL_TREE
    2257                 :         40 :           && omp_context_selector_set_compare ("construct", TREE_VALUE (attr),
    2258                 :            :                                                construct)))
    2259                 :         35 :     error_at (loc, "%qD used as a variant with incompatible %<construct%> "
    2260                 :            :                    "selector sets", variant);
    2261                 :            : }
    2262                 :            : 
    2263                 :            : /* For OpenACC, the OMP_CLAUSE_MAP_KIND of an OMP_CLAUSE_MAP is used internally
    2264                 :            :    to distinguish clauses as seen by the user.  Return the "friendly" clause
    2265                 :            :    name for error messages etc., where possible.  See also
    2266                 :            :    c/c-parser.c:c_parser_oacc_data_clause and
    2267                 :            :    cp/parser.c:cp_parser_oacc_data_clause.  */
    2268                 :            : 
    2269                 :            : const char *
    2270                 :        108 : c_omp_map_clause_name (tree clause, bool oacc)
    2271                 :            : {
    2272                 :        216 :   if (oacc && OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
    2273                 :        108 :     switch (OMP_CLAUSE_MAP_KIND (clause))
    2274                 :            :     {
    2275                 :            :     case GOMP_MAP_FORCE_ALLOC:
    2276                 :            :     case GOMP_MAP_ALLOC: return "create";
    2277                 :          0 :     case GOMP_MAP_FORCE_TO:
    2278                 :          0 :     case GOMP_MAP_TO: return "copyin";
    2279                 :          0 :     case GOMP_MAP_FORCE_FROM:
    2280                 :          0 :     case GOMP_MAP_FROM: return "copyout";
    2281                 :          0 :     case GOMP_MAP_FORCE_TOFROM:
    2282                 :          0 :     case GOMP_MAP_TOFROM: return "copy";
    2283                 :          0 :     case GOMP_MAP_RELEASE: return "delete";
    2284                 :          0 :     case GOMP_MAP_FORCE_PRESENT: return "present";
    2285                 :         54 :     case GOMP_MAP_ATTACH: return "attach";
    2286                 :         54 :     case GOMP_MAP_FORCE_DETACH:
    2287                 :         54 :     case GOMP_MAP_DETACH: return "detach";
    2288                 :          0 :     case GOMP_MAP_DEVICE_RESIDENT: return "device_resident";
    2289                 :          0 :     case GOMP_MAP_LINK: return "link";
    2290                 :          0 :     case GOMP_MAP_FORCE_DEVICEPTR: return "deviceptr";
    2291                 :            :     default: break;
    2292                 :            :     }
    2293                 :          0 :   return omp_clause_code_name[OMP_CLAUSE_CODE (clause)];
    2294                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.