1 | /* Default language-specific hooks. |
2 | Copyright (C) 2001-2024 Free Software Foundation, Inc. |
3 | Contributed by Alexandre Oliva <aoliva@redhat.com> |
4 | |
5 | This file is part of GCC. |
6 | |
7 | GCC is free software; you can redistribute it and/or modify |
8 | it under the terms of the GNU General Public License as published by |
9 | the Free Software Foundation; either version 3, or (at your option) |
10 | any later version. |
11 | |
12 | GCC is distributed in the hope that it will be useful, |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
15 | GNU General Public 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 "target.h" |
25 | #include "rtl.h" |
26 | #include "tree.h" |
27 | #include "timevar.h" |
28 | #include "stringpool.h" |
29 | #include "diagnostic.h" |
30 | #include "intl.h" |
31 | #include "toplev.h" |
32 | #include "attribs.h" |
33 | #include "gimplify.h" |
34 | #include "langhooks.h" |
35 | #include "tree-diagnostic.h" |
36 | #include "output.h" |
37 | #include "timevar.h" |
38 | #include "stor-layout.h" |
39 | #include "cgraph.h" |
40 | #include "debug.h" |
41 | |
42 | /* Do nothing; in many cases the default hook. */ |
43 | |
44 | void |
45 | lhd_do_nothing (void) |
46 | { |
47 | } |
48 | |
49 | /* Do nothing (tree). */ |
50 | |
51 | void |
52 | lhd_do_nothing_t (tree ARG_UNUSED (t)) |
53 | { |
54 | } |
55 | |
56 | /* Pass through (tree). */ |
57 | tree |
58 | lhd_pass_through_t (tree t) |
59 | { |
60 | return t; |
61 | } |
62 | |
63 | /* Do nothing (int, int, int). Return NULL_TREE. */ |
64 | |
65 | tree |
66 | lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), |
67 | int ARG_UNUSED (j), |
68 | int ARG_UNUSED (k)) |
69 | { |
70 | return NULL_TREE; |
71 | } |
72 | |
73 | /* Do nothing (function). */ |
74 | |
75 | void |
76 | lhd_do_nothing_f (struct function * ARG_UNUSED (f)) |
77 | { |
78 | } |
79 | |
80 | /* Do nothing (return NULL_TREE). */ |
81 | |
82 | tree |
83 | lhd_return_null_tree (tree ARG_UNUSED (t)) |
84 | { |
85 | return NULL_TREE; |
86 | } |
87 | |
88 | /* Do nothing (return NULL_TREE). */ |
89 | |
90 | tree |
91 | lhd_return_null_const_tree (const_tree ARG_UNUSED (t)) |
92 | { |
93 | return NULL_TREE; |
94 | } |
95 | |
96 | /* The default post options hook. */ |
97 | |
98 | bool |
99 | lhd_post_options (const char ** ARG_UNUSED (pfilename)) |
100 | { |
101 | /* Excess precision other than "fast" requires front-end |
102 | support. */ |
103 | flag_excess_precision = EXCESS_PRECISION_FAST; |
104 | return false; |
105 | } |
106 | |
107 | /* Called from by print-tree.cc. */ |
108 | |
109 | void |
110 | lhd_print_tree_nothing (FILE * ARG_UNUSED (file), |
111 | tree ARG_UNUSED (node), |
112 | int ARG_UNUSED (indent)) |
113 | { |
114 | } |
115 | |
116 | /* Called from check_global_declaration. */ |
117 | |
118 | bool |
119 | lhd_warn_unused_global_decl (const_tree decl) |
120 | { |
121 | /* This is what used to exist in check_global_declaration. Probably |
122 | not many of these actually apply to non-C languages. */ |
123 | |
124 | if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) |
125 | return false; |
126 | if (VAR_P (decl) && TREE_READONLY (decl)) |
127 | return false; |
128 | if (DECL_IN_SYSTEM_HEADER (decl)) |
129 | return false; |
130 | |
131 | return true; |
132 | } |
133 | |
134 | /* Set the DECL_ASSEMBLER_NAME for DECL. */ |
135 | void |
136 | lhd_set_decl_assembler_name (tree decl) |
137 | { |
138 | tree id; |
139 | |
140 | /* set_decl_assembler_name may be called on TYPE_DECL to record ODR |
141 | name for C++ types. By default types have no ODR names. */ |
142 | if (TREE_CODE (decl) == TYPE_DECL) |
143 | return; |
144 | |
145 | /* The language-independent code should never use the |
146 | DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and |
147 | VAR_DECLs for variables with static storage duration need a real |
148 | DECL_ASSEMBLER_NAME. */ |
149 | gcc_assert (TREE_CODE (decl) == FUNCTION_DECL |
150 | || (VAR_P (decl) |
151 | && (TREE_STATIC (decl) |
152 | || DECL_EXTERNAL (decl) |
153 | || TREE_PUBLIC (decl)))); |
154 | |
155 | /* By default, assume the name to use in assembly code is the same |
156 | as that used in the source language. (That's correct for C, and |
157 | GCC used to set DECL_ASSEMBLER_NAME to the same value as |
158 | DECL_NAME in build_decl, so this choice provides backwards |
159 | compatibility with existing front-ends. This assumption is wrapped |
160 | in a target hook, to allow for target-specific modification of the |
161 | identifier. |
162 | |
163 | Can't use just the variable's own name for a variable whose scope |
164 | is less than the whole compilation. Concatenate a distinguishing |
165 | number. */ |
166 | |
167 | if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl)) |
168 | id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl)); |
169 | else |
170 | { |
171 | const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); |
172 | static unsigned long num; |
173 | char *label; |
174 | |
175 | ASM_FORMAT_PRIVATE_NAME (label, name, num++); |
176 | id = get_identifier (label); |
177 | } |
178 | |
179 | SET_DECL_ASSEMBLER_NAME (decl, id); |
180 | } |
181 | |
182 | /* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME. */ |
183 | void |
184 | lhd_overwrite_decl_assembler_name (tree decl, tree name) |
185 | { |
186 | DECL_ASSEMBLER_NAME_RAW (decl) = name; |
187 | } |
188 | |
189 | /* Type promotion for variable arguments. */ |
190 | tree |
191 | lhd_type_promotes_to (tree ARG_UNUSED (type)) |
192 | { |
193 | gcc_unreachable (); |
194 | } |
195 | |
196 | /* Registration of machine- or os-specific builtin types. */ |
197 | void |
198 | lhd_register_builtin_type (tree ARG_UNUSED (type), |
199 | const char * ARG_UNUSED (name)) |
200 | { |
201 | } |
202 | |
203 | /* Invalid use of an incomplete type. */ |
204 | void |
205 | lhd_incomplete_type_error (location_t ARG_UNUSED (loc), |
206 | const_tree ARG_UNUSED (value), const_tree type) |
207 | { |
208 | gcc_assert (TREE_CODE (type) == ERROR_MARK); |
209 | return; |
210 | } |
211 | |
212 | /* Provide a default routine for alias sets that always returns -1. This |
213 | is used by languages that don't need to do anything special. */ |
214 | |
215 | alias_set_type |
216 | lhd_get_alias_set (tree ARG_UNUSED (t)) |
217 | { |
218 | return -1; |
219 | } |
220 | |
221 | /* This is the default decl_printable_name function. */ |
222 | |
223 | const char * |
224 | lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) |
225 | { |
226 | gcc_assert (decl && DECL_NAME (decl)); |
227 | return IDENTIFIER_POINTER (DECL_NAME (decl)); |
228 | } |
229 | |
230 | /* This is the default dwarf_name function. */ |
231 | |
232 | const char * |
233 | lhd_dwarf_name (tree t, int verbosity) |
234 | { |
235 | gcc_assert (DECL_P (t)); |
236 | |
237 | return lang_hooks.decl_printable_name (t, verbosity); |
238 | } |
239 | |
240 | /* This compares two types for equivalence ("compatible" in C-based languages). |
241 | This routine should only return 1 if it is sure. It should not be used |
242 | in contexts where erroneously returning 0 causes problems. */ |
243 | |
244 | int |
245 | lhd_types_compatible_p (tree x, tree y) |
246 | { |
247 | return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); |
248 | } |
249 | |
250 | /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree |
251 | nodes. Returns nonzero if it does not want the usual dumping of the |
252 | second argument. */ |
253 | |
254 | bool |
255 | lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) |
256 | { |
257 | return false; |
258 | } |
259 | |
260 | /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a |
261 | language-specific way. */ |
262 | |
263 | int |
264 | lhd_tree_dump_type_quals (const_tree t) |
265 | { |
266 | return TYPE_QUALS (t); |
267 | } |
268 | |
269 | /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ |
270 | |
271 | int |
272 | lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, |
273 | gimple_seq *pre_p ATTRIBUTE_UNUSED, |
274 | gimple_seq *post_p ATTRIBUTE_UNUSED) |
275 | { |
276 | return GS_UNHANDLED; |
277 | } |
278 | |
279 | /* lang_hooks.tree_size: Determine the size of a tree with code C, |
280 | which is a language-specific tree code in category tcc_constant, |
281 | tcc_exceptional or tcc_type. The default expects never to be called. */ |
282 | size_t |
283 | lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) |
284 | { |
285 | gcc_unreachable (); |
286 | } |
287 | |
288 | /* Return true if decl, which is a function decl, may be called by a |
289 | sibcall. */ |
290 | |
291 | bool |
292 | lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) |
293 | { |
294 | return true; |
295 | } |
296 | |
297 | /* Generic global declaration processing. This is meant to be called |
298 | by the front-ends at the end of parsing. C/C++ do their own thing, |
299 | but other front-ends may call this. */ |
300 | |
301 | void |
302 | global_decl_processing (void) |
303 | { |
304 | tree globals, decl, *vec; |
305 | int len, i; |
306 | |
307 | timevar_stop (TV_PHASE_PARSING); |
308 | timevar_start (TV_PHASE_DEFERRED); |
309 | /* Really define vars that have had only a tentative definition. |
310 | Really output inline functions that must actually be callable |
311 | and have not been output so far. */ |
312 | |
313 | globals = lang_hooks.decls.getdecls (); |
314 | len = list_length (globals); |
315 | vec = XNEWVEC (tree, len); |
316 | |
317 | /* Process the decls in reverse order--earliest first. |
318 | Put them into VEC from back to front, then take out from front. */ |
319 | |
320 | for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl)) |
321 | vec[len - i - 1] = decl; |
322 | |
323 | wrapup_global_declarations (vec, len); |
324 | timevar_stop (TV_PHASE_DEFERRED); |
325 | |
326 | timevar_start (TV_PHASE_PARSING); |
327 | free (ptr: vec); |
328 | } |
329 | |
330 | /* Called to perform language-specific initialization of CTX. */ |
331 | void |
332 | lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED) |
333 | { |
334 | } |
335 | |
336 | /* Called to register dumps. */ |
337 | void |
338 | lhd_register_dumps (gcc::dump_manager *) |
339 | { |
340 | } |
341 | |
342 | /* Called to perform language-specific options initialization. */ |
343 | void |
344 | lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED, |
345 | struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED) |
346 | { |
347 | } |
348 | |
349 | /* By default, always complain about options for the wrong language. */ |
350 | bool |
351 | lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED) |
352 | { |
353 | return true; |
354 | } |
355 | |
356 | /* By default, no language-specific options are valid. */ |
357 | bool |
358 | lhd_handle_option (size_t code ATTRIBUTE_UNUSED, |
359 | const char *arg ATTRIBUTE_UNUSED, |
360 | HOST_WIDE_INT value ATTRIBUTE_UNUSED, |
361 | int kind ATTRIBUTE_UNUSED, |
362 | location_t loc ATTRIBUTE_UNUSED, |
363 | const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED) |
364 | { |
365 | return false; |
366 | } |
367 | |
368 | /* The default function to print out name of current function that caused |
369 | an error. */ |
370 | void |
371 | lhd_print_error_function (diagnostic_context *context, const char *file, |
372 | const diagnostic_info *diagnostic) |
373 | { |
374 | if (diagnostic_last_function_changed (context, diagnostic)) |
375 | { |
376 | char *old_prefix = pp_take_prefix (context->printer); |
377 | tree abstract_origin = diagnostic_abstract_origin (diagnostic); |
378 | char *new_prefix = (file && abstract_origin == NULL) |
379 | ? file_name_as_prefix (context, file) : NULL; |
380 | |
381 | pp_set_prefix (context->printer, new_prefix); |
382 | |
383 | if (current_function_decl == NULL) |
384 | pp_printf (context->printer, _("At top level:" )); |
385 | else |
386 | { |
387 | tree fndecl, ao; |
388 | |
389 | if (abstract_origin) |
390 | { |
391 | ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); |
392 | gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); |
393 | fndecl = ao; |
394 | } |
395 | else |
396 | fndecl = current_function_decl; |
397 | |
398 | if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) |
399 | pp_printf |
400 | (context->printer, _("In member function %qs" ), |
401 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
402 | else |
403 | pp_printf |
404 | (context->printer, _("In function %qs" ), |
405 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
406 | |
407 | while (abstract_origin) |
408 | { |
409 | location_t *locus; |
410 | tree block = abstract_origin; |
411 | |
412 | locus = &BLOCK_SOURCE_LOCATION (block); |
413 | fndecl = NULL; |
414 | block = BLOCK_SUPERCONTEXT (block); |
415 | while (block && TREE_CODE (block) == BLOCK |
416 | && BLOCK_ABSTRACT_ORIGIN (block)) |
417 | { |
418 | ao = BLOCK_ABSTRACT_ORIGIN (block); |
419 | if (TREE_CODE (ao) == FUNCTION_DECL) |
420 | { |
421 | fndecl = ao; |
422 | break; |
423 | } |
424 | else if (TREE_CODE (ao) != BLOCK) |
425 | break; |
426 | |
427 | block = BLOCK_SUPERCONTEXT (block); |
428 | } |
429 | if (fndecl) |
430 | abstract_origin = block; |
431 | else |
432 | { |
433 | while (block && TREE_CODE (block) == BLOCK) |
434 | block = BLOCK_SUPERCONTEXT (block); |
435 | |
436 | if (block && TREE_CODE (block) == FUNCTION_DECL) |
437 | fndecl = block; |
438 | abstract_origin = NULL; |
439 | } |
440 | if (fndecl) |
441 | { |
442 | expanded_location s = expand_location (*locus); |
443 | pp_comma (context->printer); |
444 | pp_newline (context->printer); |
445 | if (s.file != NULL) |
446 | { |
447 | if (context->m_show_column) |
448 | pp_printf (context->printer, |
449 | _(" inlined from %qs at %r%s:%d:%d%R" ), |
450 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
451 | "locus" , s.file, s.line, s.column); |
452 | else |
453 | pp_printf (context->printer, |
454 | _(" inlined from %qs at %r%s:%d%R" ), |
455 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
456 | "locus" , s.file, s.line); |
457 | |
458 | } |
459 | else |
460 | pp_printf (context->printer, _(" inlined from %qs" ), |
461 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
462 | } |
463 | } |
464 | pp_colon (context->printer); |
465 | } |
466 | |
467 | diagnostic_set_last_function (context, diagnostic); |
468 | pp_newline_and_flush (context->printer); |
469 | context->printer->prefix = old_prefix; |
470 | free (ptr: (char*) new_prefix); |
471 | } |
472 | } |
473 | |
474 | tree |
475 | lhd_make_node (enum tree_code code) |
476 | { |
477 | return make_node (code); |
478 | } |
479 | |
480 | /* Default implementation of LANG_HOOKS_SIMULATE_ENUM_DECL. Assume a |
481 | simple int-based enumerator (which is all the hook can be used for |
482 | at present) and push each decl individually without any decoration. |
483 | |
484 | This definition is suitable for LTO and is generic enough that it |
485 | might be reusable elsewhere. */ |
486 | tree |
487 | lhd_simulate_enum_decl (location_t loc, const char *name, |
488 | vec<string_int_pair> *values_ptr) |
489 | { |
490 | tree enumtype = lang_hooks.types.make_type (ENUMERAL_TYPE); |
491 | tree enumdecl = build_decl (loc, TYPE_DECL, get_identifier (name), enumtype); |
492 | TYPE_STUB_DECL (enumtype) = enumdecl; |
493 | |
494 | tree value_chain = NULL_TREE; |
495 | string_int_pair *value; |
496 | vec<string_int_pair> values = *values_ptr; |
497 | unsigned int i; |
498 | FOR_EACH_VEC_ELT (values, i, value) |
499 | { |
500 | tree value_decl = build_decl (loc, CONST_DECL, |
501 | get_identifier (value->first), enumtype); |
502 | DECL_INITIAL (value_decl) = build_int_cst (integer_type_node, |
503 | value->second); |
504 | lang_hooks.decls.pushdecl (value_decl); |
505 | value_chain = tree_cons (value_decl, DECL_INITIAL (value_decl), |
506 | value_chain); |
507 | } |
508 | |
509 | TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (integer_type_node); |
510 | TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (integer_type_node); |
511 | SET_TYPE_ALIGN (enumtype, TYPE_ALIGN (integer_type_node)); |
512 | TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); |
513 | layout_type (enumtype); |
514 | lang_hooks.decls.pushdecl (enumdecl); |
515 | |
516 | return enumtype; |
517 | } |
518 | |
519 | /* Default implementation of LANG_HOOKS_SIMULATE_RECORD_DECL. |
520 | Just create a normal RECORD_TYPE and a TYPE_DECL for it. */ |
521 | tree |
522 | lhd_simulate_record_decl (location_t loc, const char *name, |
523 | array_slice<const tree> fields) |
524 | { |
525 | for (unsigned int i = 1; i < fields.size (); ++i) |
526 | /* Reversed by finish_builtin_struct. */ |
527 | DECL_CHAIN (fields[i]) = fields[i - 1]; |
528 | |
529 | tree type = lang_hooks.types.make_type (RECORD_TYPE); |
530 | finish_builtin_struct (type, name, fields.back (), NULL_TREE); |
531 | |
532 | tree decl = build_decl (loc, TYPE_DECL, get_identifier (name), type); |
533 | lang_hooks.decls.pushdecl (decl); |
534 | |
535 | return type; |
536 | } |
537 | |
538 | /* Default implementation of LANG_HOOKS_TYPE_FOR_SIZE. |
539 | Return an integer type with PRECISION bits of precision, |
540 | that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ |
541 | |
542 | tree |
543 | lhd_type_for_size (unsigned precision, int unsignedp) |
544 | { |
545 | int i; |
546 | |
547 | if (precision == TYPE_PRECISION (integer_type_node)) |
548 | return unsignedp ? unsigned_type_node : integer_type_node; |
549 | |
550 | if (precision == TYPE_PRECISION (signed_char_type_node)) |
551 | return unsignedp ? unsigned_char_type_node : signed_char_type_node; |
552 | |
553 | if (precision == TYPE_PRECISION (short_integer_type_node)) |
554 | return unsignedp ? short_unsigned_type_node : short_integer_type_node; |
555 | |
556 | if (precision == TYPE_PRECISION (long_integer_type_node)) |
557 | return unsignedp ? long_unsigned_type_node : long_integer_type_node; |
558 | |
559 | if (precision == TYPE_PRECISION (long_long_integer_type_node)) |
560 | return unsignedp |
561 | ? long_long_unsigned_type_node |
562 | : long_long_integer_type_node; |
563 | |
564 | for (i = 0; i < NUM_INT_N_ENTS; i ++) |
565 | if (int_n_enabled_p[i] |
566 | && precision == int_n_data[i].bitsize) |
567 | return (unsignedp ? int_n_trees[i].unsigned_type |
568 | : int_n_trees[i].signed_type); |
569 | |
570 | if (precision <= TYPE_PRECISION (intQI_type_node)) |
571 | return unsignedp ? unsigned_intQI_type_node : intQI_type_node; |
572 | |
573 | if (precision <= TYPE_PRECISION (intHI_type_node)) |
574 | return unsignedp ? unsigned_intHI_type_node : intHI_type_node; |
575 | |
576 | if (precision <= TYPE_PRECISION (intSI_type_node)) |
577 | return unsignedp ? unsigned_intSI_type_node : intSI_type_node; |
578 | |
579 | if (precision <= TYPE_PRECISION (intDI_type_node)) |
580 | return unsignedp ? unsigned_intDI_type_node : intDI_type_node; |
581 | |
582 | if (precision <= TYPE_PRECISION (intTI_type_node)) |
583 | return unsignedp ? unsigned_intTI_type_node : intTI_type_node; |
584 | |
585 | return NULL_TREE; |
586 | } |
587 | |
588 | HOST_WIDE_INT |
589 | lhd_to_target_charset (HOST_WIDE_INT c) |
590 | { |
591 | return c; |
592 | } |
593 | |
594 | tree |
595 | lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) |
596 | { |
597 | return expr; |
598 | } |
599 | |
600 | /* Return sharing kind if OpenMP sharing attribute of DECL is |
601 | predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ |
602 | |
603 | enum omp_clause_default_kind |
604 | lhd_omp_predetermined_sharing (tree decl) |
605 | { |
606 | if (DECL_ARTIFICIAL (decl)) |
607 | return OMP_CLAUSE_DEFAULT_SHARED; |
608 | return OMP_CLAUSE_DEFAULT_UNSPECIFIED; |
609 | } |
610 | |
611 | /* Return sharing kind if OpenMP mapping attribute of DECL is |
612 | predetermined, OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED otherwise. */ |
613 | |
614 | enum omp_clause_defaultmap_kind |
615 | lhd_omp_predetermined_mapping (tree decl) |
616 | { |
617 | if (DECL_ARTIFICIAL (decl)) |
618 | return OMP_CLAUSE_DEFAULTMAP_TO; |
619 | return OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED; |
620 | } |
621 | |
622 | /* Generate code to copy SRC to DST. */ |
623 | |
624 | tree |
625 | lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) |
626 | { |
627 | return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); |
628 | } |
629 | |
630 | /* Finalize clause C. */ |
631 | |
632 | void |
633 | lhd_omp_finish_clause (tree, gimple_seq *, bool) |
634 | { |
635 | } |
636 | |
637 | /* Return array size; cf. omp_array_data. */ |
638 | |
639 | tree |
640 | lhd_omp_array_size (tree, gimple_seq *) |
641 | { |
642 | return NULL_TREE; |
643 | } |
644 | |
645 | /* Return true if DECL is a scalar variable (for the purpose of |
646 | implicit firstprivatization & mapping). Only if alloc_ptr_ok |
647 | are allocatables and pointers accepted. */ |
648 | |
649 | bool |
650 | lhd_omp_scalar_p (tree decl, bool ptr_ok) |
651 | { |
652 | tree type = TREE_TYPE (decl); |
653 | if (TREE_CODE (type) == REFERENCE_TYPE) |
654 | type = TREE_TYPE (type); |
655 | if (TREE_CODE (type) == COMPLEX_TYPE) |
656 | type = TREE_TYPE (type); |
657 | if (INTEGRAL_TYPE_P (type) |
658 | || SCALAR_FLOAT_TYPE_P (type) |
659 | || (ptr_ok && TREE_CODE (type) == POINTER_TYPE)) |
660 | return true; |
661 | return false; |
662 | } |
663 | |
664 | /* Return static initializer for DECL. */ |
665 | |
666 | tree * |
667 | lhd_omp_get_decl_init (tree decl) |
668 | { |
669 | return &DECL_INITIAL (decl); |
670 | } |
671 | |
672 | /* Free any extra memory used to hold initializer information for |
673 | variable declarations. */ |
674 | |
675 | void |
676 | lhd_omp_finish_decl_inits (void) |
677 | { |
678 | } |
679 | |
680 | /* Register language specific type size variables as potentially OpenMP |
681 | firstprivate variables. */ |
682 | |
683 | void |
684 | lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, |
685 | tree t ATTRIBUTE_UNUSED) |
686 | { |
687 | } |
688 | |
689 | /* Common function for add_builtin_function, add_builtin_function_ext_scope |
690 | and simulate_builtin_function_decl. */ |
691 | |
692 | static tree |
693 | build_builtin_function (location_t location, const char *name, tree type, |
694 | int function_code, enum built_in_class cl, |
695 | const char *library_name, tree attrs) |
696 | { |
697 | tree id = get_identifier (name); |
698 | tree decl = build_decl (location, FUNCTION_DECL, id, type); |
699 | |
700 | TREE_PUBLIC (decl) = 1; |
701 | DECL_EXTERNAL (decl) = 1; |
702 | |
703 | set_decl_built_in_function (decl, fclass: cl, fcode: function_code); |
704 | |
705 | if (library_name) |
706 | { |
707 | tree libname = get_identifier (library_name); |
708 | |
709 | libname = targetm.mangle_decl_assembler_name (decl, libname); |
710 | SET_DECL_ASSEMBLER_NAME (decl, libname); |
711 | } |
712 | |
713 | /* Possibly apply some default attributes to this built-in function. */ |
714 | if (attrs) |
715 | decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); |
716 | else |
717 | decl_attributes (&decl, NULL_TREE, 0); |
718 | |
719 | return decl; |
720 | } |
721 | |
722 | /* Create a builtin function. */ |
723 | |
724 | tree |
725 | add_builtin_function (const char *name, |
726 | tree type, |
727 | int function_code, |
728 | enum built_in_class cl, |
729 | const char *library_name, |
730 | tree attrs) |
731 | { |
732 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, |
733 | function_code, cl, library_name, attrs); |
734 | return lang_hooks.builtin_function (decl); |
735 | } |
736 | |
737 | /* Like add_builtin_function, but make sure the scope is the external scope. |
738 | This is used to delay putting in back end builtin functions until the ISA |
739 | that defines the builtin is declared via function specific target options, |
740 | which can save memory for machines like the x86_64 that have multiple ISAs. |
741 | If this points to the same function as builtin_function, the backend must |
742 | add all of the builtins at program initialization time. */ |
743 | |
744 | tree |
745 | add_builtin_function_ext_scope (const char *name, |
746 | tree type, |
747 | int function_code, |
748 | enum built_in_class cl, |
749 | const char *library_name, |
750 | tree attrs) |
751 | { |
752 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, |
753 | function_code, cl, library_name, attrs); |
754 | return lang_hooks.builtin_function_ext_scope (decl); |
755 | } |
756 | |
757 | /* Simulate a declaration of a target-specific built-in function at |
758 | location LOCATION, as though it had been declared directly in the |
759 | source language. NAME is the name of the function, TYPE is its function |
760 | type, FUNCTION_CODE is the target-specific function code, LIBRARY_NAME |
761 | is the name of the underlying library function (NULL if none) and |
762 | ATTRS is a list of function attributes. |
763 | |
764 | Return the decl of the declared function. */ |
765 | |
766 | tree |
767 | simulate_builtin_function_decl (location_t location, const char *name, |
768 | tree type, int function_code, |
769 | const char *library_name, tree attrs) |
770 | { |
771 | tree decl = build_builtin_function (location, name, type, |
772 | function_code, cl: BUILT_IN_MD, |
773 | library_name, attrs); |
774 | tree new_decl = lang_hooks.simulate_builtin_function_decl (decl); |
775 | |
776 | /* Give the front end a chance to create a new decl if necessary, |
777 | but if the front end discards the decl in favour of a conflicting |
778 | (erroneous) previous definition, return the decl that we tried but |
779 | failed to add. This allows the caller to process the returned decl |
780 | normally, even though the source code won't be able to use it. */ |
781 | if (TREE_CODE (new_decl) == FUNCTION_DECL |
782 | && fndecl_built_in_p (node: new_decl, name: function_code, klass: BUILT_IN_MD)) |
783 | return new_decl; |
784 | |
785 | return decl; |
786 | } |
787 | |
788 | tree |
789 | lhd_builtin_function (tree decl) |
790 | { |
791 | lang_hooks.decls.pushdecl (decl); |
792 | return decl; |
793 | } |
794 | |
795 | /* Create a builtin type. */ |
796 | |
797 | tree |
798 | add_builtin_type (const char *name, tree type) |
799 | { |
800 | tree id = get_identifier (name); |
801 | tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type); |
802 | return lang_hooks.decls.pushdecl (decl); |
803 | } |
804 | |
805 | /* LTO hooks. */ |
806 | |
807 | /* Used to save and restore any previously active section. */ |
808 | static section *saved_section; |
809 | |
810 | |
811 | /* Begin a new LTO output section named NAME. This default implementation |
812 | saves the old section and emits assembly code to switch to the new |
813 | section. */ |
814 | |
815 | void |
816 | lhd_begin_section (const char *name) |
817 | { |
818 | section *section; |
819 | |
820 | /* Save the old section so we can restore it in lto_end_asm_section. */ |
821 | gcc_assert (!saved_section); |
822 | saved_section = in_section; |
823 | if (!saved_section) |
824 | saved_section = text_section; |
825 | |
826 | /* Create a new section and switch to it. */ |
827 | section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL, not_existing: true); |
828 | switch_to_section (section); |
829 | } |
830 | |
831 | |
832 | /* Write DATA of length LEN to the current LTO output section. This default |
833 | implementation just calls assemble_string. */ |
834 | |
835 | void |
836 | lhd_append_data (const void *data, size_t len, void *) |
837 | { |
838 | if (data) |
839 | { |
840 | timevar_push (tv: TV_IPA_LTO_OUTPUT); |
841 | assemble_string ((const char *)data, len); |
842 | timevar_pop (tv: TV_IPA_LTO_OUTPUT); |
843 | } |
844 | } |
845 | |
846 | |
847 | /* Finish the current LTO output section. This default implementation emits |
848 | assembly code to switch to any section previously saved by |
849 | lhd_begin_section. */ |
850 | |
851 | void |
852 | lhd_end_section (void) |
853 | { |
854 | if (saved_section) |
855 | { |
856 | switch_to_section (saved_section); |
857 | saved_section = NULL; |
858 | } |
859 | } |
860 | |
861 | /* Default implementation of enum_underlying_base_type using type_for_size. */ |
862 | |
863 | tree |
864 | lhd_enum_underlying_base_type (const_tree enum_type) |
865 | { |
866 | return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type), |
867 | TYPE_UNSIGNED (enum_type)); |
868 | } |
869 | |
870 | /* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */ |
871 | |
872 | const char * |
873 | lhd_get_substring_location (const substring_loc &, location_t *) |
874 | { |
875 | return "unimplemented" ; |
876 | } |
877 | |
878 | /* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE. Don't add |
879 | any attributes. */ |
880 | |
881 | int |
882 | lhd_decl_dwarf_attribute (const_tree, int) |
883 | { |
884 | return -1; |
885 | } |
886 | |
887 | /* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE. Don't add |
888 | any attributes. */ |
889 | |
890 | int |
891 | lhd_type_dwarf_attribute (const_tree, int) |
892 | { |
893 | return -1; |
894 | } |
895 | |
896 | /* Default implementation of LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING. |
897 | Just return TYPE_SIZE_UNIT unadjusted. */ |
898 | |
899 | tree |
900 | lhd_unit_size_without_reusable_padding (tree t) |
901 | { |
902 | return TYPE_SIZE_UNIT (t); |
903 | } |
904 | |
905 | /* Default implementation for the finalize_early_debug hook. */ |
906 | |
907 | void |
908 | lhd_finalize_early_debug (void) |
909 | { |
910 | /* Emit early debug for reachable functions, and by consequence, |
911 | locally scoped symbols. */ |
912 | struct cgraph_node *cnode; |
913 | FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode) |
914 | (*debug_hooks->early_global_decl) (cnode->decl); |
915 | } |
916 | |
917 | /* Default implementation of LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE. */ |
918 | |
919 | const char * |
920 | lhd_get_sarif_source_language (const char *) |
921 | { |
922 | return NULL; |
923 | } |
924 | |
925 | /* Returns true if the current lang_hooks represents the GNU C frontend. */ |
926 | |
927 | bool |
928 | lang_GNU_C (void) |
929 | { |
930 | return (startswith (str: lang_hooks.name, prefix: "GNU C" ) |
931 | && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5]))); |
932 | } |
933 | |
934 | /* Returns true if the current lang_hooks represents the GNU C++ frontend. */ |
935 | |
936 | bool |
937 | lang_GNU_CXX (void) |
938 | { |
939 | return startswith (str: lang_hooks.name, prefix: "GNU C++" ); |
940 | } |
941 | |
942 | /* Returns true if the current lang_hooks represents the GNU Fortran frontend. */ |
943 | |
944 | bool |
945 | lang_GNU_Fortran (void) |
946 | { |
947 | return startswith (str: lang_hooks.name, prefix: "GNU Fortran" ); |
948 | } |
949 | |
950 | /* Returns true if the current lang_hooks represents the GNU Objective-C |
951 | frontend. */ |
952 | |
953 | bool |
954 | lang_GNU_OBJC (void) |
955 | { |
956 | return startswith (str: lang_hooks.name, prefix: "GNU Objective-C" ); |
957 | } |
958 | |