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 /* The default language-specific function for expanding a decl.  After
 277    the language-independent cases are handled, this function will be
 278    called.  If this function is not defined, it is assumed that
 279    declarations other than those for variables and labels do not require
 280    any RTL generation.  */
 281
 282 int
 283 lhd_expand_decl (tree t ATTRIBUTE_UNUSED)
 284 {
 285   return 0;
 286 }
 287
 288 /* This is the default decl_printable_name function.  */
 289
 290 const char *
 291 lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
 292 {
 293   return IDENTIFIER_POINTER (DECL_NAME (decl));
 294 }
 295
 296 /* This compares two types for equivalence ("compatible" in C-based languages).
 297    This routine should only return 1 if it is sure.  It should not be used
 298    in contexts where erroneously returning 0 causes problems.  */
 299
 300 int
 301 lhd_types_compatible_p (tree x, tree y)
 302 {
 303   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 304 }
 305
 306 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 307    after handling common cases, but before walking code-specific
 308    sub-trees.  If this hook is overridden for a language, it should
 309    handle language-specific tree codes, as well as language-specific
 310    information associated to common tree codes.  If a tree node is
 311    completely handled within this function, it should set *SUBTREES to
 312    0, so that generic handling isn't attempted.  For language-specific
 313    tree codes, generic handling would abort(), so make sure it is set
 314    properly.  Both SUBTREES and *SUBTREES is guaranteed to be nonzero
 315    when the function is called.  */
 316
 317 tree
 318 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 319                                  int *subtrees ATTRIBUTE_UNUSED,
 320                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 321                                  void *data ATTRIBUTE_UNUSED,
 322                                  void *htab ATTRIBUTE_UNUSED)
 323 {
 324   return NULL_TREE;
 325 }
 326
 327 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 328    determine whether there are language-specific reasons for not
 329    inlining a given function.  */
 330
 331 int
 332 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 333 {
 334   if (flag_really_no_inline
 335       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 336     return 1;
 337
 338   return 0;
 339 }
 340
 341 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 342    determine whether a function should be considered for inlining even
 343    if it would exceed inlining limits.  */
 344
 345 int
 346 lhd_tree_inlining_disregard_inline_limits (tree fn)
 347 {
 348   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 349     return 1;
 350
 351   return 0;
 352 }
 353
 354 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 355    starting to inline a function, to push any language-specific
 356    functions that should not be inlined into the current function,
 357    into VAFNP.  PFN is the top of varray, and should be returned if no
 358    functions are pushed into VAFNP.  The top of the varray should be
 359    returned.  */
 360
 361 tree
 362 lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
 363 {
 364   return pfn;
 365 }
 366
 367 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 368    whether VT is an automatic variable defined in function FT.  */
 369
 370 int
 371 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 372 {
 373   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 374           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 375                && ! TREE_STATIC (var))
 376               || TREE_CODE (var) == LABEL_DECL
 377               || TREE_CODE (var) == RESULT_DECL));
 378 }
 379
 380 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 381    declaration for the result RES of function FN to be inlined into
 382    CALLER.  NDP points to an integer that should be set in case a new
 383    declaration wasn't created (presumably because RES was of aggregate
 384    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 385    pointer to a varray with the stack of TARGET_EXPRs seen while
 386    inlining functions into caller; the top of TEXPS is supposed to
 387    match RES.  */
 388
 389 tree
 390 lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
 391                                               void *dm ATTRIBUTE_UNUSED,
 392                                               int *ndp ATTRIBUTE_UNUSED,
 393                                               tree return_slot_addr ATTRIBUTE_UNUSED)
 394 {
 395   if (return_slot_addr)
 396     return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
 397                    return_slot_addr);
 398   else
 399     return copy_decl_for_inlining (res, fn, caller);
 400 }
 401
 402 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 403    type node representing an anonymous aggregate (union, struct, etc),
 404    i.e., one whose members are in the same scope as the union itself.  */
 405
 406 int
 407 lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 408 {
 409   return 0;
 410 }
 411
 412 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 413    language-specific bookkeeping necessary for processing
 414    FN. start_inlining returns nonzero if inlining should proceed, zero if
 415    not.
 416
 417    For instance, the C++ version keeps track of template instantiations to
 418    avoid infinite recursion.  */
 419
 420 int
 421 lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 422 {
 423   return 1;
 424 }
 425
 426 void
 427 lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 428 {
 429 }
 430
 431 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 432    language-specific conversion before assigning VALUE to PARM.  */
 433
 434 tree
 435 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 436                                              tree value,
 437                                              tree fndecl ATTRIBUTE_UNUSED,
 438                                              int argnum ATTRIBUTE_UNUSED)
 439 {
 440   return value;
 441 }
 442
 443 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 444    nodes.  Returns nonzero if it does not want the usual dumping of the
 445    second argument.  */
 446
 447 bool
 448 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 449 {
 450   return false;
 451 }
 452
 453 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 454    language-specific way.  */
 455
 456 int
 457 lhd_tree_dump_type_quals (tree t)
 458 {
 459   return TYPE_QUALS (t);
 460 }
 461
 462 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 463    in a language-specific way.  Returns a tree for the size in bytes.  */
 464
 465 tree
 466 lhd_expr_size (tree exp)
 467 {
 468   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
 469       && DECL_SIZE_UNIT (exp) != 0)
 470     return DECL_SIZE_UNIT (exp);
 471   else
 472     return size_in_bytes (TREE_TYPE (exp));
 473 }
 474
 475 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 476
 477 int
 478 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 479                    tree *post_p ATTRIBUTE_UNUSED)
 480 {
 481   return GS_UNHANDLED;
 482 }
 483
 484 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 485    which is a language-specific tree code in category 'x'.  The
 486    default expects never to be called.  */
 487 size_t
 488 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 489 {
 490   abort ();
 491   return 0;
 492 }
 493
 494 /* Return true if decl, which is a function decl, may be called by a
 495    sibcall.  */
 496
 497 bool
 498 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 499 {
 500   return true;
 501 }
 502
 503 /* lang_hooks.decls.final_write_globals: perform final processing on
 504    global variables.  */
 505 void
 506 write_global_declarations (void)
 507 {
 508   /* Really define vars that have had only a tentative definition.
 509      Really output inline functions that must actually be callable
 510      and have not been output so far.  */
 511
 512   tree globals = lang_hooks.decls.getdecls ();
 513   int len = list_length (globals);
 514   tree *vec = xmalloc (sizeof (tree) * len);
 515   int i;
 516   tree decl;
 517
 518   /* Process the decls in reverse order--earliest first.
 519      Put them into VEC from back to front, then take out from front.  */
 520
 521   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 522     vec[len - i - 1] = decl;
 523
 524   wrapup_global_declarations (vec, len);
 525
 526   check_global_declarations (vec, len);
 527
 528     /* Clean up.  */
 529   free (vec);
 530 }
 531
 532 /* Called to perform language-specific initialization of CTX.  */
 533 void
 534 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 535 {
 536 }
 537
 538 /* The default function to print out name of current function that caused
 539    an error.  */
 540 void
 541 lhd_print_error_function (diagnostic_context *context, const char *file)
 542 {
 543   if (diagnostic_last_function_changed (context))
 544     {
 545       const char *old_prefix = context->printer->prefix;
 546       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 547
 548       pp_set_prefix (context->printer, new_prefix);
 549
 550       if (current_function_decl == NULL)
 551         pp_printf (context->printer, "At top level:");
 552       else
 553         {
 554           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 555             pp_printf
 556               (context->printer, "In member function `%s':",
 557                lang_hooks.decl_printable_name (current_function_decl, 2));
 558           else
 559             pp_printf
 560               (context->printer, "In function `%s':",
 561                lang_hooks.decl_printable_name (current_function_decl, 2));
 562         }
 563
 564       diagnostic_set_last_function (context);
 565       pp_flush (context->printer);
 566       context->printer->prefix = old_prefix;
 567       free ((char*) new_prefix);
 568     }
 569 }
 570
 571 tree
 572 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 573                             int *walk_subtrees ATTRIBUTE_UNUSED,
 574                             tree decl ATTRIBUTE_UNUSED)
 575 {
 576   return NULL;
 577 }
 578
 579 tree
 580 lhd_make_node (enum tree_code code)
 581 {
 582   return make_node (code);
 583 }
 584
 585 #include "gt-langhooks.h"