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.  */
  43
  44 void
  45 lhd_do_nothing_t (t)
  46      tree t ATTRIBUTE_UNUSED;
  47 {
  48 }
  49
  50 /* Do nothing (return the tree node passed).  */
  51
  52 tree
  53 lhd_return_tree (t)
  54      tree t;
  55 {
  56   return t;
  57 }
  58
  59 /* Do nothing (return NULL_TREE).  */
  60
  61 tree
  62 lhd_return_null_tree (t)
  63      tree t ATTRIBUTE_UNUSED;
  64 {
  65   return NULL_TREE;
  66 }
  67
  68 /* Do nothing; the default hook to decode an option.  */
  69
  70 int
  71 lhd_decode_option (argc, argv)
  72      int argc ATTRIBUTE_UNUSED;
  73      char **argv ATTRIBUTE_UNUSED;
  74 {
  75   return 0;
  76 }
  77
  78 /* Called from by print-tree.c.  */
  79
  80 void
  81 lhd_print_tree_nothing (file, node, indent)
  82      FILE *file ATTRIBUTE_UNUSED;
  83      tree node ATTRIBUTE_UNUSED;
  84      int indent ATTRIBUTE_UNUSED;
  85 {
  86 }
  87
  88 /* Called from safe_from_p.  */
  89
  90 int
  91 lhd_safe_from_p (x, exp)
  92      rtx x ATTRIBUTE_UNUSED;
  93      tree exp ATTRIBUTE_UNUSED;
  94 {
  95   return 1;
  96 }
  97
  98 /* Called from unsafe_for_reeval.  */
  99
 100 int
 101 lhd_unsafe_for_reeval (t)
 102      tree t ATTRIBUTE_UNUSED;
 103 {
 104   return -1;
 105 }
 106
 107 /* Called from staticp.  */
 108
 109 int
 110 lhd_staticp (exp)
 111      tree exp ATTRIBUTE_UNUSED;
 112 {
 113   return 0;
 114 }
 115
 116 /* Called when -dy is given on the command line.  */
 117
 118 void
 119 lhd_set_yydebug (value)
 120      int value;
 121 {
 122   if (value)
 123     fprintf (stderr, "warning: no yacc/bison-generated output to debug!\n");
 124 }
 125
 126 /* Provide a default routine to clear the binding stack.  This is used
 127    by languages that don't need to do anything special.  */
 128 void
 129 lhd_clear_binding_stack ()
 130 {
 131   while (! (*lang_hooks.decls.global_bindings_p) ())
 132     poplevel (0, 0, 0);
 133 }
 134
 135 /* Provide a default routine for alias sets that always returns -1.  This
 136    is used by languages that don't need to do anything special.  */
 137
 138 HOST_WIDE_INT
 139 lhd_get_alias_set (t)
 140      tree t ATTRIBUTE_UNUSED;
 141 {
 142   return -1;
 143 }
 144
 145 /* Provide a hook routine for alias sets that always returns 0.  This is
 146    used by languages that haven't deal with alias sets yet.  */
 147
 148 HOST_WIDE_INT
 149 hook_get_alias_set_0 (t)
 150      tree t ATTRIBUTE_UNUSED;
 151 {
 152   return 0;
 153 }
 154
 155 /* This is the default expand_expr function.  */
 156
 157 rtx
 158 lhd_expand_expr (t, r, mm, em)
 159      tree t ATTRIBUTE_UNUSED;
 160      rtx r ATTRIBUTE_UNUSED;
 161      enum machine_mode mm ATTRIBUTE_UNUSED;
 162      int em ATTRIBUTE_UNUSED;
 163 {
 164   abort ();
 165 }
 166
 167 /* This is the default decl_printable_name function.  */
 168
 169 const char *
 170 lhd_decl_printable_name (decl, verbosity)
 171      tree decl;
 172      int verbosity ATTRIBUTE_UNUSED;
 173 {
 174   return IDENTIFIER_POINTER (DECL_NAME (decl));
 175 }
 176
 177 /* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
 178    after handling common cases, but before walking code-specific
 179    sub-trees.  If this hook is overridden for a language, it should
 180    handle language-specific tree codes, as well as language-specific
 181    information associated to common tree codes.  If a tree node is
 182    completely handled within this function, it should set *SUBTREES to
 183    0, so that generic handling isn't attempted.  For language-specific
 184    tree codes, generic handling would abort(), so make sure it is set
 185    properly.  Both SUBTREES and *SUBTREES is guaranteed to be non-zero
 186    when the function is called.  */
 187
 188 tree
 189 lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab)
 190      tree *tp ATTRIBUTE_UNUSED;
 191      int *subtrees ATTRIBUTE_UNUSED;
 192      walk_tree_fn func ATTRIBUTE_UNUSED;
 193      void *data ATTRIBUTE_UNUSED;
 194      void *htab ATTRIBUTE_UNUSED;
 195 {
 196   return NULL_TREE;
 197 }
 198
 199 /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
 200    determine whether there are language-specific reasons for not
 201    inlining a given function.  */
 202
 203 int
 204 lhd_tree_inlining_cannot_inline_tree_fn (fnp)
 205      tree *fnp;
 206 {
 207   if (flag_really_no_inline
 208       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
 209     return 1;
 210
 211   return 0;
 212 }
 213
 214 /* lang_hooks.tree_inlining.disregard_inline_limits is called to
 215    determine whether a function should be considered for inlining even
 216    if it would exceed inlining limits.  */
 217
 218 int
 219 lhd_tree_inlining_disregard_inline_limits (fn)
 220      tree fn;
 221 {
 222   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
 223     return 1;
 224
 225   return 0;
 226 }
 227
 228 /* lang_hooks.tree_inlining.add_pending_fn_decls is called before
 229    starting to inline a function, to push any language-specific
 230    functions that should not be inlined into the current function,
 231    into VAFNP.  PFN is the top of varray, and should be returned if no
 232    functions are pushed into VAFNP.  The top of the varray should be
 233    returned.  */
 234
 235 tree
 236 lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn)
 237      void *vafnp ATTRIBUTE_UNUSED;
 238      tree pfn;
 239 {
 240   return pfn;
 241 }
 242
 243 /* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
 244    TREE_CHAIN of a language-specific tree node is relevant, i.e.,
 245    whether it should be walked, copied and preserved across copies.  */
 246
 247 int
 248 lhd_tree_inlining_tree_chain_matters_p (t)
 249      tree t ATTRIBUTE_UNUSED;
 250 {
 251   return 0;
 252 }
 253
 254 /* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
 255    whether VT is an automatic variable defined in function FT.  */
 256
 257 int
 258 lhd_tree_inlining_auto_var_in_fn_p (var, fn)
 259      tree var, fn;
 260 {
 261   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 262           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
 263                && ! TREE_STATIC (var))
 264               || TREE_CODE (var) == LABEL_DECL
 265               || TREE_CODE (var) == RESULT_DECL));
 266 }
 267
 268 /* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
 269    declaration for the result RES of function FN to be inlined into
 270    CALLER.  NDP points to an integer that should be set in case a new
 271    declaration wasn't created (presumably because RES was of aggregate
 272    type, such that a TARGET_EXPR is used for the result).  TEXPS is a
 273    pointer to a varray with the stack of TARGET_EXPRs seen while
 274    inlining functions into caller; the top of TEXPS is supposed to
 275    match RES.  */
 276
 277 tree
 278 lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller,
 279                                               dm, ndp, texps)
 280      tree res, fn, caller;
 281      void *dm ATTRIBUTE_UNUSED;
 282      int *ndp ATTRIBUTE_UNUSED;
 283      void *texps ATTRIBUTE_UNUSED;
 284 {
 285   return copy_decl_for_inlining (res, fn, caller);
 286 }
 287
 288 /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
 289    type node representing an anonymous aggregate (union, struct, etc),
 290    i.e., one whose members are in the same scope as the union itself.  */
 291
 292 int
 293 lhd_tree_inlining_anon_aggr_type_p (t)
 294      tree t ATTRIBUTE_UNUSED;
 295 {
 296   return 0;
 297 }
 298
 299 /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
 300    language-specific bookkeeping necessary for processing
 301    FN. start_inlining returns non-zero if inlining should proceed, zero if
 302    not.
 303
 304    For instance, the C++ version keeps track of template instantiations to
 305    avoid infinite recursion.  */
 306
 307 int
 308 lhd_tree_inlining_start_inlining (fn)
 309      tree fn ATTRIBUTE_UNUSED;
 310 {
 311   return 1;
 312 }
 313
 314 void
 315 lhd_tree_inlining_end_inlining (fn)
 316      tree fn ATTRIBUTE_UNUSED;
 317 {
 318 }
 319
 320 /* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
 321    language-specific conversion before assigning VALUE to PARM.  */
 322
 323 tree
 324 lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
 325      tree parm ATTRIBUTE_UNUSED;
 326      tree value;
 327      tree fndecl ATTRIBUTE_UNUSED;
 328 {
 329   return value;
 330 }
 331
 332 /* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
 333    nodes.  Returns non-zero if it does not want the usual dumping of the
 334    second argument.  */
 335
 336 int
 337 lhd_tree_dump_dump_tree (di, t)
 338      void *di ATTRIBUTE_UNUSED;
 339      tree t ATTRIBUTE_UNUSED;
 340 {
 341   return 0;
 342 }
 343
 344 /* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
 345    language-specific way.  */
 346
 347 int
 348 lhd_tree_dump_type_quals (t)
 349      tree t;
 350 {
 351   return TYPE_QUALS (t);
 352 }
 353