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