]>
Commit | Line | Data |
---|---|---|
1 | /* Default language-specific hooks. | |
2 | Copyright (C) 2001-2021 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.c. */ | |
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 (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 | 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->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 ((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_TYPE_FOR_SIZE. | |
520 | Return an integer type with PRECISION bits of precision, | |
521 | that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ | |
522 | ||
523 | tree | |
524 | lhd_type_for_size (unsigned precision, int unsignedp) | |
525 | { | |
526 | int i; | |
527 | ||
528 | if (precision == TYPE_PRECISION (integer_type_node)) | |
529 | return unsignedp ? unsigned_type_node : integer_type_node; | |
530 | ||
531 | if (precision == TYPE_PRECISION (signed_char_type_node)) | |
532 | return unsignedp ? unsigned_char_type_node : signed_char_type_node; | |
533 | ||
534 | if (precision == TYPE_PRECISION (short_integer_type_node)) | |
535 | return unsignedp ? short_unsigned_type_node : short_integer_type_node; | |
536 | ||
537 | if (precision == TYPE_PRECISION (long_integer_type_node)) | |
538 | return unsignedp ? long_unsigned_type_node : long_integer_type_node; | |
539 | ||
540 | if (precision == TYPE_PRECISION (long_long_integer_type_node)) | |
541 | return unsignedp | |
542 | ? long_long_unsigned_type_node | |
543 | : long_long_integer_type_node; | |
544 | ||
545 | for (i = 0; i < NUM_INT_N_ENTS; i ++) | |
546 | if (int_n_enabled_p[i] | |
547 | && precision == int_n_data[i].bitsize) | |
548 | return (unsignedp ? int_n_trees[i].unsigned_type | |
549 | : int_n_trees[i].signed_type); | |
550 | ||
551 | if (precision <= TYPE_PRECISION (intQI_type_node)) | |
552 | return unsignedp ? unsigned_intQI_type_node : intQI_type_node; | |
553 | ||
554 | if (precision <= TYPE_PRECISION (intHI_type_node)) | |
555 | return unsignedp ? unsigned_intHI_type_node : intHI_type_node; | |
556 | ||
557 | if (precision <= TYPE_PRECISION (intSI_type_node)) | |
558 | return unsignedp ? unsigned_intSI_type_node : intSI_type_node; | |
559 | ||
560 | if (precision <= TYPE_PRECISION (intDI_type_node)) | |
561 | return unsignedp ? unsigned_intDI_type_node : intDI_type_node; | |
562 | ||
563 | if (precision <= TYPE_PRECISION (intTI_type_node)) | |
564 | return unsignedp ? unsigned_intTI_type_node : intTI_type_node; | |
565 | ||
566 | return NULL_TREE; | |
567 | } | |
568 | ||
569 | HOST_WIDE_INT | |
570 | lhd_to_target_charset (HOST_WIDE_INT c) | |
571 | { | |
572 | return c; | |
573 | } | |
574 | ||
575 | tree | |
576 | lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) | |
577 | { | |
578 | return expr; | |
579 | } | |
580 | ||
581 | /* Return sharing kind if OpenMP sharing attribute of DECL is | |
582 | predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ | |
583 | ||
584 | enum omp_clause_default_kind | |
585 | lhd_omp_predetermined_sharing (tree decl) | |
586 | { | |
587 | if (DECL_ARTIFICIAL (decl)) | |
588 | return OMP_CLAUSE_DEFAULT_SHARED; | |
589 | return OMP_CLAUSE_DEFAULT_UNSPECIFIED; | |
590 | } | |
591 | ||
592 | /* Return sharing kind if OpenMP mapping attribute of DECL is | |
593 | predetermined, OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED otherwise. */ | |
594 | ||
595 | enum omp_clause_defaultmap_kind | |
596 | lhd_omp_predetermined_mapping (tree decl) | |
597 | { | |
598 | if (DECL_ARTIFICIAL (decl)) | |
599 | return OMP_CLAUSE_DEFAULTMAP_TO; | |
600 | return OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED; | |
601 | } | |
602 | ||
603 | /* Generate code to copy SRC to DST. */ | |
604 | ||
605 | tree | |
606 | lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) | |
607 | { | |
608 | return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); | |
609 | } | |
610 | ||
611 | /* Finalize clause C. */ | |
612 | ||
613 | void | |
614 | lhd_omp_finish_clause (tree, gimple_seq *, bool) | |
615 | { | |
616 | } | |
617 | ||
618 | /* Return true if DECL is a scalar variable (for the purpose of | |
619 | implicit firstprivatization & mapping). Only if alloc_ptr_ok | |
620 | are allocatables and pointers accepted. */ | |
621 | ||
622 | bool | |
623 | lhd_omp_scalar_p (tree decl, bool ptr_ok) | |
624 | { | |
625 | tree type = TREE_TYPE (decl); | |
626 | if (TREE_CODE (type) == REFERENCE_TYPE) | |
627 | type = TREE_TYPE (type); | |
628 | if (TREE_CODE (type) == COMPLEX_TYPE) | |
629 | type = TREE_TYPE (type); | |
630 | if (INTEGRAL_TYPE_P (type) | |
631 | || SCALAR_FLOAT_TYPE_P (type) | |
632 | || (ptr_ok && TREE_CODE (type) == POINTER_TYPE)) | |
633 | return true; | |
634 | return false; | |
635 | } | |
636 | ||
637 | /* Return static initializer for DECL. */ | |
638 | ||
639 | tree * | |
640 | lhd_omp_get_decl_init (tree decl) | |
641 | { | |
642 | return &DECL_INITIAL (decl); | |
643 | } | |
644 | ||
645 | /* Free any extra memory used to hold initializer information for | |
646 | variable declarations. */ | |
647 | ||
648 | void | |
649 | lhd_omp_finish_decl_inits (void) | |
650 | { | |
651 | } | |
652 | ||
653 | /* Register language specific type size variables as potentially OpenMP | |
654 | firstprivate variables. */ | |
655 | ||
656 | void | |
657 | lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, | |
658 | tree t ATTRIBUTE_UNUSED) | |
659 | { | |
660 | } | |
661 | ||
662 | /* Return true if TYPE is an OpenMP mappable type. */ | |
663 | ||
664 | bool | |
665 | lhd_omp_mappable_type (tree type) | |
666 | { | |
667 | /* Mappable type has to be complete. */ | |
668 | if (type == error_mark_node || !COMPLETE_TYPE_P (type)) | |
669 | return false; | |
670 | return true; | |
671 | } | |
672 | ||
673 | /* Common function for add_builtin_function, add_builtin_function_ext_scope | |
674 | and simulate_builtin_function_decl. */ | |
675 | ||
676 | static tree | |
677 | build_builtin_function (location_t location, const char *name, tree type, | |
678 | int function_code, enum built_in_class cl, | |
679 | const char *library_name, tree attrs) | |
680 | { | |
681 | tree id = get_identifier (name); | |
682 | tree decl = build_decl (location, FUNCTION_DECL, id, type); | |
683 | ||
684 | TREE_PUBLIC (decl) = 1; | |
685 | DECL_EXTERNAL (decl) = 1; | |
686 | ||
687 | set_decl_built_in_function (decl, cl, function_code); | |
688 | ||
689 | if (library_name) | |
690 | { | |
691 | tree libname = get_identifier (library_name); | |
692 | ||
693 | libname = targetm.mangle_decl_assembler_name (decl, libname); | |
694 | SET_DECL_ASSEMBLER_NAME (decl, libname); | |
695 | } | |
696 | ||
697 | /* Possibly apply some default attributes to this built-in function. */ | |
698 | if (attrs) | |
699 | decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); | |
700 | else | |
701 | decl_attributes (&decl, NULL_TREE, 0); | |
702 | ||
703 | return decl; | |
704 | } | |
705 | ||
706 | /* Create a builtin function. */ | |
707 | ||
708 | tree | |
709 | add_builtin_function (const char *name, | |
710 | tree type, | |
711 | int function_code, | |
712 | enum built_in_class cl, | |
713 | const char *library_name, | |
714 | tree attrs) | |
715 | { | |
716 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, | |
717 | function_code, cl, library_name, attrs); | |
718 | return lang_hooks.builtin_function (decl); | |
719 | } | |
720 | ||
721 | /* Like add_builtin_function, but make sure the scope is the external scope. | |
722 | This is used to delay putting in back end builtin functions until the ISA | |
723 | that defines the builtin is declared via function specific target options, | |
724 | which can save memory for machines like the x86_64 that have multiple ISAs. | |
725 | If this points to the same function as builtin_function, the backend must | |
726 | add all of the builtins at program initialization time. */ | |
727 | ||
728 | tree | |
729 | add_builtin_function_ext_scope (const char *name, | |
730 | tree type, | |
731 | int function_code, | |
732 | enum built_in_class cl, | |
733 | const char *library_name, | |
734 | tree attrs) | |
735 | { | |
736 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, | |
737 | function_code, cl, library_name, attrs); | |
738 | return lang_hooks.builtin_function_ext_scope (decl); | |
739 | } | |
740 | ||
741 | /* Simulate a declaration of a target-specific built-in function at | |
742 | location LOCATION, as though it had been declared directly in the | |
743 | source language. NAME is the name of the function, TYPE is its function | |
744 | type, FUNCTION_CODE is the target-specific function code, LIBRARY_NAME | |
745 | is the name of the underlying library function (NULL if none) and | |
746 | ATTRS is a list of function attributes. | |
747 | ||
748 | Return the decl of the declared function. */ | |
749 | ||
750 | tree | |
751 | simulate_builtin_function_decl (location_t location, const char *name, | |
752 | tree type, int function_code, | |
753 | const char *library_name, tree attrs) | |
754 | { | |
755 | tree decl = build_builtin_function (location, name, type, | |
756 | function_code, BUILT_IN_MD, | |
757 | library_name, attrs); | |
758 | tree new_decl = lang_hooks.simulate_builtin_function_decl (decl); | |
759 | ||
760 | /* Give the front end a chance to create a new decl if necessary, | |
761 | but if the front end discards the decl in favour of a conflicting | |
762 | (erroneous) previous definition, return the decl that we tried but | |
763 | failed to add. This allows the caller to process the returned decl | |
764 | normally, even though the source code won't be able to use it. */ | |
765 | if (TREE_CODE (new_decl) == FUNCTION_DECL | |
766 | && fndecl_built_in_p (new_decl, function_code, BUILT_IN_MD)) | |
767 | return new_decl; | |
768 | ||
769 | return decl; | |
770 | } | |
771 | ||
772 | tree | |
773 | lhd_builtin_function (tree decl) | |
774 | { | |
775 | lang_hooks.decls.pushdecl (decl); | |
776 | return decl; | |
777 | } | |
778 | ||
779 | /* Create a builtin type. */ | |
780 | ||
781 | tree | |
782 | add_builtin_type (const char *name, tree type) | |
783 | { | |
784 | tree id = get_identifier (name); | |
785 | tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type); | |
786 | return lang_hooks.decls.pushdecl (decl); | |
787 | } | |
788 | ||
789 | /* LTO hooks. */ | |
790 | ||
791 | /* Used to save and restore any previously active section. */ | |
792 | static section *saved_section; | |
793 | ||
794 | ||
795 | /* Begin a new LTO output section named NAME. This default implementation | |
796 | saves the old section and emits assembly code to switch to the new | |
797 | section. */ | |
798 | ||
799 | void | |
800 | lhd_begin_section (const char *name) | |
801 | { | |
802 | section *section; | |
803 | ||
804 | /* Save the old section so we can restore it in lto_end_asm_section. */ | |
805 | gcc_assert (!saved_section); | |
806 | saved_section = in_section; | |
807 | if (!saved_section) | |
808 | saved_section = text_section; | |
809 | ||
810 | /* Create a new section and switch to it. */ | |
811 | section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL, true); | |
812 | switch_to_section (section); | |
813 | } | |
814 | ||
815 | ||
816 | /* Write DATA of length LEN to the current LTO output section. This default | |
817 | implementation just calls assemble_string. */ | |
818 | ||
819 | void | |
820 | lhd_append_data (const void *data, size_t len, void *) | |
821 | { | |
822 | if (data) | |
823 | { | |
824 | timevar_push (TV_IPA_LTO_OUTPUT); | |
825 | assemble_string ((const char *)data, len); | |
826 | timevar_pop (TV_IPA_LTO_OUTPUT); | |
827 | } | |
828 | } | |
829 | ||
830 | ||
831 | /* Finish the current LTO output section. This default implementation emits | |
832 | assembly code to switch to any section previously saved by | |
833 | lhd_begin_section. */ | |
834 | ||
835 | void | |
836 | lhd_end_section (void) | |
837 | { | |
838 | if (saved_section) | |
839 | { | |
840 | switch_to_section (saved_section); | |
841 | saved_section = NULL; | |
842 | } | |
843 | } | |
844 | ||
845 | /* Default implementation of enum_underlying_base_type using type_for_size. */ | |
846 | ||
847 | tree | |
848 | lhd_enum_underlying_base_type (const_tree enum_type) | |
849 | { | |
850 | return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type), | |
851 | TYPE_UNSIGNED (enum_type)); | |
852 | } | |
853 | ||
854 | /* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */ | |
855 | ||
856 | const char * | |
857 | lhd_get_substring_location (const substring_loc &, location_t *) | |
858 | { | |
859 | return "unimplemented"; | |
860 | } | |
861 | ||
862 | /* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE. Don't add | |
863 | any attributes. */ | |
864 | ||
865 | int | |
866 | lhd_decl_dwarf_attribute (const_tree, int) | |
867 | { | |
868 | return -1; | |
869 | } | |
870 | ||
871 | /* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE. Don't add | |
872 | any attributes. */ | |
873 | ||
874 | int | |
875 | lhd_type_dwarf_attribute (const_tree, int) | |
876 | { | |
877 | return -1; | |
878 | } | |
879 | ||
880 | /* Default implementation of LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING. | |
881 | Just return TYPE_SIZE_UNIT unadjusted. */ | |
882 | ||
883 | tree | |
884 | lhd_unit_size_without_reusable_padding (tree t) | |
885 | { | |
886 | return TYPE_SIZE_UNIT (t); | |
887 | } | |
888 | ||
889 | /* Default implementation for the finalize_early_debug hook. */ | |
890 | ||
891 | void | |
892 | lhd_finalize_early_debug (void) | |
893 | { | |
894 | /* Emit early debug for reachable functions, and by consequence, | |
895 | locally scoped symbols. */ | |
896 | struct cgraph_node *cnode; | |
897 | FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode) | |
898 | (*debug_hooks->early_global_decl) (cnode->decl); | |
899 | } | |
900 | ||
901 | /* Returns true if the current lang_hooks represents the GNU C frontend. */ | |
902 | ||
903 | bool | |
904 | lang_GNU_C (void) | |
905 | { | |
906 | return (startswith (lang_hooks.name, "GNU C") | |
907 | && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5]))); | |
908 | } | |
909 | ||
910 | /* Returns true if the current lang_hooks represents the GNU C++ frontend. */ | |
911 | ||
912 | bool | |
913 | lang_GNU_CXX (void) | |
914 | { | |
915 | return startswith (lang_hooks.name, "GNU C++"); | |
916 | } | |
917 | ||
918 | /* Returns true if the current lang_hooks represents the GNU Fortran frontend. */ | |
919 | ||
920 | bool | |
921 | lang_GNU_Fortran (void) | |
922 | { | |
923 | return startswith (lang_hooks.name, "GNU Fortran"); | |
924 | } | |
925 | ||
926 | /* Returns true if the current lang_hooks represents the GNU Objective-C | |
927 | frontend. */ | |
928 | ||
929 | bool | |
930 | lang_GNU_OBJC (void) | |
931 | { | |
932 | return startswith (lang_hooks.name, "GNU Objective-C"); | |
933 | } |