Branch data Line data Source code
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 : 65888 : lhd_do_nothing (void)
46 : : {
47 : 65888 : }
48 : :
49 : : /* Do nothing (tree). */
50 : :
51 : : void
52 : 11791565 : lhd_do_nothing_t (tree ARG_UNUSED (t))
53 : : {
54 : 11791565 : }
55 : :
56 : : /* Pass through (tree). */
57 : : tree
58 : 415 : lhd_pass_through_t (tree t)
59 : : {
60 : 415 : return t;
61 : : }
62 : :
63 : : /* Do nothing (int, int, int). Return NULL_TREE. */
64 : :
65 : : tree
66 : 0 : lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
67 : : int ARG_UNUSED (j),
68 : : int ARG_UNUSED (k))
69 : : {
70 : 0 : return NULL_TREE;
71 : : }
72 : :
73 : : /* Do nothing (function). */
74 : :
75 : : void
76 : 0 : lhd_do_nothing_f (struct function * ARG_UNUSED (f))
77 : : {
78 : 0 : }
79 : :
80 : : /* Do nothing (return NULL_TREE). */
81 : :
82 : : tree
83 : 0 : lhd_return_null_tree (tree ARG_UNUSED (t))
84 : : {
85 : 0 : return NULL_TREE;
86 : : }
87 : :
88 : : /* Do nothing (return NULL_TREE). */
89 : :
90 : : tree
91 : 9154 : lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
92 : : {
93 : 9154 : return NULL_TREE;
94 : : }
95 : :
96 : : /* The default post options hook. */
97 : :
98 : : bool
99 : 1183 : lhd_post_options (const char ** ARG_UNUSED (pfilename))
100 : : {
101 : : /* Excess precision other than "fast" requires front-end
102 : : support. */
103 : 1183 : flag_excess_precision = EXCESS_PRECISION_FAST;
104 : 1183 : return false;
105 : : }
106 : :
107 : : /* Called from by print-tree.cc. */
108 : :
109 : : void
110 : 71 : lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
111 : : tree ARG_UNUSED (node),
112 : : int ARG_UNUSED (indent))
113 : : {
114 : 71 : }
115 : :
116 : : /* Called from check_global_declaration. */
117 : :
118 : : bool
119 : 6 : 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 : 6 : if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
125 : : return false;
126 : 6 : if (VAR_P (decl) && TREE_READONLY (decl))
127 : : return false;
128 : 6 : 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 : 6337130 : lhd_set_decl_assembler_name (tree decl)
137 : : {
138 : 6337130 : 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 : 6337130 : 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 : 6237137 : 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 : 6237137 : if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl))
168 : 6029816 : id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
169 : : else
170 : : {
171 : 207321 : const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
172 : 207321 : static unsigned long num;
173 : 207321 : char *label;
174 : :
175 : 207321 : ASM_FORMAT_PRIVATE_NAME (label, name, num++);
176 : 207321 : id = get_identifier (label);
177 : : }
178 : :
179 : 6237137 : SET_DECL_ASSEMBLER_NAME (decl, id);
180 : : }
181 : :
182 : : /* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME. */
183 : : void
184 : 154325631 : lhd_overwrite_decl_assembler_name (tree decl, tree name)
185 : : {
186 : 154325631 : DECL_ASSEMBLER_NAME_RAW (decl) = name;
187 : 154325631 : }
188 : :
189 : : /* Type promotion for variable arguments. */
190 : : tree
191 : 0 : lhd_type_promotes_to (tree ARG_UNUSED (type))
192 : : {
193 : 0 : gcc_unreachable ();
194 : : }
195 : :
196 : : /* Registration of machine- or os-specific builtin types. */
197 : : void
198 : 118204 : lhd_register_builtin_type (tree ARG_UNUSED (type),
199 : : const char * ARG_UNUSED (name))
200 : : {
201 : 118204 : }
202 : :
203 : : /* Invalid use of an incomplete type. */
204 : : void
205 : 0 : lhd_incomplete_type_error (location_t ARG_UNUSED (loc),
206 : : const_tree ARG_UNUSED (value), const_tree type)
207 : : {
208 : 0 : gcc_assert (TREE_CODE (type) == ERROR_MARK);
209 : 0 : 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 : 994884969 : lhd_get_alias_set (tree ARG_UNUSED (t))
217 : : {
218 : 994884969 : return -1;
219 : : }
220 : :
221 : : /* This is the default decl_printable_name function. */
222 : :
223 : : const char *
224 : 7393953 : lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
225 : : {
226 : 7393953 : gcc_assert (decl && DECL_NAME (decl));
227 : 7393953 : return IDENTIFIER_POINTER (DECL_NAME (decl));
228 : : }
229 : :
230 : : /* This is the default dwarf_name function. */
231 : :
232 : : const char *
233 : 7078920 : lhd_dwarf_name (tree t, int verbosity)
234 : : {
235 : 7078920 : gcc_assert (DECL_P (t));
236 : :
237 : 7078920 : 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 : 0 : lhd_types_compatible_p (tree x, tree y)
246 : : {
247 : 0 : 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 : 0 : lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
256 : : {
257 : 0 : return false;
258 : : }
259 : :
260 : : /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
261 : : language-specific way. */
262 : :
263 : : int
264 : 4 : lhd_tree_dump_type_quals (const_tree t)
265 : : {
266 : 4 : return TYPE_QUALS (t);
267 : : }
268 : :
269 : : /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
270 : :
271 : : int
272 : 67898340 : lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
273 : : gimple_seq *pre_p ATTRIBUTE_UNUSED,
274 : : gimple_seq *post_p ATTRIBUTE_UNUSED)
275 : : {
276 : 67898340 : 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 : 0 : lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
284 : : {
285 : 0 : 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 : 113426 : lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
293 : : {
294 : 113426 : 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 : 29541 : global_decl_processing (void)
303 : : {
304 : 29541 : tree globals, decl, *vec;
305 : 29541 : int len, i;
306 : :
307 : 29541 : timevar_stop (TV_PHASE_PARSING);
308 : 29541 : 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 : 29541 : globals = lang_hooks.decls.getdecls ();
314 : 29541 : len = list_length (globals);
315 : 29541 : 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 : 121524119 : for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl))
321 : 121465037 : vec[len - i - 1] = decl;
322 : :
323 : 29541 : wrapup_global_declarations (vec, len);
324 : 29541 : timevar_stop (TV_PHASE_DEFERRED);
325 : :
326 : 29541 : timevar_start (TV_PHASE_PARSING);
327 : 29541 : free (vec);
328 : 29541 : }
329 : :
330 : : /* Called to perform language-specific initialization of CTX. */
331 : : void
332 : 73800 : lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED)
333 : : {
334 : 73800 : }
335 : :
336 : : /* Called to register dumps. */
337 : : void
338 : 157541 : lhd_register_dumps (gcc::dump_manager *)
339 : : {
340 : 157541 : }
341 : :
342 : : /* Called to perform language-specific options initialization. */
343 : : void
344 : 31270 : lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED,
345 : : struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED)
346 : : {
347 : 31270 : }
348 : :
349 : : /* By default, always complain about options for the wrong language. */
350 : : bool
351 : 6 : lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
352 : : {
353 : 6 : return true;
354 : : }
355 : :
356 : : /* By default, no language-specific options are valid. */
357 : : bool
358 : 0 : 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 : 0 : return false;
366 : : }
367 : :
368 : : /* The default function to print out name of current function that caused
369 : : an error. */
370 : : void
371 : 95175 : lhd_print_error_function (diagnostic_context *context, const char *file,
372 : : const diagnostic_info *diagnostic)
373 : : {
374 : 95175 : if (diagnostic_last_function_changed (context, diagnostic))
375 : : {
376 : 14819 : char *old_prefix = pp_take_prefix (context->printer);
377 : 14819 : tree abstract_origin = diagnostic_abstract_origin (diagnostic);
378 : 14819 : char *new_prefix = (file && abstract_origin == NULL)
379 : 14819 : ? file_name_as_prefix (context, file) : NULL;
380 : :
381 : 14819 : pp_set_prefix (context->printer, new_prefix);
382 : :
383 : 14819 : if (current_function_decl == NULL)
384 : 582 : pp_printf (context->printer, _("At top level:"));
385 : : else
386 : : {
387 : 14237 : tree fndecl, ao;
388 : :
389 : 14237 : if (abstract_origin)
390 : : {
391 : 183 : ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
392 : 183 : gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
393 : : fndecl = ao;
394 : : }
395 : : else
396 : : fndecl = current_function_decl;
397 : :
398 : 14237 : if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
399 : 8 : pp_printf
400 : 8 : (context->printer, _("In member function %qs"),
401 : 8 : identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
402 : : else
403 : 14229 : pp_printf
404 : 14229 : (context->printer, _("In function %qs"),
405 : 14229 : identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
406 : :
407 : 14481 : while (abstract_origin)
408 : : {
409 : 244 : location_t *locus;
410 : 244 : tree block = abstract_origin;
411 : :
412 : 244 : locus = &BLOCK_SOURCE_LOCATION (block);
413 : 244 : fndecl = NULL;
414 : 244 : block = BLOCK_SUPERCONTEXT (block);
415 : 511 : while (block && TREE_CODE (block) == BLOCK
416 : 534 : && BLOCK_ABSTRACT_ORIGIN (block))
417 : : {
418 : 84 : ao = BLOCK_ABSTRACT_ORIGIN (block);
419 : 84 : if (TREE_CODE (ao) == FUNCTION_DECL)
420 : : {
421 : : fndecl = ao;
422 : : break;
423 : : }
424 : 23 : else if (TREE_CODE (ao) != BLOCK)
425 : : break;
426 : :
427 : 23 : block = BLOCK_SUPERCONTEXT (block);
428 : : }
429 : 244 : if (fndecl)
430 : : abstract_origin = block;
431 : : else
432 : : {
433 : 427 : while (block && TREE_CODE (block) == BLOCK)
434 : 244 : block = BLOCK_SUPERCONTEXT (block);
435 : :
436 : 183 : if (block && TREE_CODE (block) == FUNCTION_DECL)
437 : : fndecl = block;
438 : : abstract_origin = NULL;
439 : : }
440 : : if (fndecl)
441 : : {
442 : 244 : expanded_location s = expand_location (*locus);
443 : 244 : pp_comma (context->printer);
444 : 244 : pp_newline (context->printer);
445 : 244 : if (s.file != NULL)
446 : : {
447 : 244 : if (context->m_show_column)
448 : 244 : pp_printf (context->printer,
449 : 244 : _(" inlined from %qs at %r%s:%d:%d%R"),
450 : 244 : identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
451 : : "locus", s.file, s.line, s.column);
452 : : else
453 : 0 : pp_printf (context->printer,
454 : 0 : _(" inlined from %qs at %r%s:%d%R"),
455 : 0 : identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
456 : : "locus", s.file, s.line);
457 : :
458 : : }
459 : : else
460 : 0 : pp_printf (context->printer, _(" inlined from %qs"),
461 : 0 : identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
462 : : }
463 : : }
464 : 14237 : pp_colon (context->printer);
465 : : }
466 : :
467 : 14819 : diagnostic_set_last_function (context, diagnostic);
468 : 14819 : pp_newline_and_flush (context->printer);
469 : 14819 : context->printer->prefix = old_prefix;
470 : 14819 : free ((char*) new_prefix);
471 : : }
472 : 95175 : }
473 : :
474 : : tree
475 : 212501 : lhd_make_node (enum tree_code code)
476 : : {
477 : 212501 : 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 : 0 : lhd_simulate_enum_decl (location_t loc, const char *name,
488 : : vec<string_int_pair> *values_ptr)
489 : : {
490 : 0 : tree enumtype = lang_hooks.types.make_type (ENUMERAL_TYPE);
491 : 0 : tree enumdecl = build_decl (loc, TYPE_DECL, get_identifier (name), enumtype);
492 : 0 : TYPE_STUB_DECL (enumtype) = enumdecl;
493 : :
494 : 0 : tree value_chain = NULL_TREE;
495 : 0 : string_int_pair *value;
496 : 0 : vec<string_int_pair> values = *values_ptr;
497 : 0 : unsigned int i;
498 : 0 : FOR_EACH_VEC_ELT (values, i, value)
499 : : {
500 : 0 : tree value_decl = build_decl (loc, CONST_DECL,
501 : : get_identifier (value->first), enumtype);
502 : 0 : DECL_INITIAL (value_decl) = build_int_cst (integer_type_node,
503 : 0 : value->second);
504 : 0 : lang_hooks.decls.pushdecl (value_decl);
505 : 0 : value_chain = tree_cons (value_decl, DECL_INITIAL (value_decl),
506 : : value_chain);
507 : : }
508 : :
509 : 0 : TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (integer_type_node);
510 : 0 : TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (integer_type_node);
511 : 0 : SET_TYPE_ALIGN (enumtype, TYPE_ALIGN (integer_type_node));
512 : 0 : TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
513 : 0 : layout_type (enumtype);
514 : 0 : lang_hooks.decls.pushdecl (enumdecl);
515 : :
516 : 0 : 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 : 0 : lhd_simulate_record_decl (location_t loc, const char *name,
523 : : array_slice<const tree> fields)
524 : : {
525 : 0 : for (unsigned int i = 1; i < fields.size (); ++i)
526 : : /* Reversed by finish_builtin_struct. */
527 : 0 : DECL_CHAIN (fields[i]) = fields[i - 1];
528 : :
529 : 0 : tree type = lang_hooks.types.make_type (RECORD_TYPE);
530 : 0 : finish_builtin_struct (type, name, fields.back (), NULL_TREE);
531 : :
532 : 0 : tree decl = build_decl (loc, TYPE_DECL, get_identifier (name), type);
533 : 0 : lang_hooks.decls.pushdecl (decl);
534 : :
535 : 0 : 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 : 120606 : lhd_type_for_size (unsigned precision, int unsignedp)
544 : : {
545 : 120606 : int i;
546 : :
547 : 120606 : if (precision == TYPE_PRECISION (integer_type_node))
548 : 24031 : return unsignedp ? unsigned_type_node : integer_type_node;
549 : :
550 : 96575 : if (precision == TYPE_PRECISION (signed_char_type_node))
551 : 23310 : return unsignedp ? unsigned_char_type_node : signed_char_type_node;
552 : :
553 : 73265 : if (precision == TYPE_PRECISION (short_integer_type_node))
554 : 23002 : return unsignedp ? short_unsigned_type_node : short_integer_type_node;
555 : :
556 : 50263 : if (precision == TYPE_PRECISION (long_integer_type_node))
557 : 27439 : return unsignedp ? long_unsigned_type_node : long_integer_type_node;
558 : :
559 : 22824 : if (precision == TYPE_PRECISION (long_long_integer_type_node))
560 : 0 : return unsignedp
561 : 0 : ? long_long_unsigned_type_node
562 : 0 : : long_long_integer_type_node;
563 : :
564 : 22824 : for (i = 0; i < NUM_INT_N_ENTS; i ++)
565 : 22824 : if (int_n_enabled_p[i]
566 : 22824 : && precision == int_n_data[i].bitsize)
567 : 22824 : return (unsignedp ? int_n_trees[i].unsigned_type
568 : 22824 : : int_n_trees[i].signed_type);
569 : :
570 : 0 : if (precision <= TYPE_PRECISION (intQI_type_node))
571 : 0 : return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
572 : :
573 : 0 : if (precision <= TYPE_PRECISION (intHI_type_node))
574 : 0 : return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
575 : :
576 : 0 : if (precision <= TYPE_PRECISION (intSI_type_node))
577 : 0 : return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
578 : :
579 : 0 : if (precision <= TYPE_PRECISION (intDI_type_node))
580 : 0 : return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
581 : :
582 : 0 : if (precision <= TYPE_PRECISION (intTI_type_node))
583 : 0 : return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
584 : :
585 : : return NULL_TREE;
586 : : }
587 : :
588 : : HOST_WIDE_INT
589 : 4247866 : lhd_to_target_charset (HOST_WIDE_INT c)
590 : : {
591 : 4247866 : return c;
592 : : }
593 : :
594 : : tree
595 : 924136654 : lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
596 : : {
597 : 924136654 : 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 : 0 : lhd_omp_predetermined_sharing (tree decl)
605 : : {
606 : 0 : if (DECL_ARTIFICIAL (decl))
607 : 0 : 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 : 0 : lhd_omp_predetermined_mapping (tree decl)
616 : : {
617 : 0 : if (DECL_ARTIFICIAL (decl))
618 : 0 : 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 : 0 : lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
626 : : {
627 : 0 : return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
628 : : }
629 : :
630 : : /* Finalize clause C. */
631 : :
632 : : void
633 : 47927 : lhd_omp_finish_clause (tree, gimple_seq *, bool)
634 : : {
635 : 47927 : }
636 : :
637 : : /* Return array size; cf. omp_array_data. */
638 : :
639 : : tree
640 : 0 : lhd_omp_array_size (tree, gimple_seq *)
641 : : {
642 : 0 : 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 : 12067 : lhd_omp_scalar_p (tree decl, bool ptr_ok)
651 : : {
652 : 12067 : tree type = TREE_TYPE (decl);
653 : 12067 : if (TREE_CODE (type) == REFERENCE_TYPE)
654 : 97 : type = TREE_TYPE (type);
655 : 12067 : if (TREE_CODE (type) == COMPLEX_TYPE)
656 : 0 : type = TREE_TYPE (type);
657 : 12067 : if (INTEGRAL_TYPE_P (type)
658 : 12067 : || SCALAR_FLOAT_TYPE_P (type)
659 : 1179 : || (ptr_ok && TREE_CODE (type) == POINTER_TYPE))
660 : 10908 : return true;
661 : : return false;
662 : : }
663 : :
664 : : /* Return static initializer for DECL. */
665 : :
666 : : tree *
667 : 4102 : lhd_omp_get_decl_init (tree decl)
668 : : {
669 : 4102 : return &DECL_INITIAL (decl);
670 : : }
671 : :
672 : : /* Free any extra memory used to hold initializer information for
673 : : variable declarations. */
674 : :
675 : : void
676 : 4547 : lhd_omp_finish_decl_inits (void)
677 : : {
678 : 4547 : }
679 : :
680 : : /* Register language specific type size variables as potentially OpenMP
681 : : firstprivate variables. */
682 : :
683 : : void
684 : 9971 : lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
685 : : tree t ATTRIBUTE_UNUSED)
686 : : {
687 : 9971 : }
688 : :
689 : : /* Common function for add_builtin_function, add_builtin_function_ext_scope
690 : : and simulate_builtin_function_decl. */
691 : :
692 : : static tree
693 : 751617724 : 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 : 751617724 : tree id = get_identifier (name);
698 : 751617724 : tree decl = build_decl (location, FUNCTION_DECL, id, type);
699 : :
700 : 751617724 : TREE_PUBLIC (decl) = 1;
701 : 751617724 : DECL_EXTERNAL (decl) = 1;
702 : :
703 : 751617724 : set_decl_built_in_function (decl, cl, function_code);
704 : :
705 : 751617724 : if (library_name)
706 : : {
707 : 244473551 : tree libname = get_identifier (library_name);
708 : :
709 : 244473551 : libname = targetm.mangle_decl_assembler_name (decl, libname);
710 : 244473551 : SET_DECL_ASSEMBLER_NAME (decl, libname);
711 : : }
712 : :
713 : : /* Possibly apply some default attributes to this built-in function. */
714 : 751617724 : if (attrs)
715 : 445202026 : decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
716 : : else
717 : 306415698 : decl_attributes (&decl, NULL_TREE, 0);
718 : :
719 : 751617724 : return decl;
720 : : }
721 : :
722 : : /* Create a builtin function. */
723 : :
724 : : tree
725 : 742199973 : 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 : 742199973 : tree decl = build_builtin_function (BUILTINS_LOCATION, name, type,
733 : : function_code, cl, library_name, attrs);
734 : 742199973 : 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 : 9417751 : 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 : 9417751 : tree decl = build_builtin_function (BUILTINS_LOCATION, name, type,
753 : : function_code, cl, library_name, attrs);
754 : 9417751 : 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 : 0 : 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 : 0 : tree decl = build_builtin_function (location, name, type,
772 : : function_code, BUILT_IN_MD,
773 : : library_name, attrs);
774 : 0 : 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 : 0 : if (TREE_CODE (new_decl) == FUNCTION_DECL
782 : 0 : && fndecl_built_in_p (new_decl, function_code, BUILT_IN_MD))
783 : 0 : return new_decl;
784 : :
785 : : return decl;
786 : : }
787 : :
788 : : tree
789 : 0 : lhd_builtin_function (tree decl)
790 : : {
791 : 0 : lang_hooks.decls.pushdecl (decl);
792 : 0 : return decl;
793 : : }
794 : :
795 : : /* Create a builtin type. */
796 : :
797 : : tree
798 : 0 : add_builtin_type (const char *name, tree type)
799 : : {
800 : 0 : tree id = get_identifier (name);
801 : 0 : tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type);
802 : 0 : 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 : 416612 : lhd_begin_section (const char *name)
817 : : {
818 : 416612 : section *section;
819 : :
820 : : /* Save the old section so we can restore it in lto_end_asm_section. */
821 : 416612 : gcc_assert (!saved_section);
822 : 416612 : saved_section = in_section;
823 : 416612 : if (!saved_section)
824 : 21944 : saved_section = text_section;
825 : :
826 : : /* Create a new section and switch to it. */
827 : 416612 : section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL, true);
828 : 416612 : switch_to_section (section);
829 : 416612 : }
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 : 4689404 : lhd_append_data (const void *data, size_t len, void *)
837 : : {
838 : 4689404 : if (data)
839 : : {
840 : 4689404 : timevar_push (TV_IPA_LTO_OUTPUT);
841 : 4689404 : assemble_string ((const char *)data, len);
842 : 4689404 : timevar_pop (TV_IPA_LTO_OUTPUT);
843 : : }
844 : 4689404 : }
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 : 416612 : lhd_end_section (void)
853 : : {
854 : 416612 : if (saved_section)
855 : : {
856 : 416612 : switch_to_section (saved_section);
857 : 416612 : saved_section = NULL;
858 : : }
859 : 416612 : }
860 : :
861 : : /* Default implementation of enum_underlying_base_type using type_for_size. */
862 : :
863 : : tree
864 : 82182 : lhd_enum_underlying_base_type (const_tree enum_type)
865 : : {
866 : 82182 : return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type),
867 : 82182 : TYPE_UNSIGNED (enum_type));
868 : : }
869 : :
870 : : /* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */
871 : :
872 : : const char *
873 : 530 : lhd_get_substring_location (const substring_loc &, location_t *)
874 : : {
875 : 530 : return "unimplemented";
876 : : }
877 : :
878 : : /* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE. Don't add
879 : : any attributes. */
880 : :
881 : : int
882 : 5922268 : lhd_decl_dwarf_attribute (const_tree, int)
883 : : {
884 : 5922268 : return -1;
885 : : }
886 : :
887 : : /* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE. Don't add
888 : : any attributes. */
889 : :
890 : : int
891 : 113806 : lhd_type_dwarf_attribute (const_tree, int)
892 : : {
893 : 113806 : 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 : 7436 : lhd_unit_size_without_reusable_padding (tree t)
901 : : {
902 : 7436 : return TYPE_SIZE_UNIT (t);
903 : : }
904 : :
905 : : /* Default implementation for the finalize_early_debug hook. */
906 : :
907 : : void
908 : 48246 : lhd_finalize_early_debug (void)
909 : : {
910 : : /* Emit early debug for reachable functions, and by consequence,
911 : : locally scoped symbols. */
912 : 48246 : struct cgraph_node *cnode;
913 : 535768 : FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode)
914 : 487522 : (*debug_hooks->early_global_decl) (cnode->decl);
915 : 48246 : }
916 : :
917 : : /* Default implementation of LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE. */
918 : :
919 : : const char *
920 : 0 : lhd_get_sarif_source_language (const char *)
921 : : {
922 : 0 : return NULL;
923 : : }
924 : :
925 : : /* Returns true if the current lang_hooks represents the GNU C frontend. */
926 : :
927 : : bool
928 : 514594 : lang_GNU_C (void)
929 : : {
930 : 514594 : return (startswith (lang_hooks.name, "GNU C")
931 : 514594 : && (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 : 16855 : lang_GNU_CXX (void)
938 : : {
939 : 16855 : return startswith (lang_hooks.name, "GNU C++");
940 : : }
941 : :
942 : : /* Returns true if the current lang_hooks represents the GNU Fortran frontend. */
943 : :
944 : : bool
945 : 204377 : lang_GNU_Fortran (void)
946 : : {
947 : 204377 : return startswith (lang_hooks.name, "GNU Fortran");
948 : : }
949 : :
950 : : /* Returns true if the current lang_hooks represents the GNU Objective-C
951 : : frontend. */
952 : :
953 : : bool
954 : 124031 : lang_GNU_OBJC (void)
955 : : {
956 : 124031 : return startswith (lang_hooks.name, "GNU Objective-C");
957 : : }
|
