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