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.copy_res_decl_for_inlining should return a
 366    declaration for the result RES of function FN to be inlined into
 367    CALLER.  NDP points to an integer that should be set in case a new
 368    declaration wasn't created (presumably because RES was of aggregate
 369    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 370    pointer to a varray with the stack of TARGET_EXPRs seen while
 371    inlining functions into caller; the top of TEXPS is supposed to
 372    match RES.  */
 373
 374 tree
 375 lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
 376                                               void *dm ATTRIBUTE_UNUSED,
 377                                               int *ndp ATTRIBUTE_UNUSED,
 378                                               tree return_slot_addr ATTRIBUTE_UNUSED)
 379 {
 380   if (return_slot_addr)
 381     return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
 382                    return_slot_addr);
 383   else
 384     return copy_decl_for_inlining (res, fn, caller);
 385 }
 386
 387 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 388    type node representing an anonymous aggregate (union, struct, etc),
 389    i.e., one whose members are in the same scope as the union itself.  */
 390
 391 int
 392 lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 393 {
 394   return 0;
 395 }
 396
 397 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 398    language-specific bookkeeping necessary for processing
 399    FN. start_inlining returns nonzero if inlining should proceed, zero if
 400    not.
 401
 402    For instance, the C++ version keeps track of template instantiations to
 403    avoid infinite recursion.  */
 404
 405 int
 406 lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 407 {
 408   return 1;
 409 }
 410
 411 void
 412 lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 413 {
 414 }
 415
 416 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 417    language-specific conversion before assigning VALUE to PARM.  */
 418
 419 tree
 420 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 421                                              tree value,
 422                                              tree fndecl ATTRIBUTE_UNUSED,
 423                                              int argnum ATTRIBUTE_UNUSED)
 424 {
 425   return value;
 426 }
 427
 428 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 429    nodes.  Returns nonzero if it does not want the usual dumping of the
 430    second argument.  */
 431
 432 bool
 433 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 434 {
 435   return false;
 436 }
 437
 438 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 439    language-specific way.  */
 440
 441 int
 442 lhd_tree_dump_type_quals (tree t)
 443 {
 444   return TYPE_QUALS (t);
 445 }
 446
 447 /* lang_hooks.expr_size: Determine the size of the value of an expression T
 448    in a language-specific way.  Returns a tree for the size in bytes.  */
 449
 450 tree
 451 lhd_expr_size (tree exp)
 452 {
 453   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
 454       && DECL_SIZE_UNIT (exp) != 0)
 455     return DECL_SIZE_UNIT (exp);
 456   else
 457     return size_in_bytes (TREE_TYPE (exp));
 458 }
 459
 460 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 461
 462 int
 463 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
 464                    tree *post_p ATTRIBUTE_UNUSED)
 465 {
 466   return GS_UNHANDLED;
 467 }
 468
 469 /* lang_hooks.tree_size: Determine the size of a tree with code C,
 470    which is a language-specific tree code in category 'x'.  The
 471    default expects never to be called.  */
 472 size_t
 473 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 474 {
 475   abort ();
 476   return 0;
 477 }
 478
 479 /* Return true if decl, which is a function decl, may be called by a
 480    sibcall.  */
 481
 482 bool
 483 lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 484 {
 485   return true;
 486 }
 487
 488 /* lang_hooks.decls.final_write_globals: perform final processing on
 489    global variables.  */
 490 void
 491 write_global_declarations (void)
 492 {
 493   /* Really define vars that have had only a tentative definition.
 494      Really output inline functions that must actually be callable
 495      and have not been output so far.  */
 496
 497   tree globals = lang_hooks.decls.getdecls ();
 498   int len = list_length (globals);
 499   tree *vec = xmalloc (sizeof (tree) * len);
 500   int i;
 501   tree decl;
 502
 503   /* Process the decls in reverse order--earliest first.
 504      Put them into VEC from back to front, then take out from front.  */
 505
 506   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
 507     vec[len - i - 1] = decl;
 508
 509   wrapup_global_declarations (vec, len);
 510
 511   check_global_declarations (vec, len);
 512
 513     /* Clean up.  */
 514   free (vec);
 515 }
 516
 517 /* Called to perform language-specific initialization of CTX.  */
 518 void
 519 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
 520 {
 521 }
 522
 523 /* The default function to print out name of current function that caused
 524    an error.  */
 525 void
 526 lhd_print_error_function (diagnostic_context *context, const char *file)
 527 {
 528   if (diagnostic_last_function_changed (context))
 529     {
 530       const char *old_prefix = context->printer->prefix;
 531       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
 532
 533       pp_set_prefix (context->printer, new_prefix);
 534
 535       if (current_function_decl == NULL)
 536         pp_printf (context->printer, "At top level:");
 537       else
 538         {
 539           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 540             pp_printf
 541               (context->printer, "In member function `%s':",
 542                lang_hooks.decl_printable_name (current_function_decl, 2));
 543           else
 544             pp_printf
 545               (context->printer, "In function `%s':",
 546                lang_hooks.decl_printable_name (current_function_decl, 2));
 547         }
 548
 549       diagnostic_set_last_function (context);
 550       pp_flush (context->printer);
 551       context->printer->prefix = old_prefix;
 552       free ((char*) new_prefix);
 553     }
 554 }
 555
 556 tree
 557 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
 558                             int *walk_subtrees ATTRIBUTE_UNUSED,
 559                             tree decl ATTRIBUTE_UNUSED)
 560 {
 561   return NULL;
 562 }
 563
 564 tree
 565 lhd_make_node (enum tree_code code)
 566 {
 567   return make_node (code);
 568 }