1/* Default language-specific hooks. 2 Copyright 2001, 2002, 2003, 2004, 2005 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 compares two types for equivalence ("compatible" in C-based languages). 268 This routine should only return 1 if it is sure. It should not be used 269 in contexts where erroneously returning 0 causes problems. */ 270 271int 272lhd_types_compatible_p (tree x, tree y) 273{ 274 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); 275} 276 277/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree() 278 after handling common cases, but before walking code-specific 279 sub-trees. If this hook is overridden for a language, it should 280 handle language-specific tree codes, as well as language-specific 281 information associated to common tree codes. If a tree node is 282 completely handled within this function, it should set *SUBTREES to 283 0, so that generic handling isn't attempted. The generic handling 284 cannot deal with language-specific tree codes, so make sure it is 285 set properly. Both SUBTREES and *SUBTREES is guaranteed to be 286 nonzero when the function is called. */ 287 288tree 289lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED, 290 int *subtrees ATTRIBUTE_UNUSED, 291 walk_tree_fn func ATTRIBUTE_UNUSED, 292 void *data ATTRIBUTE_UNUSED, 293 struct pointer_set_t *pset ATTRIBUTE_UNUSED) 294{ 295 return NULL_TREE; 296} 297 298/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to 299 determine whether there are language-specific reasons for not 300 inlining a given function. */ 301 302int 303lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp) 304{ 305 if (flag_really_no_inline 306 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL) 307 return 1; 308 309 return 0; 310} 311 312/* lang_hooks.tree_inlining.disregard_inline_limits is called to 313 determine whether a function should be considered for inlining even 314 if it would exceed inlining limits. */ 315 316int 317lhd_tree_inlining_disregard_inline_limits (tree fn) 318{ 319 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL) 320 return 1; 321 322 return 0; 323} 324 325/* lang_hooks.tree_inlining.add_pending_fn_decls is called before 326 starting to inline a function, to push any language-specific 327 functions that should not be inlined into the current function, 328 into VAFNP. PFN is the top of varray, and should be returned if no 329 functions are pushed into VAFNP. The top of the varray should be 330 returned. */ 331 332tree 333lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn) 334{ 335 return pfn; 336} 337 338/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine 339 whether VT is an automatic variable defined in function FT. */ 340 341int 342lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn) 343{ 344 return (DECL_P (var) && DECL_CONTEXT (var) == fn 345 && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL) 346 && ! TREE_STATIC (var)) 347 || TREE_CODE (var) == LABEL_DECL 348 || TREE_CODE (var) == RESULT_DECL)); 349} 350 351/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a 352 type node representing an anonymous aggregate (union, struct, etc), 353 i.e., one whose members are in the same scope as the union itself. */ 354 355int 356lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED) 357{ 358 return 0; 359} 360 361/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any 362 language-specific bookkeeping necessary for processing 363 FN. start_inlining returns nonzero if inlining should proceed, zero if 364 not. 365 366 For instance, the C++ version keeps track of template instantiations to 367 avoid infinite recursion. */ 368 369int 370lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED) 371{ 372 return 1; 373} 374 375void 376lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED) 377{ 378} 379 380/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any 381 language-specific conversion before assigning VALUE to PARM. */ 382 383tree 384lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED, 385 tree value, 386 tree fndecl ATTRIBUTE_UNUSED, 387 int argnum ATTRIBUTE_UNUSED) 388{ 389 return value; 390} 391 392/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree 393 nodes. Returns nonzero if it does not want the usual dumping of the 394 second argument. */ 395 396bool 397lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) 398{ 399 return false; 400} 401 402/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a 403 language-specific way. */ 404 405int 406lhd_tree_dump_type_quals (tree t) 407{ 408 return TYPE_QUALS (t); 409} 410 411/* lang_hooks.expr_size: Determine the size of the value of an expression T 412 in a language-specific way. Returns a tree for the size in bytes. */ 413 414tree 415lhd_expr_size (tree exp) 416{ 417 if (DECL_P (exp) 418 && DECL_SIZE_UNIT (exp) != 0) 419 return DECL_SIZE_UNIT (exp); 420 else 421 return size_in_bytes (TREE_TYPE (exp)); 422} 423 424/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ 425 426int 427lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED, 428 tree *post_p ATTRIBUTE_UNUSED) 429{ 430 return GS_UNHANDLED; 431} 432 433/* lang_hooks.tree_size: Determine the size of a tree with code C, 434 which is a language-specific tree code in category tcc_constant or 435 tcc_exceptional. The default expects never to be called. */ 436size_t 437lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) 438{ 439 gcc_unreachable (); 440} 441 442/* Return true if decl, which is a function decl, may be called by a 443 sibcall. */ 444 445bool 446lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED) 447{ 448 return true; 449} 450 451/* Return the COMDAT group into which DECL should be placed. */ 452 453const char * 454lhd_comdat_group (tree decl) 455{ 456 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 457} 458 459/* lang_hooks.decls.final_write_globals: perform final processing on 460 global variables. */ 461void 462write_global_declarations (void) 463{ 464 /* Really define vars that have had only a tentative definition. 465 Really output inline functions that must actually be callable 466 and have not been output so far. */ 467 468 tree globals = lang_hooks.decls.getdecls (); 469 int len = list_length (globals); 470 tree *vec = xmalloc (sizeof (tree) * len); 471 int i; 472 tree decl; 473 474 /* Process the decls in reverse order--earliest first. 475 Put them into VEC from back to front, then take out from front. */ 476 477 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl)) 478 vec[len - i - 1] = decl; 479 480 wrapup_global_declarations (vec, len); 481 check_global_declarations (vec, len); 482 emit_debug_global_declarations (vec, len); 483 484 /* Clean up. */ 485 free (vec); 486} 487 488/* Called to perform language-specific initialization of CTX. */ 489void 490lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED) 491{ 492} 493 494/* The default function to print out name of current function that caused 495 an error. */ 496void 497lhd_print_error_function (diagnostic_context *context, const char *file) 498{ 499 if (diagnostic_last_function_changed (context)) 500 { 501 const char *old_prefix = context->printer->prefix; 502 char *new_prefix = file ? file_name_as_prefix (file) : NULL; 503 504 pp_set_prefix (context->printer, new_prefix); 505 506 if (current_function_decl == NULL) 507 pp_printf (context->printer, _("At top level:")); 508 else 509 { 510 if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) 511 pp_printf 512 (context->printer, _("In member function %qs:"), 513 lang_hooks.decl_printable_name (current_function_decl, 2)); 514 else 515 pp_printf 516 (context->printer, _("In function %qs:"), 517 lang_hooks.decl_printable_name (current_function_decl, 2)); 518 } 519 520 diagnostic_set_last_function (context); 521 pp_flush (context->printer); 522 context->printer->prefix = old_prefix; 523 free ((char*) new_prefix); 524 } 525} 526 527tree 528lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED, 529 int *walk_subtrees ATTRIBUTE_UNUSED, 530 tree decl ATTRIBUTE_UNUSED) 531{ 532 return NULL; 533} 534 535tree 536lhd_make_node (enum tree_code code) 537{ 538 return make_node (code); 539} 540 541HOST_WIDE_INT 542lhd_to_target_charset (HOST_WIDE_INT c) 543{ 544 return c; 545} 546 547tree 548lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 549 bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) 550{ 551 return expr; 552} 553