* langhooks.h: New file.

* Makefile.in (OBJS): Added langhooks.o.
(c-lang.o): Depend on langhooks.h.
(c-common.o): Don't depend on tree-inline.h.
(tree-inline.o): Depend on toplev.h.
(langhooks.o): New rule.
* c-common.c: Don't include tree-inline.h.
(c_mark_lang_decl): Mark argument c as unused.
(c_common_lang_init): Don't initialize hooks here.
* c-lang.c: Include langhooks.h, then override some macros.
(lang_hooks): Initialize with macros in langhooks.h.
(c_init): Don't initialize hooks here.
* toplev.c (struct lang_hooks_for_tree_inlining): New struct.
(struct lang_hooks): Add tree_inlining.  Refer to langhooks.h.
* tree-inline.c: Include toplev.h.  Don't define hook variables.
* tree-inline.h: Don't define hook types nor declare hook
variables.  Move macros to...
* langhooks.c: ... new file, as functions.  Adjust all callers.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@46096 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 142 insertions, 0 deletions

diff --git a/gcc/langhooks.c b/gcc/langhooks.c
new file mode 100644
index 00000000000..dae764c24ab
--- /dev/null
+++ b/gcc/langhooks.c
@@ -0,0 +1,142 @@
+/* Default language-specific hooks.
+   Copyright 2001 Free Software Foundation, Inc.
+   Contributed by Alexandre Oliva  <aoliva@redhat.com>
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "toplev.h"
+#include "tree.h"
+#include "tree-inline.h"
+
+/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
+   after handling common cases, but before walking code-specific
+   sub-trees.  If this hook is overridden for a language, it should
+   handle language-specific tree codes, as well as language-specific
+   information associated to common tree codes.  If a tree node is
+   completely handled within this function, it should set *SUBTREES to
+   0, so that generic handling isn't attempted.  For language-specific
+   tree codes, generic handling would abort(), so make sure it is set
+   properly.  Both SUBTREES and *SUBTREES is guaranteed to be non-zero
+   when the function is called.  */
+
+tree
+tree_inlining_default_hook_walk_subtrees (tp,subtrees,func,data,htab)
+     tree *tp ATTRIBUTE_UNUSED;
+     int *subtrees ATTRIBUTE_UNUSED;
+     walk_tree_fn func ATTRIBUTE_UNUSED;
+     void *data ATTRIBUTE_UNUSED;
+     void *htab ATTRIBUTE_UNUSED;
+{
+  return NULL_TREE;
+}
+
+/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
+   determine whether there are language-specific reasons for not
+   inlining a given function.  */
+
+int
+tree_inlining_default_hook_cannot_inline_tree_fn (fnp)
+     tree *fnp ATTRIBUTE_UNUSED;
+{
+  return 0;
+}
+
+/* lang_hooks.tree_inlining.disregard_inline_limits is called to
+   determine whether a function should be considered for inlining even
+   if it would exceed inlining limits.  */
+
+int
+tree_inlining_default_hook_disregard_inline_limits (fn)
+     tree fn ATTRIBUTE_UNUSED;
+{
+  return 0;
+}
+
+/* lang_hooks.tree_inlining.add_pending_fn_decls is called before
+   starting to inline a function, to push any language-specific
+   functions that should not be inlined into the current function,
+   into VAFNP.  PFN is the top of varray, and should be returned if no
+   functions are pushed into VAFNP.  The top of the varray should be
+   returned.  */
+
+tree
+tree_inlining_default_hook_add_pending_fn_decls (vafnp, pfn)
+     void *vafnp ATTRIBUTE_UNUSED;
+     tree pfn;
+{
+  return pfn;
+}
+
+/* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
+   TREE_CHAIN of a language-specific tree node is relevant, i.e.,
+   whether it should be walked, copied and preserved across copies.  */
+
+int
+tree_inlining_default_hook_tree_chain_matters_p (t)
+     tree t ATTRIBUTE_UNUSED;
+{
+  return 0;
+}
+
+/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
+   whether VT is an automatic variable defined in function FT.  */
+
+int
+tree_inlining_default_hook_auto_var_in_fn_p (var, fn)
+     tree var, fn;
+{
+  return (DECL_P (var) && DECL_CONTEXT (var) == fn
+	  && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
+	       && ! TREE_STATIC (var))
+	      || TREE_CODE (var) == LABEL_DECL
+	      || TREE_CODE (var) == RESULT_DECL));
+}
+
+/* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
+   declaration for the result RES of function FN to be inlined into
+   CALLER.  NDP points to an integer that should be set in case a new
+   declaration wasn't created (presumably because RES was of aggregate
+   type, such that a TARGET_EXPR is used for the result).  TEXPS is a
+   pointer to a varray with the stack of TARGET_EXPRs seen while
+   inlining functions into caller; the top of TEXPS is supposed to
+   match RES.  */
+
+tree
+tree_inlining_default_hook_copy_res_decl_for_inlining (res, fn, caller,
+						       dm, ndp, texps)
+     tree res, fn, caller;
+     void *dm ATTRIBUTE_UNUSED;
+     int *ndp ATTRIBUTE_UNUSED;
+     void *texps ATTRIBUTE_UNUSED;
+{
+  return copy_decl_for_inlining (res, fn, caller);
+}
+
+/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
+   type node representing an anonymous aggregate (union, struct, etc),
+   i.e., one whose members are in the same scope as the union itself.  */
+
+int
+tree_inlining_default_hook_anon_aggr_type_p (t)
+     tree t ATTRIBUTE_UNUSED;
+{
+  return 0;
+}
+