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 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 161 void
 162 lhd_set_decl_assembler_name (tree decl)
 163 {
 164   /* The language-independent code should never use the
 165      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
 166      VAR_DECLs for variables with static storage duration need a real
 167      DECL_ASSEMBLER_NAME.  */
 168   if (TREE_CODE (decl) == FUNCTION_DECL
 169       || (TREE_CODE (decl) == VAR_DECL
 170           && (TREE_STATIC (decl)
 171               || DECL_EXTERNAL (decl)
 172               || TREE_PUBLIC (decl))))
 173     {
 174       /* By default, assume the name to use in assembly code is the
 175          same as that used in the source language.  (That's correct
 176          for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
 177          value as DECL_NAME in build_decl, so this choice provides
 178          backwards compatibility with existing front-ends.
 179
 180          Can't use just the variable's own name for a variable whose
 181          scope is less than the whole compilation.  Concatenate a
 182          distinguishing number - we use the DECL_UID.  */
 183       if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
 184         SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 185       else
 186         {
 187           const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 188           char *label;
 189
 190           ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
 191           SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
 192         }
 193     }
 194   else
 195     /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
 196        these DECLs -- unless they're in language-dependent code, in
 197        which case set_decl_assembler_name hook should handle things.  */
 198     abort ();
 199 }
 200
 201 /* By default we always allow bit-field based optimizations.  */
 202 bool
 203 lhd_can_use_bit_fields_p (void)
 204 {
 205   return true;
 206 }
 207
 208 /* Type promotion for variable arguments.  */
 209 tree
 210 lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
 211 {
 212   abort ();
 213 }
 214
 215 /* Registration of machine- or os-specific builtin types.  */
 216 void
 217 lhd_register_builtin_type (tree type ATTRIBUTE_UNUSED,
 218                            const char* name ATTRIBUTE_UNUSED)
 219 {
 220 }
 221
 222 /* Invalid use of an incomplete type.  */
 223 void
 224 lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
 225 {
 226   if (TREE_CODE (type) == ERROR_MARK)
 227     return;
 228
 229   abort ();
 230 }
 231
 232 /* Provide a default routine for alias sets that always returns -1.  This
 233    is used by languages that don't need to do anything special.  */
 234
 235 HOST_WIDE_INT
 236 lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
 237 {
 238   return -1;
 239 }
 240
 241 /* Provide a hook routine for alias sets that always returns 0.  This is
 242    used by languages that haven't deal with alias sets yet.  */
 243
 244 HOST_WIDE_INT
 245 hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
 246 {
 247   return 0;
 248 }
 249
 250 /* This is the default expand_expr function.  */
 251
 252 rtx
 253 lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
 254                  enum machine_mode mm ATTRIBUTE_UNUSED,
 255                  int em ATTRIBUTE_UNUSED,
 256                  rtx *a ATTRIBUTE_UNUSED)
 257 {
 258   abort ();
 259 }
 260
 261 /* The default language-specific function for expanding a decl.  After
 262    the language-independent cases are handled, this function will be
 263    called.  If this function is not defined, it is assumed that
 264    declarations other than those for variables and labels do not require
 265    any RTL generation.  */
 266
 267 int
 268 lhd_expand_decl (tree t ATTRIBUTE_UNUSED)
 269 {
 270   return 0;
 271 }
 272
 273 /* This is the default decl_printable_name function.  */
 274
 275 const char *
 276 lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
 277 {
 278   return IDENTIFIER_POINTER (DECL_NAME (decl));
 279 }
 280
 281 /* This compares two types for equivalence ("compatible" in C-based languages).
 282    This routine should only return 1 if it is sure.  It should not be used
 283    in contexts where erroneously returning 0 causes problems.  */
 284
 285 int
 286 lhd_types_compatible_p (tree x, tree y)
 287 {
 288   return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 289 }
 290
 291 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 292    after handling common cases, but before walking code-specific
 293    sub-trees.  If this hook is overridden for a language, it should
 294    handle language-specific tree codes, as well as language-specific
 295    information associated to common tree codes.  If a tree node is
 296    completely handled within this function, it should set *SUBTREES to
 297    0, so that generic handling isn't attempted.  For language-specific
 298    tree codes, generic handling would abort(), so make sure it is set
 299    properly.  Both SUBTREES and *SUBTREES is guaranteed to be nonzero
 300    when the function is called.  */
 301
 302 tree
 303 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 304                                  int *subtrees ATTRIBUTE_UNUSED,
 305                                  walk_tree_fn func ATTRIBUTE_UNUSED,
 306                                  void *data ATTRIBUTE_UNUSED,
 307                                  void *htab ATTRIBUTE_UNUSED)
 308 {
 309   return NULL_TREE;
 310 }
 311
 312 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 313    determine whether there are language-specific reasons for not
 314    inlining a given function.  */
 315
 316 int
 317 lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 318 {
 319   if (flag_really_no_inline
 320       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 321     return 1;
 322
 323   return 0;
 324 }
 325
 326 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 327    determine whether a function should be considered for inlining even
 328    if it would exceed inlining limits.  */
 329
 330 int
 331 lhd_tree_inlining_disregard_inline_limits (tree fn)
 332 {
 333   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 334     return 1;
 335
 336   return 0;
 337 }
 338
 339 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 340    starting to inline a function, to push any language-specific
 341    functions that should not be inlined into the current function,
 342    into VAFNP.  PFN is the top of varray, and should be returned if no
 343    functions are pushed into VAFNP.  The top of the varray should be
 344    returned.  */
 345
 346 tree
 347 lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
 348 {
 349   return pfn;
 350 }
 351
 352 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 353    whether VT is an automatic variable defined in function FT.  */
 354
 355 int
 356 lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 357 {
 358   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 359           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 360                && ! TREE_STATIC (var))
 361               || TREE_CODE (var) == LABEL_DECL
 362               || TREE_CODE (var) == RESULT_DECL));
 363 }
 364
 365 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 366    type node representing an anonymous aggregate (union, struct, etc),
 367    i.e., one whose members are in the same scope as the union itself.  */
 368
 369 int
 370 lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 371 {
 372   return 0;
 373 }
 374
 375 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 376    language-specific bookkeeping necessary for processing
 377    FN. start_inlining returns nonzero if inlining should proceed, zero if
 378    not.
 379
 380    For instance, the C++ version keeps track of template instantiations to
 381    avoid infinite recursion.  */
 382
 383 int
 384 lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 385 {
 386   return 1;
 387 }
 388
 389 void
 390 lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 391 {
 392 }
 393
 394 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 395    language-specific conversion before assigning VALUE to PARM.  */
 396
 397 tree
 398 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 399                                              tree value,
 400                                              tree fndecl ATTRIBUTE_UNUSED,
 401                                              int argnum ATTRIBUTE_UNUSED)
 402 {
 403   return value;
 404 }
 405
 406 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 407    nodes.  Returns nonzero if it does not want the usual dumping of the
 408    second argument.  */
 409
 410 bool
 411 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 412 {
 413   return false;
 414 }
 415
 416 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 417    language-specific way.  */
 418
 419 int
 420 lhd_tree_dump_type_quals (tree t)
 421 {
 422   return TYPE_QUALS (t);
 423 }
 424
 425 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 426    in a language-specific way.  Returns a tree for the size in bytes.  */
 427
 428 tree
 429 lhd_expr_size (tree exp)
 430 {
 431   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
 432       && DECL_SIZE_UNIT (exp) != 0)
 433     return DECL_SIZE_UNIT (exp);
 434   else
 435     return size_in_bytes (TREE_TYPE (exp));
 436 }
 437
 438 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 439
 440 int
 441 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 442                    tree *post_p ATTRIBUTE_UNUSED)
 443 {
 444   return GS_UNHANDLED;
 445 }
 446
 447 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 448    which is a language-specific tree code in category 'x'.  The
 449    default expects never to be called.  */
 450 size_t
 451 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 452 {
 453   abort ();
 454   return 0;
 455 }
 456
 457 /* Return true if decl, which is a function decl, may be called by a
 458    sibcall.  */
 459
 460 bool
 461 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 462 {
 463   return true;
 464 }
 465
 466 /* lang_hooks.decls.final_write_globals: perform final processing on
 467    global variables.  */
 468 void
 469 write_global_declarations (void)
 470 {
 471   /* Really define vars that have had only a tentative definition.
 472      Really output inline functions that must actually be callable
 473      and have not been output so far.  */
 474
 475   tree globals = lang_hooks.decls.getdecls ();
 476   int len = list_length (globals);
 477   tree *vec = xmalloc (sizeof (tree) * len);
 478   int i;
 479   tree decl;
 480
 481   /* Process the decls in reverse order--earliest first.
 482      Put them into VEC from back to front, then take out from front.  */
 483
 484   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 485     vec[len - i - 1] = decl;
 486
 487   wrapup_global_declarations (vec, len);
 488
 489   check_global_declarations (vec, len);
 490
 491     /* Clean up.  */
 492   free (vec);
 493 }
 494
 495 /* Called to perform language-specific initialization of CTX.  */
 496 void
 497 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 498 {
 499 }
 500
 501 /* The default function to print out name of current function that caused
 502    an error.  */
 503 void
 504 lhd_print_error_function (diagnostic_context *context, const char *file)
 505 {
 506   if (diagnostic_last_function_changed (context))
 507     {
 508       const char *old_prefix = context->printer->prefix;
 509       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 510
 511       pp_set_prefix (context->printer, new_prefix);
 512
 513       if (current_function_decl == NULL)
 514         pp_printf (context->printer, "At top level:");
 515       else
 516         {
 517           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 518             pp_printf
 519               (context->printer, "In member function `%s':",
 520                lang_hooks.decl_printable_name (current_function_decl, 2));
 521           else
 522             pp_printf
 523               (context->printer, "In function `%s':",
 524                lang_hooks.decl_printable_name (current_function_decl, 2));
 525         }
 526
 527       diagnostic_set_last_function (context);
 528       pp_flush (context->printer);
 529       context->printer->prefix = old_prefix;
 530       free ((char*) new_prefix);
 531     }
 532 }
 533
 534 tree
 535 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 536                             int *walk_subtrees ATTRIBUTE_UNUSED,
 537                             tree decl ATTRIBUTE_UNUSED)
 538 {
 539   return NULL;
 540 }
 541
 542 tree
 543 lhd_make_node (enum tree_code code)
 544 {
 545   return make_node (code);
 546 }