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