gcc/ipa-hsa.c

   1 /* Callgraph based analysis of static variables.
   2    Copyright (C) 2015-2020 Free Software Foundation, Inc.
   3    Contributed by Martin Liska <mliska@suse.cz>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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 /* Interprocedural HSA pass is responsible for creation of HSA clones.
  22    For all these HSA clones, we emit HSAIL instructions and pass processing
  23    is terminated.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "is-a.h"
  30 #include "hash-set.h"
  31 #include "vec.h"
  32 #include "tree.h"
  33 #include "tree-pass.h"
  34 #include "function.h"
  35 #include "basic-block.h"
  36 #include "gimple.h"
  37 #include "dumpfile.h"
  38 #include "gimple-pretty-print.h"
  39 #include "tree-streamer.h"
  40 #include "stringpool.h"
  41 #include "cgraph.h"
  42 #include "print-tree.h"
  43 #include "alloc-pool.h"
  44 #include "symbol-summary.h"
  45 #include "hsa-common.h"
  46
  47 namespace {
  48
  49 /* If NODE is not versionable, warn about not emiting HSAIL and return false.
  50    Otherwise return true.  */
  51
  52 static bool
  53 check_warn_node_versionable (cgraph_node *node)
  54 {
  55   if (!node->versionable)
  56     {
  57       warning_at (EXPR_LOCATION (node->decl), OPT_Whsa,
  58                   "could not emit HSAIL for function %s: function cannot be "
  59                   "cloned", node->dump_name ());
  60       return false;
  61     }
  62   return true;
  63 }
  64
  65 /* The function creates HSA clones for all functions that were either
  66    marked as HSA kernels or are callable HSA functions.  Apart from that,
  67    we redirect all edges that come from an HSA clone and end in another
  68    HSA clone to connect these two functions.  */
  69
  70 static unsigned int
  71 process_hsa_functions (void)
  72 {
  73   struct cgraph_node *node;
  74
  75   if (hsa_summaries == NULL)
  76     hsa_summaries = new hsa_summary_t (symtab);
  77
  78   FOR_EACH_DEFINED_FUNCTION (node)
  79     {
  80       hsa_function_summary *s = hsa_summaries->get (node);
  81
  82       /* A linked function is skipped.  */
  83       if (s != NULL && s->m_bound_function != NULL)
  84         continue;
  85
  86       if (s != NULL)
  87         {
  88           if (!check_warn_node_versionable (node))
  89             continue;
  90           cgraph_node *clone
  91             = node->create_virtual_clone (vec <cgraph_edge *> (),
  92                                           NULL, NULL, "hsa", 0);
  93           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
  94           clone->externally_visible = node->externally_visible;
  95
  96           clone->force_output = true;
  97           hsa_summaries->link_functions (clone, node, s->m_kind, false);
  98
  99           if (dump_file)
 100             fprintf (dump_file, "Created a new HSA clone: %s, type: %s\n",
 101                      clone->dump_name (),
 102                      s->m_kind == HSA_KERNEL ? "kernel" : "function");
 103         }
 104       else if (hsa_callable_function_p (node->decl)
 105                /* At this point, this is enough to identify clones for
 106                   parallel, which for HSA would need to be kernels anyway.  */
 107                && !DECL_ARTIFICIAL (node->decl))
 108         {
 109           if (!check_warn_node_versionable (node))
 110             continue;
 111           cgraph_node *clone
 112             = node->create_virtual_clone (vec <cgraph_edge *> (),
 113                                           NULL, NULL, "hsa", 0);
 114           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
 115           clone->externally_visible = node->externally_visible;
 116
 117           if (!node->local)
 118             clone->force_output = true;
 119           hsa_summaries->link_functions (clone, node, HSA_FUNCTION, false);
 120
 121           if (dump_file)
 122             fprintf (dump_file, "Created a new HSA function clone: %s\n",
 123                      clone->dump_name ());
 124         }
 125     }
 126
 127   /* Redirect all edges that are between HSA clones.  */
 128   FOR_EACH_DEFINED_FUNCTION (node)
 129     {
 130       cgraph_edge *e = node->callees;
 131
 132       while (e)
 133         {
 134           hsa_function_summary *src = hsa_summaries->get (node);
 135           if (src != NULL && src->m_gpu_implementation_p)
 136             {
 137               hsa_function_summary *dst = hsa_summaries->get (e->callee);
 138               if (dst != NULL && !dst->m_gpu_implementation_p)
 139                 {
 140                   e->redirect_callee (dst->m_bound_function);
 141                   if (dump_file)
 142                     fprintf (dump_file,
 143                              "Redirecting edge to HSA function: %s->%s\n",
 144                              e->caller->dump_name (),
 145                              e->callee->dump_name ());
 146                 }
 147             }
 148
 149           e = e->next_callee;
 150         }
 151     }
 152
 153   return 0;
 154 }
 155
 156 /* Iterate all HSA functions and stream out HSA function summary.  */
 157
 158 static void
 159 ipa_hsa_write_summary (void)
 160 {
 161   struct bitpack_d bp;
 162   struct cgraph_node *node;
 163   struct output_block *ob;
 164   unsigned int count = 0;
 165   lto_symtab_encoder_iterator lsei;
 166   lto_symtab_encoder_t encoder;
 167
 168   if (!hsa_summaries)
 169     return;
 170
 171   ob = create_output_block (LTO_section_ipa_hsa);
 172   encoder = ob->decl_state->symtab_node_encoder;
 173   ob->symbol = NULL;
 174   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
 175        lsei_next_function_in_partition (&lsei))
 176     {
 177       node = lsei_cgraph_node (lsei);
 178       hsa_function_summary *s = hsa_summaries->get (node);
 179
 180       if (s != NULL)
 181         count++;
 182     }
 183
 184   streamer_write_uhwi (ob, count);
 185
 186   /* Process all of the functions.  */
 187   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
 188        lsei_next_function_in_partition (&lsei))
 189     {
 190       node = lsei_cgraph_node (lsei);
 191       hsa_function_summary *s = hsa_summaries->get (node);
 192
 193       if (s != NULL)
 194         {
 195           encoder = ob->decl_state->symtab_node_encoder;
 196           int node_ref = lto_symtab_encoder_encode (encoder, node);
 197           streamer_write_uhwi (ob, node_ref);
 198
 199           bp = bitpack_create (ob->main_stream);
 200           bp_pack_value (&bp, s->m_kind, 2);
 201           bp_pack_value (&bp, s->m_gpu_implementation_p, 1);
 202           bp_pack_value (&bp, s->m_bound_function != NULL, 1);
 203           streamer_write_bitpack (&bp);
 204           if (s->m_bound_function)
 205             stream_write_tree (ob, s->m_bound_function->decl, true);
 206         }
 207     }
 208
 209   streamer_write_char_stream (ob->main_stream, 0);
 210   produce_asm (ob, NULL);
 211   destroy_output_block (ob);
 212 }
 213
 214 /* Read section in file FILE_DATA of length LEN with data DATA.  */
 215
 216 static void
 217 ipa_hsa_read_section (struct lto_file_decl_data *file_data, const char *data,
 218                        size_t len)
 219 {
 220   const struct lto_function_header *header
 221     = (const struct lto_function_header *) data;
 222   const int cfg_offset = sizeof (struct lto_function_header);
 223   const int main_offset = cfg_offset + header->cfg_size;
 224   const int string_offset = main_offset + header->main_size;
 225   class data_in *data_in;
 226   unsigned int i;
 227   unsigned int count;
 228
 229   lto_input_block ib_main ((const char *) data + main_offset,
 230                            header->main_size, file_data->mode_table);
 231
 232   data_in
 233     = lto_data_in_create (file_data, (const char *) data + string_offset,
 234                           header->string_size, vNULL);
 235   count = streamer_read_uhwi (&ib_main);
 236
 237   for (i = 0; i < count; i++)
 238     {
 239       unsigned int index;
 240       struct cgraph_node *node;
 241       lto_symtab_encoder_t encoder;
 242
 243       index = streamer_read_uhwi (&ib_main);
 244       encoder = file_data->symtab_node_encoder;
 245       node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
 246                                                                 index));
 247       gcc_assert (node->definition);
 248       hsa_function_summary *s = hsa_summaries->get_create (node);
 249
 250       struct bitpack_d bp = streamer_read_bitpack (&ib_main);
 251       s->m_kind = (hsa_function_kind) bp_unpack_value (&bp, 2);
 252       s->m_gpu_implementation_p = bp_unpack_value (&bp, 1);
 253       bool has_tree = bp_unpack_value (&bp, 1);
 254
 255       if (has_tree)
 256         {
 257           tree decl = stream_read_tree (&ib_main, data_in);
 258           s->m_bound_function = cgraph_node::get_create (decl);
 259         }
 260     }
 261   lto_free_section_data (file_data, LTO_section_ipa_hsa, NULL, data,
 262                          len);
 263   lto_data_in_delete (data_in);
 264 }
 265
 266 /* Load streamed HSA functions summary and assign the summary to a function.  */
 267
 268 static void
 269 ipa_hsa_read_summary (void)
 270 {
 271   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 272   struct lto_file_decl_data *file_data;
 273   unsigned int j = 0;
 274
 275   if (hsa_summaries == NULL)
 276     hsa_summaries = new hsa_summary_t (symtab);
 277
 278   while ((file_data = file_data_vec[j++]))
 279     {
 280       size_t len;
 281       const char *data
 282         = lto_get_summary_section_data (file_data, LTO_section_ipa_hsa, &len);
 283       if (data)
 284         ipa_hsa_read_section (file_data, data, len);
 285     }
 286 }
 287
 288 const pass_data pass_data_ipa_hsa =
 289 {
 290   IPA_PASS, /* type */
 291   "hsa", /* name */
 292   OPTGROUP_OMP, /* optinfo_flags */
 293   TV_IPA_HSA, /* tv_id */
 294   0, /* properties_required */
 295   0, /* properties_provided */
 296   0, /* properties_destroyed */
 297   0, /* todo_flags_start */
 298   TODO_dump_symtab, /* todo_flags_finish */
 299 };
 300
 301 class pass_ipa_hsa : public ipa_opt_pass_d
 302 {
 303 public:
 304   pass_ipa_hsa (gcc::context *ctxt)
 305     : ipa_opt_pass_d (pass_data_ipa_hsa, ctxt,
 306                       NULL, /* generate_summary */
 307                       ipa_hsa_write_summary, /* write_summary */
 308                       ipa_hsa_read_summary, /* read_summary */
 309                       ipa_hsa_write_summary, /* write_optimization_summary */
 310                       ipa_hsa_read_summary, /* read_optimization_summary */
 311                       NULL, /* stmt_fixup */
 312                       0, /* function_transform_todo_flags_start */
 313                       NULL, /* function_transform */
 314                       NULL) /* variable_transform */
 315     {}
 316
 317   /* opt_pass methods: */
 318   virtual bool gate (function *);
 319
 320   virtual unsigned int execute (function *) { return process_hsa_functions (); }
 321
 322 }; // class pass_ipa_reference
 323
 324 bool
 325 pass_ipa_hsa::gate (function *)
 326 {
 327   return hsa_gen_requested_p ();
 328 }
 329
 330 } // anon namespace
 331
 332 ipa_opt_pass_d *
 333 make_pass_ipa_hsa (gcc::context *ctxt)
 334 {
 335   return new pass_ipa_hsa (ctxt);
 336 }