gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
   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 2, 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 COPYING.  If not, write to
  20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "intl.h"
  27 #include "tm.h"
  28 #include "toplev.h"
  29 #include "tree.h"
  30 #include "tree-inline.h"
  31 #include "tree-gimple.h"
  32 #include "rtl.h"
  33 #include "insn-config.h"
  34 #include "integrate.h"
  35 #include "flags.h"
  36 #include "langhooks.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 the tree node passed).  */
  80
  81 tree
  82 lhd_return_tree (tree t)
  83 {
  84   return t;
  85 }
  86
  87 /* Do nothing (return NULL_TREE).  */
  88
  89 tree
  90 lhd_return_null_tree_v (void)
  91 {
  92   return NULL_TREE;
  93 }
  94
  95 /* Do nothing (return NULL_TREE).  */
  96
  97 tree
  98 lhd_return_null_tree (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 (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_INLINE (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   /* The language-independent code should never use the
 151      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
 152      VAR_DECLs for variables with static storage duration need a real
 153      DECL_ASSEMBLER_NAME.  */
 154   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
 155               || (TREE_CODE (decl) == VAR_DECL
 156                   && (TREE_STATIC (decl)
 157                       || DECL_EXTERNAL (decl)
 158                       || TREE_PUBLIC (decl))));
 159
 160   /* By default, assume the name to use in assembly code is the same
 161      as that used in the source language.  (That's correct for C, and
 162      GCC used to set DECL_ASSEMBLER_NAME to the same value as
 163      DECL_NAME in build_decl, so this choice provides backwards
 164      compatibility with existing front-ends.
 165
 166      Can't use just the variable's own name for a variable whose scope
 167      is less than the whole compilation.  Concatenate a distinguishing
 168      number - we use the DECL_UID.  */
 169   if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
 170     SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 171   else
 172     {
 173       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 174       char *label;
 175
 176       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
 177       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
 178     }
 179 }
 180
 181 /* Type promotion for variable arguments.  */
 182 tree
 183 lhd_type_promotes_to (tree ARG_UNUSED (type))
 184 {
 185   gcc_unreachable ();
 186 }
 187
 188 /* Registration of machine- or os-specific builtin types.  */
 189 void
 190 lhd_register_builtin_type (tree ARG_UNUSED (type),
 191                            const char * ARG_UNUSED (name))
 192 {
 193 }
 194
 195 /* Invalid use of an incomplete type.  */
 196 void
 197 lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
 198 {
 199   gcc_assert (TREE_CODE (type) == ERROR_MARK);
 200   return;
 201 }
 202
 203 /* Provide a default routine for alias sets that always returns -1.  This
 204    is used by languages that don't need to do anything special.  */
 205
 206 HOST_WIDE_INT
 207 lhd_get_alias_set (tree ARG_UNUSED (t))
 208 {
 209   return -1;
 210 }
 211
 212 /* Provide a hook routine for alias sets that always returns 0.  This is
 213    used by languages that haven't deal with alias sets yet.  */
 214
 215 HOST_WIDE_INT
 216 hook_get_alias_set_0 (tree ARG_UNUSED (t))
 217 {
 218   return 0;
 219 }
 220
 221 /* This is the default expand_expr function.  */
 222
 223 rtx
 224 lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
 225                  enum machine_mode ARG_UNUSED (mm),
 226                  int ARG_UNUSED (em),
 227                  rtx * ARG_UNUSED (a))
 228 {
 229   gcc_unreachable ();
 230 }
 231
 232 /* The default language-specific function for expanding a decl.  After
 233    the language-independent cases are handled, this function will be
 234    called.  If this function is not defined, it is assumed that
 235    declarations other than those for variables and labels do not require
 236    any RTL generation.  */
 237
 238 int
 239 lhd_expand_decl (tree ARG_UNUSED (t))
 240 {
 241   return 0;
 242 }
 243
 244 /* This is the default decl_printable_name function.  */
 245
 246 const char *
 247 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 248 {
 249   gcc_assert (decl && DECL_NAME (decl));
 250   return IDENTIFIER_POINTER (DECL_NAME (decl));
 251 }
 252
 253 /* This is the default dwarf_name function.  */
 254
 255 const char *
 256 lhd_dwarf_name (tree t, int verbosity)
 257 {
 258   gcc_assert (DECL_P (t));
 259
 260   return lang_hooks.decl_printable_name (t, verbosity);
 261 }
 262
 263 /* This compares two types for equivalence ("compatible" in C-based languages).
 264    This routine should only return 1 if it is sure.  It should not be used
 265    in contexts where erroneously returning 0 causes problems.  */
 266
 267 int
 268 lhd_types_compatible_p (tree x, tree y)
 269 {
 270   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 271 }
 272
 273 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 274    after handling common cases, but before walking code-specific
 275    sub-trees.  If this hook is overridden for a language, it should
 276    handle language-specific tree codes, as well as language-specific
 277    information associated to common tree codes.  If a tree node is
 278    completely handled within this function, it should set *SUBTREES to
 279    0, so that generic handling isn't attempted.  The generic handling
 280    cannot deal with language-specific tree codes, so make sure it is
 281    set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
 282    nonzero when the function is called.  */
 283
 284 tree
 285 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 286                                  int *subtrees ATTRIBUTE_UNUSED,
 287                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 288                                  void *data ATTRIBUTE_UNUSED,
 289                                  struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 290 {
 291   return NULL_TREE;
 292 }
 293
 294 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 295    determine whether there are language-specific reasons for not
 296    inlining a given function.  */
 297
 298 int
 299 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 300 {
 301   if (flag_really_no_inline
 302       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 303     return 1;
 304
 305   return 0;
 306 }
 307
 308 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 309    determine whether a function should be considered for inlining even
 310    if it would exceed inlining limits.  */
 311
 312 int
 313 lhd_tree_inlining_disregard_inline_limits (tree fn)
 314 {
 315   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 316     return 1;
 317
 318   return 0;
 319 }
 320
 321 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 322    whether VT is an automatic variable defined in function FT.  */
 323
 324 int
 325 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 326 {
 327   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 328           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 329                && ! TREE_STATIC (var))
 330               || TREE_CODE (var) == LABEL_DECL
 331               || TREE_CODE (var) == RESULT_DECL));
 332 }
 333
 334 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 335    language-specific conversion before assigning VALUE to PARM.  */
 336
 337 tree
 338 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 339                                              tree value,
 340                                              tree fndecl ATTRIBUTE_UNUSED,
 341                                              int argnum ATTRIBUTE_UNUSED)
 342 {
 343   return value;
 344 }
 345
 346 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 347    nodes.  Returns nonzero if it does not want the usual dumping of the
 348    second argument.  */
 349
 350 bool
 351 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 352 {
 353   return false;
 354 }
 355
 356 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 357    language-specific way.  */
 358
 359 int
 360 lhd_tree_dump_type_quals (tree t)
 361 {
 362   return TYPE_QUALS (t);
 363 }
 364
 365 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 366    in a language-specific way.  Returns a tree for the size in bytes.  */
 367
 368 tree
 369 lhd_expr_size (tree exp)
 370 {
 371   if (DECL_P (exp)
 372       && DECL_SIZE_UNIT (exp) != 0)
 373     return DECL_SIZE_UNIT (exp);
 374   else
 375     return size_in_bytes (TREE_TYPE (exp));
 376 }
 377
 378 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 379
 380 int
 381 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 382                    tree *post_p ATTRIBUTE_UNUSED)
 383 {
 384   return GS_UNHANDLED;
 385 }
 386
 387 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 388    which is a language-specific tree code in category tcc_constant or
 389    tcc_exceptional.  The default expects never to be called.  */
 390 size_t
 391 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 392 {
 393   gcc_unreachable ();
 394 }
 395
 396 /* Return true if decl, which is a function decl, may be called by a
 397    sibcall.  */
 398
 399 bool
 400 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 401 {
 402   return true;
 403 }
 404
 405 /* Return the COMDAT group into which DECL should be placed.  */
 406
 407 const char *
 408 lhd_comdat_group (tree decl)
 409 {
 410   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 411 }
 412
 413 /* lang_hooks.decls.final_write_globals: perform final processing on
 414    global variables.  */
 415 void
 416 write_global_declarations (void)
 417 {
 418   /* Really define vars that have had only a tentative definition.
 419      Really output inline functions that must actually be callable
 420      and have not been output so far.  */
 421
 422   tree globals = lang_hooks.decls.getdecls ();
 423   int len = list_length (globals);
 424   tree *vec = XNEWVEC (tree, len);
 425   int i;
 426   tree decl;
 427
 428   /* Process the decls in reverse order--earliest first.
 429      Put them into VEC from back to front, then take out from front.  */
 430
 431   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 432     vec[len - i - 1] = decl;
 433
 434   wrapup_global_declarations (vec, len);
 435   check_global_declarations (vec, len);
 436   emit_debug_global_declarations (vec, len);
 437
 438   /* Clean up.  */
 439   free (vec);
 440 }
 441
 442 /* Called to perform language-specific initialization of CTX.  */
 443 void
 444 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 445 {
 446 }
 447
 448 /* The default function to print out name of current function that caused
 449    an error.  */
 450 void
 451 lhd_print_error_function (diagnostic_context *context, const char *file)
 452 {
 453   if (diagnostic_last_function_changed (context))
 454     {
 455       const char *old_prefix = context->printer->prefix;
 456       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 457
 458       pp_set_prefix (context->printer, new_prefix);
 459
 460       if (current_function_decl == NULL)
 461         pp_printf (context->printer, _("At top level:"));
 462       else
 463         {
 464           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 465             pp_printf
 466               (context->printer, _("In member function %qs:"),
 467                lang_hooks.decl_printable_name (current_function_decl, 2));
 468           else
 469             pp_printf
 470               (context->printer, _("In function %qs:"),
 471                lang_hooks.decl_printable_name (current_function_decl, 2));
 472         }
 473
 474       diagnostic_set_last_function (context);
 475       pp_flush (context->printer);
 476       context->printer->prefix = old_prefix;
 477       free ((char*) new_prefix);
 478     }
 479 }
 480
 481 tree
 482 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 483                             int *walk_subtrees ATTRIBUTE_UNUSED,
 484                             tree decl ATTRIBUTE_UNUSED)
 485 {
 486   return NULL;
 487 }
 488
 489 tree
 490 lhd_make_node (enum tree_code code)
 491 {
 492   return make_node (code);
 493 }
 494
 495 HOST_WIDE_INT
 496 lhd_to_target_charset (HOST_WIDE_INT c)
 497 {
 498   return c;
 499 }
 500
 501 tree
 502 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
 503                   bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
 504 {
 505   return expr;
 506 }
 507
 508 /* Return sharing kind if OpenMP sharing attribute of DECL is
 509    predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 510
 511 enum omp_clause_default_kind
 512 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 513 {
 514   if (DECL_ARTIFICIAL (decl))
 515     return OMP_CLAUSE_DEFAULT_SHARED;
 516   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 517 }
 518
 519 /* Generate code to copy SRC to DST.  */
 520
 521 tree
 522 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 523 {
 524   return build_gimple_modify_stmt (dst, src);
 525 }
 526
 527 /* Register language specific type size variables as potentially OpenMP
 528    firstprivate variables.  */
 529
 530 void
 531 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
 532                                    tree t ATTRIBUTE_UNUSED)
 533 {
 534 }
 535
 536 tree
 537 add_builtin_function (const char *name,
 538                       tree type,
 539                       int function_code,
 540                       enum built_in_class cl,
 541                       const char *library_name,
 542                       tree attrs)
 543 {
 544   tree   id = get_identifier (name);
 545   tree decl = build_decl (FUNCTION_DECL, id, type);
 546
 547   TREE_PUBLIC (decl)         = 1;
 548   DECL_EXTERNAL (decl)       = 1;
 549   DECL_BUILT_IN_CLASS (decl) = cl;
 550   DECL_FUNCTION_CODE (decl)  = function_code;
 551
 552   if (library_name)
 553     {
 554       tree libname = get_identifier (library_name);
 555       SET_DECL_ASSEMBLER_NAME (decl, libname);
 556     }
 557
 558   /* Possibly apply some default attributes to this built-in function.  */
 559   if (attrs)
 560     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
 561   else
 562     decl_attributes (&decl, NULL_TREE, 0);
 563
 564   return lang_hooks.builtin_function (decl);
 565
 566 }
 567
 568 tree
 569 lhd_builtin_function (tree decl)
 570 {
 571   lang_hooks.decls.pushdecl (decl);
 572   return decl;
 573 }
 574
 575 /* If TYPE is an integral type, return an equivalent type which is
 576     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
 577     return TYPE itself.  */
 578
 579 tree
 580 get_signed_or_unsigned_type (int unsignedp, tree type)
 581 {
 582   return lang_hooks.types.signed_or_unsigned_type(unsignedp, type);
 583 }
 584
 585 /* Default implementation of the signed_or_unsigned_type language hook */
 586
 587 tree
 588 lhd_signed_or_unsigned_type (int unsignedp, tree type)
 589 {
 590   if (!INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
 591     return type;
 592
 593   return lang_hooks.types.type_for_size (TYPE_PRECISION (type), unsignedp);
 594 }