gcc/langhooks.c

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