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