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