gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002, 2003 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 "rtl.h"
  30 #include "insn-config.h"
  31 #include "integrate.h"
  32 #include "flags.h"
  33 #include "langhooks.h"
  34 #include "langhooks-def.h"
  35 #include "ggc.h"
  36 #include "diagnostic.h"
  37
  38 /* Do nothing; in many cases the default hook.  */
  39
  40 void
  41 lhd_do_nothing (void)
  42 {
  43 }
  44
  45 /* Do nothing (tree).  */
  46
  47 void
  48 lhd_do_nothing_t (tree t ATTRIBUTE_UNUSED)
  49 {
  50 }
  51
  52 /* Do nothing (int).  */
  53
  54 void
  55 lhd_do_nothing_i (int i ATTRIBUTE_UNUSED)
  56 {
  57 }
  58
  59 /* Do nothing (function).  */
  60
  61 void
  62 lhd_do_nothing_f (struct function *f ATTRIBUTE_UNUSED)
  63 {
  64 }
  65
  66 /* Do nothing (return the tree node passed).  */
  67
  68 tree
  69 lhd_return_tree (tree t)
  70 {
  71   return t;
  72 }
  73
  74 /* Do nothing (return NULL_TREE).  */
  75
  76 tree
  77 lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
  78 {
  79   return NULL_TREE;
  80 }
  81
  82 /* The default post options hook.  */
  83
  84 bool
  85 lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
  86 {
  87   return false;
  88 }
  89
  90 /* Called from by print-tree.c.  */
  91
  92 void
  93 lhd_print_tree_nothing (FILE *file ATTRIBUTE_UNUSED,
  94                         tree node ATTRIBUTE_UNUSED,
  95                         int indent ATTRIBUTE_UNUSED)
  96 {
  97 }
  98
  99 /* Called from safe_from_p.  */
 100
 101 int
 102 lhd_safe_from_p (rtx x ATTRIBUTE_UNUSED, tree exp ATTRIBUTE_UNUSED)
 103 {
 104   return 1;
 105 }
 106
 107 /* Called from unsafe_for_reeval.  */
 108
 109 int
 110 lhd_unsafe_for_reeval (tree t ATTRIBUTE_UNUSED)
 111 {
 112   return -1;
 113 }
 114
 115 /* Called from staticp.  */
 116
 117 int
 118 lhd_staticp (tree exp ATTRIBUTE_UNUSED)
 119 {
 120   return 0;
 121 }
 122
 123 /* Called from check_global_declarations.  */
 124
 125 bool
 126 lhd_warn_unused_global_decl (tree decl)
 127 {
 128   /* This is what used to exist in check_global_declarations.  Probably
 129      not many of these actually apply to non-C languages.  */
 130
 131   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
 132     return false;
 133   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
 134     return false;
 135   if (DECL_IN_SYSTEM_HEADER (decl))
 136     return false;
 137
 138   return true;
 139 }
 140
 141 /* Number for making the label on the next
 142    static variable internal to a function.  */
 143
 144 static GTY(()) int var_labelno;
 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   if (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
 161          same as that used in the source language.  (That's correct
 162          for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
 163          value as DECL_NAME in build_decl, so this choice provides
 164          backwards compatibility with existing front-ends.
 165
 166          Can't use just the variable's own name for a variable whose
 167          scope is less than the whole compilation.  Concatenate a
 168          distinguishing number.  */
 169       if (!TREE_PUBLIC (decl) && DECL_CONTEXT (decl))
 170         {
 171           const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 172           char *label;
 173
 174           ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 175           var_labelno++;
 176           SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
 177         }
 178       else
 179         SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 180     }
 181   else
 182     /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
 183        these DECLs -- unless they're in language-dependent code, in
 184        which case set_decl_assembler_name hook should handle things.  */
 185     abort ();
 186 }
 187
 188 /* By default we always allow bit-field based optimizations.  */
 189 bool
 190 lhd_can_use_bit_fields_p (void)
 191 {
 192   return true;
 193 }
 194
 195 /* Provide a default routine to clear the binding stack.  This is used
 196    by languages that don't need to do anything special.  */
 197 void
 198 lhd_clear_binding_stack (void)
 199 {
 200   while (! (*lang_hooks.decls.global_bindings_p) ())
 201     poplevel (0, 0, 0);
 202 }
 203
 204 /* Type promotion for variable arguments.  */
 205 tree
 206 lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
 207 {
 208   abort ();
 209 }
 210
 211 /* Invalid use of an incomplete type.  */
 212 void
 213 lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
 214 {
 215   if (TREE_CODE (type) == ERROR_MARK)
 216     return;
 217
 218   abort ();
 219 }
 220
 221 /* Provide a default routine for alias sets that always returns -1.  This
 222    is used by languages that don't need to do anything special.  */
 223
 224 HOST_WIDE_INT
 225 lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
 226 {
 227   return -1;
 228 }
 229
 230 /* Provide a hook routine for alias sets that always returns 0.  This is
 231    used by languages that haven't deal with alias sets yet.  */
 232
 233 HOST_WIDE_INT
 234 hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
 235 {
 236   return 0;
 237 }
 238
 239 /* This is the default expand_expr function.  */
 240
 241 rtx
 242 lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
 243                  enum machine_mode mm ATTRIBUTE_UNUSED,
 244                  int em ATTRIBUTE_UNUSED)
 245 {
 246   abort ();
 247 }
 248
 249 /* This is the default decl_printable_name function.  */
 250
 251 const char *
 252 lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
 253 {
 254   return IDENTIFIER_POINTER (DECL_NAME (decl));
 255 }
 256
 257 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 258    after handling common cases, but before walking code-specific
 259    sub-trees.  If this hook is overridden for a language, it should
 260    handle language-specific tree codes, as well as language-specific
 261    information associated to common tree codes.  If a tree node is
 262    completely handled within this function, it should set *SUBTREES to
 263    0, so that generic handling isn't attempted.  For language-specific
 264    tree codes, generic handling would abort(), so make sure it is set
 265    properly.  Both SUBTREES and *SUBTREES is guaranteed to be nonzero
 266    when the function is called.  */
 267
 268 tree
 269 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 270                                  int *subtrees ATTRIBUTE_UNUSED,
 271                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 272                                  void *data ATTRIBUTE_UNUSED,
 273                                  void *htab ATTRIBUTE_UNUSED)
 274 {
 275   return NULL_TREE;
 276 }
 277
 278 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 279    determine whether there are language-specific reasons for not
 280    inlining a given function.  */
 281
 282 int
 283 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 284 {
 285   if (flag_really_no_inline
 286       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 287     return 1;
 288
 289   return 0;
 290 }
 291
 292 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 293    determine whether a function should be considered for inlining even
 294    if it would exceed inlining limits.  */
 295
 296 int
 297 lhd_tree_inlining_disregard_inline_limits (tree fn)
 298 {
 299   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 300     return 1;
 301
 302   return 0;
 303 }
 304
 305 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 306    starting to inline a function, to push any language-specific
 307    functions that should not be inlined into the current function,
 308    into VAFNP.  PFN is the top of varray, and should be returned if no
 309    functions are pushed into VAFNP.  The top of the varray should be
 310    returned.  */
 311
 312 tree
 313 lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
 314 {
 315   return pfn;
 316 }
 317
 318 /* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
 319    TREE_CHAIN of a language-specific tree node is relevant, i.e.,
 320    whether it should be walked, copied and preserved across copies.  */
 321
 322 int
 323 lhd_tree_inlining_tree_chain_matters_p (tree t ATTRIBUTE_UNUSED)
 324 {
 325   return 0;
 326 }
 327
 328 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 329    whether VT is an automatic variable defined in function FT.  */
 330
 331 int
 332 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 333 {
 334   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 335           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 336                && ! TREE_STATIC (var))
 337               || TREE_CODE (var) == LABEL_DECL
 338               || TREE_CODE (var) == RESULT_DECL));
 339 }
 340
 341 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 342    declaration for the result RES of function FN to be inlined into
 343    CALLER.  NDP points to an integer that should be set in case a new
 344    declaration wasn't created (presumably because RES was of aggregate
 345    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 346    pointer to a varray with the stack of TARGET_EXPRs seen while
 347    inlining functions into caller; the top of TEXPS is supposed to
 348    match RES.  */
 349
 350 tree
 351 lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
 352                                               void *dm ATTRIBUTE_UNUSED,
 353                                               int *ndp ATTRIBUTE_UNUSED,
 354                                               tree return_slot_addr ATTRIBUTE_UNUSED)
 355 {
 356   if (return_slot_addr)
 357     return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
 358                    return_slot_addr);
 359   else
 360     return copy_decl_for_inlining (res, fn, caller);
 361 }
 362
 363 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 364    type node representing an anonymous aggregate (union, struct, etc),
 365    i.e., one whose members are in the same scope as the union itself.  */
 366
 367 int
 368 lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 369 {
 370   return 0;
 371 }
 372
 373 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 374    language-specific bookkeeping necessary for processing
 375    FN. start_inlining returns nonzero if inlining should proceed, zero if
 376    not.
 377
 378    For instance, the C++ version keeps track of template instantiations to
 379    avoid infinite recursion.  */
 380
 381 int
 382 lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 383 {
 384   return 1;
 385 }
 386
 387 void
 388 lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 389 {
 390 }
 391
 392 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 393    language-specific conversion before assigning VALUE to PARM.  */
 394
 395 tree
 396 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 397                                              tree value,
 398                                              tree fndecl ATTRIBUTE_UNUSED)
 399 {
 400   return value;
 401 }
 402
 403 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 404    nodes.  Returns nonzero if it does not want the usual dumping of the
 405    second argument.  */
 406
 407 bool
 408 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 409 {
 410   return false;
 411 }
 412
 413 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 414    language-specific way.  */
 415
 416 int
 417 lhd_tree_dump_type_quals (tree t)
 418 {
 419   return TYPE_QUALS (t);
 420 }
 421
 422 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 423    in a language-specific way.  Returns a tree for the size in bytes.  */
 424
 425 tree
 426 lhd_expr_size (tree exp)
 427 {
 428   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
 429       && DECL_SIZE_UNIT (exp) != 0)
 430     return DECL_SIZE_UNIT (exp);
 431   else
 432     return size_in_bytes (TREE_TYPE (exp));
 433 }
 434 /* lang_hooks.decl_uninit: Find out if a variable is uninitialized based
 435    on DECL_INITIAL.  */
 436
 437 bool
 438 lhd_decl_uninit (tree t ATTRIBUTE_UNUSED)
 439 {
 440   return false;
 441 }
 442
 443 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 444    which is a language-specific tree code in category 'x'.  The
 445    default expects never to be called.  */
 446 size_t
 447 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 448 {
 449   abort ();
 450   return 0;
 451 }
 452
 453 /* Return true if decl, which is a function decl, may be called by a
 454    sibcall.  */
 455
 456 bool
 457 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 458 {
 459   return true;
 460 }
 461
 462 /* lang_hooks.decls.final_write_globals: perform final processing on
 463    global variables.  */
 464 void
 465 write_global_declarations (void)
 466 {
 467   /* Really define vars that have had only a tentative definition.
 468      Really output inline functions that must actually be callable
 469      and have not been output so far.  */
 470
 471   tree globals = (*lang_hooks.decls.getdecls) ();
 472   int len = list_length (globals);
 473   tree *vec = xmalloc (sizeof (tree) * len);
 474   int i;
 475   tree decl;
 476
 477   /* Process the decls in reverse order--earliest first.
 478      Put them into VEC from back to front, then take out from front.  */
 479
 480   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 481     vec[len - i - 1] = decl;
 482
 483   wrapup_global_declarations (vec, len);
 484
 485   check_global_declarations (vec, len);
 486
 487     /* Clean up.  */
 488   free (vec);
 489 }
 490
 491 /* Called to perform language-specific initialization of CTX.  */
 492 void
 493 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 494 {
 495 }
 496
 497 /* The default function to print out name of current function that caused
 498    an error.  */
 499 void
 500 lhd_print_error_function (diagnostic_context *context, const char *file)
 501 {
 502   if (diagnostic_last_function_changed (context))
 503     {
 504       const char *old_prefix = context->printer->prefix;
 505       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 506
 507       pp_set_prefix (context->printer, new_prefix);
 508
 509       if (current_function_decl == NULL)
 510         pp_printf (context->printer, "At top level:");
 511       else
 512         {
 513           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 514             pp_printf
 515               (context->printer, "In member function `%s':",
 516                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 517           else
 518             pp_printf
 519               (context->printer, "In function `%s':",
 520                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 521         }
 522       pp_newline (context->printer);
 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 #include "gt-langhooks.h"