1 /* Default language-specific hooks. 2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 Contributed by Alexandre Oliva <aoliva@redhat.com> 5 6 This file is part of GCC. 7 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) 11 any later version. 12 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. 17 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/>. */ 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 "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 "target.h" 37 #include "langhooks-def.h" 38 #include "ggc.h" 39 #include "diagnostic.h" 40 #include "tree-diagnostic.h" 41 #include "cgraph.h" 42 #include "output.h" 43 44 /* Do nothing; in many cases the default hook. */ 45 46 void 47 lhd_do_nothing (void) 48 { 49 } 50 51 /* Do nothing (tree). */ 52 53 void 54 lhd_do_nothing_t (tree ARG_UNUSED (t)) 55 { 56 } 57 58 /* Pass through (tree). */ 59 tree 60 lhd_pass_through_t (tree t) 61 { 62 return t; 63 } 64 65 /* Do nothing (int, int, int). Return NULL_TREE. */ 66 67 tree 68 lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), 69 int ARG_UNUSED (j), 70 int ARG_UNUSED (k)) 71 { 72 return NULL_TREE; 73 } 74 75 /* Do nothing (function). */ 76 77 void 78 lhd_do_nothing_f (struct function * ARG_UNUSED (f)) 79 { 80 } 81 82 /* Do nothing (return NULL_TREE). */ 83 84 tree 85 lhd_return_null_tree_v (void) 86 { 87 return NULL_TREE; 88 } 89 90 /* Do nothing (return NULL_TREE). */ 91 92 tree 93 lhd_return_null_tree (tree ARG_UNUSED (t)) 94 { 95 return NULL_TREE; 96 } 97 98 /* Do nothing (return NULL_TREE). */ 99 100 tree 101 lhd_return_null_const_tree (const_tree ARG_UNUSED (t)) 102 { 103 return NULL_TREE; 104 } 105 106 /* The default post options hook. */ 107 108 bool 109 lhd_post_options (const char ** ARG_UNUSED (pfilename)) 110 { 111 /* Excess precision other than "fast" requires front-end 112 support. */ 113 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; 114 return false; 115 } 116 117 /* Called from by print-tree.c. */ 118 119 void 120 lhd_print_tree_nothing (FILE * ARG_UNUSED (file), 121 tree ARG_UNUSED (node), 122 int ARG_UNUSED (indent)) 123 { 124 } 125 126 /* Called from check_global_declarations. */ 127 128 bool 129 lhd_warn_unused_global_decl (const_tree decl) 130 { 131 /* This is what used to exist in check_global_declarations. Probably 132 not many of these actually apply to non-C languages. */ 133 134 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) 135 return false; 136 if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)) 137 return false; 138 if (DECL_IN_SYSTEM_HEADER (decl)) 139 return false; 140 141 return true; 142 } 143 144 /* Set the DECL_ASSEMBLER_NAME for DECL. */ 145 void 146 lhd_set_decl_assembler_name (tree decl) 147 { 148 tree id; 149 150 /* The language-independent code should never use the 151 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and 152 VAR_DECLs for variables with static storage duration need a real 153 DECL_ASSEMBLER_NAME. */ 154 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 155 || (TREE_CODE (decl) == VAR_DECL 156 && (TREE_STATIC (decl) 157 || DECL_EXTERNAL (decl) 158 || TREE_PUBLIC (decl)))); 159 160 /* By default, assume the name to use in assembly code is the same 161 as that used in the source language. (That's correct for C, and 162 GCC used to set DECL_ASSEMBLER_NAME to the same value as 163 DECL_NAME in build_decl, so this choice provides backwards 164 compatibility with existing front-ends. This assumption is wrapped 165 in a target hook, to allow for target-specific modification of the 166 identifier. 167 168 Can't use just the variable's own name for a variable whose scope 169 is less than the whole compilation. Concatenate a distinguishing 170 number - we use the DECL_UID. */ 171 172 if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl)) 173 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl)); 174 else 175 { 176 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); 177 char *label; 178 179 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl)); 180 id = get_identifier (label); 181 } 182 SET_DECL_ASSEMBLER_NAME (decl, id); 183 184 } 185 186 /* Type promotion for variable arguments. */ 187 tree 188 lhd_type_promotes_to (tree ARG_UNUSED (type)) 189 { 190 gcc_unreachable (); 191 } 192 193 /* Registration of machine- or os-specific builtin types. */ 194 void 195 lhd_register_builtin_type (tree ARG_UNUSED (type), 196 const char * ARG_UNUSED (name)) 197 { 198 } 199 200 /* Invalid use of an incomplete type. */ 201 void 202 lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type) 203 { 204 gcc_assert (TREE_CODE (type) == ERROR_MARK); 205 return; 206 } 207 208 /* Provide a default routine for alias sets that always returns -1. This 209 is used by languages that don't need to do anything special. */ 210 211 alias_set_type 212 lhd_get_alias_set (tree ARG_UNUSED (t)) 213 { 214 return -1; 215 } 216 217 /* This is the default decl_printable_name function. */ 218 219 const char * 220 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) 221 { 222 gcc_assert (decl && DECL_NAME (decl)); 223 return IDENTIFIER_POINTER (DECL_NAME (decl)); 224 } 225 226 /* This is the default dwarf_name function. */ 227 228 const char * 229 lhd_dwarf_name (tree t, int verbosity) 230 { 231 gcc_assert (DECL_P (t)); 232 233 return lang_hooks.decl_printable_name (t, verbosity); 234 } 235 236 /* This compares two types for equivalence ("compatible" in C-based languages). 237 This routine should only return 1 if it is sure. It should not be used 238 in contexts where erroneously returning 0 causes problems. */ 239 240 int 241 lhd_types_compatible_p (tree x, tree y) 242 { 243 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); 244 } 245 246 /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree 247 nodes. Returns nonzero if it does not want the usual dumping of the 248 second argument. */ 249 250 bool 251 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) 252 { 253 return false; 254 } 255 256 /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a 257 language-specific way. */ 258 259 int 260 lhd_tree_dump_type_quals (const_tree t) 261 { 262 return TYPE_QUALS (t); 263 } 264 265 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ 266 267 int 268 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, 269 gimple_seq *pre_p ATTRIBUTE_UNUSED, 270 gimple_seq *post_p ATTRIBUTE_UNUSED) 271 { 272 return GS_UNHANDLED; 273 } 274 275 /* lang_hooks.tree_size: Determine the size of a tree with code C, 276 which is a language-specific tree code in category tcc_constant or 277 tcc_exceptional. The default expects never to be called. */ 278 size_t 279 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) 280 { 281 gcc_unreachable (); 282 } 283 284 /* Return true if decl, which is a function decl, may be called by a 285 sibcall. */ 286 287 bool 288 lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) 289 { 290 return true; 291 } 292 293 /* lang_hooks.decls.final_write_globals: perform final processing on 294 global variables. */ 295 void 296 write_global_declarations (void) 297 { 298 tree globals, decl, *vec; 299 int len, i; 300 301 /* This lang hook is dual-purposed, and also finalizes the 302 compilation unit. */ 303 cgraph_finalize_compilation_unit (); 304 305 /* Really define vars that have had only a tentative definition. 306 Really output inline functions that must actually be callable 307 and have not been output so far. */ 308 309 globals = lang_hooks.decls.getdecls (); 310 len = list_length (globals); 311 vec = XNEWVEC (tree, len); 312 313 /* Process the decls in reverse order--earliest first. 314 Put them into VEC from back to front, then take out from front. */ 315 316 for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl)) 317 vec[len - i - 1] = decl; 318 319 wrapup_global_declarations (vec, len); 320 check_global_declarations (vec, len); 321 emit_debug_global_declarations (vec, len); 322 323 /* Clean up. */ 324 free (vec); 325 } 326 327 /* Called to perform language-specific initialization of CTX. */ 328 void 329 lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED) 330 { 331 } 332 333 /* Called to perform language-specific options initialization. */ 334 void 335 lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED, 336 struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED) 337 { 338 } 339 340 /* By default, always complain about options for the wrong language. */ 341 bool 342 lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED) 343 { 344 return true; 345 } 346 347 /* By default, no language-specific options are valid. */ 348 bool 349 lhd_handle_option (size_t code ATTRIBUTE_UNUSED, 350 const char *arg ATTRIBUTE_UNUSED, 351 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED, 352 location_t loc ATTRIBUTE_UNUSED, 353 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED) 354 { 355 return false; 356 } 357 358 /* The default function to print out name of current function that caused 359 an error. */ 360 void 361 lhd_print_error_function (diagnostic_context *context, const char *file, 362 diagnostic_info *diagnostic) 363 { 364 if (diagnostic_last_function_changed (context, diagnostic)) 365 { 366 const char *old_prefix = context->printer->prefix; 367 tree abstract_origin = diagnostic_abstract_origin (diagnostic); 368 char *new_prefix = (file && abstract_origin == NULL) 369 ? file_name_as_prefix (file) : NULL; 370 371 pp_set_prefix (context->printer, new_prefix); 372 373 if (current_function_decl == NULL) 374 pp_printf (context->printer, _("At top level:")); 375 else 376 { 377 tree fndecl, ao; 378 379 if (abstract_origin) 380 { 381 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); 382 while (TREE_CODE (ao) == BLOCK 383 && BLOCK_ABSTRACT_ORIGIN (ao) 384 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 385 ao = BLOCK_ABSTRACT_ORIGIN (ao); 386 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); 387 fndecl = ao; 388 } 389 else 390 fndecl = current_function_decl; 391 392 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) 393 pp_printf 394 (context->printer, _("In member function %qs"), 395 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 396 else 397 pp_printf 398 (context->printer, _("In function %qs"), 399 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 400 401 while (abstract_origin) 402 { 403 location_t *locus; 404 tree block = abstract_origin; 405 406 locus = &BLOCK_SOURCE_LOCATION (block); 407 fndecl = NULL; 408 block = BLOCK_SUPERCONTEXT (block); 409 while (block && TREE_CODE (block) == BLOCK 410 && BLOCK_ABSTRACT_ORIGIN (block)) 411 { 412 ao = BLOCK_ABSTRACT_ORIGIN (block); 413 414 while (TREE_CODE (ao) == BLOCK 415 && BLOCK_ABSTRACT_ORIGIN (ao) 416 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 417 ao = BLOCK_ABSTRACT_ORIGIN (ao); 418 419 if (TREE_CODE (ao) == FUNCTION_DECL) 420 { 421 fndecl = ao; 422 break; 423 } 424 else if (TREE_CODE (ao) != BLOCK) 425 break; 426 427 block = BLOCK_SUPERCONTEXT (block); 428 } 429 if (fndecl) 430 abstract_origin = block; 431 else 432 { 433 while (block && TREE_CODE (block) == BLOCK) 434 block = BLOCK_SUPERCONTEXT (block); 435 436 if (block && TREE_CODE (block) == FUNCTION_DECL) 437 fndecl = block; 438 abstract_origin = NULL; 439 } 440 if (fndecl) 441 { 442 expanded_location s = expand_location (*locus); 443 pp_character (context->printer, ','); 444 pp_newline (context->printer); 445 if (s.file != NULL) 446 { 447 if (context->show_column) 448 pp_printf (context->printer, 449 _(" inlined from %qs at %s:%d:%d"), 450 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), 451 s.file, s.line, s.column); 452 else 453 pp_printf (context->printer, 454 _(" inlined from %qs at %s:%d"), 455 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), 456 s.file, s.line); 457 458 } 459 else 460 pp_printf (context->printer, _(" inlined from %qs"), 461 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 462 } 463 } 464 pp_character (context->printer, ':'); 465 } 466 467 diagnostic_set_last_function (context, diagnostic); 468 pp_flush (context->printer); 469 context->printer->prefix = old_prefix; 470 free ((char*) new_prefix); 471 } 472 } 473 474 tree 475 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED, 476 int *walk_subtrees ATTRIBUTE_UNUSED) 477 { 478 return NULL; 479 } 480 481 tree 482 lhd_make_node (enum tree_code code) 483 { 484 return make_node (code); 485 } 486 487 HOST_WIDE_INT 488 lhd_to_target_charset (HOST_WIDE_INT c) 489 { 490 return c; 491 } 492 493 tree 494 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) 495 { 496 return expr; 497 } 498 499 /* Return sharing kind if OpenMP sharing attribute of DECL is 500 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ 501 502 enum omp_clause_default_kind 503 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED) 504 { 505 if (DECL_ARTIFICIAL (decl)) 506 return OMP_CLAUSE_DEFAULT_SHARED; 507 return OMP_CLAUSE_DEFAULT_UNSPECIFIED; 508 } 509 510 /* Generate code to copy SRC to DST. */ 511 512 tree 513 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) 514 { 515 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); 516 } 517 518 /* Register language specific type size variables as potentially OpenMP 519 firstprivate variables. */ 520 521 void 522 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, 523 tree t ATTRIBUTE_UNUSED) 524 { 525 } 526 527 /* Common function for add_builtin_function and 528 add_builtin_function_ext_scope. */ 529 static tree 530 add_builtin_function_common (const char *name, 531 tree type, 532 int function_code, 533 enum built_in_class cl, 534 const char *library_name, 535 tree attrs, 536 tree (*hook) (tree)) 537 { 538 tree id = get_identifier (name); 539 tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, id, type); 540 541 TREE_PUBLIC (decl) = 1; 542 DECL_EXTERNAL (decl) = 1; 543 DECL_BUILT_IN_CLASS (decl) = cl; 544 545 DECL_FUNCTION_CODE (decl) = (enum built_in_function) function_code; 546 547 /* DECL_FUNCTION_CODE is a bitfield; verify that the value fits. */ 548 gcc_assert (DECL_FUNCTION_CODE (decl) == function_code); 549 550 if (library_name) 551 { 552 tree libname = get_identifier (library_name); 553 SET_DECL_ASSEMBLER_NAME (decl, libname); 554 } 555 556 /* Possibly apply some default attributes to this built-in function. */ 557 if (attrs) 558 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); 559 else 560 decl_attributes (&decl, NULL_TREE, 0); 561 562 return hook (decl); 563 564 } 565 566 /* Create a builtin function. */ 567 568 tree 569 add_builtin_function (const char *name, 570 tree type, 571 int function_code, 572 enum built_in_class cl, 573 const char *library_name, 574 tree attrs) 575 { 576 return add_builtin_function_common (name, type, function_code, cl, 577 library_name, attrs, 578 lang_hooks.builtin_function); 579 } 580 581 /* Like add_builtin_function, but make sure the scope is the external scope. 582 This is used to delay putting in back end builtin functions until the ISA 583 that defines the builtin is declared via function specific target options, 584 which can save memory for machines like the x86_64 that have multiple ISAs. 585 If this points to the same function as builtin_function, the backend must 586 add all of the builtins at program initialization time. */ 587 588 tree 589 add_builtin_function_ext_scope (const char *name, 590 tree type, 591 int function_code, 592 enum built_in_class cl, 593 const char *library_name, 594 tree attrs) 595 { 596 return add_builtin_function_common (name, type, function_code, cl, 597 library_name, attrs, 598 lang_hooks.builtin_function_ext_scope); 599 } 600 601 tree 602 lhd_builtin_function (tree decl) 603 { 604 lang_hooks.decls.pushdecl (decl); 605 return decl; 606 } 607 608 /* LTO hooks. */ 609 610 /* Used to save and restore any previously active section. */ 611 static section *saved_section; 612 613 614 /* Begin a new LTO output section named NAME. This default implementation 615 saves the old section and emits assembly code to switch to the new 616 section. */ 617 618 void 619 lhd_begin_section (const char *name) 620 { 621 section *section; 622 623 /* Save the old section so we can restore it in lto_end_asm_section. */ 624 gcc_assert (!saved_section); 625 saved_section = in_section; 626 if (!saved_section) 627 saved_section = text_section; 628 629 /* Create a new section and switch to it. */ 630 section = get_section (name, SECTION_DEBUG, NULL); 631 switch_to_section (section); 632 } 633 634 635 /* Write DATA of length LEN to the current LTO output section. This default 636 implementation just calls assemble_string and frees BLOCK. */ 637 638 void 639 lhd_append_data (const void *data, size_t len, void *block) 640 { 641 if (data) 642 assemble_string ((const char *)data, len); 643 free (block); 644 } 645 646 647 /* Finish the current LTO output section. This default implementation emits 648 assembly code to switch to any section previously saved by 649 lhd_begin_section. */ 650 651 void 652 lhd_end_section (void) 653 { 654 if (saved_section) 655 { 656 switch_to_section (saved_section); 657 saved_section = NULL; 658 } 659 } 660