gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright 2001 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 "tree-inline.h"
  27 #include "rtl.h"
  28 #include "insn-config.h"
  29 #include "integrate.h"
  30 #include "langhooks.h"
  31
  32 /* Do nothing; in many cases the default hook.  */
  33
  34 void
  35 lang_hook_default_do_nothing ()
  36 {
  37 }
  38
  39 /* Do nothing; the default hook to decode an option.  */
  40
  41 int
  42 lang_hook_default_decode_option (argc, argv)
  43      int argc ATTRIBUTE_UNUSED;
  44      char **argv ATTRIBUTE_UNUSED;
  45 {
  46   return 0;
  47 }
  48
  49 /* Provide a default routine to clear the binding stack.  This is used
  50    by languages that don't need to do anything special.  */
  51 void
  52 lang_hook_default_clear_binding_stack ()
  53 {
  54   while (! global_bindings_p ())
  55     poplevel (0, 0, 0);
  56 }
  57
  58 /* Provide a default routine for alias sets that always returns -1.  This
  59    is used by languages that don't need to do anything special.  */
  60
  61 HOST_WIDE_INT
  62 lang_hook_default_get_alias_set (t)
  63      tree t ATTRIBUTE_UNUSED;
  64 {
  65   return -1;
  66 }
  67
  68 /* Provide a hook routine for alias sets that always returns 0.  This is
  69    used by languages that haven't deal with alias sets yet.  */
  70
  71 HOST_WIDE_INT
  72 hook_get_alias_set_0 (t)
  73      tree t ATTRIBUTE_UNUSED;
  74 {
  75   return 0;
  76 }
  77
  78 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
  79    after handling common cases, but before walking code-specific
  80    sub-trees.  If this hook is overridden for a language, it should
  81    handle language-specific tree codes, as well as language-specific
  82    information associated to common tree codes.  If a tree node is
  83    completely handled within this function, it should set *SUBTREES to
  84    0, so that generic handling isn't attempted.  For language-specific
  85    tree codes, generic handling would abort(), so make sure it is set
  86    properly.  Both SUBTREES and *SUBTREES is guaranteed to be non-zero
  87    when the function is called.  */
  88
  89 tree
  90 tree_inlining_default_hook_walk_subtrees (tp,subtrees,func,data,htab)
  91      tree *tp ATTRIBUTE_UNUSED;
  92      int *subtrees ATTRIBUTE_UNUSED;
  93      walk_tree_fn func ATTRIBUTE_UNUSED;
  94      void *data ATTRIBUTE_UNUSED;
  95      void *htab ATTRIBUTE_UNUSED;
  96 {
  97   return NULL_TREE;
  98 }
  99
 100 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 101    determine whether there are language-specific reasons for not
 102    inlining a given function.  */
 103
 104 int
 105 tree_inlining_default_hook_cannot_inline_tree_fn (fnp)
 106      tree *fnp ATTRIBUTE_UNUSED;
 107 {
 108   return 0;
 109 }
 110
 111 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 112    determine whether a function should be considered for inlining even
 113    if it would exceed inlining limits.  */
 114
 115 int
 116 tree_inlining_default_hook_disregard_inline_limits (fn)
 117      tree fn ATTRIBUTE_UNUSED;
 118 {
 119   return 0;
 120 }
 121
 122 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 123    starting to inline a function, to push any language-specific
 124    functions that should not be inlined into the current function,
 125    into VAFNP.  PFN is the top of varray, and should be returned if no
 126    functions are pushed into VAFNP.  The top of the varray should be
 127    returned.  */
 128
 129 tree
 130 tree_inlining_default_hook_add_pending_fn_decls (vafnp, pfn)
 131      void *vafnp ATTRIBUTE_UNUSED;
 132      tree pfn;
 133 {
 134   return pfn;
 135 }
 136
 137 /* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
 138    TREE_CHAIN of a language-specific tree node is relevant, i.e.,
 139    whether it should be walked, copied and preserved across copies.  */
 140
 141 int
 142 tree_inlining_default_hook_tree_chain_matters_p (t)
 143      tree t ATTRIBUTE_UNUSED;
 144 {
 145   return 0;
 146 }
 147
 148 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 149    whether VT is an automatic variable defined in function FT.  */
 150
 151 int
 152 tree_inlining_default_hook_auto_var_in_fn_p (var, fn)
 153      tree var, fn;
 154 {
 155   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 156           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 157                && ! TREE_STATIC (var))
 158               || TREE_CODE (var) == LABEL_DECL
 159               || TREE_CODE (var) == RESULT_DECL));
 160 }
 161
 162 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 163    declaration for the result RES of function FN to be inlined into
 164    CALLER.  NDP points to an integer that should be set in case a new
 165    declaration wasn't created (presumably because RES was of aggregate
 166    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 167    pointer to a varray with the stack of TARGET_EXPRs seen while
 168    inlining functions into caller; the top of TEXPS is supposed to
 169    match RES.  */
 170
 171 tree
 172 tree_inlining_default_hook_copy_res_decl_for_inlining (res, fn, caller,
 173                                                        dm, ndp, texps)
 174      tree res, fn, caller;
 175      void *dm ATTRIBUTE_UNUSED;
 176      int *ndp ATTRIBUTE_UNUSED;
 177      void *texps ATTRIBUTE_UNUSED;
 178 {
 179   return copy_decl_for_inlining (res, fn, caller);
 180 }
 181
 182 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 183    type node representing an anonymous aggregate (union, struct, etc),
 184    i.e., one whose members are in the same scope as the union itself.  */
 185
 186 int
 187 tree_inlining_default_hook_anon_aggr_type_p (t)
 188      tree t ATTRIBUTE_UNUSED;
 189 {
 190   return 0;
 191 }
 192