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
check_warn_node_versionable(cgraph_node * node)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
process_hsa_functions(void)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
ipa_hsa_write_summary(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
ipa_hsa_read_section(struct lto_file_decl_data * file_data,const char * data,size_t len)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
ipa_hsa_read_summary(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:
pass_ipa_hsa(gcc::context * ctxt)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
execute(function *)320 virtual unsigned int execute (function *) { return process_hsa_functions (); }
321
322 }; // class pass_ipa_reference
323
324 bool
gate(function *)325 pass_ipa_hsa::gate (function *)
326 {
327 return hsa_gen_requested_p ();
328 }
329
330 } // anon namespace
331
332 ipa_opt_pass_d *
make_pass_ipa_hsa(gcc::context * ctxt)333 make_pass_ipa_hsa (gcc::context *ctxt)
334 {
335 return new pass_ipa_hsa (ctxt);
336 }
337