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