gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001, 2002 Free Software Foundation, Inc.
   3    Contributed by Alexandre Oliva  <aoliva@redhat.com>
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC 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 GNU CC 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 GNU CC; 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 "toplev.h"
  25 #include "tree.h"
  26 #include "c-tree.h"
  27 #include "tree-inline.h"
  28 #include "rtl.h"
  29 #include "insn-config.h"
  30 #include "integrate.h"
  31 #include "flags.h"
  32 #include "langhooks.h"
  33 #include "langhooks-def.h"
  34
  35 /* Do nothing; in many cases the default hook.  */
  36
  37 void
  38 lhd_do_nothing ()
  39 {
  40 }
  41
  42 /* Do nothing (tree).  */
  43
  44 void
  45 lhd_do_nothing_t (t)
  46      tree t ATTRIBUTE_UNUSED;
  47 {
  48 }
  49
  50 /* Do nothing (int).  */
  51
  52 void
  53 lhd_do_nothing_i (i)
  54      int i ATTRIBUTE_UNUSED;
  55 {
  56 }
  57
  58 /* Do nothing (function).  */
  59
  60 void
  61 lhd_do_nothing_f (f)
  62      struct function *f ATTRIBUTE_UNUSED;
  63 {
  64 }
  65
  66 /* Do nothing (return the tree node passed).  */
  67
  68 tree
  69 lhd_return_tree (t)
  70      tree t;
  71 {
  72   return t;
  73 }
  74
  75 /* Do nothing (return NULL_TREE).  */
  76
  77 tree
  78 lhd_return_null_tree (t)
  79      tree t ATTRIBUTE_UNUSED;
  80 {
  81   return NULL_TREE;
  82 }
  83
  84 /* Do nothing; the default hook to decode an option.  */
  85
  86 int
  87 lhd_decode_option (argc, argv)
  88      int argc ATTRIBUTE_UNUSED;
  89      char **argv ATTRIBUTE_UNUSED;
  90 {
  91   return 0;
  92 }
  93
  94 /* Called from by print-tree.c.  */
  95
  96 void
  97 lhd_print_tree_nothing (file, node, indent)
  98      FILE *file ATTRIBUTE_UNUSED;
  99      tree node ATTRIBUTE_UNUSED;
 100      int indent ATTRIBUTE_UNUSED;
 101 {
 102 }
 103
 104 /* Called from safe_from_p.  */
 105
 106 int
 107 lhd_safe_from_p (x, exp)
 108      rtx x ATTRIBUTE_UNUSED;
 109      tree exp ATTRIBUTE_UNUSED;
 110 {
 111   return 1;
 112 }
 113
 114 /* Called from unsafe_for_reeval.  */
 115
 116 int
 117 lhd_unsafe_for_reeval (t)
 118      tree t ATTRIBUTE_UNUSED;
 119 {
 120   return -1;
 121 }
 122
 123 /* Called from staticp.  */
 124
 125 int
 126 lhd_staticp (exp)
 127      tree exp ATTRIBUTE_UNUSED;
 128 {
 129   return 0;
 130 }
 131
 132 /* Called from check_global_declarations.  */
 133
 134 bool
 135 lhd_warn_unused_global_decl (decl)
 136      tree decl;
 137 {
 138   /* This is what used to exist in check_global_declarations.  Probably
 139      not many of these actually apply to non-C languages.  */
 140
 141   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
 142     return false;
 143   if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
 144     return false;
 145   if (DECL_IN_SYSTEM_HEADER (decl))
 146     return false;
 147
 148   return true;
 149 }
 150
 151 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 152 void
 153 lhd_set_decl_assembler_name (decl)
 154      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     /* By default, assume the name to use in assembly code is the
 166        same as that used in the source language.  (That's correct
 167        for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
 168        value as DECL_NAME in build_decl, so this choice provides
 169        backwards compatibility with existing front-ends.  */
 170     SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
 171   else
 172     /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
 173        these DECLs -- unless they're in language-dependent code, in
 174        which case set_decl_assembler_name hook should handle things.  */
 175     abort ();
 176 }
 177
 178 /* Provide a default routine to clear the binding stack.  This is used
 179    by languages that don't need to do anything special.  */
 180 void
 181 lhd_clear_binding_stack ()
 182 {
 183   while (! (*lang_hooks.decls.global_bindings_p) ())
 184     poplevel (0, 0, 0);
 185 }
 186
 187 /* Type promotion for variable arguments.  */
 188 tree
 189 lhd_type_promotes_to (type)
 190      tree type ATTRIBUTE_UNUSED;
 191 {
 192   abort ();
 193 }
 194
 195 /* Invalid use of an incomplete type.  */
 196 void
 197 lhd_incomplete_type_error (value, type)
 198      tree value ATTRIBUTE_UNUSED, type;
 199 {
 200   if (TREE_CODE (type) == ERROR_MARK)
 201     return;
 202
 203   abort ();
 204 }
 205
 206 /* Provide a default routine for alias sets that always returns -1.  This
 207    is used by languages that don't need to do anything special.  */
 208
 209 HOST_WIDE_INT
 210 lhd_get_alias_set (t)
 211      tree t ATTRIBUTE_UNUSED;
 212 {
 213   return -1;
 214 }
 215
 216 /* Provide a hook routine for alias sets that always returns 0.  This is
 217    used by languages that haven't deal with alias sets yet.  */
 218
 219 HOST_WIDE_INT
 220 hook_get_alias_set_0 (t)
 221      tree t ATTRIBUTE_UNUSED;
 222 {
 223   return 0;
 224 }
 225
 226 /* This is the default expand_expr function.  */
 227
 228 rtx
 229 lhd_expand_expr (t, r, mm, em)
 230      tree t ATTRIBUTE_UNUSED;
 231      rtx r ATTRIBUTE_UNUSED;
 232      enum machine_mode mm ATTRIBUTE_UNUSED;
 233      int em ATTRIBUTE_UNUSED;
 234 {
 235   abort ();
 236 }
 237
 238 /* This is the default decl_printable_name function.  */
 239
 240 const char *
 241 lhd_decl_printable_name (decl, verbosity)
 242      tree decl;
 243      int verbosity ATTRIBUTE_UNUSED;
 244 {
 245   return IDENTIFIER_POINTER (DECL_NAME (decl));
 246 }
 247
 248 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 249    after handling common cases, but before walking code-specific
 250    sub-trees.  If this hook is overridden for a language, it should
 251    handle language-specific tree codes, as well as language-specific
 252    information associated to common tree codes.  If a tree node is
 253    completely handled within this function, it should set *SUBTREES to
 254    0, so that generic handling isn't attempted.  For language-specific
 255    tree codes, generic handling would abort(), so make sure it is set
 256    properly.  Both SUBTREES and *SUBTREES is guaranteed to be non-zero
 257    when the function is called.  */
 258
 259 tree
 260 lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab)
 261      tree *tp ATTRIBUTE_UNUSED;
 262      int *subtrees ATTRIBUTE_UNUSED;
 263      walk_tree_fn func ATTRIBUTE_UNUSED;
 264      void *data ATTRIBUTE_UNUSED;
 265      void *htab ATTRIBUTE_UNUSED;
 266 {
 267   return NULL_TREE;
 268 }
 269
 270 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 271    determine whether there are language-specific reasons for not
 272    inlining a given function.  */
 273
 274 int
 275 lhd_tree_inlining_cannot_inline_tree_fn (fnp)
 276      tree *fnp;
 277 {
 278   if (flag_really_no_inline
 279       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 280     return 1;
 281
 282   return 0;
 283 }
 284
 285 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 286    determine whether a function should be considered for inlining even
 287    if it would exceed inlining limits.  */
 288
 289 int
 290 lhd_tree_inlining_disregard_inline_limits (fn)
 291      tree fn;
 292 {
 293   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 294     return 1;
 295
 296   return 0;
 297 }
 298
 299 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 300    starting to inline a function, to push any language-specific
 301    functions that should not be inlined into the current function,
 302    into VAFNP.  PFN is the top of varray, and should be returned if no
 303    functions are pushed into VAFNP.  The top of the varray should be
 304    returned.  */
 305
 306 tree
 307 lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn)
 308      void *vafnp ATTRIBUTE_UNUSED;
 309      tree pfn;
 310 {
 311   return pfn;
 312 }
 313
 314 /* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
 315    TREE_CHAIN of a language-specific tree node is relevant, i.e.,
 316    whether it should be walked, copied and preserved across copies.  */
 317
 318 int
 319 lhd_tree_inlining_tree_chain_matters_p (t)
 320      tree t ATTRIBUTE_UNUSED;
 321 {
 322   return 0;
 323 }
 324
 325 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 326    whether VT is an automatic variable defined in function FT.  */
 327
 328 int
 329 lhd_tree_inlining_auto_var_in_fn_p (var, fn)
 330      tree var, fn;
 331 {
 332   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 333           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 334                && ! TREE_STATIC (var))
 335               || TREE_CODE (var) == LABEL_DECL
 336               || TREE_CODE (var) == RESULT_DECL));
 337 }
 338
 339 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 340    declaration for the result RES of function FN to be inlined into
 341    CALLER.  NDP points to an integer that should be set in case a new
 342    declaration wasn't created (presumably because RES was of aggregate
 343    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 344    pointer to a varray with the stack of TARGET_EXPRs seen while
 345    inlining functions into caller; the top of TEXPS is supposed to
 346    match RES.  */
 347
 348 tree
 349 lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller,
 350                                               dm, ndp, texps)
 351      tree res, fn, caller;
 352      void *dm ATTRIBUTE_UNUSED;
 353      int *ndp ATTRIBUTE_UNUSED;
 354      void *texps ATTRIBUTE_UNUSED;
 355 {
 356   return copy_decl_for_inlining (res, fn, caller);
 357 }
 358
 359 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 360    type node representing an anonymous aggregate (union, struct, etc),
 361    i.e., one whose members are in the same scope as the union itself.  */
 362
 363 int
 364 lhd_tree_inlining_anon_aggr_type_p (t)
 365      tree t ATTRIBUTE_UNUSED;
 366 {
 367   return 0;
 368 }
 369
 370 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 371    language-specific bookkeeping necessary for processing
 372    FN. start_inlining returns non-zero if inlining should proceed, zero if
 373    not.
 374
 375    For instance, the C++ version keeps track of template instantiations to
 376    avoid infinite recursion.  */
 377
 378 int
 379 lhd_tree_inlining_start_inlining (fn)
 380      tree fn ATTRIBUTE_UNUSED;
 381 {
 382   return 1;
 383 }
 384
 385 void
 386 lhd_tree_inlining_end_inlining (fn)
 387      tree fn ATTRIBUTE_UNUSED;
 388 {
 389 }
 390
 391 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 392    language-specific conversion before assigning VALUE to PARM.  */
 393
 394 tree
 395 lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
 396      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 non-zero if it does not want the usual dumping of the
 405    second argument.  */
 406
 407 int
 408 lhd_tree_dump_dump_tree (di, t)
 409      void *di ATTRIBUTE_UNUSED;
 410      tree t ATTRIBUTE_UNUSED;
 411 {
 412   return 0;
 413 }
 414
 415 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 416    language-specific way.  */
 417
 418 int
 419 lhd_tree_dump_type_quals (t)
 420      tree t;
 421 {
 422   return TYPE_QUALS (t);
 423 }
 424