gcc/langhooks.c

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