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 /* Return true if TYPE is an OpenMP mappable type.  By default return true
 527    if type is complete.  */
 528
 529 bool
 530 lhd_omp_mappable_type (tree type)
 531 {
 532   return COMPLETE_TYPE_P (type);
 533 }
 534
 535 /* Common function for add_builtin_function and
 536    add_builtin_function_ext_scope.  */
 537 static tree
 538 add_builtin_function_common (const char *name,
 539                              tree type,
 540                              int function_code,
 541                              enum built_in_class cl,
 542                              const char *library_name,
 543                              tree attrs,
 544                              tree (*hook) (tree))
 545 {
 546   tree   id = get_identifier (name);
 547   tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, id, type);
 548
 549   TREE_PUBLIC (decl)         = 1;
 550   DECL_EXTERNAL (decl)       = 1;
 551   DECL_BUILT_IN_CLASS (decl) = cl;
 552
 553   DECL_FUNCTION_CODE (decl)  = (enum built_in_function) function_code;
 554
 555   /* DECL_FUNCTION_CODE is a bitfield; verify that the value fits.  */
 556   gcc_assert (DECL_FUNCTION_CODE (decl) == function_code);
 557
 558   if (library_name)
 559     {
 560       tree libname = get_identifier (library_name);
 561       SET_DECL_ASSEMBLER_NAME (decl, libname);
 562     }
 563
 564   /* Possibly apply some default attributes to this built-in function.  */
 565   if (attrs)
 566     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
 567   else
 568     decl_attributes (&decl, NULL_TREE, 0);
 569
 570   return hook (decl);
 571
 572 }
 573
 574 /* Create a builtin function.  */
 575
 576 tree
 577 add_builtin_function (const char *name,
 578                       tree type,
 579                       int function_code,
 580                       enum built_in_class cl,
 581                       const char *library_name,
 582                       tree attrs)
 583 {
 584   return add_builtin_function_common (name, type, function_code, cl,
 585                                       library_name, attrs,
 586                                       lang_hooks.builtin_function);
 587 }
 588
 589 /* Like add_builtin_function, but make sure the scope is the external scope.
 590    This is used to delay putting in back end builtin functions until the ISA
 591    that defines the builtin is declared via function specific target options,
 592    which can save memory for machines like the x86_64 that have multiple ISAs.
 593    If this points to the same function as builtin_function, the backend must
 594    add all of the builtins at program initialization time.  */
 595
 596 tree
 597 add_builtin_function_ext_scope (const char *name,
 598                                 tree type,
 599                                 int function_code,
 600                                 enum built_in_class cl,
 601                                 const char *library_name,
 602                                 tree attrs)
 603 {
 604   return add_builtin_function_common (name, type, function_code, cl,
 605                                       library_name, attrs,
 606                                       lang_hooks.builtin_function_ext_scope);
 607 }
 608
 609 tree
 610 lhd_builtin_function (tree decl)
 611 {
 612   lang_hooks.decls.pushdecl (decl);
 613   return decl;
 614 }
 615
 616 /* Create a builtin type.  */
 617
 618 tree
 619 add_builtin_type (const char *name, tree type)
 620 {
 621   tree   id = get_identifier (name);
 622   tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type);
 623   return lang_hooks.decls.pushdecl (decl);
 624 }
 625
 626 /* LTO hooks.  */
 627
 628 /* Used to save and restore any previously active section.  */
 629 static section *saved_section;
 630
 631
 632 /* Begin a new LTO output section named NAME.  This default implementation
 633    saves the old section and emits assembly code to switch to the new
 634    section.  */
 635
 636 void
 637 lhd_begin_section (const char *name)
 638 {
 639   section *section;
 640
 641   /* Save the old section so we can restore it in lto_end_asm_section.  */
 642   gcc_assert (!saved_section);
 643   saved_section = in_section;
 644   if (!saved_section)
 645     saved_section = text_section;
 646
 647   /* Create a new section and switch to it.  */
 648   section = get_section (name, SECTION_DEBUG, NULL);
 649   switch_to_section (section);
 650 }
 651
 652
 653 /* Write DATA of length LEN to the current LTO output section.  This default
 654    implementation just calls assemble_string and frees BLOCK.  */
 655
 656 void
 657 lhd_append_data (const void *data, size_t len, void *block)
 658 {
 659   if (data)
 660     assemble_string ((const char *)data, len);
 661   free (block);
 662 }
 663
 664
 665 /* Finish the current LTO output section.  This default implementation emits
 666    assembly code to switch to any section previously saved by
 667    lhd_begin_section.  */
 668
 669 void
 670 lhd_end_section (void)
 671 {
 672   if (saved_section)
 673     {
 674       switch_to_section (saved_section);
 675       saved_section = NULL;
 676     }
 677 }
 678
 679 /* Empty function that is replaced with appropriate language dependent
 680    frame cleanup function for _Cilk_spawn.  */
 681
 682 void
 683 lhd_install_body_with_frame_cleanup (tree, tree)
 684 {
 685 }
 686
 687 /* Empty function to handle cilk_valid_spawn.  */
 688 bool
 689 lhd_cilk_detect_spawn (tree *)
 690 {
 691   return false;
 692 }