gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Alexandre Oliva  <aoliva@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "toplev.h"
  27 #include "tree.h"
  28 #include "tree-inline.h"
  29 #include "tree-gimple.h"
  30 #include "rtl.h"
  31 #include "insn-config.h"
  32 #include "integrate.h"
  33 #include "flags.h"
  34 #include "langhooks.h"
  35 #include "langhooks-def.h"
  36 #include "ggc.h"
  37 #include "diagnostic.h"
  38
  39 /* Do nothing; in many cases the default hook.  */
  40
  41 void
  42 lhd_do_nothing (void)
  43 {
  44 }
  45
  46 /* Do nothing (tree).  */
  47
  48 void
  49 lhd_do_nothing_t (tree t ATTRIBUTE_UNUSED)
  50 {
  51 }
  52
  53 /* Do nothing (int).  */
  54
  55 void
  56 lhd_do_nothing_i (int i ATTRIBUTE_UNUSED)
  57 {
  58 }
  59
  60 /* Do nothing (int, int, int).  Return NULL_TREE.  */
  61
  62 tree
  63 lhd_do_nothing_iii_return_null_tree (int i ATTRIBUTE_UNUSED,
  64                                      int j ATTRIBUTE_UNUSED,
  65                                      int k ATTRIBUTE_UNUSED)
  66 {
  67   return NULL_TREE;
  68 }
  69
  70 /* Do nothing (function).  */
  71
  72 void
  73 lhd_do_nothing_f (struct function *f ATTRIBUTE_UNUSED)
  74 {
  75 }
  76
  77 /* Do nothing (return the tree node passed).  */
  78
  79 tree
  80 lhd_return_tree (tree t)
  81 {
  82   return t;
  83 }
  84
  85 /* Do nothing (return NULL_TREE).  */
  86
  87 tree
  88 lhd_return_null_tree_v (void)
  89 {
  90   return NULL_TREE;
  91 }
  92
  93 /* Do nothing (return NULL_TREE).  */
  94
  95 tree
  96 lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
  97 {
  98   return NULL_TREE;
  99 }
 100
 101 /* The default post options hook.  */
 102
 103 bool
 104 lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
 105 {
 106   return false;
 107 }
 108
 109 /* Called from by print-tree.c.  */
 110
 111 void
 112 lhd_print_tree_nothing (FILE *file ATTRIBUTE_UNUSED,
 113                         tree node ATTRIBUTE_UNUSED,
 114                         int indent ATTRIBUTE_UNUSED)
 115 {
 116 }
 117
 118 /* Called from safe_from_p.  */
 119
 120 int
 121 lhd_safe_from_p (rtx x ATTRIBUTE_UNUSED, tree exp ATTRIBUTE_UNUSED)
 122 {
 123   return 1;
 124 }
 125
 126 /* Called from unsafe_for_reeval.  */
 127
 128 int
 129 lhd_unsafe_for_reeval (tree t ATTRIBUTE_UNUSED)
 130 {
 131   return -1;
 132 }
 133
 134 /* Called from staticp.  */
 135
 136 int
 137 lhd_staticp (tree exp ATTRIBUTE_UNUSED)
 138 {
 139   return 0;
 140 }
 141
 142 /* Called from check_global_declarations.  */
 143
 144 bool
 145 lhd_warn_unused_global_decl (tree decl)
 146 {
 147   /* This is what used to exist in check_global_declarations.  Probably
 148      not many of these actually apply to non-C languages.  */
 149
 150   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
 151     return false;
 152   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
 153     return false;
 154   if (DECL_IN_SYSTEM_HEADER (decl))
 155     return false;
 156
 157   return true;
 158 }
 159
 160 /* Number for making the label on the next
 161    static variable internal to a function.  */
 162
 163 static GTY(()) int var_labelno;
 164
 165 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 166 void
 167 lhd_set_decl_assembler_name (tree decl)
 168 {
 169   /* The language-independent code should never use the
 170      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
 171      VAR_DECLs for variables with static storage duration need a real
 172      DECL_ASSEMBLER_NAME.  */
 173   if (TREE_CODE (decl) == FUNCTION_DECL
 174       || (TREE_CODE (decl) == VAR_DECL
 175           && (TREE_STATIC (decl)
 176               || DECL_EXTERNAL (decl)
 177               || TREE_PUBLIC (decl))))
 178     {
 179       /* By default, assume the name to use in assembly code is the
 180          same as that used in the source language.  (That's correct
 181          for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
 182          value as DECL_NAME in build_decl, so this choice provides
 183          backwards compatibility with existing front-ends.
 184
 185          Can't use just the variable's own name for a variable whose
 186          scope is less than the whole compilation.  Concatenate a
 187          distinguishing number.  */
 188       if (!TREE_PUBLIC (decl) && DECL_CONTEXT (decl))
 189         {
 190           const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 191           char *label;
 192
 193           ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 194           var_labelno++;
 195           SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
 196         }
 197       else
 198         SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 199     }
 200   else
 201     /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
 202        these DECLs -- unless they're in language-dependent code, in
 203        which case set_decl_assembler_name hook should handle things.  */
 204     abort ();
 205 }
 206
 207 /* By default we always allow bit-field based optimizations.  */
 208 bool
 209 lhd_can_use_bit_fields_p (void)
 210 {
 211   return true;
 212 }
 213
 214 /* Provide a default routine to clear the binding stack.  This is used
 215    by languages that don't need to do anything special.  */
 216 void
 217 lhd_clear_binding_stack (void)
 218 {
 219   while (! lang_hooks.decls.global_bindings_p ())
 220     lang_hooks.decls.poplevel (0, 0, 0);
 221 }
 222
 223 /* Type promotion for variable arguments.  */
 224 tree
 225 lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
 226 {
 227   abort ();
 228 }
 229
 230 /* Registration of machine- or os-specific builtin types.  */
 231 void
 232 lhd_register_builtin_type (tree type ATTRIBUTE_UNUSED,
 233                            const char* name ATTRIBUTE_UNUSED)
 234 {
 235 }
 236
 237 /* Invalid use of an incomplete type.  */
 238 void
 239 lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
 240 {
 241   if (TREE_CODE (type) == ERROR_MARK)
 242     return;
 243
 244   abort ();
 245 }
 246
 247 /* Provide a default routine for alias sets that always returns -1.  This
 248    is used by languages that don't need to do anything special.  */
 249
 250 HOST_WIDE_INT
 251 lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
 252 {
 253   return -1;
 254 }
 255
 256 /* Provide a hook routine for alias sets that always returns 0.  This is
 257    used by languages that haven't deal with alias sets yet.  */
 258
 259 HOST_WIDE_INT
 260 hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
 261 {
 262   return 0;
 263 }
 264
 265 /* This is the default expand_expr function.  */
 266
 267 rtx
 268 lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
 269                  enum machine_mode mm ATTRIBUTE_UNUSED,
 270                  int em ATTRIBUTE_UNUSED,
 271                  rtx *a ATTRIBUTE_UNUSED)
 272 {
 273   abort ();
 274 }
 275
 276 /* This is the default expand_decl function.  */
 277 /* The default language-specific function for expanding a DECL_STMT.  After
 278    the language-independent cases are handled, this function will be
 279    called.  If this function is not defined, it is assumed that
 280    declarations other than those for variables and labels do not require
 281    any RTL generation.  */
 282
 283 int
 284 lhd_expand_decl (tree t ATTRIBUTE_UNUSED)
 285 {
 286   return 0;
 287 }
 288
 289 /* This is the default decl_printable_name function.  */
 290
 291 const char *
 292 lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
 293 {
 294   return IDENTIFIER_POINTER (DECL_NAME (decl));
 295 }
 296
 297 /* This compares two types for equivalence ("compatible" in C-based languages).
 298    This routine should only return 1 if it is sure.  It should not be used
 299    in contexts where erroneously returning 0 causes problems.  */
 300
 301 int
 302 lhd_types_compatible_p (tree x, tree y)
 303 {
 304   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 305 }
 306
 307 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 308    after handling common cases, but before walking code-specific
 309    sub-trees.  If this hook is overridden for a language, it should
 310    handle language-specific tree codes, as well as language-specific
 311    information associated to common tree codes.  If a tree node is
 312    completely handled within this function, it should set *SUBTREES to
 313    0, so that generic handling isn't attempted.  For language-specific
 314    tree codes, generic handling would abort(), so make sure it is set
 315    properly.  Both SUBTREES and *SUBTREES is guaranteed to be nonzero
 316    when the function is called.  */
 317
 318 tree
 319 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 320                                  int *subtrees ATTRIBUTE_UNUSED,
 321                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 322                                  void *data ATTRIBUTE_UNUSED,
 323                                  void *htab ATTRIBUTE_UNUSED)
 324 {
 325   return NULL_TREE;
 326 }
 327
 328 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 329    determine whether there are language-specific reasons for not
 330    inlining a given function.  */
 331
 332 int
 333 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 334 {
 335   if (flag_really_no_inline
 336       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 337     return 1;
 338
 339   return 0;
 340 }
 341
 342 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 343    determine whether a function should be considered for inlining even
 344    if it would exceed inlining limits.  */
 345
 346 int
 347 lhd_tree_inlining_disregard_inline_limits (tree fn)
 348 {
 349   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 350     return 1;
 351
 352   return 0;
 353 }
 354
 355 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 356    starting to inline a function, to push any language-specific
 357    functions that should not be inlined into the current function,
 358    into VAFNP.  PFN is the top of varray, and should be returned if no
 359    functions are pushed into VAFNP.  The top of the varray should be
 360    returned.  */
 361
 362 tree
 363 lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
 364 {
 365   return pfn;
 366 }
 367
 368 /* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
 369    TREE_CHAIN of a language-specific tree node is relevant, i.e.,
 370    whether it should be walked, copied and preserved across copies.  */
 371
 372 int
 373 lhd_tree_inlining_tree_chain_matters_p (tree t ATTRIBUTE_UNUSED)
 374 {
 375   return 0;
 376 }
 377
 378 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 379    whether VT is an automatic variable defined in function FT.  */
 380
 381 int
 382 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 383 {
 384   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 385           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 386                && ! TREE_STATIC (var))
 387               || TREE_CODE (var) == LABEL_DECL
 388               || TREE_CODE (var) == RESULT_DECL));
 389 }
 390
 391 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 392    declaration for the result RES of function FN to be inlined into
 393    CALLER.  NDP points to an integer that should be set in case a new
 394    declaration wasn't created (presumably because RES was of aggregate
 395    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 396    pointer to a varray with the stack of TARGET_EXPRs seen while
 397    inlining functions into caller; the top of TEXPS is supposed to
 398    match RES.  */
 399
 400 tree
 401 lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
 402                                               void *dm ATTRIBUTE_UNUSED,
 403                                               int *ndp ATTRIBUTE_UNUSED,
 404                                               tree return_slot_addr ATTRIBUTE_UNUSED)
 405 {
 406   if (return_slot_addr)
 407     return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
 408                    return_slot_addr);
 409   else
 410     return copy_decl_for_inlining (res, fn, caller);
 411 }
 412
 413 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 414    type node representing an anonymous aggregate (union, struct, etc),
 415    i.e., one whose members are in the same scope as the union itself.  */
 416
 417 int
 418 lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 419 {
 420   return 0;
 421 }
 422
 423 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 424    language-specific bookkeeping necessary for processing
 425    FN. start_inlining returns nonzero if inlining should proceed, zero if
 426    not.
 427
 428    For instance, the C++ version keeps track of template instantiations to
 429    avoid infinite recursion.  */
 430
 431 int
 432 lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 433 {
 434   return 1;
 435 }
 436
 437 void
 438 lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 439 {
 440 }
 441
 442 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 443    language-specific conversion before assigning VALUE to PARM.  */
 444
 445 tree
 446 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 447                                              tree value,
 448                                              tree fndecl ATTRIBUTE_UNUSED,
 449                                              int argnum ATTRIBUTE_UNUSED)
 450 {
 451   return value;
 452 }
 453
 454 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 455    nodes.  Returns nonzero if it does not want the usual dumping of the
 456    second argument.  */
 457
 458 bool
 459 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 460 {
 461   return false;
 462 }
 463
 464 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 465    language-specific way.  */
 466
 467 int
 468 lhd_tree_dump_type_quals (tree t)
 469 {
 470   return TYPE_QUALS (t);
 471 }
 472
 473 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 474    in a language-specific way.  Returns a tree for the size in bytes.  */
 475
 476 tree
 477 lhd_expr_size (tree exp)
 478 {
 479   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
 480       && DECL_SIZE_UNIT (exp) != 0)
 481     return DECL_SIZE_UNIT (exp);
 482   else
 483     return size_in_bytes (TREE_TYPE (exp));
 484 }
 485
 486 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 487
 488 int
 489 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 490                    tree *post_p ATTRIBUTE_UNUSED)
 491 {
 492   return GS_UNHANDLED;
 493 }
 494
 495 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 496    which is a language-specific tree code in category 'x'.  The
 497    default expects never to be called.  */
 498 size_t
 499 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 500 {
 501   abort ();
 502   return 0;
 503 }
 504
 505 /* Return true if decl, which is a function decl, may be called by a
 506    sibcall.  */
 507
 508 bool
 509 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 510 {
 511   return true;
 512 }
 513
 514 /* lang_hooks.decls.final_write_globals: perform final processing on
 515    global variables.  */
 516 void
 517 write_global_declarations (void)
 518 {
 519   /* Really define vars that have had only a tentative definition.
 520      Really output inline functions that must actually be callable
 521      and have not been output so far.  */
 522
 523   tree globals = lang_hooks.decls.getdecls ();
 524   int len = list_length (globals);
 525   tree *vec = xmalloc (sizeof (tree) * len);
 526   int i;
 527   tree decl;
 528
 529   /* Process the decls in reverse order--earliest first.
 530      Put them into VEC from back to front, then take out from front.  */
 531
 532   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 533     vec[len - i - 1] = decl;
 534
 535   wrapup_global_declarations (vec, len);
 536
 537   check_global_declarations (vec, len);
 538
 539     /* Clean up.  */
 540   free (vec);
 541 }
 542
 543 /* Called to perform language-specific initialization of CTX.  */
 544 void
 545 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 546 {
 547 }
 548
 549 /* The default function to print out name of current function that caused
 550    an error.  */
 551 void
 552 lhd_print_error_function (diagnostic_context *context, const char *file)
 553 {
 554   if (diagnostic_last_function_changed (context))
 555     {
 556       const char *old_prefix = context->printer->prefix;
 557       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 558
 559       pp_set_prefix (context->printer, new_prefix);
 560
 561       if (current_function_decl == NULL)
 562         pp_printf (context->printer, "At top level:");
 563       else
 564         {
 565           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 566             pp_printf
 567               (context->printer, "In member function `%s':",
 568                lang_hooks.decl_printable_name (current_function_decl, 2));
 569           else
 570             pp_printf
 571               (context->printer, "In function `%s':",
 572                lang_hooks.decl_printable_name (current_function_decl, 2));
 573         }
 574
 575       diagnostic_set_last_function (context);
 576       pp_flush (context->printer);
 577       context->printer->prefix = old_prefix;
 578       free ((char*) new_prefix);
 579     }
 580 }
 581
 582 tree
 583 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 584                             int *walk_subtrees ATTRIBUTE_UNUSED,
 585                             tree decl ATTRIBUTE_UNUSED)
 586 {
 587   return NULL;
 588 }
 589
 590 tree
 591 lhd_make_node (enum tree_code code)
 592 {
 593   return make_node (code);
 594 }
 595
 596 #include "gt-langhooks.h"