gcc/langhooks.c

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