1/* Default language-specific hooks. 2 Copyright 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 3 Contributed by Alexandre Oliva <aoliva@redhat.com> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to 19the Free Software Foundation, 51 Franklin Street, Fifth Floor, 20Boston, MA 02110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "intl.h" 26#include "tm.h" 27#include "toplev.h" 28#include "tree.h" 29#include "tree-inline.h" 30#include "tree-gimple.h" 31#include "rtl.h" 32#include "insn-config.h" 33#include "integrate.h" 34#include "flags.h" 35#include "langhooks.h" 36#include "langhooks-def.h" 37#include "ggc.h" 38#include "diagnostic.h" 39 40/* Do nothing; in many cases the default hook. */ 41 42void 43lhd_do_nothing (void) 44{ 45} 46 47/* Do nothing (tree). */ 48 49void 50lhd_do_nothing_t (tree ARG_UNUSED (t)) 51{ 52} 53 54/* Do nothing (int). */ 55 56void 57lhd_do_nothing_i (int ARG_UNUSED (i)) 58{ 59} 60 61/* Do nothing (int, int, int). Return NULL_TREE. */ 62 63tree 64lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), 65 int ARG_UNUSED (j), 66 int ARG_UNUSED (k)) 67{ 68 return NULL_TREE; 69} 70 71/* Do nothing (function). */ 72 73void 74lhd_do_nothing_f (struct function * ARG_UNUSED (f)) 75{ 76} 77 78/* Do nothing (return the tree node passed). */ 79 80tree 81lhd_return_tree (tree t) 82{ 83 return t; 84} 85 86/* Do nothing (return NULL_TREE). */ 87 88tree 89lhd_return_null_tree_v (void) 90{ 91 return NULL_TREE; 92} 93 94/* Do nothing (return NULL_TREE). */ 95 96tree 97lhd_return_null_tree (tree ARG_UNUSED (t)) 98{ 99 return NULL_TREE; 100} 101 102/* The default post options hook. */ 103 104bool 105lhd_post_options (const char ** ARG_UNUSED (pfilename)) 106{ 107 return false; 108} 109 110/* Called from by print-tree.c. */ 111 112void 113lhd_print_tree_nothing (FILE * ARG_UNUSED (file), 114 tree ARG_UNUSED (node), 115 int ARG_UNUSED (indent)) 116{ 117} 118 119/* Called from safe_from_p. */ 120 121int 122lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp)) 123{ 124 return 1; 125} 126 127/* Called from staticp. */ 128 129tree 130lhd_staticp (tree ARG_UNUSED (exp)) 131{ 132 return NULL; 133} 134 135/* Called from check_global_declarations. */ 136 137bool 138lhd_warn_unused_global_decl (tree decl) 139{ 140 /* This is what used to exist in check_global_declarations. Probably 141 not many of these actually apply to non-C languages. */ 142 143 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl)) 144 return false; 145 if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)) 146 return false; 147 if (DECL_IN_SYSTEM_HEADER (decl)) 148 return false; 149 150 return true; 151} 152 153/* Set the DECL_ASSEMBLER_NAME for DECL. */ 154void 155lhd_set_decl_assembler_name (tree decl) 156{ 157 /* The language-independent code should never use the 158 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and 159 VAR_DECLs for variables with static storage duration need a real 160 DECL_ASSEMBLER_NAME. */ 161 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 162 || (TREE_CODE (decl) == VAR_DECL 163 && (TREE_STATIC (decl) 164 || DECL_EXTERNAL (decl) 165 || TREE_PUBLIC (decl)))); 166 167 /* By default, assume the name to use in assembly code is the same 168 as that used in the source language. (That's correct for C, and 169 GCC used to set DECL_ASSEMBLER_NAME to the same value as 170 DECL_NAME in build_decl, so this choice provides backwards 171 compatibility with existing front-ends. 172 173 Can't use just the variable's own name for a variable whose scope 174 is less than the whole compilation. Concatenate a distinguishing 175 number - we use the DECL_UID. */ 176 if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE) 177 SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl)); 178 else 179 { 180 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); 181 char *label; 182 183 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl)); 184 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label)); 185 } 186} 187 188/* By default we always allow bit-field based optimizations. */ 189bool 190lhd_can_use_bit_fields_p (void) 191{ 192 return true; 193} 194 195/* Type promotion for variable arguments. */ 196tree 197lhd_type_promotes_to (tree ARG_UNUSED (type)) 198{ 199 gcc_unreachable (); 200} 201 202/* Registration of machine- or os-specific builtin types. */ 203void 204lhd_register_builtin_type (tree ARG_UNUSED (type), 205 const char * ARG_UNUSED (name)) 206{ 207} 208 209/* Invalid use of an incomplete type. */ 210void 211lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type) 212{ 213 gcc_assert (TREE_CODE (type) == ERROR_MARK); 214 return; 215} 216 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. */ 219 220HOST_WIDE_INT 221lhd_get_alias_set (tree ARG_UNUSED (t)) 222{ 223 return -1; 224} 225 226/* Provide a hook routine for alias sets that always returns 0. This is 227 used by languages that haven't deal with alias sets yet. */ 228 229HOST_WIDE_INT 230hook_get_alias_set_0 (tree ARG_UNUSED (t)) 231{ 232 return 0; 233} 234 235/* This is the default expand_expr function. */ 236 237rtx 238lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r), 239 enum machine_mode ARG_UNUSED (mm), 240 int ARG_UNUSED (em), 241 rtx * ARG_UNUSED (a)) 242{ 243 gcc_unreachable (); 244} 245 246/* The default language-specific function for expanding a decl. After 247 the language-independent cases are handled, this function will be 248 called. If this function is not defined, it is assumed that 249 declarations other than those for variables and labels do not require 250 any RTL generation. */ 251 252int 253lhd_expand_decl (tree ARG_UNUSED (t)) 254{ 255 return 0; 256} 257 258/* This is the default decl_printable_name function. */ 259 260const char * 261lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) 262{ 263 gcc_assert (decl && DECL_NAME (decl)); 264 return IDENTIFIER_POINTER (DECL_NAME (decl)); 265} 266 267/* This is the default dwarf_name function. */ 268 269const char * 270lhd_dwarf_name (tree t, int verbosity) 271{ 272 gcc_assert (DECL_P (t)); 273 274 return lang_hooks.decl_printable_name (t, verbosity); 275} 276 277/* This compares two types for equivalence ("compatible" in C-based languages). 278 This routine should only return 1 if it is sure. It should not be used 279 in contexts where erroneously returning 0 causes problems. */ 280 281int 282lhd_types_compatible_p (tree x, tree y) 283{ 284 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); 285} 286 287/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree() 288 after handling common cases, but before walking code-specific 289 sub-trees. If this hook is overridden for a language, it should 290 handle language-specific tree codes, as well as language-specific 291 information associated to common tree codes. If a tree node is 292 completely handled within this function, it should set *SUBTREES to 293 0, so that generic handling isn't attempted. The generic handling 294 cannot deal with language-specific tree codes, so make sure it is 295 set properly. Both SUBTREES and *SUBTREES is guaranteed to be 296 nonzero when the function is called. */ 297 298tree 299lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED, 300 int *subtrees ATTRIBUTE_UNUSED, 301 walk_tree_fn func ATTRIBUTE_UNUSED, 302 void *data ATTRIBUTE_UNUSED, 303 struct pointer_set_t *pset ATTRIBUTE_UNUSED) 304{ 305 return NULL_TREE; 306} 307 308/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to 309 determine whether there are language-specific reasons for not 310 inlining a given function. */ 311 312int 313lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp) 314{ 315 if (flag_really_no_inline 316 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL) 317 return 1; 318 319 return 0; 320} 321 322/* lang_hooks.tree_inlining.disregard_inline_limits is called to 323 determine whether a function should be considered for inlining even 324 if it would exceed inlining limits. */ 325 326int 327lhd_tree_inlining_disregard_inline_limits (tree fn) 328{ 329 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL) 330 return 1; 331 332 return 0; 333} 334 335/* lang_hooks.tree_inlining.add_pending_fn_decls is called before 336 starting to inline a function, to push any language-specific 337 functions that should not be inlined into the current function, 338 into VAFNP. PFN is the top of varray, and should be returned if no 339 functions are pushed into VAFNP. The top of the varray should be 340 returned. */ 341 342tree 343lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn) 344{ 345 return pfn; 346} 347 348/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine 349 whether VT is an automatic variable defined in function FT. */ 350 351int 352lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn) 353{ 354 return (DECL_P (var) && DECL_CONTEXT (var) == fn 355 && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL) 356 && ! TREE_STATIC (var)) 357 || TREE_CODE (var) == LABEL_DECL 358 || TREE_CODE (var) == RESULT_DECL)); 359} 360 361/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a 362 type node representing an anonymous aggregate (union, struct, etc), 363 i.e., one whose members are in the same scope as the union itself. */ 364 365int 366lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED) 367{ 368 return 0; 369} 370 371/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any 372 language-specific bookkeeping necessary for processing 373 FN. start_inlining returns nonzero if inlining should proceed, zero if 374 not. 375 376 For instance, the C++ version keeps track of template instantiations to 377 avoid infinite recursion. */ 378 379int 380lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED) 381{ 382 return 1; 383} 384 385void 386lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED) 387{ 388} 389 390/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any 391 language-specific conversion before assigning VALUE to PARM. */ 392 393tree 394lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED, 395 tree value, 396 tree fndecl ATTRIBUTE_UNUSED, 397 int argnum ATTRIBUTE_UNUSED) 398{ 399 return value; 400} 401 402/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree 403 nodes. Returns nonzero if it does not want the usual dumping of the 404 second argument. */ 405 406bool 407lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) 408{ 409 return false; 410} 411 412/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a 413 language-specific way. */ 414 415int 416lhd_tree_dump_type_quals (tree t) 417{ 418 return TYPE_QUALS (t); 419} 420 421/* lang_hooks.expr_size: Determine the size of the value of an expression T 422 in a language-specific way. Returns a tree for the size in bytes. */ 423 424tree 425lhd_expr_size (tree exp) 426{ 427 if (DECL_P (exp) 428 && DECL_SIZE_UNIT (exp) != 0) 429 return DECL_SIZE_UNIT (exp); 430 else 431 return size_in_bytes (TREE_TYPE (exp)); 432} 433 434/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ 435 436int 437lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED, 438 tree *post_p ATTRIBUTE_UNUSED) 439{ 440 return GS_UNHANDLED; 441} 442 443/* lang_hooks.tree_size: Determine the size of a tree with code C, 444 which is a language-specific tree code in category tcc_constant or 445 tcc_exceptional. The default expects never to be called. */ 446size_t 447lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) 448{ 449 gcc_unreachable (); 450} 451 452/* Return true if decl, which is a function decl, may be called by a 453 sibcall. */ 454 455bool 456lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED) 457{ 458 return true; 459} 460 461/* Return the COMDAT group into which DECL should be placed. */ 462 463const char * 464lhd_comdat_group (tree decl) 465{ 466 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 467} 468 469/* lang_hooks.decls.final_write_globals: perform final processing on 470 global variables. */ 471void 472write_global_declarations (void) 473{ 474 /* Really define vars that have had only a tentative definition. 475 Really output inline functions that must actually be callable 476 and have not been output so far. */ 477 478 tree globals = lang_hooks.decls.getdecls (); 479 int len = list_length (globals); 480 tree *vec = XNEWVEC (tree, len); 481 int i; 482 tree decl; 483 484 /* Process the decls in reverse order--earliest first. 485 Put them into VEC from back to front, then take out from front. */ 486 487 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl)) 488 vec[len - i - 1] = decl; 489 490 wrapup_global_declarations (vec, len); 491 check_global_declarations (vec, len); 492 emit_debug_global_declarations (vec, len); 493 494 /* Clean up. */ 495 free (vec); 496} 497 498/* Called to perform language-specific initialization of CTX. */ 499void 500lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED) 501{ 502} 503 504/* The default function to print out name of current function that caused 505 an error. */ 506void 507lhd_print_error_function (diagnostic_context *context, const char *file) 508{ 509 if (diagnostic_last_function_changed (context)) 510 { 511 const char *old_prefix = context->printer->prefix; 512 char *new_prefix = file ? file_name_as_prefix (file) : NULL; 513 514 pp_set_prefix (context->printer, new_prefix); 515 516 if (current_function_decl == NULL) 517 pp_printf (context->printer, _("At top level:")); 518 else 519 { 520 if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) 521 pp_printf 522 (context->printer, _("In member function %qs:"), 523 lang_hooks.decl_printable_name (current_function_decl, 2)); 524 else 525 pp_printf 526 (context->printer, _("In function %qs:"), 527 lang_hooks.decl_printable_name (current_function_decl, 2)); 528 } 529 530 diagnostic_set_last_function (context); 531 pp_flush (context->printer); 532 context->printer->prefix = old_prefix; 533 free ((char*) new_prefix); 534 } 535} 536 537tree 538lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED, 539 int *walk_subtrees ATTRIBUTE_UNUSED, 540 tree decl ATTRIBUTE_UNUSED) 541{ 542 return NULL; 543} 544 545tree 546lhd_make_node (enum tree_code code) 547{ 548 return make_node (code); 549} 550 551HOST_WIDE_INT 552lhd_to_target_charset (HOST_WIDE_INT c) 553{ 554 return c; 555} 556 557tree 558lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 559 bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) 560{ 561 return expr; 562} 563 564/* Return sharing kind if OpenMP sharing attribute of DECL is 565 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ 566 567enum omp_clause_default_kind 568lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED) 569{ 570 if (DECL_ARTIFICIAL (decl)) 571 return OMP_CLAUSE_DEFAULT_SHARED; 572 return OMP_CLAUSE_DEFAULT_UNSPECIFIED; 573} 574 575/* Generate code to copy SRC to DST. */ 576 577tree 578lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) 579{ 580 return build2 (MODIFY_EXPR, void_type_node, dst, src); 581} 582 583/* Register language specific type size variables as potentially OpenMP 584 firstprivate variables. */ 585 586void 587lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, 588 tree t ATTRIBUTE_UNUSED) 589{ 590} 591