LCOV - code coverage report
Current view: top level - gcc - omp-oacc-neuter-broadcast.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 0.7 % 941 7
Test Date: 2024-03-23 14:05:01 Functions: 5.7 % 35 2
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* OpenACC worker partitioning via middle end neutering/broadcasting scheme
       2                 :             : 
       3                 :             :    Copyright (C) 2015-2024 Free Software Foundation, Inc.
       4                 :             : 
       5                 :             :    This file is part of GCC.
       6                 :             : 
       7                 :             :    GCC is free software; you can redistribute it and/or modify it
       8                 :             :    under the terms of the GNU General Public License as published
       9                 :             :    by the Free Software Foundation; either version 3, or (at your
      10                 :             :    option) any later version.
      11                 :             : 
      12                 :             :    GCC is distributed in the hope that it will be useful, but WITHOUT
      13                 :             :    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      14                 :             :    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      15                 :             :    License for more details.
      16                 :             : 
      17                 :             :    You should have received a copy of the GNU General Public License
      18                 :             :    along with GCC; see the file COPYING3.  If not see
      19                 :             :    <http://www.gnu.org/licenses/>.  */
      20                 :             : 
      21                 :             : #include "config.h"
      22                 :             : #include "system.h"
      23                 :             : #include "coretypes.h"
      24                 :             : #include "backend.h"
      25                 :             : #include "rtl.h"
      26                 :             : #include "tree.h"
      27                 :             : #include "gimple.h"
      28                 :             : #include "tree-pass.h"
      29                 :             : #include "ssa.h"
      30                 :             : #include "cgraph.h"
      31                 :             : #include "pretty-print.h"
      32                 :             : #include "fold-const.h"
      33                 :             : #include "gimplify.h"
      34                 :             : #include "gimple-iterator.h"
      35                 :             : #include "gimple-walk.h"
      36                 :             : #include "tree-inline.h"
      37                 :             : #include "langhooks.h"
      38                 :             : #include "omp-general.h"
      39                 :             : #include "omp-low.h"
      40                 :             : #include "gimple-pretty-print.h"
      41                 :             : #include "cfghooks.h"
      42                 :             : #include "insn-config.h"
      43                 :             : #include "recog.h"
      44                 :             : #include "internal-fn.h"
      45                 :             : #include "bitmap.h"
      46                 :             : #include "tree-nested.h"
      47                 :             : #include "stor-layout.h"
      48                 :             : #include "tree-ssa-threadupdate.h"
      49                 :             : #include "tree-into-ssa.h"
      50                 :             : #include "splay-tree.h"
      51                 :             : #include "target.h"
      52                 :             : #include "cfgloop.h"
      53                 :             : #include "tree-cfg.h"
      54                 :             : #include "omp-offload.h"
      55                 :             : #include "attribs.h"
      56                 :             : #include "targhooks.h"
      57                 :             : #include "diagnostic-core.h"
      58                 :             : 
      59                 :             : /* Loop structure of the function.  The entire function is described as
      60                 :             :    a NULL loop.  */
      61                 :             : /* Adapted from 'gcc/config/nvptx/nvptx.cc:struct parallel'.  */
      62                 :             : 
      63                 :             : struct parallel_g
      64                 :             : {
      65                 :             :   /* Parent parallel.  */
      66                 :             :   parallel_g *parent;
      67                 :             : 
      68                 :             :   /* Next sibling parallel.  */
      69                 :             :   parallel_g *next;
      70                 :             : 
      71                 :             :   /* First child parallel.  */
      72                 :             :   parallel_g *inner;
      73                 :             : 
      74                 :             :   /* Partitioning mask of the parallel.  */
      75                 :             :   unsigned mask;
      76                 :             : 
      77                 :             :   /* Partitioning used within inner parallels. */
      78                 :             :   unsigned inner_mask;
      79                 :             : 
      80                 :             :   /* Location of parallel forked and join.  The forked is the first
      81                 :             :      block in the parallel and the join is the first block after of
      82                 :             :      the partition.  */
      83                 :             :   basic_block forked_block;
      84                 :             :   basic_block join_block;
      85                 :             : 
      86                 :             :   gimple *forked_stmt;
      87                 :             :   gimple *join_stmt;
      88                 :             : 
      89                 :             :   gimple *fork_stmt;
      90                 :             :   gimple *joining_stmt;
      91                 :             : 
      92                 :             :   /* Basic blocks in this parallel, but not in child parallels.  The
      93                 :             :      FORKED and JOINING blocks are in the partition.  The FORK and JOIN
      94                 :             :      blocks are not.  */
      95                 :             :   auto_vec<basic_block> blocks;
      96                 :             : 
      97                 :             :   tree record_type;
      98                 :             :   tree sender_decl;
      99                 :             :   tree receiver_decl;
     100                 :             : 
     101                 :             : public:
     102                 :             :   parallel_g (parallel_g *parent, unsigned mode);
     103                 :             :   ~parallel_g ();
     104                 :             : };
     105                 :             : 
     106                 :             : /* Constructor links the new parallel into it's parent's chain of
     107                 :             :    children.  */
     108                 :             : 
     109                 :           0 : parallel_g::parallel_g (parallel_g *parent_, unsigned mask_)
     110                 :           0 :   :parent (parent_), next (0), inner (0), mask (mask_), inner_mask (0)
     111                 :             : {
     112                 :           0 :   forked_block = join_block = 0;
     113                 :           0 :   forked_stmt = join_stmt = NULL;
     114                 :           0 :   fork_stmt = joining_stmt = NULL;
     115                 :             : 
     116                 :           0 :   record_type = NULL_TREE;
     117                 :           0 :   sender_decl = NULL_TREE;
     118                 :           0 :   receiver_decl = NULL_TREE;
     119                 :             : 
     120                 :           0 :   if (parent)
     121                 :             :     {
     122                 :           0 :       next = parent->inner;
     123                 :           0 :       parent->inner = this;
     124                 :             :     }
     125                 :           0 : }
     126                 :             : 
     127                 :           0 : parallel_g::~parallel_g ()
     128                 :             : {
     129                 :           0 :   delete inner;
     130                 :           0 :   delete next;
     131                 :           0 : }
     132                 :             : 
     133                 :             : static bool
     134                 :           0 : local_var_based_p (tree decl)
     135                 :             : {
     136                 :           0 :   switch (TREE_CODE (decl))
     137                 :             :     {
     138                 :           0 :     case VAR_DECL:
     139                 :           0 :       return !is_global_var (decl);
     140                 :             : 
     141                 :           0 :     case COMPONENT_REF:
     142                 :           0 :     case BIT_FIELD_REF:
     143                 :           0 :     case ARRAY_REF:
     144                 :           0 :       return local_var_based_p (TREE_OPERAND (decl, 0));
     145                 :             : 
     146                 :             :     default:
     147                 :             :       return false;
     148                 :             :     }
     149                 :             : }
     150                 :             : 
     151                 :             : /* Map of basic blocks to gimple stmts.  */
     152                 :             : typedef hash_map<basic_block, gimple *> bb_stmt_map_t;
     153                 :             : 
     154                 :             : /* Calls to OpenACC routines are made by all workers/wavefronts/warps, since
     155                 :             :    the routine likely contains partitioned loops (else will do its own
     156                 :             :    neutering and variable propagation). Return TRUE if a function call CALL
     157                 :             :    should be made in (worker) single mode instead, rather than redundant
     158                 :             :    mode.  */
     159                 :             : 
     160                 :             : static bool
     161                 :           0 : omp_sese_active_worker_call (gcall *call)
     162                 :             : {
     163                 :             : #define GOMP_DIM_SEQ GOMP_DIM_MAX
     164                 :           0 :   tree fndecl = gimple_call_fndecl (call);
     165                 :             : 
     166                 :           0 :   if (!fndecl)
     167                 :             :     return true;
     168                 :             : 
     169                 :           0 :   tree attrs = oacc_get_fn_attrib (fndecl);
     170                 :             : 
     171                 :           0 :   if (!attrs)
     172                 :             :     return true;
     173                 :             : 
     174                 :           0 :   int level = oacc_fn_attrib_level (attrs);
     175                 :             : 
     176                 :             :   /* Neither regular functions nor "seq" routines should be run by all threads
     177                 :             :      in worker-single mode.  */
     178                 :           0 :   return level == -1 || level == GOMP_DIM_SEQ;
     179                 :             : #undef GOMP_DIM_SEQ
     180                 :             : }
     181                 :             : 
     182                 :             : /* Split basic blocks such that each forked and join unspecs are at
     183                 :             :    the start of their basic blocks.  Thus afterwards each block will
     184                 :             :    have a single partitioning mode.  We also do the same for return
     185                 :             :    insns, as they are executed by every thread.  Return the
     186                 :             :    partitioning mode of the function as a whole.  Populate MAP with
     187                 :             :    head and tail blocks.  We also clear the BB visited flag, which is
     188                 :             :    used when finding partitions.  */
     189                 :             : /* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_split_blocks'.  */
     190                 :             : 
     191                 :             : static void
     192                 :           0 : omp_sese_split_blocks (bb_stmt_map_t *map)
     193                 :             : {
     194                 :           0 :   auto_vec<gimple *> worklist;
     195                 :           0 :   basic_block block;
     196                 :             : 
     197                 :             :   /* Locate all the reorg instructions of interest.  */
     198                 :           0 :   FOR_ALL_BB_FN (block, cfun)
     199                 :             :     {
     200                 :             :       /* Clear visited flag, for use by parallel locator  */
     201                 :           0 :       block->flags &= ~BB_VISITED;
     202                 :             : 
     203                 :           0 :       for (gimple_stmt_iterator gsi = gsi_start_bb (block);
     204                 :           0 :            !gsi_end_p (gsi);
     205                 :           0 :            gsi_next (&gsi))
     206                 :             :         {
     207                 :           0 :           gimple *stmt = gsi_stmt (gsi);
     208                 :             : 
     209                 :           0 :           if (gimple_call_internal_p (stmt, IFN_UNIQUE))
     210                 :             :             {
     211                 :           0 :               enum ifn_unique_kind k = ((enum ifn_unique_kind)
     212                 :           0 :                 TREE_INT_CST_LOW (gimple_call_arg (stmt, 0)));
     213                 :             : 
     214                 :           0 :               if (k == IFN_UNIQUE_OACC_JOIN)
     215                 :           0 :                 worklist.safe_push (stmt);
     216                 :           0 :               else if (k == IFN_UNIQUE_OACC_FORK)
     217                 :             :                 {
     218                 :           0 :                   gcc_assert (gsi_one_before_end_p (gsi));
     219                 :           0 :                   basic_block forked_block = single_succ (block);
     220                 :           0 :                   gimple_stmt_iterator gsi2 = gsi_start_bb (forked_block);
     221                 :             : 
     222                 :             :                   /* We push a NOP as a placeholder for the "forked" stmt.
     223                 :             :                      This is then recognized in omp_sese_find_par.  */
     224                 :           0 :                   gimple *nop = gimple_build_nop ();
     225                 :           0 :                   gsi_insert_before (&gsi2, nop, GSI_SAME_STMT);
     226                 :             : 
     227                 :           0 :                   worklist.safe_push (nop);
     228                 :             :                 }
     229                 :             :             }
     230                 :           0 :           else if (gimple_code (stmt) == GIMPLE_RETURN
     231                 :           0 :                    || gimple_code (stmt) == GIMPLE_COND
     232                 :           0 :                    || gimple_code (stmt) == GIMPLE_SWITCH
     233                 :           0 :                    || (gimple_code (stmt) == GIMPLE_CALL
     234                 :           0 :                        && !gimple_call_internal_p (stmt)
     235                 :           0 :                        && !omp_sese_active_worker_call (as_a <gcall *> (stmt))))
     236                 :           0 :             worklist.safe_push (stmt);
     237                 :           0 :           else if (is_gimple_assign (stmt))
     238                 :             :             {
     239                 :           0 :               tree lhs = gimple_assign_lhs (stmt);
     240                 :             : 
     241                 :             :               /* Force assignments to components/fields/elements of local
     242                 :             :                  aggregates into fully-partitioned (redundant) mode.  This
     243                 :             :                  avoids having to broadcast the whole aggregate.  The RHS of
     244                 :             :                  the assignment will be propagated using the normal
     245                 :             :                  mechanism.  */
     246                 :             : 
     247                 :           0 :               switch (TREE_CODE (lhs))
     248                 :             :                 {
     249                 :           0 :                 case COMPONENT_REF:
     250                 :           0 :                 case BIT_FIELD_REF:
     251                 :           0 :                 case ARRAY_REF:
     252                 :           0 :                   {
     253                 :           0 :                     tree aggr = TREE_OPERAND (lhs, 0);
     254                 :             : 
     255                 :           0 :                     if (local_var_based_p (aggr))
     256                 :           0 :                       worklist.safe_push (stmt);
     257                 :             :                   }
     258                 :             :                   break;
     259                 :             : 
     260                 :             :                 default:
     261                 :             :                   ;
     262                 :             :                 }
     263                 :             :             }
     264                 :             :         }
     265                 :             :     }
     266                 :             : 
     267                 :             :   /* Split blocks on the worklist.  */
     268                 :             :   unsigned ix;
     269                 :             :   gimple *stmt;
     270                 :             : 
     271                 :           0 :   for (ix = 0; worklist.iterate (ix, &stmt); ix++)
     272                 :             :     {
     273                 :           0 :       basic_block block = gimple_bb (stmt);
     274                 :             : 
     275                 :           0 :       if (gimple_code (stmt) == GIMPLE_COND)
     276                 :             :         {
     277                 :           0 :           gcond *orig_cond = as_a <gcond *> (stmt);
     278                 :           0 :           tree_code code = gimple_expr_code (orig_cond);
     279                 :           0 :           tree pred = make_ssa_name (boolean_type_node);
     280                 :           0 :           gimple *asgn = gimple_build_assign (pred, code,
     281                 :             :                            gimple_cond_lhs (orig_cond),
     282                 :             :                            gimple_cond_rhs (orig_cond));
     283                 :           0 :           gcond *new_cond
     284                 :           0 :             = gimple_build_cond (NE_EXPR, pred, boolean_false_node,
     285                 :             :                                  gimple_cond_true_label (orig_cond),
     286                 :             :                                  gimple_cond_false_label (orig_cond));
     287                 :             : 
     288                 :           0 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
     289                 :           0 :           gsi_insert_before (&gsi, asgn, GSI_SAME_STMT);
     290                 :           0 :           gsi_replace (&gsi, new_cond, true);
     291                 :             : 
     292                 :           0 :           edge e = split_block (block, asgn);
     293                 :           0 :           block = e->dest;
     294                 :           0 :           map->get_or_insert (block) = new_cond;
     295                 :             :         }
     296                 :           0 :       else if ((gimple_code (stmt) == GIMPLE_CALL
     297                 :           0 :                 && !gimple_call_internal_p (stmt))
     298                 :           0 :                || is_gimple_assign (stmt))
     299                 :             :         {
     300                 :           0 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
     301                 :           0 :           gsi_prev (&gsi);
     302                 :             : 
     303                 :           0 :           edge call = split_block (block, gsi_stmt (gsi));
     304                 :             : 
     305                 :           0 :           gimple *call_stmt = gsi_stmt (gsi_start_bb (call->dest));
     306                 :             : 
     307                 :           0 :           edge call_to_ret = split_block (call->dest, call_stmt);
     308                 :             : 
     309                 :           0 :           map->get_or_insert (call_to_ret->src) = call_stmt;
     310                 :             :         }
     311                 :             :       else
     312                 :             :         {
     313                 :           0 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
     314                 :           0 :           gsi_prev (&gsi);
     315                 :             : 
     316                 :           0 :           if (gsi_end_p (gsi))
     317                 :           0 :             map->get_or_insert (block) = stmt;
     318                 :             :           else
     319                 :             :             {
     320                 :             :               /* Split block before insn. The insn is in the new block.  */
     321                 :           0 :               edge e = split_block (block, gsi_stmt (gsi));
     322                 :             : 
     323                 :           0 :               block = e->dest;
     324                 :           0 :               map->get_or_insert (block) = stmt;
     325                 :             :             }
     326                 :             :         }
     327                 :             :     }
     328                 :           0 : }
     329                 :             : 
     330                 :             : static const char *
     331                 :           0 : mask_name (unsigned mask)
     332                 :             : {
     333                 :           0 :   switch (mask)
     334                 :             :     {
     335                 :             :     case 0: return "gang redundant";
     336                 :           0 :     case 1: return "gang partitioned";
     337                 :           0 :     case 2: return "worker partitioned";
     338                 :           0 :     case 3: return "gang+worker partitioned";
     339                 :           0 :     case 4: return "vector partitioned";
     340                 :           0 :     case 5: return "gang+vector partitioned";
     341                 :           0 :     case 6: return "worker+vector partitioned";
     342                 :           0 :     case 7: return "fully partitioned";
     343                 :           0 :     default: return "<illegal>";
     344                 :             :     }
     345                 :             : }
     346                 :             : 
     347                 :             : /* Dump this parallel and all its inner parallels.  */
     348                 :             : /* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_dump_pars'.  */
     349                 :             : 
     350                 :             : static void
     351                 :           0 : omp_sese_dump_pars (parallel_g *par, unsigned depth)
     352                 :             : {
     353                 :           0 :   fprintf (dump_file, "%u: mask %d (%s) head=%d, tail=%d\n",
     354                 :             :            depth, par->mask, mask_name (par->mask),
     355                 :           0 :            par->forked_block ? par->forked_block->index : -1,
     356                 :           0 :            par->join_block ? par->join_block->index : -1);
     357                 :             : 
     358                 :           0 :   fprintf (dump_file, "    blocks:");
     359                 :             : 
     360                 :           0 :   basic_block block;
     361                 :           0 :   for (unsigned ix = 0; par->blocks.iterate (ix, &block); ix++)
     362                 :           0 :     fprintf (dump_file, " %d", block->index);
     363                 :           0 :   fprintf (dump_file, "\n");
     364                 :           0 :   if (par->inner)
     365                 :           0 :     omp_sese_dump_pars (par->inner, depth + 1);
     366                 :             : 
     367                 :           0 :   if (par->next)
     368                 :             :     omp_sese_dump_pars (par->next, depth);
     369                 :           0 : }
     370                 :             : 
     371                 :             : /* If BLOCK contains a fork/join marker, process it to create or
     372                 :             :    terminate a loop structure.  Add this block to the current loop,
     373                 :             :    and then walk successor blocks.   */
     374                 :             : /* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_find_par'.  */
     375                 :             : 
     376                 :             : static parallel_g *
     377                 :           0 : omp_sese_find_par (bb_stmt_map_t *map, parallel_g *par, basic_block block)
     378                 :             : {
     379                 :           0 :   if (block->flags & BB_VISITED)
     380                 :             :     return par;
     381                 :           0 :   block->flags |= BB_VISITED;
     382                 :             : 
     383                 :           0 :   if (gimple **stmtp = map->get (block))
     384                 :             :     {
     385                 :           0 :       gimple *stmt = *stmtp;
     386                 :             : 
     387                 :           0 :       if (gimple_code (stmt) == GIMPLE_COND
     388                 :           0 :           || gimple_code (stmt) == GIMPLE_SWITCH
     389                 :           0 :           || gimple_code (stmt) == GIMPLE_RETURN
     390                 :           0 :           || (gimple_code (stmt) == GIMPLE_CALL
     391                 :           0 :               && !gimple_call_internal_p (stmt))
     392                 :           0 :           || is_gimple_assign (stmt))
     393                 :             :         {
     394                 :             :           /* A single block that is forced to be at the maximum partition
     395                 :             :              level.  Make a singleton par for it.  */
     396                 :           0 :           par = new parallel_g (par, GOMP_DIM_MASK (GOMP_DIM_GANG)
     397                 :             :                                    | GOMP_DIM_MASK (GOMP_DIM_WORKER)
     398                 :           0 :                                    | GOMP_DIM_MASK (GOMP_DIM_VECTOR));
     399                 :           0 :           par->forked_block = block;
     400                 :           0 :           par->forked_stmt = stmt;
     401                 :           0 :           par->blocks.safe_push (block);
     402                 :           0 :           par = par->parent;
     403                 :           0 :           goto walk_successors;
     404                 :             :         }
     405                 :           0 :       else if (gimple_nop_p (stmt))
     406                 :             :         {
     407                 :           0 :           basic_block pred = single_pred (block);
     408                 :           0 :           gcc_assert (pred);
     409                 :           0 :           gimple_stmt_iterator gsi = gsi_last_bb (pred);
     410                 :           0 :           gimple *final_stmt = gsi_stmt (gsi);
     411                 :             : 
     412                 :           0 :           if (gimple_call_internal_p (final_stmt, IFN_UNIQUE))
     413                 :             :             {
     414                 :           0 :               gcall *call = as_a <gcall *> (final_stmt);
     415                 :           0 :               enum ifn_unique_kind k = ((enum ifn_unique_kind)
     416                 :           0 :                 TREE_INT_CST_LOW (gimple_call_arg (call, 0)));
     417                 :             : 
     418                 :           0 :               if (k == IFN_UNIQUE_OACC_FORK)
     419                 :             :                 {
     420                 :           0 :                   HOST_WIDE_INT dim
     421                 :           0 :                     = TREE_INT_CST_LOW (gimple_call_arg (call, 2));
     422                 :           0 :                   unsigned mask = (dim >= 0) ? GOMP_DIM_MASK (dim) : 0;
     423                 :             : 
     424                 :           0 :                   par = new parallel_g (par, mask);
     425                 :           0 :                   par->forked_block = block;
     426                 :           0 :                   par->forked_stmt = final_stmt;
     427                 :           0 :                   par->fork_stmt = stmt;
     428                 :             :                 }
     429                 :             :               else
     430                 :           0 :                 gcc_unreachable ();
     431                 :             :             }
     432                 :             :           else
     433                 :           0 :             gcc_unreachable ();
     434                 :             :         }
     435                 :           0 :       else if (gimple_call_internal_p (stmt, IFN_UNIQUE))
     436                 :             :         {
     437                 :           0 :           gcall *call = as_a <gcall *> (stmt);
     438                 :           0 :           enum ifn_unique_kind k = ((enum ifn_unique_kind)
     439                 :           0 :             TREE_INT_CST_LOW (gimple_call_arg (call, 0)));
     440                 :           0 :           if (k == IFN_UNIQUE_OACC_JOIN)
     441                 :             :             {
     442                 :           0 :               HOST_WIDE_INT dim = TREE_INT_CST_LOW (gimple_call_arg (stmt, 2));
     443                 :           0 :               unsigned mask = (dim >= 0) ? GOMP_DIM_MASK (dim) : 0;
     444                 :             : 
     445                 :           0 :               gcc_assert (par->mask == mask);
     446                 :           0 :               par->join_block = block;
     447                 :           0 :               par->join_stmt = stmt;
     448                 :           0 :               par = par->parent;
     449                 :             :             }
     450                 :             :           else
     451                 :           0 :             gcc_unreachable ();
     452                 :             :         }
     453                 :             :       else
     454                 :           0 :         gcc_unreachable ();
     455                 :             :     }
     456                 :             : 
     457                 :           0 :   if (par)
     458                 :             :     /* Add this block onto the current loop's list of blocks.  */
     459                 :           0 :     par->blocks.safe_push (block);
     460                 :             :   else
     461                 :             :     /* This must be the entry block.  Create a NULL parallel.  */
     462                 :           0 :     par = new parallel_g (0, 0);
     463                 :             : 
     464                 :           0 : walk_successors:
     465                 :             :   /* Walk successor blocks.  */
     466                 :           0 :   edge e;
     467                 :           0 :   edge_iterator ei;
     468                 :             : 
     469                 :           0 :   FOR_EACH_EDGE (e, ei, block->succs)
     470                 :           0 :     omp_sese_find_par (map, par, e->dest);
     471                 :             : 
     472                 :             :   return par;
     473                 :             : }
     474                 :             : 
     475                 :             : /* DFS walk the CFG looking for fork & join markers.  Construct
     476                 :             :    loop structures as we go.  MAP is a mapping of basic blocks
     477                 :             :    to head & tail markers, discovered when splitting blocks.  This
     478                 :             :    speeds up the discovery.  We rely on the BB visited flag having
     479                 :             :    been cleared when splitting blocks.  */
     480                 :             : /* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_discover_pars'.  */
     481                 :             : 
     482                 :             : static parallel_g *
     483                 :           0 : omp_sese_discover_pars (bb_stmt_map_t *map)
     484                 :             : {
     485                 :           0 :   basic_block block;
     486                 :             : 
     487                 :             :   /* Mark exit blocks as visited.  */
     488                 :           0 :   block = EXIT_BLOCK_PTR_FOR_FN (cfun);
     489                 :           0 :   block->flags |= BB_VISITED;
     490                 :             : 
     491                 :             :   /* And entry block as not.  */
     492                 :           0 :   block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
     493                 :           0 :   block->flags &= ~BB_VISITED;
     494                 :             : 
     495                 :           0 :   parallel_g *par = omp_sese_find_par (map, 0, block);
     496                 :             : 
     497                 :           0 :   if (dump_file)
     498                 :             :     {
     499                 :           0 :       fprintf (dump_file, "\nLoops\n");
     500                 :           0 :       omp_sese_dump_pars (par, 0);
     501                 :           0 :       fprintf (dump_file, "\n");
     502                 :             :     }
     503                 :             : 
     504                 :           0 :   return par;
     505                 :             : }
     506                 :             : 
     507                 :             : static void
     508                 :           0 : populate_single_mode_bitmaps (parallel_g *par, bitmap worker_single,
     509                 :             :                               bitmap vector_single, unsigned outer_mask,
     510                 :             :                               int depth)
     511                 :             : {
     512                 :           0 :   unsigned mask = outer_mask | par->mask;
     513                 :             : 
     514                 :           0 :   basic_block block;
     515                 :             : 
     516                 :           0 :   for (unsigned i = 0; par->blocks.iterate (i, &block); i++)
     517                 :             :     {
     518                 :           0 :       if ((mask & GOMP_DIM_MASK (GOMP_DIM_WORKER)) == 0)
     519                 :           0 :         bitmap_set_bit (worker_single, block->index);
     520                 :             : 
     521                 :           0 :       if ((mask & GOMP_DIM_MASK (GOMP_DIM_VECTOR)) == 0)
     522                 :           0 :         bitmap_set_bit (vector_single, block->index);
     523                 :             :     }
     524                 :             : 
     525                 :           0 :   if (par->inner)
     526                 :           0 :     populate_single_mode_bitmaps (par->inner, worker_single, vector_single,
     527                 :             :                                   mask, depth + 1);
     528                 :           0 :   if (par->next)
     529                 :             :     populate_single_mode_bitmaps (par->next, worker_single, vector_single,
     530                 :             :                                   outer_mask, depth);
     531                 :           0 : }
     532                 :             : 
     533                 :             : /* A map from SSA names or var decls to record fields.  */
     534                 :             : 
     535                 :             : typedef hash_map<tree, tree> field_map_t;
     536                 :             : 
     537                 :             : /* For each propagation record type, this is a map from SSA names or var decls
     538                 :             :    to propagate, to the field in the record type that should be used for
     539                 :             :    transmission and reception.  */
     540                 :             : 
     541                 :             : typedef hash_map<tree, field_map_t> record_field_map_t;
     542                 :             : 
     543                 :             : static void
     544                 :           0 : install_var_field (tree var, tree record_type, field_map_t *fields)
     545                 :             : {
     546                 :           0 :   tree name;
     547                 :           0 :   char tmp[20];
     548                 :             : 
     549                 :           0 :   if (TREE_CODE (var) == SSA_NAME)
     550                 :             :     {
     551                 :           0 :       name = SSA_NAME_IDENTIFIER (var);
     552                 :           0 :       if (!name)
     553                 :             :         {
     554                 :           0 :           sprintf (tmp, "_%u", (unsigned) SSA_NAME_VERSION (var));
     555                 :           0 :           name = get_identifier (tmp);
     556                 :             :         }
     557                 :             :     }
     558                 :           0 :   else if (VAR_P (var))
     559                 :             :     {
     560                 :           0 :       name = DECL_NAME (var);
     561                 :           0 :       if (!name)
     562                 :             :         {
     563                 :           0 :           sprintf (tmp, "D_%u", (unsigned) DECL_UID (var));
     564                 :           0 :           name = get_identifier (tmp);
     565                 :             :         }
     566                 :             :     }
     567                 :             :   else
     568                 :           0 :     gcc_unreachable ();
     569                 :             : 
     570                 :           0 :   gcc_assert (!fields->get (var));
     571                 :             : 
     572                 :           0 :   tree type = TREE_TYPE (var);
     573                 :             : 
     574                 :           0 :   if (POINTER_TYPE_P (type)
     575                 :           0 :       && TYPE_RESTRICT (type))
     576                 :           0 :     type = build_qualified_type (type, TYPE_QUALS (type) & ~TYPE_QUAL_RESTRICT);
     577                 :             : 
     578                 :           0 :   tree field = build_decl (BUILTINS_LOCATION, FIELD_DECL, name, type);
     579                 :             : 
     580                 :           0 :   if (VAR_P (var) && type == TREE_TYPE (var))
     581                 :             :     {
     582                 :           0 :       SET_DECL_ALIGN (field, DECL_ALIGN (var));
     583                 :           0 :       DECL_USER_ALIGN (field) = DECL_USER_ALIGN (var);
     584                 :           0 :       TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (var);
     585                 :             :     }
     586                 :             :   else
     587                 :           0 :     SET_DECL_ALIGN (field, TYPE_ALIGN (type));
     588                 :             : 
     589                 :           0 :   fields->put (var, field);
     590                 :             : 
     591                 :           0 :   insert_field_into_struct (record_type, field);
     592                 :           0 : }
     593                 :             : 
     594                 :             : /* Sets of SSA_NAMES or VAR_DECLs to propagate.  */
     595                 :             : typedef hash_set<tree> propagation_set;
     596                 :             : 
     597                 :             : static void
     598                 :           0 : find_ssa_names_to_propagate (parallel_g *par, unsigned outer_mask,
     599                 :             :                              bitmap worker_single, bitmap vector_single,
     600                 :             :                              vec<propagation_set *> *prop_set)
     601                 :             : {
     602                 :           0 :   unsigned mask = outer_mask | par->mask;
     603                 :             : 
     604                 :           0 :   if (par->inner)
     605                 :           0 :     find_ssa_names_to_propagate (par->inner, mask, worker_single,
     606                 :             :                                  vector_single, prop_set);
     607                 :           0 :   if (par->next)
     608                 :           0 :     find_ssa_names_to_propagate (par->next, outer_mask, worker_single,
     609                 :             :                                  vector_single, prop_set);
     610                 :             : 
     611                 :           0 :   if (mask & GOMP_DIM_MASK (GOMP_DIM_WORKER))
     612                 :             :     {
     613                 :             :       basic_block block;
     614                 :             :       int ix;
     615                 :             : 
     616                 :           0 :       for (ix = 0; par->blocks.iterate (ix, &block); ix++)
     617                 :             :         {
     618                 :           0 :           for (gphi_iterator psi = gsi_start_phis (block);
     619                 :           0 :                !gsi_end_p (psi); gsi_next (&psi))
     620                 :             :             {
     621                 :           0 :               gphi *phi = psi.phi ();
     622                 :           0 :               use_operand_p use;
     623                 :           0 :               ssa_op_iter iter;
     624                 :             : 
     625                 :           0 :               FOR_EACH_PHI_ARG (use, phi, iter, SSA_OP_USE)
     626                 :             :                 {
     627                 :           0 :                   tree var = USE_FROM_PTR (use);
     628                 :             : 
     629                 :           0 :                   if (TREE_CODE (var) != SSA_NAME)
     630                 :           0 :                     continue;
     631                 :             : 
     632                 :           0 :                   gimple *def_stmt = SSA_NAME_DEF_STMT (var);
     633                 :             : 
     634                 :           0 :                   if (gimple_nop_p (def_stmt))
     635                 :           0 :                     continue;
     636                 :             : 
     637                 :           0 :                   basic_block def_bb = gimple_bb (def_stmt);
     638                 :             : 
     639                 :           0 :                   if (bitmap_bit_p (worker_single, def_bb->index))
     640                 :             :                     {
     641                 :           0 :                       if (!(*prop_set)[def_bb->index])
     642                 :           0 :                         (*prop_set)[def_bb->index] = new propagation_set;
     643                 :             : 
     644                 :           0 :                       propagation_set *ws_prop = (*prop_set)[def_bb->index];
     645                 :             : 
     646                 :           0 :                       ws_prop->add (var);
     647                 :             :                     }
     648                 :             :                 }
     649                 :             :             }
     650                 :             : 
     651                 :           0 :           for (gimple_stmt_iterator gsi = gsi_start_bb (block);
     652                 :           0 :                !gsi_end_p (gsi); gsi_next (&gsi))
     653                 :             :             {
     654                 :           0 :               use_operand_p use;
     655                 :           0 :               ssa_op_iter iter;
     656                 :           0 :               gimple *stmt = gsi_stmt (gsi);
     657                 :             : 
     658                 :           0 :               FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
     659                 :             :                 {
     660                 :           0 :                   tree var = USE_FROM_PTR (use);
     661                 :             : 
     662                 :           0 :                   gimple *def_stmt = SSA_NAME_DEF_STMT (var);
     663                 :             : 
     664                 :           0 :                   if (gimple_nop_p (def_stmt))
     665                 :           0 :                     continue;
     666                 :             : 
     667                 :           0 :                   basic_block def_bb = gimple_bb (def_stmt);
     668                 :             : 
     669                 :           0 :                   if (bitmap_bit_p (worker_single, def_bb->index))
     670                 :             :                     {
     671                 :           0 :                       if (!(*prop_set)[def_bb->index])
     672                 :           0 :                         (*prop_set)[def_bb->index] = new propagation_set;
     673                 :             : 
     674                 :           0 :                       propagation_set *ws_prop = (*prop_set)[def_bb->index];
     675                 :             : 
     676                 :           0 :                       ws_prop->add (var);
     677                 :             :                     }
     678                 :             :                 }
     679                 :             :             }
     680                 :             :         }
     681                 :             :     }
     682                 :           0 : }
     683                 :             : 
     684                 :             : /* Callback for walk_gimple_stmt to find RHS VAR_DECLs (uses) in a
     685                 :             :    statement.  */
     686                 :             : 
     687                 :             : static tree
     688                 :           0 : find_partitioned_var_uses_1 (tree *node, int *, void *data)
     689                 :             : {
     690                 :           0 :   walk_stmt_info *wi = (walk_stmt_info *) data;
     691                 :           0 :   hash_set<tree> *partitioned_var_uses = (hash_set<tree> *) wi->info;
     692                 :             : 
     693                 :           0 :   if (!wi->is_lhs && VAR_P (*node))
     694                 :           0 :     partitioned_var_uses->add (*node);
     695                 :             : 
     696                 :           0 :   return NULL_TREE;
     697                 :             : }
     698                 :             : 
     699                 :             : static void
     700                 :           0 : find_partitioned_var_uses (parallel_g *par, unsigned outer_mask,
     701                 :             :                            hash_set<tree> *partitioned_var_uses)
     702                 :             : {
     703                 :           0 :   unsigned mask = outer_mask | par->mask;
     704                 :             : 
     705                 :           0 :   if (par->inner)
     706                 :           0 :     find_partitioned_var_uses (par->inner, mask, partitioned_var_uses);
     707                 :           0 :   if (par->next)
     708                 :           0 :     find_partitioned_var_uses (par->next, outer_mask, partitioned_var_uses);
     709                 :             : 
     710                 :           0 :   if (mask & GOMP_DIM_MASK (GOMP_DIM_WORKER))
     711                 :             :     {
     712                 :             :       basic_block block;
     713                 :             :       int ix;
     714                 :             : 
     715                 :           0 :       for (ix = 0; par->blocks.iterate (ix, &block); ix++)
     716                 :           0 :         for (gimple_stmt_iterator gsi = gsi_start_bb (block);
     717                 :           0 :              !gsi_end_p (gsi); gsi_next (&gsi))
     718                 :             :           {
     719                 :           0 :             walk_stmt_info wi;
     720                 :           0 :             memset (&wi, 0, sizeof (wi));
     721                 :           0 :             wi.info = (void *) partitioned_var_uses;
     722                 :           0 :             walk_gimple_stmt (&gsi, NULL, find_partitioned_var_uses_1, &wi);
     723                 :             :           }
     724                 :             :     }
     725                 :           0 : }
     726                 :             : 
     727                 :             : /* Gang-private variables (typically placed in a GPU's shared memory) do not
     728                 :             :    need to be processed by the worker-propagation mechanism.  Populate the
     729                 :             :    GANG_PRIVATE_VARS set with any such variables found in the current
     730                 :             :    function.  */
     731                 :             : 
     732                 :             : static void
     733                 :           0 : find_gang_private_vars (hash_set<tree> *gang_private_vars)
     734                 :             : {
     735                 :           0 :   basic_block block;
     736                 :             : 
     737                 :           0 :   FOR_EACH_BB_FN (block, cfun)
     738                 :             :     {
     739                 :           0 :       for (gimple_stmt_iterator gsi = gsi_start_bb (block);
     740                 :           0 :            !gsi_end_p (gsi);
     741                 :           0 :            gsi_next (&gsi))
     742                 :             :         {
     743                 :           0 :           gimple *stmt = gsi_stmt (gsi);
     744                 :             : 
     745                 :           0 :           if (gimple_call_internal_p (stmt, IFN_UNIQUE))
     746                 :             :             {
     747                 :           0 :               enum ifn_unique_kind k = ((enum ifn_unique_kind)
     748                 :           0 :                 TREE_INT_CST_LOW (gimple_call_arg (stmt, 0)));
     749                 :           0 :               if (k == IFN_UNIQUE_OACC_PRIVATE)
     750                 :             :                 {
     751                 :           0 :                   HOST_WIDE_INT level
     752                 :           0 :                     = TREE_INT_CST_LOW (gimple_call_arg (stmt, 2));
     753                 :           0 :                   if (level != GOMP_DIM_GANG)
     754                 :           0 :                     continue;
     755                 :           0 :                   for (unsigned i = 3; i < gimple_call_num_args (stmt); i++)
     756                 :             :                     {
     757                 :           0 :                       tree arg = gimple_call_arg (stmt, i);
     758                 :           0 :                       gcc_assert (TREE_CODE (arg) == ADDR_EXPR);
     759                 :           0 :                       tree decl = TREE_OPERAND (arg, 0);
     760                 :           0 :                       gang_private_vars->add (decl);
     761                 :             :                     }
     762                 :             :                 }
     763                 :             :             }
     764                 :             :         }
     765                 :             :     }
     766                 :           0 : }
     767                 :             : 
     768                 :             : static void
     769                 :           0 : find_local_vars_to_propagate (parallel_g *par, unsigned outer_mask,
     770                 :             :                               hash_set<tree> *partitioned_var_uses,
     771                 :             :                               hash_set<tree> *gang_private_vars,
     772                 :             :                               bitmap writes_gang_private,
     773                 :             :                               vec<propagation_set *> *prop_set)
     774                 :             : {
     775                 :           0 :   unsigned mask = outer_mask | par->mask;
     776                 :             : 
     777                 :           0 :   if (par->inner)
     778                 :           0 :     find_local_vars_to_propagate (par->inner, mask, partitioned_var_uses,
     779                 :             :                                   gang_private_vars, writes_gang_private,
     780                 :             :                                   prop_set);
     781                 :           0 :   if (par->next)
     782                 :           0 :     find_local_vars_to_propagate (par->next, outer_mask, partitioned_var_uses,
     783                 :             :                                   gang_private_vars, writes_gang_private,
     784                 :             :                                   prop_set);
     785                 :             : 
     786                 :           0 :   if (!(mask & GOMP_DIM_MASK (GOMP_DIM_WORKER)))
     787                 :             :     {
     788                 :             :       basic_block block;
     789                 :             :       int ix;
     790                 :             : 
     791                 :           0 :       for (ix = 0; par->blocks.iterate (ix, &block); ix++)
     792                 :             :         {
     793                 :           0 :           for (gimple_stmt_iterator gsi = gsi_start_bb (block);
     794                 :           0 :                !gsi_end_p (gsi); gsi_next (&gsi))
     795                 :             :             {
     796                 :           0 :               gimple *stmt = gsi_stmt (gsi);
     797                 :           0 :               tree var;
     798                 :           0 :               unsigned i;
     799                 :             : 
     800                 :           0 :               FOR_EACH_LOCAL_DECL (cfun, i, var)
     801                 :             :                 {
     802                 :           0 :                   if (!VAR_P (var)
     803                 :           0 :                       || is_global_var (var)
     804                 :           0 :                       || AGGREGATE_TYPE_P (TREE_TYPE (var))
     805                 :           0 :                       || !partitioned_var_uses->contains (var))
     806                 :           0 :                     continue;
     807                 :             : 
     808                 :           0 :                   if (stmt_may_clobber_ref_p (stmt, var))
     809                 :             :                     {
     810                 :           0 :                       if (dump_file)
     811                 :             :                         {
     812                 :           0 :                           fprintf (dump_file, "bb %u: local variable may be "
     813                 :             :                                    "clobbered in %s mode: ", block->index,
     814                 :             :                                    mask_name (mask));
     815                 :           0 :                           print_generic_expr (dump_file, var, TDF_SLIM);
     816                 :           0 :                           fprintf (dump_file, "\n");
     817                 :             :                         }
     818                 :             : 
     819                 :           0 :                       if (gang_private_vars->contains (var))
     820                 :             :                         {
     821                 :             :                           /* If we write a gang-private variable, we want a
     822                 :             :                              barrier at the end of the block.  */
     823                 :           0 :                           bitmap_set_bit (writes_gang_private, block->index);
     824                 :           0 :                           continue;
     825                 :             :                         }
     826                 :             : 
     827                 :           0 :                       if (!(*prop_set)[block->index])
     828                 :           0 :                         (*prop_set)[block->index] = new propagation_set;
     829                 :             : 
     830                 :           0 :                       propagation_set *ws_prop
     831                 :           0 :                         = (*prop_set)[block->index];
     832                 :             : 
     833                 :           0 :                       ws_prop->add (var);
     834                 :             :                     }
     835                 :             :                 }
     836                 :             :             }
     837                 :             :         }
     838                 :             :     }
     839                 :           0 : }
     840                 :             : 
     841                 :             : /* Transform basic blocks FROM, TO (which may be the same block) into:
     842                 :             :    if (GOACC_single_start ())
     843                 :             :      BLOCK;
     844                 :             :    GOACC_barrier ();
     845                 :             :                               \  |  /
     846                 :             :                               +----+
     847                 :             :                               |    |        (new) predicate block
     848                 :             :                               +----+--
     849                 :             :    \  |  /   \  |  /            |t    \
     850                 :             :    +----+    +----+           +----+  |
     851                 :             :    |    |    |    |     ===>  |    |  | f   (old) from block
     852                 :             :    +----+    +----+           +----+  |
     853                 :             :      |       t/  \f             |    /
     854                 :             :                               +----+/
     855                 :             :   (split  (split before       |    |        skip block
     856                 :             :   at end)   condition)        +----+
     857                 :             :                               t/  \f
     858                 :             : */
     859                 :             : 
     860                 :             : static void
     861                 :           0 : worker_single_simple (basic_block from, basic_block to,
     862                 :             :                       hash_set<tree> *def_escapes_block)
     863                 :             : {
     864                 :           0 :   gimple *call, *cond;
     865                 :           0 :   tree lhs, decl;
     866                 :           0 :   basic_block skip_block;
     867                 :             : 
     868                 :           0 :   gimple_stmt_iterator gsi = gsi_last_bb (to);
     869                 :           0 :   if (EDGE_COUNT (to->succs) > 1)
     870                 :             :     {
     871                 :           0 :       gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_COND);
     872                 :           0 :       gsi_prev (&gsi);
     873                 :             :     }
     874                 :           0 :   edge e = split_block (to, gsi_stmt (gsi));
     875                 :           0 :   skip_block = e->dest;
     876                 :             : 
     877                 :           0 :   gimple_stmt_iterator start = gsi_after_labels (from);
     878                 :             : 
     879                 :           0 :   decl = builtin_decl_explicit (BUILT_IN_GOACC_SINGLE_START);
     880                 :           0 :   lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (decl)));
     881                 :           0 :   call = gimple_build_call (decl, 0);
     882                 :           0 :   gimple_call_set_lhs (call, lhs);
     883                 :           0 :   gsi_insert_before (&start, call, GSI_NEW_STMT);
     884                 :           0 :   update_stmt (call);
     885                 :             : 
     886                 :           0 :   cond = gimple_build_cond (EQ_EXPR, lhs,
     887                 :             :                             fold_convert_loc (UNKNOWN_LOCATION,
     888                 :           0 :                                               TREE_TYPE (lhs),
     889                 :             :                                               boolean_true_node),
     890                 :             :                             NULL_TREE, NULL_TREE);
     891                 :           0 :   gsi_insert_after (&start, cond, GSI_NEW_STMT);
     892                 :           0 :   update_stmt (cond);
     893                 :             : 
     894                 :           0 :   edge et = split_block (from, cond);
     895                 :           0 :   et->flags &= ~EDGE_FALLTHRU;
     896                 :           0 :   et->flags |= EDGE_TRUE_VALUE;
     897                 :             :   /* Make the active worker the more probable path so we prefer fallthrough
     898                 :             :      (letting the idle workers jump around more).  */
     899                 :           0 :   et->probability = profile_probability::likely ();
     900                 :             : 
     901                 :           0 :   edge ef = make_edge (from, skip_block, EDGE_FALSE_VALUE);
     902                 :           0 :   ef->probability = et->probability.invert ();
     903                 :             : 
     904                 :           0 :   basic_block neutered = split_edge (ef);
     905                 :           0 :   gimple_stmt_iterator neut_gsi = gsi_last_bb (neutered);
     906                 :             : 
     907                 :           0 :   for (gsi = gsi_start_bb (et->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     908                 :             :     {
     909                 :           0 :       gimple *stmt = gsi_stmt (gsi);
     910                 :           0 :       ssa_op_iter iter;
     911                 :           0 :       tree var;
     912                 :             : 
     913                 :           0 :       FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_DEF)
     914                 :             :         {
     915                 :           0 :           if (def_escapes_block->contains (var))
     916                 :             :             {
     917                 :           0 :               gphi *join_phi = create_phi_node (NULL_TREE, skip_block);
     918                 :           0 :               create_new_def_for (var, join_phi,
     919                 :             :                                   gimple_phi_result_ptr (join_phi));
     920                 :           0 :               add_phi_arg (join_phi, var, e, UNKNOWN_LOCATION);
     921                 :             : 
     922                 :           0 :               tree neutered_def = copy_ssa_name (var, NULL);
     923                 :             :               /* We really want "don't care" or some value representing
     924                 :             :                  undefined here, but optimizers will probably get rid of the
     925                 :             :                  zero-assignments anyway.  */
     926                 :           0 :               gassign *zero = gimple_build_assign (neutered_def,
     927                 :           0 :                                 build_zero_cst (TREE_TYPE (neutered_def)));
     928                 :             : 
     929                 :           0 :               gsi_insert_after (&neut_gsi, zero, GSI_CONTINUE_LINKING);
     930                 :           0 :               update_stmt (zero);
     931                 :             : 
     932                 :           0 :               add_phi_arg (join_phi, neutered_def, single_succ_edge (neutered),
     933                 :             :                            UNKNOWN_LOCATION);
     934                 :           0 :               update_stmt (join_phi);
     935                 :             :             }
     936                 :             :         }
     937                 :             :     }
     938                 :           0 : }
     939                 :             : 
     940                 :             : static tree
     941                 :           0 : build_receiver_ref (tree var, tree receiver_decl, field_map_t *fields)
     942                 :             : {
     943                 :           0 :   tree x = build_simple_mem_ref (receiver_decl);
     944                 :           0 :   tree field = *fields->get (var);
     945                 :           0 :   TREE_THIS_NOTRAP (x) = 1;
     946                 :           0 :   x = omp_build_component_ref (x, field);
     947                 :           0 :   return x;
     948                 :             : }
     949                 :             : 
     950                 :             : static tree
     951                 :           0 : build_sender_ref (tree var, tree sender_decl, field_map_t *fields)
     952                 :             : {
     953                 :           0 :   if (POINTER_TYPE_P (TREE_TYPE (sender_decl)))
     954                 :           0 :     sender_decl = build_simple_mem_ref (sender_decl);
     955                 :           0 :   tree field = *fields->get (var);
     956                 :           0 :   return omp_build_component_ref (sender_decl, field);
     957                 :             : }
     958                 :             : 
     959                 :             : static int
     960                 :           0 : sort_by_ssa_version_or_uid (const void *p1, const void *p2)
     961                 :             : {
     962                 :           0 :   const tree t1 = *(const tree *)p1;
     963                 :           0 :   const tree t2 = *(const tree *)p2;
     964                 :             : 
     965                 :           0 :   if (TREE_CODE (t1) == SSA_NAME && TREE_CODE (t2) == SSA_NAME)
     966                 :           0 :     return SSA_NAME_VERSION (t1) - SSA_NAME_VERSION (t2);
     967                 :           0 :   else if (TREE_CODE (t1) == SSA_NAME && TREE_CODE (t2) != SSA_NAME)
     968                 :             :     return -1;
     969                 :           0 :   else if (TREE_CODE (t1) != SSA_NAME && TREE_CODE (t2) == SSA_NAME)
     970                 :             :     return 1;
     971                 :             :   else
     972                 :           0 :     return DECL_UID (t1) - DECL_UID (t2);
     973                 :             : }
     974                 :             : 
     975                 :             : static int
     976                 :           0 : sort_by_size_then_ssa_version_or_uid (const void *p1, const void *p2)
     977                 :             : {
     978                 :           0 :   const tree t1 = *(const tree *)p1;
     979                 :           0 :   const tree t2 = *(const tree *)p2;
     980                 :           0 :   unsigned HOST_WIDE_INT s1 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t1)));
     981                 :           0 :   unsigned HOST_WIDE_INT s2 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t2)));
     982                 :           0 :   if (s1 != s2)
     983                 :           0 :     return s2 - s1;
     984                 :             :   else
     985                 :           0 :     return sort_by_ssa_version_or_uid (p1, p2);
     986                 :             : }
     987                 :             : 
     988                 :             : static void
     989                 :           0 : worker_single_copy (basic_block from, basic_block to,
     990                 :             :                     hash_set<tree> *def_escapes_block,
     991                 :             :                     hash_set<tree> *worker_partitioned_uses,
     992                 :             :                     tree record_type, record_field_map_t *record_field_map,
     993                 :             :                     unsigned HOST_WIDE_INT placement,
     994                 :             :                     bool isolate_broadcasts, bool has_gang_private_write)
     995                 :             : {
     996                 :             :   /* If we only have virtual defs, we'll have no record type, but we still want
     997                 :             :      to emit single_copy_start and (particularly) single_copy_end to act as
     998                 :             :      a vdef source on the neutered edge representing memory writes on the
     999                 :             :      non-neutered edge.  */
    1000                 :           0 :   if (!record_type)
    1001                 :           0 :     record_type = char_type_node;
    1002                 :             : 
    1003                 :           0 :   tree sender_decl
    1004                 :           0 :     = targetm.goacc.create_worker_broadcast_record (record_type, true,
    1005                 :             :                                                     ".oacc_worker_o",
    1006                 :             :                                                     placement);
    1007                 :           0 :   tree receiver_decl
    1008                 :           0 :     = targetm.goacc.create_worker_broadcast_record (record_type, false,
    1009                 :             :                                                     ".oacc_worker_i",
    1010                 :             :                                                     placement);
    1011                 :             : 
    1012                 :           0 :   gimple_stmt_iterator gsi = gsi_last_bb (to);
    1013                 :           0 :   if (EDGE_COUNT (to->succs) > 1)
    1014                 :           0 :     gsi_prev (&gsi);
    1015                 :           0 :   edge e = split_block (to, gsi_stmt (gsi));
    1016                 :           0 :   basic_block barrier_block = e->dest;
    1017                 :             : 
    1018                 :           0 :   gimple_stmt_iterator start = gsi_after_labels (from);
    1019                 :             : 
    1020                 :           0 :   tree decl = builtin_decl_explicit (BUILT_IN_GOACC_SINGLE_COPY_START);
    1021                 :             : 
    1022                 :           0 :   tree lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (decl)));
    1023                 :             : 
    1024                 :           0 :   gimple *call
    1025                 :           0 :     = gimple_build_call (decl, 1,
    1026                 :           0 :                          POINTER_TYPE_P (TREE_TYPE (sender_decl))
    1027                 :           0 :                          ? sender_decl : build_fold_addr_expr (sender_decl));
    1028                 :           0 :   gimple_call_set_lhs (call, lhs);
    1029                 :           0 :   gsi_insert_before (&start, call, GSI_NEW_STMT);
    1030                 :           0 :   update_stmt (call);
    1031                 :             : 
    1032                 :             :   /* The shared-memory range for this block overflowed.  Add a barrier before
    1033                 :             :      the GOACC_single_copy_start call.  */
    1034                 :           0 :   if (isolate_broadcasts)
    1035                 :             :     {
    1036                 :           0 :       decl = builtin_decl_explicit (BUILT_IN_GOACC_BARRIER);
    1037                 :           0 :       gimple *acc_bar = gimple_build_call (decl, 0);
    1038                 :           0 :       gsi_insert_before (&start, acc_bar, GSI_SAME_STMT);
    1039                 :             :     }
    1040                 :             : 
    1041                 :           0 :   tree conv_tmp = make_ssa_name (TREE_TYPE (receiver_decl));
    1042                 :             : 
    1043                 :           0 :   gimple *conv = gimple_build_assign (conv_tmp,
    1044                 :           0 :                                       fold_convert (TREE_TYPE (receiver_decl),
    1045                 :             :                                                     lhs));
    1046                 :           0 :   update_stmt (conv);
    1047                 :           0 :   gsi_insert_after (&start, conv, GSI_NEW_STMT);
    1048                 :           0 :   gimple *asgn = gimple_build_assign (receiver_decl, conv_tmp);
    1049                 :           0 :   gsi_insert_after (&start, asgn, GSI_NEW_STMT);
    1050                 :           0 :   update_stmt (asgn);
    1051                 :             : 
    1052                 :           0 :   tree zero_ptr = build_int_cst (TREE_TYPE (receiver_decl), 0);
    1053                 :             : 
    1054                 :           0 :   tree recv_tmp = make_ssa_name (TREE_TYPE (receiver_decl));
    1055                 :           0 :   asgn = gimple_build_assign (recv_tmp, receiver_decl);
    1056                 :           0 :   gsi_insert_after (&start, asgn, GSI_NEW_STMT);
    1057                 :           0 :   update_stmt (asgn);
    1058                 :             : 
    1059                 :           0 :   gimple *cond = gimple_build_cond (EQ_EXPR, recv_tmp, zero_ptr, NULL_TREE,
    1060                 :             :                                     NULL_TREE);
    1061                 :           0 :   update_stmt (cond);
    1062                 :             : 
    1063                 :           0 :   gsi_insert_after (&start, cond, GSI_NEW_STMT);
    1064                 :             : 
    1065                 :           0 :   edge et = split_block (from, cond);
    1066                 :           0 :   et->flags &= ~EDGE_FALLTHRU;
    1067                 :           0 :   et->flags |= EDGE_TRUE_VALUE;
    1068                 :             :   /* Make the active worker the more probable path so we prefer fallthrough
    1069                 :             :      (letting the idle workers jump around more).  */
    1070                 :           0 :   et->probability = profile_probability::likely ();
    1071                 :             : 
    1072                 :           0 :   basic_block body = et->dest;
    1073                 :             : 
    1074                 :           0 :   edge ef = make_edge (from, barrier_block, EDGE_FALSE_VALUE);
    1075                 :           0 :   ef->probability = et->probability.invert ();
    1076                 :             : 
    1077                 :           0 :   gimple_stmt_iterator bar_gsi = gsi_start_bb (barrier_block);
    1078                 :           0 :   cond = gimple_build_cond (NE_EXPR, recv_tmp, zero_ptr, NULL_TREE, NULL_TREE);
    1079                 :             : 
    1080                 :           0 :   if (record_type != char_type_node || has_gang_private_write)
    1081                 :             :     {
    1082                 :           0 :       decl = builtin_decl_explicit (BUILT_IN_GOACC_BARRIER);
    1083                 :           0 :       gimple *acc_bar = gimple_build_call (decl, 0);
    1084                 :             : 
    1085                 :           0 :       gsi_insert_before (&bar_gsi, acc_bar, GSI_NEW_STMT);
    1086                 :           0 :       gsi_insert_after (&bar_gsi, cond, GSI_NEW_STMT);
    1087                 :           0 :     }
    1088                 :             :   else
    1089                 :           0 :     gsi_insert_before (&bar_gsi, cond, GSI_NEW_STMT);
    1090                 :             : 
    1091                 :           0 :   edge et2 = split_block (barrier_block, cond);
    1092                 :           0 :   et2->flags &= ~EDGE_FALLTHRU;
    1093                 :           0 :   et2->flags |= EDGE_TRUE_VALUE;
    1094                 :           0 :   et2->probability = profile_probability::unlikely ();
    1095                 :             : 
    1096                 :           0 :   basic_block exit_block = et2->dest;
    1097                 :             : 
    1098                 :           0 :   basic_block copyout_block = split_edge (et2);
    1099                 :           0 :   edge ef2 = make_edge (barrier_block, exit_block, EDGE_FALSE_VALUE);
    1100                 :           0 :   ef2->probability = et2->probability.invert ();
    1101                 :             : 
    1102                 :           0 :   gimple_stmt_iterator copyout_gsi = gsi_start_bb (copyout_block);
    1103                 :             : 
    1104                 :           0 :   edge copyout_to_exit = single_succ_edge (copyout_block);
    1105                 :             : 
    1106                 :           0 :   gimple_seq sender_seq = NULL;
    1107                 :             : 
    1108                 :             :   /* Make sure we iterate over definitions in a stable order.  */
    1109                 :           0 :   auto_vec<tree> escape_vec (def_escapes_block->elements ());
    1110                 :           0 :   for (hash_set<tree>::iterator it = def_escapes_block->begin ();
    1111                 :           0 :        it != def_escapes_block->end (); ++it)
    1112                 :           0 :     escape_vec.quick_push (*it);
    1113                 :           0 :   escape_vec.qsort (sort_by_ssa_version_or_uid);
    1114                 :             : 
    1115                 :           0 :   for (unsigned i = 0; i < escape_vec.length (); i++)
    1116                 :             :     {
    1117                 :           0 :       tree var = escape_vec[i];
    1118                 :             : 
    1119                 :           0 :       if (TREE_CODE (var) == SSA_NAME && SSA_NAME_IS_VIRTUAL_OPERAND (var))
    1120                 :           0 :         continue;
    1121                 :             : 
    1122                 :           0 :       tree barrier_def = 0;
    1123                 :             : 
    1124                 :           0 :       if (TREE_CODE (var) == SSA_NAME)
    1125                 :             :         {
    1126                 :           0 :           gimple *def_stmt = SSA_NAME_DEF_STMT (var);
    1127                 :             : 
    1128                 :           0 :           if (gimple_nop_p (def_stmt))
    1129                 :           0 :             continue;
    1130                 :             : 
    1131                 :             :           /* The barrier phi takes one result from the actual work of the
    1132                 :             :              block we're neutering, and the other result is constant zero of
    1133                 :             :              the same type.  */
    1134                 :             : 
    1135                 :           0 :           gphi *barrier_phi = create_phi_node (NULL_TREE, barrier_block);
    1136                 :           0 :           barrier_def = create_new_def_for (var, barrier_phi,
    1137                 :             :                           gimple_phi_result_ptr (barrier_phi));
    1138                 :             : 
    1139                 :           0 :           add_phi_arg (barrier_phi, var, e, UNKNOWN_LOCATION);
    1140                 :           0 :           add_phi_arg (barrier_phi, build_zero_cst (TREE_TYPE (var)), ef,
    1141                 :             :                        UNKNOWN_LOCATION);
    1142                 :             : 
    1143                 :           0 :           update_stmt (barrier_phi);
    1144                 :             :         }
    1145                 :             :       else
    1146                 :           0 :         gcc_assert (VAR_P (var));
    1147                 :             : 
    1148                 :             :       /* If we had no record type, we will have no fields map.  */
    1149                 :           0 :       field_map_t *fields = record_field_map->get (record_type);
    1150                 :             : 
    1151                 :           0 :       if (worker_partitioned_uses->contains (var)
    1152                 :           0 :           && fields
    1153                 :           0 :           && fields->get (var))
    1154                 :             :         {
    1155                 :           0 :           tree neutered_def = make_ssa_name (TREE_TYPE (var));
    1156                 :             : 
    1157                 :             :           /* Receive definition from shared memory block.  */
    1158                 :             : 
    1159                 :           0 :           tree receiver_ref = build_receiver_ref (var, receiver_decl, fields);
    1160                 :           0 :           gassign *recv = gimple_build_assign (neutered_def,
    1161                 :             :                                                receiver_ref);
    1162                 :           0 :           gsi_insert_after (&copyout_gsi, recv, GSI_CONTINUE_LINKING);
    1163                 :           0 :           update_stmt (recv);
    1164                 :             : 
    1165                 :           0 :           if (VAR_P (var))
    1166                 :             :             {
    1167                 :             :               /* If it's a VAR_DECL, we only copied to an SSA temporary.  Copy
    1168                 :             :                  to the final location now.  */
    1169                 :           0 :               gassign *asgn = gimple_build_assign (var, neutered_def);
    1170                 :           0 :               gsi_insert_after (&copyout_gsi, asgn, GSI_CONTINUE_LINKING);
    1171                 :           0 :               update_stmt (asgn);
    1172                 :             :             }
    1173                 :             :           else
    1174                 :             :             {
    1175                 :             :               /* If it's an SSA name, create a new phi at the join node to
    1176                 :             :                  represent either the output from the active worker (the
    1177                 :             :                  barrier) or the inactive workers (the copyout block).  */
    1178                 :           0 :               gphi *join_phi = create_phi_node (NULL_TREE, exit_block);
    1179                 :           0 :               create_new_def_for (barrier_def, join_phi,
    1180                 :             :                                   gimple_phi_result_ptr (join_phi));
    1181                 :           0 :               add_phi_arg (join_phi, barrier_def, ef2, UNKNOWN_LOCATION);
    1182                 :           0 :               add_phi_arg (join_phi, neutered_def, copyout_to_exit,
    1183                 :             :                            UNKNOWN_LOCATION);
    1184                 :           0 :               update_stmt (join_phi);
    1185                 :             :             }
    1186                 :             : 
    1187                 :             :           /* Send definition to shared memory block.  */
    1188                 :             : 
    1189                 :           0 :           tree sender_ref = build_sender_ref (var, sender_decl, fields);
    1190                 :             : 
    1191                 :           0 :           if (TREE_CODE (var) == SSA_NAME)
    1192                 :             :             {
    1193                 :           0 :               gassign *send = gimple_build_assign (sender_ref, var);
    1194                 :           0 :               gimple_seq_add_stmt (&sender_seq, send);
    1195                 :           0 :               update_stmt (send);
    1196                 :             :             }
    1197                 :           0 :           else if (VAR_P (var))
    1198                 :             :             {
    1199                 :           0 :               tree tmp = make_ssa_name (TREE_TYPE (var));
    1200                 :           0 :               gassign *send = gimple_build_assign (tmp, var);
    1201                 :           0 :               gimple_seq_add_stmt (&sender_seq, send);
    1202                 :           0 :               update_stmt (send);
    1203                 :           0 :               send = gimple_build_assign (sender_ref, tmp);
    1204                 :           0 :               gimple_seq_add_stmt (&sender_seq, send);
    1205                 :           0 :               update_stmt (send);
    1206                 :             :             }
    1207                 :             :           else
    1208                 :           0 :             gcc_unreachable ();
    1209                 :             :         }
    1210                 :             :     }
    1211                 :             : 
    1212                 :             :   /* The shared-memory range for this block overflowed.  Add a barrier at the
    1213                 :             :      end.  */
    1214                 :           0 :   if (isolate_broadcasts)
    1215                 :             :     {
    1216                 :           0 :       gsi = gsi_start_bb (exit_block);
    1217                 :           0 :       decl = builtin_decl_explicit (BUILT_IN_GOACC_BARRIER);
    1218                 :           0 :       gimple *acc_bar = gimple_build_call (decl, 0);
    1219                 :           0 :       gsi_insert_before (&gsi, acc_bar, GSI_SAME_STMT);
    1220                 :             :     }
    1221                 :             : 
    1222                 :             :   /* It's possible for the ET->DEST block (the work done by the active thread)
    1223                 :             :      to finish with a control-flow insn, e.g. a UNIQUE function call.  Split
    1224                 :             :      the block and add SENDER_SEQ in the latter part to avoid having control
    1225                 :             :      flow in the middle of a BB.  */
    1226                 :             : 
    1227                 :           0 :   decl = builtin_decl_explicit (BUILT_IN_GOACC_SINGLE_COPY_END);
    1228                 :           0 :   call = gimple_build_call (decl, 1,
    1229                 :           0 :                             POINTER_TYPE_P (TREE_TYPE (sender_decl))
    1230                 :             :                             ? sender_decl
    1231                 :           0 :                             : build_fold_addr_expr (sender_decl));
    1232                 :           0 :   gimple_seq_add_stmt (&sender_seq, call);
    1233                 :             : 
    1234                 :           0 :   gsi = gsi_last_bb (body);
    1235                 :           0 :   gimple *last = gsi_stmt (gsi);
    1236                 :           0 :   basic_block sender_block = split_block (body, last)->dest;
    1237                 :           0 :   gsi = gsi_last_bb (sender_block);
    1238                 :           0 :   gsi_insert_seq_after (&gsi, sender_seq, GSI_CONTINUE_LINKING);
    1239                 :           0 : }
    1240                 :             : 
    1241                 :             : typedef hash_map<basic_block, std::pair<unsigned HOST_WIDE_INT, bool> >
    1242                 :             :   blk_offset_map_t;
    1243                 :             : 
    1244                 :             : static void
    1245                 :           0 : neuter_worker_single (parallel_g *par, unsigned outer_mask,
    1246                 :             :                       bitmap worker_single, bitmap vector_single,
    1247                 :             :                       vec<propagation_set *> *prop_set,
    1248                 :             :                       hash_set<tree> *partitioned_var_uses,
    1249                 :             :                       record_field_map_t *record_field_map,
    1250                 :             :                       blk_offset_map_t *blk_offset_map,
    1251                 :             :                       bitmap writes_gang_private)
    1252                 :             : {
    1253                 :           0 :   unsigned mask = outer_mask | par->mask;
    1254                 :             : 
    1255                 :           0 :   if ((mask & GOMP_DIM_MASK (GOMP_DIM_WORKER)) == 0)
    1256                 :             :     {
    1257                 :             :       basic_block block;
    1258                 :             : 
    1259                 :           0 :       for (unsigned i = 0; par->blocks.iterate (i, &block); i++)
    1260                 :             :         {
    1261                 :           0 :           bool has_defs = false;
    1262                 :           0 :           hash_set<tree> def_escapes_block;
    1263                 :           0 :           hash_set<tree> worker_partitioned_uses;
    1264                 :           0 :           unsigned j;
    1265                 :           0 :           tree var;
    1266                 :             : 
    1267                 :           0 :           FOR_EACH_SSA_NAME (j, var, cfun)
    1268                 :             :             {
    1269                 :           0 :               if (SSA_NAME_IS_VIRTUAL_OPERAND (var))
    1270                 :             :                 {
    1271                 :           0 :                   has_defs = true;
    1272                 :           0 :                   continue;
    1273                 :             :                 }
    1274                 :             : 
    1275                 :           0 :               gimple *def_stmt = SSA_NAME_DEF_STMT (var);
    1276                 :             : 
    1277                 :           0 :               if (gimple_nop_p (def_stmt))
    1278                 :           0 :                 continue;
    1279                 :             : 
    1280                 :           0 :               if (gimple_bb (def_stmt)->index != block->index)
    1281                 :           0 :                 continue;
    1282                 :             : 
    1283                 :           0 :               gimple *use_stmt;
    1284                 :           0 :               imm_use_iterator use_iter;
    1285                 :           0 :               bool uses_outside_block = false;
    1286                 :           0 :               bool worker_partitioned_use = false;
    1287                 :             : 
    1288                 :           0 :               FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, var)
    1289                 :             :                 {
    1290                 :           0 :                   int blocknum = gimple_bb (use_stmt)->index;
    1291                 :             : 
    1292                 :             :                   /* Don't propagate SSA names that are only used in the
    1293                 :             :                      current block, unless the usage is in a phi node: that
    1294                 :             :                      means the name left the block, then came back in at the
    1295                 :             :                      top.  */
    1296                 :           0 :                   if (blocknum != block->index
    1297                 :           0 :                       || gimple_code (use_stmt) == GIMPLE_PHI)
    1298                 :             :                     uses_outside_block = true;
    1299                 :           0 :                   if (!bitmap_bit_p (worker_single, blocknum))
    1300                 :           0 :                     worker_partitioned_use = true;
    1301                 :           0 :                 }
    1302                 :             : 
    1303                 :           0 :               if (uses_outside_block)
    1304                 :           0 :                 def_escapes_block.add (var);
    1305                 :             : 
    1306                 :           0 :               if (worker_partitioned_use)
    1307                 :             :                 {
    1308                 :           0 :                   worker_partitioned_uses.add (var);
    1309                 :           0 :                   has_defs = true;
    1310                 :             :                 }
    1311                 :             :             }
    1312                 :             : 
    1313                 :           0 :           propagation_set *ws_prop = (*prop_set)[block->index];
    1314                 :             : 
    1315                 :           0 :           if (ws_prop)
    1316                 :             :             {
    1317                 :           0 :               for (propagation_set::iterator it = ws_prop->begin ();
    1318                 :           0 :                    it != ws_prop->end ();
    1319                 :           0 :                    ++it)
    1320                 :             :                 {
    1321                 :           0 :                   tree var = *it;
    1322                 :           0 :                   if (TREE_CODE (var) == VAR_DECL)
    1323                 :             :                     {
    1324                 :           0 :                       def_escapes_block.add (var);
    1325                 :           0 :                       if (partitioned_var_uses->contains (var))
    1326                 :             :                         {
    1327                 :           0 :                           worker_partitioned_uses.add (var);
    1328                 :           0 :                           has_defs = true;
    1329                 :             :                         }
    1330                 :             :                     }
    1331                 :             :                 }
    1332                 :             : 
    1333                 :           0 :               delete ws_prop;
    1334                 :           0 :               (*prop_set)[block->index] = 0;
    1335                 :             :             }
    1336                 :             : 
    1337                 :           0 :           bool only_marker_fns = true;
    1338                 :           0 :           bool join_block = false;
    1339                 :             : 
    1340                 :           0 :           for (gimple_stmt_iterator gsi = gsi_start_bb (block);
    1341                 :           0 :                !gsi_end_p (gsi);
    1342                 :           0 :                gsi_next (&gsi))
    1343                 :             :             {
    1344                 :           0 :               gimple *stmt = gsi_stmt (gsi);
    1345                 :           0 :               if (gimple_code (stmt) == GIMPLE_CALL
    1346                 :           0 :                   && gimple_call_internal_p (stmt, IFN_UNIQUE))
    1347                 :             :                 {
    1348                 :           0 :                   enum ifn_unique_kind k = ((enum ifn_unique_kind)
    1349                 :           0 :                     TREE_INT_CST_LOW (gimple_call_arg (stmt, 0)));
    1350                 :           0 :                   if (k != IFN_UNIQUE_OACC_PRIVATE
    1351                 :           0 :                       && k != IFN_UNIQUE_OACC_JOIN
    1352                 :           0 :                       && k != IFN_UNIQUE_OACC_FORK
    1353                 :           0 :                       && k != IFN_UNIQUE_OACC_HEAD_MARK
    1354                 :           0 :                       && k != IFN_UNIQUE_OACC_TAIL_MARK)
    1355                 :             :                     only_marker_fns = false;
    1356                 :           0 :                   else if (k == IFN_UNIQUE_OACC_JOIN)
    1357                 :             :                     /* The JOIN marker is special in that it *cannot* be
    1358                 :             :                        predicated for worker zero, because it may be lowered
    1359                 :             :                        to a barrier instruction and all workers must typically
    1360                 :             :                        execute that barrier.  We shouldn't be doing any
    1361                 :             :                        broadcasts from the join block anyway.  */
    1362                 :           0 :                     join_block = true;
    1363                 :             :                 }
    1364                 :           0 :               else if (gimple_code (stmt) == GIMPLE_CALL
    1365                 :           0 :                        && gimple_call_internal_p (stmt, IFN_GOACC_LOOP))
    1366                 :             :                 /* Empty.  */;
    1367                 :           0 :               else if (gimple_nop_p (stmt))
    1368                 :             :                 /* Empty.  */;
    1369                 :             :               else
    1370                 :           0 :                 only_marker_fns = false;
    1371                 :             :             }
    1372                 :             : 
    1373                 :             :           /* We can skip predicating this block for worker zero if the only
    1374                 :             :              thing it contains is marker functions that will be removed in the
    1375                 :             :              oaccdevlow pass anyway.
    1376                 :             :              Don't do this if the block has (any) phi nodes, because those
    1377                 :             :              might define SSA names that need broadcasting.
    1378                 :             :              TODO: We might be able to skip transforming blocks that only
    1379                 :             :              contain some other trivial statements too.  */
    1380                 :           0 :           if (only_marker_fns && !phi_nodes (block))
    1381                 :           0 :             continue;
    1382                 :             : 
    1383                 :           0 :           gcc_assert (!join_block);
    1384                 :             : 
    1385                 :           0 :           if (has_defs)
    1386                 :             :             {
    1387                 :           0 :               tree record_type = (tree) block->aux;
    1388                 :           0 :               std::pair<unsigned HOST_WIDE_INT, bool> *off_rngalloc
    1389                 :           0 :                 = blk_offset_map->get (block);
    1390                 :           0 :               gcc_assert (!record_type || off_rngalloc);
    1391                 :           0 :               unsigned HOST_WIDE_INT offset
    1392                 :           0 :                 = off_rngalloc ? off_rngalloc->first : 0;
    1393                 :           0 :               bool range_allocated
    1394                 :           0 :                 = off_rngalloc ? off_rngalloc->second : true;
    1395                 :           0 :               bool has_gang_private_write
    1396                 :           0 :                 = bitmap_bit_p (writes_gang_private, block->index);
    1397                 :           0 :               worker_single_copy (block, block, &def_escapes_block,
    1398                 :             :                                   &worker_partitioned_uses, record_type,
    1399                 :             :                                   record_field_map,
    1400                 :           0 :                                   offset, !range_allocated,
    1401                 :             :                                   has_gang_private_write);
    1402                 :             :             }
    1403                 :             :           else
    1404                 :           0 :             worker_single_simple (block, block, &def_escapes_block);
    1405                 :           0 :         }
    1406                 :             :     }
    1407                 :             : 
    1408                 :           0 :   if ((outer_mask & GOMP_DIM_MASK (GOMP_DIM_WORKER)) == 0)
    1409                 :             :     {
    1410                 :             :       basic_block block;
    1411                 :             : 
    1412                 :           0 :       for (unsigned i = 0; par->blocks.iterate (i, &block); i++)
    1413                 :           0 :         for (gimple_stmt_iterator gsi = gsi_start_bb (block);
    1414                 :           0 :              !gsi_end_p (gsi);
    1415                 :           0 :              gsi_next (&gsi))
    1416                 :             :           {
    1417                 :           0 :             gimple *stmt = gsi_stmt (gsi);
    1418                 :             : 
    1419                 :           0 :             if (gimple_code (stmt) == GIMPLE_CALL
    1420                 :           0 :                 && !gimple_call_internal_p (stmt)
    1421                 :           0 :                 && !omp_sese_active_worker_call (as_a <gcall *> (stmt)))
    1422                 :             :               {
    1423                 :             :                 /* If we have an OpenACC routine call in worker-single mode,
    1424                 :             :                    place barriers before and afterwards to prevent
    1425                 :             :                    clobbering re-used shared memory regions (as are used
    1426                 :             :                    for AMDGCN at present, for example).  */
    1427                 :           0 :                 tree decl = builtin_decl_explicit (BUILT_IN_GOACC_BARRIER);
    1428                 :           0 :                 gsi_insert_before (&gsi, gimple_build_call (decl, 0),
    1429                 :             :                                    GSI_SAME_STMT);
    1430                 :           0 :                 gsi_insert_after (&gsi, gimple_build_call (decl, 0),
    1431                 :             :                                   GSI_NEW_STMT);
    1432                 :             :               }
    1433                 :             :           }
    1434                 :             :     }
    1435                 :             : 
    1436                 :           0 :   if (par->inner)
    1437                 :           0 :     neuter_worker_single (par->inner, mask, worker_single, vector_single,
    1438                 :             :                           prop_set, partitioned_var_uses, record_field_map,
    1439                 :             :                           blk_offset_map, writes_gang_private);
    1440                 :           0 :   if (par->next)
    1441                 :             :     neuter_worker_single (par->next, outer_mask, worker_single, vector_single,
    1442                 :             :                           prop_set, partitioned_var_uses, record_field_map,
    1443                 :             :                           blk_offset_map, writes_gang_private);
    1444                 :           0 : }
    1445                 :             : 
    1446                 :             : static void
    1447                 :           0 : dfs_broadcast_reachable_1 (basic_block bb, sbitmap reachable)
    1448                 :             : {
    1449                 :           0 :   if (bb->flags & BB_VISITED)
    1450                 :             :     return;
    1451                 :             : 
    1452                 :           0 :   bb->flags |= BB_VISITED;
    1453                 :             : 
    1454                 :           0 :   if (bb->succs)
    1455                 :             :     {
    1456                 :           0 :       edge e;
    1457                 :           0 :       edge_iterator ei;
    1458                 :           0 :       FOR_EACH_EDGE (e, ei, bb->succs)
    1459                 :             :         {
    1460                 :           0 :           basic_block dest = e->dest;
    1461                 :           0 :           if (dest->aux)
    1462                 :           0 :             bitmap_set_bit (reachable, dest->index);
    1463                 :             :           else
    1464                 :           0 :             dfs_broadcast_reachable_1 (dest, reachable);
    1465                 :             :         }
    1466                 :             :     }
    1467                 :             : }
    1468                 :             : 
    1469                 :             : typedef std::pair<int, tree> idx_decl_pair_t;
    1470                 :             : 
    1471                 :             : typedef auto_vec<splay_tree> used_range_vec_t;
    1472                 :             : 
    1473                 :             : static int
    1474                 :           0 : sort_size_descending (const void *a, const void *b)
    1475                 :             : {
    1476                 :           0 :   const idx_decl_pair_t *pa = (const idx_decl_pair_t *) a;
    1477                 :           0 :   const idx_decl_pair_t *pb = (const idx_decl_pair_t *) b;
    1478                 :           0 :   unsigned HOST_WIDE_INT asize = tree_to_uhwi (TYPE_SIZE_UNIT (pa->second));
    1479                 :           0 :   unsigned HOST_WIDE_INT bsize = tree_to_uhwi (TYPE_SIZE_UNIT (pb->second));
    1480                 :           0 :   return bsize - asize;
    1481                 :             : }
    1482                 :             : 
    1483                 :             : class addr_range
    1484                 :             : {
    1485                 :             : public:
    1486                 :           0 :   addr_range (unsigned HOST_WIDE_INT addr_lo, unsigned HOST_WIDE_INT addr_hi)
    1487                 :           0 :     : lo (addr_lo), hi (addr_hi)
    1488                 :           0 :     { }
    1489                 :           0 :   addr_range (const addr_range &ar) : lo (ar.lo), hi (ar.hi)
    1490                 :             :     { }
    1491                 :           0 :   addr_range () : lo (0), hi (0)
    1492                 :           0 :     { }
    1493                 :             : 
    1494                 :           0 :   bool invalid () { return lo == 0 && hi == 0; }
    1495                 :             : 
    1496                 :             :   unsigned HOST_WIDE_INT lo;
    1497                 :             :   unsigned HOST_WIDE_INT hi;
    1498                 :             : };
    1499                 :             : 
    1500                 :             : static int
    1501                 :           0 : splay_tree_compare_addr_range (splay_tree_key a, splay_tree_key b)
    1502                 :             : {
    1503                 :           0 :   addr_range *ar = (addr_range *) a;
    1504                 :           0 :   addr_range *br = (addr_range *) b;
    1505                 :           0 :   if (ar->lo == br->lo && ar->hi == br->hi)
    1506                 :             :     return 0;
    1507                 :           0 :   if (ar->hi <= br->lo)
    1508                 :             :     return -1;
    1509                 :           0 :   else if (ar->lo >= br->hi)
    1510                 :           0 :     return 1;
    1511                 :             :   return 0;
    1512                 :             : }
    1513                 :             : 
    1514                 :             : static void
    1515                 :           0 : splay_tree_free_key (splay_tree_key k)
    1516                 :             : {
    1517                 :           0 :   addr_range *ar = (addr_range *) k;
    1518                 :           0 :   delete ar;
    1519                 :           0 : }
    1520                 :             : 
    1521                 :             : static addr_range
    1522                 :           0 : first_fit_range (splay_tree s, unsigned HOST_WIDE_INT size,
    1523                 :             :                  unsigned HOST_WIDE_INT align, addr_range *bounds)
    1524                 :             : {
    1525                 :           0 :   splay_tree_node min = splay_tree_min (s);
    1526                 :           0 :   if (min)
    1527                 :             :     {
    1528                 :             :       splay_tree_node next;
    1529                 :           0 :       while ((next = splay_tree_successor (s, min->key)))
    1530                 :             :         {
    1531                 :           0 :           unsigned HOST_WIDE_INT lo = ((addr_range *) min->key)->hi;
    1532                 :           0 :           unsigned HOST_WIDE_INT hi = ((addr_range *) next->key)->lo;
    1533                 :           0 :           unsigned HOST_WIDE_INT base = (lo + align - 1) & ~(align - 1);
    1534                 :           0 :           if (base + size <= hi)
    1535                 :           0 :             return addr_range (base, base + size);
    1536                 :             :           min = next;
    1537                 :             :         }
    1538                 :             : 
    1539                 :           0 :       unsigned HOST_WIDE_INT base = ((addr_range *)min->key)->hi;
    1540                 :           0 :       base = (base + align - 1) & ~(align - 1);
    1541                 :           0 :       if (base + size <= bounds->hi)
    1542                 :           0 :         return addr_range (base, base + size);
    1543                 :             :       else
    1544                 :           0 :         return addr_range ();
    1545                 :             :     }
    1546                 :             :   else
    1547                 :             :     {
    1548                 :           0 :       unsigned HOST_WIDE_INT lo = bounds->lo;
    1549                 :           0 :       lo = (lo + align - 1) & ~(align - 1);
    1550                 :           0 :       if (lo + size <= bounds->hi)
    1551                 :           0 :         return addr_range (lo, lo + size);
    1552                 :             :       else
    1553                 :           0 :         return addr_range ();
    1554                 :             :     }
    1555                 :             : }
    1556                 :             : 
    1557                 :             : static int
    1558                 :           0 : merge_ranges_1 (splay_tree_node n, void *ptr)
    1559                 :             : {
    1560                 :           0 :   splay_tree accum = (splay_tree) ptr;
    1561                 :           0 :   addr_range ar = *(addr_range *) n->key;
    1562                 :             : 
    1563                 :           0 :   splay_tree_node old = splay_tree_lookup (accum, n->key);
    1564                 :             : 
    1565                 :             :   /* We might have an overlap.  Create a new range covering the
    1566                 :             :      overlapping parts.  */
    1567                 :           0 :   if (old)
    1568                 :             :     {
    1569                 :           0 :       addr_range *old_ar = (addr_range *) old->key;
    1570                 :           0 :       ar.lo = MIN (old_ar->lo, ar.lo);
    1571                 :           0 :       ar.hi = MAX (old_ar->hi, ar.hi);
    1572                 :           0 :       splay_tree_remove (accum, old->key);
    1573                 :             :     }
    1574                 :             : 
    1575                 :           0 :   addr_range *new_ar = new addr_range (ar);
    1576                 :             : 
    1577                 :           0 :   splay_tree_insert (accum, (splay_tree_key) new_ar, n->value);
    1578                 :             : 
    1579                 :           0 :   return 0;
    1580                 :             : }
    1581                 :             : 
    1582                 :             : static void
    1583                 :           0 : merge_ranges (splay_tree accum, splay_tree sp)
    1584                 :             : {
    1585                 :           0 :   splay_tree_foreach (sp, merge_ranges_1, (void *) accum);
    1586                 :           0 : }
    1587                 :             : 
    1588                 :             : static void
    1589                 :           0 : oacc_do_neutering (unsigned HOST_WIDE_INT bounds_lo,
    1590                 :             :                    unsigned HOST_WIDE_INT bounds_hi)
    1591                 :             : {
    1592                 :           0 :   bb_stmt_map_t bb_stmt_map;
    1593                 :           0 :   auto_bitmap worker_single, vector_single;
    1594                 :             : 
    1595                 :           0 :   omp_sese_split_blocks (&bb_stmt_map);
    1596                 :             : 
    1597                 :           0 :   if (dump_file)
    1598                 :             :     {
    1599                 :           0 :       fprintf (dump_file, "\n\nAfter splitting:\n\n");
    1600                 :           0 :       dump_function_to_file (current_function_decl, dump_file, dump_flags);
    1601                 :             :     }
    1602                 :             : 
    1603                 :           0 :   unsigned mask = 0;
    1604                 :             : 
    1605                 :             :   /* If this is a routine, calculate MASK as if the outer levels are already
    1606                 :             :      partitioned.  */
    1607                 :           0 :   {
    1608                 :           0 :     tree attr = oacc_get_fn_attrib (current_function_decl);
    1609                 :           0 :     tree dims = TREE_VALUE (attr);
    1610                 :           0 :     unsigned ix;
    1611                 :           0 :     for (ix = 0; ix != GOMP_DIM_MAX; ix++, dims = TREE_CHAIN (dims))
    1612                 :             :       {
    1613                 :           0 :         tree allowed = TREE_PURPOSE (dims);
    1614                 :           0 :         if (allowed && integer_zerop (allowed))
    1615                 :           0 :           mask |= GOMP_DIM_MASK (ix);
    1616                 :             :       }
    1617                 :             :   }
    1618                 :             : 
    1619                 :           0 :   parallel_g *par = omp_sese_discover_pars (&bb_stmt_map);
    1620                 :           0 :   populate_single_mode_bitmaps (par, worker_single, vector_single, mask, 0);
    1621                 :             : 
    1622                 :           0 :   basic_block bb;
    1623                 :           0 :   FOR_ALL_BB_FN (bb, cfun)
    1624                 :           0 :     bb->aux = NULL;
    1625                 :             : 
    1626                 :           0 :   vec<propagation_set *> prop_set (vNULL);
    1627                 :           0 :   prop_set.safe_grow_cleared (last_basic_block_for_fn (cfun), true);
    1628                 :             : 
    1629                 :           0 :   find_ssa_names_to_propagate (par, mask, worker_single, vector_single,
    1630                 :             :                                &prop_set);
    1631                 :             : 
    1632                 :           0 :   hash_set<tree> partitioned_var_uses;
    1633                 :           0 :   hash_set<tree> gang_private_vars;
    1634                 :           0 :   auto_bitmap writes_gang_private;
    1635                 :             : 
    1636                 :           0 :   find_gang_private_vars (&gang_private_vars);
    1637                 :           0 :   find_partitioned_var_uses (par, mask, &partitioned_var_uses);
    1638                 :           0 :   find_local_vars_to_propagate (par, mask, &partitioned_var_uses,
    1639                 :             :                                 &gang_private_vars, writes_gang_private,
    1640                 :             :                                 &prop_set);
    1641                 :             : 
    1642                 :           0 :   record_field_map_t record_field_map;
    1643                 :             : 
    1644                 :           0 :   FOR_ALL_BB_FN (bb, cfun)
    1645                 :             :     {
    1646                 :           0 :       propagation_set *ws_prop = prop_set[bb->index];
    1647                 :           0 :       if (ws_prop)
    1648                 :             :         {
    1649                 :           0 :           tree record_type = lang_hooks.types.make_type (RECORD_TYPE);
    1650                 :           0 :           tree name = create_tmp_var_name (".oacc_ws_data_s");
    1651                 :           0 :           name = build_decl (UNKNOWN_LOCATION, TYPE_DECL, name, record_type);
    1652                 :           0 :           DECL_ARTIFICIAL (name) = 1;
    1653                 :           0 :           DECL_NAMELESS (name) = 1;
    1654                 :           0 :           TYPE_NAME (record_type) = name;
    1655                 :           0 :           TYPE_ARTIFICIAL (record_type) = 1;
    1656                 :             : 
    1657                 :           0 :           auto_vec<tree> field_vec (ws_prop->elements ());
    1658                 :           0 :           for (hash_set<tree>::iterator it = ws_prop->begin ();
    1659                 :           0 :                it != ws_prop->end (); ++it)
    1660                 :           0 :             field_vec.quick_push (*it);
    1661                 :             : 
    1662                 :           0 :           field_vec.qsort (sort_by_size_then_ssa_version_or_uid);
    1663                 :             : 
    1664                 :           0 :           bool existed;
    1665                 :           0 :           field_map_t *fields
    1666                 :           0 :             = &record_field_map.get_or_insert (record_type, &existed);
    1667                 :           0 :           gcc_checking_assert (!existed);
    1668                 :             : 
    1669                 :             :           /* Insert var fields in reverse order, so the last inserted element
    1670                 :             :              is the first in the structure.  */
    1671                 :           0 :           for (int i = field_vec.length () - 1; i >= 0; i--)
    1672                 :           0 :             install_var_field (field_vec[i], record_type, fields);
    1673                 :             : 
    1674                 :           0 :           layout_type (record_type);
    1675                 :             : 
    1676                 :           0 :           bb->aux = (tree) record_type;
    1677                 :           0 :         }
    1678                 :             :     }
    1679                 :             : 
    1680                 :           0 :   sbitmap *reachable
    1681                 :           0 :     = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
    1682                 :           0 :                             last_basic_block_for_fn (cfun));
    1683                 :             : 
    1684                 :           0 :   bitmap_vector_clear (reachable, last_basic_block_for_fn (cfun));
    1685                 :             : 
    1686                 :           0 :   auto_vec<std::pair<int, tree> > priority;
    1687                 :             : 
    1688                 :           0 :   FOR_ALL_BB_FN (bb, cfun)
    1689                 :             :     {
    1690                 :           0 :       if (bb->aux)
    1691                 :             :         {
    1692                 :           0 :           tree record_type = (tree) bb->aux;
    1693                 :             : 
    1694                 :           0 :           basic_block bb2;
    1695                 :           0 :           FOR_ALL_BB_FN (bb2, cfun)
    1696                 :           0 :             bb2->flags &= ~BB_VISITED;
    1697                 :             : 
    1698                 :           0 :           priority.safe_push (std::make_pair (bb->index, record_type));
    1699                 :           0 :           dfs_broadcast_reachable_1 (bb, reachable[bb->index]);
    1700                 :             :         }
    1701                 :             :     }
    1702                 :             : 
    1703                 :           0 :   sbitmap *inverted
    1704                 :           0 :     = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
    1705                 :           0 :                             last_basic_block_for_fn (cfun));
    1706                 :             : 
    1707                 :           0 :   bitmap_vector_clear (inverted, last_basic_block_for_fn (cfun));
    1708                 :             : 
    1709                 :           0 :   for (int i = 0; i < last_basic_block_for_fn (cfun); i++)
    1710                 :             :     {
    1711                 :           0 :       sbitmap_iterator bi;
    1712                 :           0 :       unsigned int j;
    1713                 :           0 :       EXECUTE_IF_SET_IN_BITMAP (reachable[i], 0, j, bi)
    1714                 :           0 :         bitmap_set_bit (inverted[j], i);
    1715                 :             :     }
    1716                 :             : 
    1717                 :           0 :   for (int i = 0; i < last_basic_block_for_fn (cfun); i++)
    1718                 :           0 :     bitmap_ior (reachable[i], reachable[i], inverted[i]);
    1719                 :             : 
    1720                 :           0 :   sbitmap_vector_free (inverted);
    1721                 :             : 
    1722                 :           0 :   used_range_vec_t used_ranges;
    1723                 :             : 
    1724                 :           0 :   used_ranges.safe_grow_cleared (last_basic_block_for_fn (cfun));
    1725                 :             : 
    1726                 :           0 :   blk_offset_map_t blk_offset_map;
    1727                 :             : 
    1728                 :           0 :   addr_range worker_shm_bounds (bounds_lo, bounds_hi);
    1729                 :             : 
    1730                 :           0 :   priority.qsort (sort_size_descending);
    1731                 :           0 :   for (unsigned int i = 0; i < priority.length (); i++)
    1732                 :             :     {
    1733                 :           0 :       idx_decl_pair_t p = priority[i];
    1734                 :           0 :       int blkno = p.first;
    1735                 :           0 :       tree record_type = p.second;
    1736                 :           0 :       HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE_UNIT (record_type));
    1737                 :           0 :       HOST_WIDE_INT align = TYPE_ALIGN_UNIT (record_type);
    1738                 :             : 
    1739                 :           0 :       splay_tree conflicts = splay_tree_new (splay_tree_compare_addr_range,
    1740                 :             :                                              splay_tree_free_key, NULL);
    1741                 :             : 
    1742                 :           0 :       if (!used_ranges[blkno])
    1743                 :           0 :         used_ranges[blkno] = splay_tree_new (splay_tree_compare_addr_range,
    1744                 :             :                                              splay_tree_free_key, NULL);
    1745                 :             :       else
    1746                 :           0 :         merge_ranges (conflicts, used_ranges[blkno]);
    1747                 :             : 
    1748                 :           0 :       sbitmap_iterator bi;
    1749                 :           0 :       unsigned int j;
    1750                 :           0 :       EXECUTE_IF_SET_IN_BITMAP (reachable[blkno], 0, j, bi)
    1751                 :           0 :         if (used_ranges[j])
    1752                 :           0 :           merge_ranges (conflicts, used_ranges[j]);
    1753                 :             : 
    1754                 :           0 :       addr_range ar
    1755                 :           0 :         = first_fit_range (conflicts, size, align, &worker_shm_bounds);
    1756                 :             : 
    1757                 :           0 :       splay_tree_delete (conflicts);
    1758                 :             : 
    1759                 :           0 :       if (ar.invalid ())
    1760                 :             :         {
    1761                 :           0 :           unsigned HOST_WIDE_INT base
    1762                 :           0 :             = (bounds_lo + align - 1) & ~(align - 1);
    1763                 :           0 :           if (base + size > bounds_hi)
    1764                 :           0 :             error_at (UNKNOWN_LOCATION, "shared-memory region overflow");
    1765                 :           0 :           std::pair<unsigned HOST_WIDE_INT, bool> base_inrng
    1766                 :           0 :             = std::make_pair (base, false);
    1767                 :           0 :           blk_offset_map.put (BASIC_BLOCK_FOR_FN (cfun, blkno), base_inrng);
    1768                 :             :         }
    1769                 :             :       else
    1770                 :             :         {
    1771                 :           0 :           splay_tree_node old = splay_tree_lookup (used_ranges[blkno],
    1772                 :             :                                                    (splay_tree_key) &ar);
    1773                 :           0 :           if (old)
    1774                 :             :             {
    1775                 :           0 :               fprintf (stderr, "trying to map [%d..%d] but [%d..%d] is "
    1776                 :           0 :                        "already mapped in block %d\n", (int) ar.lo,
    1777                 :           0 :                        (int) ar.hi, (int) ((addr_range *) old->key)->lo,
    1778                 :           0 :                        (int) ((addr_range *) old->key)->hi, blkno);
    1779                 :           0 :               abort ();
    1780                 :             :             }
    1781                 :             : 
    1782                 :           0 :           addr_range *arp = new addr_range (ar);
    1783                 :           0 :           splay_tree_insert (used_ranges[blkno], (splay_tree_key) arp,
    1784                 :             :                              (splay_tree_value) blkno);
    1785                 :           0 :           std::pair<unsigned HOST_WIDE_INT, bool> base_inrng
    1786                 :           0 :             = std::make_pair (ar.lo, true);
    1787                 :           0 :           blk_offset_map.put (BASIC_BLOCK_FOR_FN (cfun, blkno), base_inrng);
    1788                 :             :         }
    1789                 :             :     }
    1790                 :             : 
    1791                 :           0 :   sbitmap_vector_free (reachable);
    1792                 :             : 
    1793                 :           0 :   neuter_worker_single (par, mask, worker_single, vector_single, &prop_set,
    1794                 :             :                         &partitioned_var_uses, &record_field_map,
    1795                 :             :                         &blk_offset_map, writes_gang_private);
    1796                 :             : 
    1797                 :           0 :   record_field_map.empty ();
    1798                 :             : 
    1799                 :             :   /* These are supposed to have been 'delete'd by 'neuter_worker_single'.  */
    1800                 :           0 :   for (auto it : prop_set)
    1801                 :           0 :     gcc_checking_assert (!it);
    1802                 :           0 :   prop_set.release ();
    1803                 :             : 
    1804                 :           0 :   delete par;
    1805                 :             : 
    1806                 :             :   /* This doesn't seem to make a difference.  */
    1807                 :           0 :   loops_state_clear (LOOP_CLOSED_SSA);
    1808                 :             : 
    1809                 :             :   /* Neutering worker-single neutered blocks will invalidate dominance info.
    1810                 :             :      It may be possible to incrementally update just the affected blocks, but
    1811                 :             :      obliterate everything for now.  */
    1812                 :           0 :   free_dominance_info (CDI_DOMINATORS);
    1813                 :           0 :   free_dominance_info (CDI_POST_DOMINATORS);
    1814                 :             : 
    1815                 :           0 :   if (dump_file)
    1816                 :             :     {
    1817                 :           0 :       fprintf (dump_file, "\n\nAfter neutering:\n\n");
    1818                 :           0 :       dump_function_to_file (current_function_decl, dump_file, dump_flags);
    1819                 :             :     }
    1820                 :           0 : }
    1821                 :             : 
    1822                 :             : static int
    1823                 :           0 : execute_omp_oacc_neuter_broadcast ()
    1824                 :             : {
    1825                 :           0 :   unsigned HOST_WIDE_INT reduction_size[GOMP_DIM_MAX];
    1826                 :           0 :   unsigned HOST_WIDE_INT private_size[GOMP_DIM_MAX];
    1827                 :             : 
    1828                 :           0 :   for (unsigned i = 0; i < GOMP_DIM_MAX; i++)
    1829                 :             :     {
    1830                 :           0 :       reduction_size[i] = 0;
    1831                 :           0 :       private_size[i] = 0;
    1832                 :             :     }
    1833                 :             : 
    1834                 :             :   /* Calculate shared memory size required for reduction variables and
    1835                 :             :      gang-private memory for this offloaded function.  */
    1836                 :           0 :   basic_block bb;
    1837                 :           0 :   FOR_ALL_BB_FN (bb, cfun)
    1838                 :             :     {
    1839                 :           0 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
    1840                 :           0 :            !gsi_end_p (gsi);
    1841                 :           0 :            gsi_next (&gsi))
    1842                 :             :         {
    1843                 :           0 :           gimple *stmt = gsi_stmt (gsi);
    1844                 :           0 :           if (!is_gimple_call (stmt))
    1845                 :           0 :             continue;
    1846                 :           0 :           gcall *call = as_a <gcall *> (stmt);
    1847                 :           0 :           if (!gimple_call_internal_p (call))
    1848                 :           0 :             continue;
    1849                 :           0 :           enum internal_fn ifn_code = gimple_call_internal_fn (call);
    1850                 :           0 :           switch (ifn_code)
    1851                 :             :             {
    1852                 :             :             default: break;
    1853                 :           0 :             case IFN_GOACC_REDUCTION:
    1854                 :           0 :               if (integer_minus_onep (gimple_call_arg (call, 3)))
    1855                 :           0 :                 continue;
    1856                 :             :               else
    1857                 :             :                 {
    1858                 :           0 :                   unsigned code = TREE_INT_CST_LOW (gimple_call_arg (call, 0));
    1859                 :             :                   /* Only count reduction variables once: the choice to pick
    1860                 :             :                      the setup call is fairly arbitrary.  */
    1861                 :           0 :                   if (code == IFN_GOACC_REDUCTION_SETUP)
    1862                 :             :                     {
    1863                 :           0 :                       int level = TREE_INT_CST_LOW (gimple_call_arg (call, 3));
    1864                 :           0 :                       tree var = gimple_call_arg (call, 2);
    1865                 :           0 :                       tree offset = gimple_call_arg (call, 5);
    1866                 :           0 :                       tree var_type = TREE_TYPE (var);
    1867                 :           0 :                       unsigned HOST_WIDE_INT limit
    1868                 :           0 :                         = (tree_to_uhwi (offset)
    1869                 :           0 :                            + tree_to_uhwi (TYPE_SIZE_UNIT (var_type)));
    1870                 :           0 :                       reduction_size[level]
    1871                 :           0 :                         = MAX (reduction_size[level], limit);
    1872                 :             :                     }
    1873                 :             :                 }
    1874                 :             :               break;
    1875                 :           0 :             case IFN_UNIQUE:
    1876                 :           0 :               {
    1877                 :           0 :                 enum ifn_unique_kind kind
    1878                 :             :                   = ((enum ifn_unique_kind)
    1879                 :           0 :                      TREE_INT_CST_LOW (gimple_call_arg (call, 0)));
    1880                 :             : 
    1881                 :           0 :                 if (kind == IFN_UNIQUE_OACC_PRIVATE)
    1882                 :             :                   {
    1883                 :           0 :                     HOST_WIDE_INT level
    1884                 :           0 :                       = TREE_INT_CST_LOW (gimple_call_arg (call, 2));
    1885                 :           0 :                     if (level == -1)
    1886                 :             :                       break;
    1887                 :           0 :                     for (unsigned i = 3;
    1888                 :           0 :                          i < gimple_call_num_args (call);
    1889                 :             :                          i++)
    1890                 :             :                       {
    1891                 :           0 :                         tree arg = gimple_call_arg (call, i);
    1892                 :           0 :                         gcc_assert (TREE_CODE (arg) == ADDR_EXPR);
    1893                 :           0 :                         tree decl = TREE_OPERAND (arg, 0);
    1894                 :           0 :                         unsigned HOST_WIDE_INT align = DECL_ALIGN_UNIT (decl);
    1895                 :           0 :                         private_size[level] = ((private_size[level] + align - 1)
    1896                 :           0 :                                                & ~(align - 1));
    1897                 :           0 :                         unsigned HOST_WIDE_INT decl_size
    1898                 :           0 :                           = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (decl)));
    1899                 :           0 :                         private_size[level] += decl_size;
    1900                 :             :                       }
    1901                 :             :                   }
    1902                 :             :               }
    1903                 :             :               break;
    1904                 :             :             }
    1905                 :             :         }
    1906                 :             :     }
    1907                 :             : 
    1908                 :             :   int dims[GOMP_DIM_MAX];
    1909                 :           0 :   for (unsigned i = 0; i < GOMP_DIM_MAX; i++)
    1910                 :           0 :     dims[i] = oacc_get_fn_dim_size (current_function_decl, i);
    1911                 :             : 
    1912                 :             :   /* Find bounds of shared-memory buffer space we can use.  */
    1913                 :           0 :   unsigned HOST_WIDE_INT bounds_lo = 0, bounds_hi = 0;
    1914                 :           0 :   if (targetm.goacc.shared_mem_layout)
    1915                 :           0 :     targetm.goacc.shared_mem_layout (&bounds_lo, &bounds_hi, dims,
    1916                 :             :                                      private_size, reduction_size);
    1917                 :             : 
    1918                 :             :   /* Perform worker partitioning unless we know 'num_workers(1)'.  */
    1919                 :           0 :   if (dims[GOMP_DIM_WORKER] != 1)
    1920                 :           0 :     oacc_do_neutering (bounds_lo, bounds_hi);
    1921                 :             : 
    1922                 :           0 :   return 0;
    1923                 :             : }
    1924                 :             : 
    1925                 :             : namespace {
    1926                 :             : 
    1927                 :             : const pass_data pass_data_omp_oacc_neuter_broadcast =
    1928                 :             : {
    1929                 :             :   GIMPLE_PASS, /* type */
    1930                 :             :   "omp_oacc_neuter_broadcast", /* name */
    1931                 :             :   OPTGROUP_OMP, /* optinfo_flags */
    1932                 :             :   TV_NONE, /* tv_id */
    1933                 :             :   PROP_cfg, /* properties_required */
    1934                 :             :   0, /* properties_provided */
    1935                 :             :   0, /* properties_destroyed */
    1936                 :             :   0, /* todo_flags_start */
    1937                 :             :   TODO_update_ssa | TODO_cleanup_cfg, /* todo_flags_finish */
    1938                 :             : };
    1939                 :             : 
    1940                 :             : class pass_omp_oacc_neuter_broadcast : public gimple_opt_pass
    1941                 :             : {
    1942                 :             : public:
    1943                 :      285617 :   pass_omp_oacc_neuter_broadcast (gcc::context *ctxt)
    1944                 :      571234 :     : gimple_opt_pass (pass_data_omp_oacc_neuter_broadcast, ctxt)
    1945                 :             :   {}
    1946                 :             : 
    1947                 :             :   /* opt_pass methods: */
    1948                 :     1420452 :   bool gate (function *fun) final override
    1949                 :             :   {
    1950                 :     1420452 :     if (!flag_openacc)
    1951                 :             :       return false;
    1952                 :             : 
    1953                 :       14824 :     if (!targetm.goacc.create_worker_broadcast_record)
    1954                 :             :       return false;
    1955                 :             : 
    1956                 :             :     /* Only relevant for OpenACC offloaded functions.  */
    1957                 :           0 :     tree attr = oacc_get_fn_attrib (fun->decl);
    1958                 :           0 :     if (!attr)
    1959                 :             :       return false;
    1960                 :             : 
    1961                 :             :     return true;
    1962                 :             :   }
    1963                 :             : 
    1964                 :           0 :   unsigned int execute (function *) final override
    1965                 :             :     {
    1966                 :           0 :       return execute_omp_oacc_neuter_broadcast ();
    1967                 :             :     }
    1968                 :             : 
    1969                 :             : }; // class pass_omp_oacc_neuter_broadcast
    1970                 :             : 
    1971                 :             : } // anon namespace
    1972                 :             : 
    1973                 :             : gimple_opt_pass *
    1974                 :      285617 : make_pass_omp_oacc_neuter_broadcast (gcc::context *ctxt)
    1975                 :             : {
    1976                 :      285617 :   return new pass_omp_oacc_neuter_broadcast (ctxt);
    1977                 :             : }
        

Generated by: LCOV version 2.0-1

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.