gcc/langhooks.c

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