gcc/langhooks.c

   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 }