gcc/ipa-hsa.c

   1 /* Callgraph based analysis of static variables.
   2    Copyright (C) 2015-2018 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 "symbol-summary.h"
  44 #include "hsa-common.h"
  45
  46 namespace {
  47
  48 /* If NODE is not versionable, warn about not emiting HSAIL and return false.
  49    Otherwise return true.  */
  50
  51 static bool
  52 check_warn_node_versionable (cgraph_node *node)
  53 {
  54   if (!node->local.versionable)
  55     {
  56       warning_at (EXPR_LOCATION (node->decl), OPT_Whsa,
  57                   "could not emit HSAIL for function %s: function cannot be "
  58                   "cloned", node->name ());
  59       return false;
  60     }
  61   return true;
  62 }
  63
  64 /* The function creates HSA clones for all functions that were either
  65    marked as HSA kernels or are callable HSA functions.  Apart from that,
  66    we redirect all edges that come from an HSA clone and end in another
  67    HSA clone to connect these two functions.  */
  68
  69 static unsigned int
  70 process_hsa_functions (void)
  71 {
  72   struct cgraph_node *node;
  73
  74   if (hsa_summaries == NULL)
  75     hsa_summaries = new hsa_summary_t (symtab);
  76
  77   FOR_EACH_DEFINED_FUNCTION (node)
  78     {
  79       hsa_function_summary *s = hsa_summaries->get (node);
  80
  81       /* A linked function is skipped.  */
  82       if (s->m_bound_function != NULL)
  83         continue;
  84
  85       if (s->m_kind != HSA_NONE)
  86         {
  87           if (!check_warn_node_versionable (node))
  88             continue;
  89           cgraph_node *clone
  90             = node->create_virtual_clone (vec <cgraph_edge *> (),
  91                                           NULL, NULL, "hsa");
  92           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
  93           clone->externally_visible = node->externally_visible;
  94
  95           clone->force_output = true;
  96           hsa_summaries->link_functions (clone, node, s->m_kind, false);
  97
  98           if (dump_file)
  99             fprintf (dump_file, "Created a new HSA clone: %s, type: %s\n",
 100                      clone->name (),
 101                      s->m_kind == HSA_KERNEL ? "kernel" : "function");
 102         }
 103       else if (hsa_callable_function_p (node->decl)
 104                /* At this point, this is enough to identify clones for
 105                   parallel, which for HSA would need to be kernels anyway.  */
 106                && !DECL_ARTIFICIAL (node->decl))
 107         {
 108           if (!check_warn_node_versionable (node))
 109             continue;
 110           cgraph_node *clone
 111             = node->create_virtual_clone (vec <cgraph_edge *> (),
 112                                           NULL, NULL, "hsa");
 113           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
 114           clone->externally_visible = node->externally_visible;
 115
 116           if (!cgraph_local_p (node))
 117             clone->force_output = true;
 118           hsa_summaries->link_functions (clone, node, HSA_FUNCTION, false);
 119
 120           if (dump_file)
 121             fprintf (dump_file, "Created a new HSA function clone: %s\n",
 122                      clone->name ());
 123         }
 124     }
 125
 126   /* Redirect all edges that are between HSA clones.  */
 127   FOR_EACH_DEFINED_FUNCTION (node)
 128     {
 129       cgraph_edge *e = node->callees;
 130
 131       while (e)
 132         {
 133           hsa_function_summary *src = hsa_summaries->get (node);
 134           if (src->m_kind != HSA_NONE && src->m_gpu_implementation_p)
 135             {
 136               hsa_function_summary *dst = hsa_summaries->get (e->callee);
 137               if (dst->m_kind != HSA_NONE && !dst->m_gpu_implementation_p)
 138                 {
 139                   e->redirect_callee (dst->m_bound_function);
 140                   if (dump_file)
 141                     fprintf (dump_file,
 142                              "Redirecting edge to HSA function: %s->%s\n",
 143                              xstrdup_for_dump (e->caller->name ()),
 144                              xstrdup_for_dump (e->callee->name ()));
 145                 }
 146             }
 147
 148           e = e->next_callee;
 149         }
 150     }
 151
 152   return 0;
 153 }
 154
 155 /* Iterate all HSA functions and stream out HSA function summary.  */
 156
 157 static void
 158 ipa_hsa_write_summary (void)
 159 {
 160   struct bitpack_d bp;
 161   struct cgraph_node *node;
 162   struct output_block *ob;
 163   unsigned int count = 0;
 164   lto_symtab_encoder_iterator lsei;
 165   lto_symtab_encoder_t encoder;
 166
 167   if (!hsa_summaries)
 168     return;
 169
 170   ob = create_output_block (LTO_section_ipa_hsa);
 171   encoder = ob->decl_state->symtab_node_encoder;
 172   ob->symbol = NULL;
 173   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
 174        lsei_next_function_in_partition (&lsei))
 175     {
 176       node = lsei_cgraph_node (lsei);
 177       hsa_function_summary *s = hsa_summaries->get (node);
 178
 179       if (s->m_kind != HSA_NONE)
 180         count++;
 181     }
 182
 183   streamer_write_uhwi (ob, count);
 184
 185   /* Process all of the functions.  */
 186   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
 187        lsei_next_function_in_partition (&lsei))
 188     {
 189       node = lsei_cgraph_node (lsei);
 190       hsa_function_summary *s = hsa_summaries->get (node);
 191
 192       if (s->m_kind != HSA_NONE)
 193         {
 194           encoder = ob->decl_state->symtab_node_encoder;
 195           int node_ref = lto_symtab_encoder_encode (encoder, node);
 196           streamer_write_uhwi (ob, node_ref);
 197
 198           bp = bitpack_create (ob->main_stream);
 199           bp_pack_value (&bp, s->m_kind, 2);
 200           bp_pack_value (&bp, s->m_gpu_implementation_p, 1);
 201           bp_pack_value (&bp, s->m_bound_function != NULL, 1);
 202           streamer_write_bitpack (&bp);
 203           if (s->m_bound_function)
 204             stream_write_tree (ob, s->m_bound_function->decl, true);
 205         }
 206     }
 207
 208   streamer_write_char_stream (ob->main_stream, 0);
 209   produce_asm (ob, NULL);
 210   destroy_output_block (ob);
 211 }
 212
 213 /* Read section in file FILE_DATA of length LEN with data DATA.  */
 214
 215 static void
 216 ipa_hsa_read_section (struct lto_file_decl_data *file_data, const char *data,
 217                        size_t len)
 218 {
 219   const struct lto_function_header *header
 220     = (const struct lto_function_header *) data;
 221   const int cfg_offset = sizeof (struct lto_function_header);
 222   const int main_offset = cfg_offset + header->cfg_size;
 223   const int string_offset = main_offset + header->main_size;
 224   struct data_in *data_in;
 225   unsigned int i;
 226   unsigned int count;
 227
 228   lto_input_block ib_main ((const char *) data + main_offset,
 229                            header->main_size, file_data->mode_table);
 230
 231   data_in
 232     = lto_data_in_create (file_data, (const char *) data + string_offset,
 233                           header->string_size, vNULL);
 234   count = streamer_read_uhwi (&ib_main);
 235
 236   for (i = 0; i < count; i++)
 237     {
 238       unsigned int index;
 239       struct cgraph_node *node;
 240       lto_symtab_encoder_t encoder;
 241
 242       index = streamer_read_uhwi (&ib_main);
 243       encoder = file_data->symtab_node_encoder;
 244       node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
 245                                                                 index));
 246       gcc_assert (node->definition);
 247       hsa_function_summary *s = hsa_summaries->get (node);
 248
 249       struct bitpack_d bp = streamer_read_bitpack (&ib_main);
 250       s->m_kind = (hsa_function_kind) bp_unpack_value (&bp, 2);
 251       s->m_gpu_implementation_p = bp_unpack_value (&bp, 1);
 252       bool has_tree = bp_unpack_value (&bp, 1);
 253
 254       if (has_tree)
 255         {
 256           tree decl = stream_read_tree (&ib_main, data_in);
 257           s->m_bound_function = cgraph_node::get_create (decl);
 258         }
 259     }
 260   lto_free_section_data (file_data, LTO_section_ipa_hsa, NULL, data,
 261                          len);
 262   lto_data_in_delete (data_in);
 263 }
 264
 265 /* Load streamed HSA functions summary and assign the summary to a function.  */
 266
 267 static void
 268 ipa_hsa_read_summary (void)
 269 {
 270   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 271   struct lto_file_decl_data *file_data;
 272   unsigned int j = 0;
 273
 274   if (hsa_summaries == NULL)
 275     hsa_summaries = new hsa_summary_t (symtab);
 276
 277   while ((file_data = file_data_vec[j++]))
 278     {
 279       size_t len;
 280       const char *data = lto_get_section_data (file_data, LTO_section_ipa_hsa,
 281                                                NULL, &len);
 282
 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 }