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