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