* gcc.dg/store-motion-fgcse-sm.c (dg-final): Cleanup
[official-gcc.git] / gcc / langhooks.c
blobe24dabbb2e0fd9189a0092d4e2697e3f6498198e
1 /* Default language-specific hooks.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
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.
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.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "intl.h"
25 #include "tm.h"
26 #include "toplev.h"
27 #include "tree.h"
28 #include "stringpool.h"
29 #include "attribs.h"
30 #include "tree-inline.h"
31 #include "gimplify.h"
32 #include "rtl.h"
33 #include "insn-config.h"
34 #include "flags.h"
35 #include "langhooks.h"
36 #include "target.h"
37 #include "langhooks-def.h"
38 #include "diagnostic.h"
39 #include "tree-diagnostic.h"
40 #include "hash-map.h"
41 #include "is-a.h"
42 #include "plugin-api.h"
43 #include "vec.h"
44 #include "hashtab.h"
45 #include "hash-set.h"
46 #include "machmode.h"
47 #include "hard-reg-set.h"
48 #include "input.h"
49 #include "function.h"
50 #include "ipa-ref.h"
51 #include "cgraph.h"
52 #include "timevar.h"
53 #include "output.h"
55 /* Do nothing; in many cases the default hook. */
57 void
58 lhd_do_nothing (void)
62 /* Do nothing (tree). */
64 void
65 lhd_do_nothing_t (tree ARG_UNUSED (t))
69 /* Pass through (tree). */
70 tree
71 lhd_pass_through_t (tree t)
73 return t;
76 /* Do nothing (int, int, int). Return NULL_TREE. */
78 tree
79 lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
80 int ARG_UNUSED (j),
81 int ARG_UNUSED (k))
83 return NULL_TREE;
86 /* Do nothing (function). */
88 void
89 lhd_do_nothing_f (struct function * ARG_UNUSED (f))
93 /* Do nothing (return NULL_TREE). */
95 tree
96 lhd_return_null_tree_v (void)
98 return NULL_TREE;
101 /* Do nothing (return NULL_TREE). */
103 tree
104 lhd_return_null_tree (tree ARG_UNUSED (t))
106 return NULL_TREE;
109 /* Do nothing (return NULL_TREE). */
111 tree
112 lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
114 return NULL_TREE;
117 /* The default post options hook. */
119 bool
120 lhd_post_options (const char ** ARG_UNUSED (pfilename))
122 /* Excess precision other than "fast" requires front-end
123 support. */
124 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
125 return false;
128 /* Called from by print-tree.c. */
130 void
131 lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
132 tree ARG_UNUSED (node),
133 int ARG_UNUSED (indent))
137 /* Called from check_global_declarations. */
139 bool
140 lhd_warn_unused_global_decl (const_tree decl)
142 /* This is what used to exist in check_global_declarations. Probably
143 not many of these actually apply to non-C languages. */
145 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
146 return false;
147 if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
148 return false;
149 if (DECL_IN_SYSTEM_HEADER (decl))
150 return false;
152 return true;
155 /* Set the DECL_ASSEMBLER_NAME for DECL. */
156 void
157 lhd_set_decl_assembler_name (tree decl)
159 tree id;
161 /* set_decl_assembler_name may be called on TYPE_DECL to record ODR
162 name for C++ types. By default types have no ODR names. */
163 if (TREE_CODE (decl) == TYPE_DECL)
164 return;
166 /* The language-independent code should never use the
167 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
168 VAR_DECLs for variables with static storage duration need a real
169 DECL_ASSEMBLER_NAME. */
170 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
171 || (TREE_CODE (decl) == VAR_DECL
172 && (TREE_STATIC (decl)
173 || DECL_EXTERNAL (decl)
174 || TREE_PUBLIC (decl))));
176 /* By default, assume the name to use in assembly code is the same
177 as that used in the source language. (That's correct for C, and
178 GCC used to set DECL_ASSEMBLER_NAME to the same value as
179 DECL_NAME in build_decl, so this choice provides backwards
180 compatibility with existing front-ends. This assumption is wrapped
181 in a target hook, to allow for target-specific modification of the
182 identifier.
184 Can't use just the variable's own name for a variable whose scope
185 is less than the whole compilation. Concatenate a distinguishing
186 number - we use the DECL_UID. */
188 if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl))
189 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
190 else
192 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
193 char *label;
195 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
196 id = get_identifier (label);
198 SET_DECL_ASSEMBLER_NAME (decl, id);
202 /* Type promotion for variable arguments. */
203 tree
204 lhd_type_promotes_to (tree ARG_UNUSED (type))
206 gcc_unreachable ();
209 /* Registration of machine- or os-specific builtin types. */
210 void
211 lhd_register_builtin_type (tree ARG_UNUSED (type),
212 const char * ARG_UNUSED (name))
216 /* Invalid use of an incomplete type. */
217 void
218 lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type)
220 gcc_assert (TREE_CODE (type) == ERROR_MARK);
221 return;
224 /* Provide a default routine for alias sets that always returns -1. This
225 is used by languages that don't need to do anything special. */
227 alias_set_type
228 lhd_get_alias_set (tree ARG_UNUSED (t))
230 return -1;
233 /* This is the default decl_printable_name function. */
235 const char *
236 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
238 gcc_assert (decl && DECL_NAME (decl));
239 return IDENTIFIER_POINTER (DECL_NAME (decl));
242 /* This is the default dwarf_name function. */
244 const char *
245 lhd_dwarf_name (tree t, int verbosity)
247 gcc_assert (DECL_P (t));
249 return lang_hooks.decl_printable_name (t, verbosity);
252 /* This compares two types for equivalence ("compatible" in C-based languages).
253 This routine should only return 1 if it is sure. It should not be used
254 in contexts where erroneously returning 0 causes problems. */
257 lhd_types_compatible_p (tree x, tree y)
259 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
262 /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
263 nodes. Returns nonzero if it does not want the usual dumping of the
264 second argument. */
266 bool
267 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
269 return false;
272 /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
273 language-specific way. */
276 lhd_tree_dump_type_quals (const_tree t)
278 return TYPE_QUALS (t);
281 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
284 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
285 gimple_seq *pre_p ATTRIBUTE_UNUSED,
286 gimple_seq *post_p ATTRIBUTE_UNUSED)
288 return GS_UNHANDLED;
291 /* lang_hooks.tree_size: Determine the size of a tree with code C,
292 which is a language-specific tree code in category tcc_constant or
293 tcc_exceptional. The default expects never to be called. */
294 size_t
295 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
297 gcc_unreachable ();
300 /* Return true if decl, which is a function decl, may be called by a
301 sibcall. */
303 bool
304 lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
306 return true;
309 /* lang_hooks.decls.final_write_globals: perform final processing on
310 global variables. */
311 void
312 write_global_declarations (void)
314 tree globals, decl, *vec;
315 int len, i;
317 timevar_start (TV_PHASE_DEFERRED);
318 /* Really define vars that have had only a tentative definition.
319 Really output inline functions that must actually be callable
320 and have not been output so far. */
322 globals = lang_hooks.decls.getdecls ();
323 len = list_length (globals);
324 vec = XNEWVEC (tree, len);
326 /* Process the decls in reverse order--earliest first.
327 Put them into VEC from back to front, then take out from front. */
329 for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl))
330 vec[len - i - 1] = decl;
332 wrapup_global_declarations (vec, len);
333 check_global_declarations (vec, len);
334 timevar_stop (TV_PHASE_DEFERRED);
336 timevar_start (TV_PHASE_OPT_GEN);
337 /* This lang hook is dual-purposed, and also finalizes the
338 compilation unit. */
339 symtab->finalize_compilation_unit ();
340 timevar_stop (TV_PHASE_OPT_GEN);
342 timevar_start (TV_PHASE_DBGINFO);
343 emit_debug_global_declarations (vec, len);
344 timevar_stop (TV_PHASE_DBGINFO);
346 /* Clean up. */
347 free (vec);
350 /* Called to perform language-specific initialization of CTX. */
351 void
352 lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED)
356 /* Called to perform language-specific options initialization. */
357 void
358 lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED,
359 struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED)
363 /* By default, always complain about options for the wrong language. */
364 bool
365 lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
367 return true;
370 /* By default, no language-specific options are valid. */
371 bool
372 lhd_handle_option (size_t code ATTRIBUTE_UNUSED,
373 const char *arg ATTRIBUTE_UNUSED,
374 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
375 location_t loc ATTRIBUTE_UNUSED,
376 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
378 return false;
381 /* The default function to print out name of current function that caused
382 an error. */
383 void
384 lhd_print_error_function (diagnostic_context *context, const char *file,
385 diagnostic_info *diagnostic)
387 if (diagnostic_last_function_changed (context, diagnostic))
389 const char *old_prefix = context->printer->prefix;
390 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
391 char *new_prefix = (file && abstract_origin == NULL)
392 ? file_name_as_prefix (context, file) : NULL;
394 pp_set_prefix (context->printer, new_prefix);
396 if (current_function_decl == NULL)
397 pp_printf (context->printer, _("At top level:"));
398 else
400 tree fndecl, ao;
402 if (abstract_origin)
404 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
405 while (TREE_CODE (ao) == BLOCK
406 && BLOCK_ABSTRACT_ORIGIN (ao)
407 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
408 ao = BLOCK_ABSTRACT_ORIGIN (ao);
409 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
410 fndecl = ao;
412 else
413 fndecl = current_function_decl;
415 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
416 pp_printf
417 (context->printer, _("In member function %qs"),
418 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
419 else
420 pp_printf
421 (context->printer, _("In function %qs"),
422 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
424 while (abstract_origin)
426 location_t *locus;
427 tree block = abstract_origin;
429 locus = &BLOCK_SOURCE_LOCATION (block);
430 fndecl = NULL;
431 block = BLOCK_SUPERCONTEXT (block);
432 while (block && TREE_CODE (block) == BLOCK
433 && BLOCK_ABSTRACT_ORIGIN (block))
435 ao = BLOCK_ABSTRACT_ORIGIN (block);
437 while (TREE_CODE (ao) == BLOCK
438 && BLOCK_ABSTRACT_ORIGIN (ao)
439 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
440 ao = BLOCK_ABSTRACT_ORIGIN (ao);
442 if (TREE_CODE (ao) == FUNCTION_DECL)
444 fndecl = ao;
445 break;
447 else if (TREE_CODE (ao) != BLOCK)
448 break;
450 block = BLOCK_SUPERCONTEXT (block);
452 if (fndecl)
453 abstract_origin = block;
454 else
456 while (block && TREE_CODE (block) == BLOCK)
457 block = BLOCK_SUPERCONTEXT (block);
459 if (block && TREE_CODE (block) == FUNCTION_DECL)
460 fndecl = block;
461 abstract_origin = NULL;
463 if (fndecl)
465 expanded_location s = expand_location (*locus);
466 pp_comma (context->printer);
467 pp_newline (context->printer);
468 if (s.file != NULL)
470 if (context->show_column)
471 pp_printf (context->printer,
472 _(" inlined from %qs at %r%s:%d:%d%R"),
473 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
474 "locus", s.file, s.line, s.column);
475 else
476 pp_printf (context->printer,
477 _(" inlined from %qs at %r%s:%d%R"),
478 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)),
479 "locus", s.file, s.line);
482 else
483 pp_printf (context->printer, _(" inlined from %qs"),
484 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
487 pp_colon (context->printer);
490 diagnostic_set_last_function (context, diagnostic);
491 pp_newline_and_flush (context->printer);
492 context->printer->prefix = old_prefix;
493 free ((char*) new_prefix);
497 tree
498 lhd_make_node (enum tree_code code)
500 return make_node (code);
503 HOST_WIDE_INT
504 lhd_to_target_charset (HOST_WIDE_INT c)
506 return c;
509 tree
510 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
512 return expr;
515 /* Return sharing kind if OpenMP sharing attribute of DECL is
516 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
518 enum omp_clause_default_kind
519 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
521 if (DECL_ARTIFICIAL (decl))
522 return OMP_CLAUSE_DEFAULT_SHARED;
523 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
526 /* Generate code to copy SRC to DST. */
528 tree
529 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
531 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
534 /* Finalize clause C. */
536 void
537 lhd_omp_finish_clause (tree, gimple_seq *)
541 /* Register language specific type size variables as potentially OpenMP
542 firstprivate variables. */
544 void
545 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
546 tree t ATTRIBUTE_UNUSED)
550 /* Return true if TYPE is an OpenMP mappable type. */
552 bool
553 lhd_omp_mappable_type (tree type)
555 /* Mappable type has to be complete. */
556 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
557 return false;
558 return true;
561 /* Common function for add_builtin_function and
562 add_builtin_function_ext_scope. */
563 static tree
564 add_builtin_function_common (const char *name,
565 tree type,
566 int function_code,
567 enum built_in_class cl,
568 const char *library_name,
569 tree attrs,
570 tree (*hook) (tree))
572 tree id = get_identifier (name);
573 tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, id, type);
575 TREE_PUBLIC (decl) = 1;
576 DECL_EXTERNAL (decl) = 1;
577 DECL_BUILT_IN_CLASS (decl) = cl;
579 DECL_FUNCTION_CODE (decl) = (enum built_in_function) function_code;
581 /* DECL_FUNCTION_CODE is a bitfield; verify that the value fits. */
582 gcc_assert (DECL_FUNCTION_CODE (decl) == function_code);
584 if (library_name)
586 tree libname = get_identifier (library_name);
587 SET_DECL_ASSEMBLER_NAME (decl, libname);
590 /* Possibly apply some default attributes to this built-in function. */
591 if (attrs)
592 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
593 else
594 decl_attributes (&decl, NULL_TREE, 0);
596 return hook (decl);
600 /* Create a builtin function. */
602 tree
603 add_builtin_function (const char *name,
604 tree type,
605 int function_code,
606 enum built_in_class cl,
607 const char *library_name,
608 tree attrs)
610 return add_builtin_function_common (name, type, function_code, cl,
611 library_name, attrs,
612 lang_hooks.builtin_function);
615 /* Like add_builtin_function, but make sure the scope is the external scope.
616 This is used to delay putting in back end builtin functions until the ISA
617 that defines the builtin is declared via function specific target options,
618 which can save memory for machines like the x86_64 that have multiple ISAs.
619 If this points to the same function as builtin_function, the backend must
620 add all of the builtins at program initialization time. */
622 tree
623 add_builtin_function_ext_scope (const char *name,
624 tree type,
625 int function_code,
626 enum built_in_class cl,
627 const char *library_name,
628 tree attrs)
630 return add_builtin_function_common (name, type, function_code, cl,
631 library_name, attrs,
632 lang_hooks.builtin_function_ext_scope);
635 tree
636 lhd_builtin_function (tree decl)
638 lang_hooks.decls.pushdecl (decl);
639 return decl;
642 /* Create a builtin type. */
644 tree
645 add_builtin_type (const char *name, tree type)
647 tree id = get_identifier (name);
648 tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type);
649 return lang_hooks.decls.pushdecl (decl);
652 /* LTO hooks. */
654 /* Used to save and restore any previously active section. */
655 static section *saved_section;
658 /* Begin a new LTO output section named NAME. This default implementation
659 saves the old section and emits assembly code to switch to the new
660 section. */
662 void
663 lhd_begin_section (const char *name)
665 section *section;
667 /* Save the old section so we can restore it in lto_end_asm_section. */
668 gcc_assert (!saved_section);
669 saved_section = in_section;
670 if (!saved_section)
671 saved_section = text_section;
673 /* Create a new section and switch to it. */
674 section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL);
675 switch_to_section (section);
679 /* Write DATA of length LEN to the current LTO output section. This default
680 implementation just calls assemble_string. */
682 void
683 lhd_append_data (const void *data, size_t len, void *)
685 if (data)
686 assemble_string ((const char *)data, len);
690 /* Finish the current LTO output section. This default implementation emits
691 assembly code to switch to any section previously saved by
692 lhd_begin_section. */
694 void
695 lhd_end_section (void)
697 if (saved_section)
699 switch_to_section (saved_section);
700 saved_section = NULL;
704 /* Default implementation of enum_underlying_base_type using type_for_size. */
706 tree
707 lhd_enum_underlying_base_type (const_tree enum_type)
709 return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type),
710 TYPE_UNSIGNED (enum_type));
713 /* Returns true if the current lang_hooks represents the GNU C frontend. */
715 bool
716 lang_GNU_C (void)
718 return (strncmp (lang_hooks.name, "GNU C", 5) == 0
719 && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5])));
722 /* Returns true if the current lang_hooks represents the GNU C++ frontend. */
724 bool
725 lang_GNU_CXX (void)
727 return strncmp (lang_hooks.name, "GNU C++", 7) == 0;