1 /* Default language-specific hooks.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "tree-inline.h"
32 #include "insn-config.h"
33 #include "integrate.h"
35 #include "langhooks.h"
37 #include "langhooks-def.h"
39 #include "diagnostic.h"
41 /* Do nothing; in many cases the default hook. */
48 /* Do nothing (tree). */
51 lhd_do_nothing_t (tree ARG_UNUSED (t))
55 /* Pass through (tree). */
57 lhd_pass_through_t (tree t)
62 /* Do nothing (int). */
65 lhd_do_nothing_i (int ARG_UNUSED (i))
69 /* Do nothing (int, int, int). Return NULL_TREE. */
72 lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
79 /* Do nothing (function). */
82 lhd_do_nothing_f (struct function * ARG_UNUSED (f))
86 /* Do nothing (return NULL_TREE). */
89 lhd_return_null_tree_v (void)
94 /* Do nothing (return NULL_TREE). */
97 lhd_return_null_tree (tree ARG_UNUSED (t))
102 /* Do nothing (return NULL_TREE). */
105 lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
110 /* The default post options hook. */
113 lhd_post_options (const char ** ARG_UNUSED (pfilename))
118 /* Called from by print-tree.c. */
121 lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
122 tree ARG_UNUSED (node),
123 int ARG_UNUSED (indent))
127 /* Called from staticp. */
130 lhd_staticp (tree ARG_UNUSED (exp))
135 /* Called from check_global_declarations. */
138 lhd_warn_unused_global_decl (const_tree decl)
140 /* This is what used to exist in check_global_declarations. Probably
141 not many of these actually apply to non-C languages. */
143 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
145 if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
147 if (DECL_IN_SYSTEM_HEADER (decl))
153 /* Set the DECL_ASSEMBLER_NAME for DECL. */
155 lhd_set_decl_assembler_name (tree decl)
159 /* The language-independent code should never use the
160 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
161 VAR_DECLs for variables with static storage duration need a real
162 DECL_ASSEMBLER_NAME. */
163 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
164 || (TREE_CODE (decl) == VAR_DECL
165 && (TREE_STATIC (decl)
166 || DECL_EXTERNAL (decl)
167 || TREE_PUBLIC (decl))));
169 /* By default, assume the name to use in assembly code is the same
170 as that used in the source language. (That's correct for C, and
171 GCC used to set DECL_ASSEMBLER_NAME to the same value as
172 DECL_NAME in build_decl, so this choice provides backwards
173 compatibility with existing front-ends. This assumption is wrapped
174 in a target hook, to allow for target-specific modification of the
177 Can't use just the variable's own name for a variable whose scope
178 is less than the whole compilation. Concatenate a distinguishing
179 number - we use the DECL_UID. */
181 if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
182 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
185 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
188 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
189 id = get_identifier (label);
191 SET_DECL_ASSEMBLER_NAME (decl, id);
195 /* Type promotion for variable arguments. */
197 lhd_type_promotes_to (tree ARG_UNUSED (type))
202 /* Registration of machine- or os-specific builtin types. */
204 lhd_register_builtin_type (tree ARG_UNUSED (type),
205 const char * ARG_UNUSED (name))
209 /* Invalid use of an incomplete type. */
211 lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type)
213 gcc_assert (TREE_CODE (type) == ERROR_MARK);
217 /* Provide a default routine for alias sets that always returns -1. This
218 is used by languages that don't need to do anything special. */
221 lhd_get_alias_set (tree ARG_UNUSED (t))
226 /* This is the default expand_expr function. */
229 lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
230 enum machine_mode ARG_UNUSED (mm),
232 rtx * ARG_UNUSED (a))
237 /* This is the default decl_printable_name function. */
240 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
242 gcc_assert (decl && DECL_NAME (decl));
243 return IDENTIFIER_POINTER (DECL_NAME (decl));
246 /* This is the default dwarf_name function. */
249 lhd_dwarf_name (tree t, int verbosity)
251 gcc_assert (DECL_P (t));
253 return lang_hooks.decl_printable_name (t, verbosity);
256 /* This compares two types for equivalence ("compatible" in C-based languages).
257 This routine should only return 1 if it is sure. It should not be used
258 in contexts where erroneously returning 0 causes problems. */
261 lhd_types_compatible_p (tree x, tree y)
263 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
266 /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
267 nodes. Returns nonzero if it does not want the usual dumping of the
271 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
276 /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
277 language-specific way. */
280 lhd_tree_dump_type_quals (const_tree t)
282 return TYPE_QUALS (t);
285 /* lang_hooks.expr_size: Determine the size of the value of an expression T
286 in a language-specific way. Returns a tree for the size in bytes. */
289 lhd_expr_size (const_tree exp)
292 && DECL_SIZE_UNIT (exp) != 0)
293 return DECL_SIZE_UNIT (exp);
295 return size_in_bytes (TREE_TYPE (exp));
298 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
301 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
302 gimple_seq *pre_p ATTRIBUTE_UNUSED,
303 gimple_seq *post_p ATTRIBUTE_UNUSED)
308 /* lang_hooks.tree_size: Determine the size of a tree with code C,
309 which is a language-specific tree code in category tcc_constant or
310 tcc_exceptional. The default expects never to be called. */
312 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
317 /* Return true if decl, which is a function decl, may be called by a
321 lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
326 /* Return the COMDAT group into which DECL should be placed. */
329 lhd_comdat_group (tree decl)
331 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
334 /* lang_hooks.decls.final_write_globals: perform final processing on
337 write_global_declarations (void)
339 /* Really define vars that have had only a tentative definition.
340 Really output inline functions that must actually be callable
341 and have not been output so far. */
343 tree globals = lang_hooks.decls.getdecls ();
344 int len = list_length (globals);
345 tree *vec = XNEWVEC (tree, len);
349 /* Process the decls in reverse order--earliest first.
350 Put them into VEC from back to front, then take out from front. */
352 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
353 vec[len - i - 1] = decl;
355 wrapup_global_declarations (vec, len);
356 check_global_declarations (vec, len);
357 emit_debug_global_declarations (vec, len);
363 /* Called to perform language-specific initialization of CTX. */
365 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
369 /* The default function to print out name of current function that caused
372 lhd_print_error_function (diagnostic_context *context, const char *file,
373 diagnostic_info *diagnostic)
375 if (diagnostic_last_function_changed (context, diagnostic))
377 const char *old_prefix = context->printer->prefix;
378 tree abstract_origin = diagnostic->abstract_origin;
379 char *new_prefix = (file && abstract_origin == NULL)
380 ? file_name_as_prefix (file) : NULL;
382 pp_set_prefix (context->printer, new_prefix);
384 if (current_function_decl == NULL)
385 pp_printf (context->printer, _("At top level:"));
392 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
393 while (TREE_CODE (ao) == BLOCK
394 && BLOCK_ABSTRACT_ORIGIN (ao)
395 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
396 ao = BLOCK_ABSTRACT_ORIGIN (ao);
397 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
401 fndecl = current_function_decl;
403 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
405 (context->printer, _("In member function %qs"),
406 lang_hooks.decl_printable_name (fndecl, 2));
409 (context->printer, _("In function %qs"),
410 lang_hooks.decl_printable_name (fndecl, 2));
412 while (abstract_origin)
415 tree block = abstract_origin;
417 locus = &BLOCK_SOURCE_LOCATION (block);
419 block = BLOCK_SUPERCONTEXT (block);
420 while (block && TREE_CODE (block) == BLOCK
421 && BLOCK_ABSTRACT_ORIGIN (block))
423 ao = BLOCK_ABSTRACT_ORIGIN (block);
425 while (TREE_CODE (ao) == BLOCK
426 && BLOCK_ABSTRACT_ORIGIN (ao)
427 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
428 ao = BLOCK_ABSTRACT_ORIGIN (ao);
430 if (TREE_CODE (ao) == FUNCTION_DECL)
435 else if (TREE_CODE (ao) != BLOCK)
438 block = BLOCK_SUPERCONTEXT (block);
441 abstract_origin = block;
444 while (block && TREE_CODE (block) == BLOCK)
445 block = BLOCK_SUPERCONTEXT (block);
447 if (block && TREE_CODE (block) == FUNCTION_DECL)
449 abstract_origin = NULL;
453 expanded_location s = expand_location (*locus);
454 pp_character (context->printer, ',');
455 pp_newline (context->printer);
458 if (flag_show_column && s.column != 0)
459 pp_printf (context->printer,
460 _(" inlined from %qs at %s:%d:%d"),
461 lang_hooks.decl_printable_name (fndecl, 2),
462 s.file, s.line, s.column);
464 pp_printf (context->printer,
465 _(" inlined from %qs at %s:%d"),
466 lang_hooks.decl_printable_name (fndecl, 2),
471 pp_printf (context->printer, _(" inlined from %qs"),
472 lang_hooks.decl_printable_name (fndecl, 2));
475 pp_character (context->printer, ':');
478 diagnostic_set_last_function (context, diagnostic);
479 pp_flush (context->printer);
480 context->printer->prefix = old_prefix;
481 free ((char*) new_prefix);
486 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
487 int *walk_subtrees ATTRIBUTE_UNUSED)
493 lhd_make_node (enum tree_code code)
495 return make_node (code);
499 lhd_to_target_charset (HOST_WIDE_INT c)
505 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
510 /* Return sharing kind if OpenMP sharing attribute of DECL is
511 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
513 enum omp_clause_default_kind
514 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
516 if (DECL_ARTIFICIAL (decl))
517 return OMP_CLAUSE_DEFAULT_SHARED;
518 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
521 /* Generate code to copy SRC to DST. */
524 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
526 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
529 /* Register language specific type size variables as potentially OpenMP
530 firstprivate variables. */
533 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
534 tree t ATTRIBUTE_UNUSED)
538 /* Common function for add_builtin_function and
539 add_builtin_function_ext_scope. */
541 add_builtin_function_common (const char *name,
544 enum built_in_class cl,
545 const char *library_name,
549 tree id = get_identifier (name);
550 tree decl = build_decl (FUNCTION_DECL, id, type);
552 TREE_PUBLIC (decl) = 1;
553 DECL_EXTERNAL (decl) = 1;
554 DECL_BUILT_IN_CLASS (decl) = cl;
556 DECL_FUNCTION_CODE (decl) = -1;
557 gcc_assert (DECL_FUNCTION_CODE (decl) >= function_code);
558 DECL_FUNCTION_CODE (decl) = function_code;
562 tree libname = get_identifier (library_name);
563 SET_DECL_ASSEMBLER_NAME (decl, libname);
566 /* Possibly apply some default attributes to this built-in function. */
568 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
570 decl_attributes (&decl, NULL_TREE, 0);
576 /* Create a builtin function. */
579 add_builtin_function (const char *name,
582 enum built_in_class cl,
583 const char *library_name,
586 return add_builtin_function_common (name, type, function_code, cl,
588 lang_hooks.builtin_function);
591 /* Like add_builtin_function, but make sure the scope is the external scope.
592 This is used to delay putting in back end builtin functions until the ISA
593 that defines the builtin is declared via function specific target options,
594 which can save memory for machines like the x86_64 that have multiple ISAs.
595 If this points to the same function as builtin_function, the backend must
596 add all of the builtins at program initialization time. */
599 add_builtin_function_ext_scope (const char *name,
602 enum built_in_class cl,
603 const char *library_name,
606 return add_builtin_function_common (name, type, function_code, cl,
608 lang_hooks.builtin_function_ext_scope);
612 lhd_builtin_function (tree decl)
614 lang_hooks.decls.pushdecl (decl);