X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flanghooks.c;h=d7ed7505300790e6dd892944ba01cae0844cc1ef;hb=29f9683a5f2242786773eaa8f066001a39f18c82;hp=622e0626801d54c6d7d37642b68fac8b6996dd83;hpb=2a576742fab3c384196446017f65f4ce9077ceb7;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/langhooks.c b/gcc/langhooks.c
index 622e0626801..d7ed7505300 100644
--- a/gcc/langhooks.c
+++ b/gcc/langhooks.c
@@ -1,5 +1,5 @@
 /* Default language-specific hooks.
-   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    Contributed by Alexandre Oliva  <aoliva@redhat.com>
 
 This file is part of GCC.
@@ -16,16 +16,18 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
+#include "intl.h"
 #include "tm.h"
 #include "toplev.h"
 #include "tree.h"
 #include "tree-inline.h"
+#include "tree-gimple.h"
 #include "rtl.h"
 #include "insn-config.h"
 #include "integrate.h"
@@ -45,21 +47,31 @@ lhd_do_nothing (void)
 /* Do nothing (tree).  */
 
 void
-lhd_do_nothing_t (tree t ATTRIBUTE_UNUSED)
+lhd_do_nothing_t (tree ARG_UNUSED (t))
 {
 }
 
 /* Do nothing (int).  */
 
 void
-lhd_do_nothing_i (int i ATTRIBUTE_UNUSED)
+lhd_do_nothing_i (int ARG_UNUSED (i))
 {
 }
 
+/* Do nothing (int, int, int).  Return NULL_TREE.  */
+
+tree
+lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
+				     int ARG_UNUSED (j),
+				     int ARG_UNUSED (k))
+{
+  return NULL_TREE;
+}
+
 /* Do nothing (function).  */
 
 void
-lhd_do_nothing_f (struct function *f ATTRIBUTE_UNUSED)
+lhd_do_nothing_f (struct function * ARG_UNUSED (f))
 {
 }
 
@@ -74,7 +86,15 @@ lhd_return_tree (tree t)
 /* Do nothing (return NULL_TREE).  */
 
 tree
-lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
+lhd_return_null_tree_v (void)
+{
+  return NULL_TREE;
+}
+
+/* Do nothing (return NULL_TREE).  */
+
+tree
+lhd_return_null_tree (tree ARG_UNUSED (t))
 {
   return NULL_TREE;
 }
@@ -82,7 +102,7 @@ lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
 /* The default post options hook.  */
 
 bool
-lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
+lhd_post_options (const char ** ARG_UNUSED (pfilename))
 {
   return false;
 }
@@ -90,34 +110,26 @@ lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
 /* Called from by print-tree.c.  */
 
 void
-lhd_print_tree_nothing (FILE *file ATTRIBUTE_UNUSED,
-			tree node ATTRIBUTE_UNUSED,
-			int indent ATTRIBUTE_UNUSED)
+lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
+			tree ARG_UNUSED (node),
+			int ARG_UNUSED (indent))
 {
 }
 
 /* Called from safe_from_p.  */
 
 int
-lhd_safe_from_p (rtx x ATTRIBUTE_UNUSED, tree exp ATTRIBUTE_UNUSED)
+lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp))
 {
   return 1;
 }
 
-/* Called from unsafe_for_reeval.  */
-
-int
-lhd_unsafe_for_reeval (tree t ATTRIBUTE_UNUSED)
-{
-  return -1;
-}
-
 /* Called from staticp.  */
 
-int
-lhd_staticp (tree exp ATTRIBUTE_UNUSED)
+tree
+lhd_staticp (tree ARG_UNUSED (exp))
 {
-  return 0;
+  return NULL;
 }
 
 /* Called from check_global_declarations.  */
@@ -138,11 +150,6 @@ lhd_warn_unused_global_decl (tree decl)
   return true;
 }
 
-/* Number for making the label on the next
-   static variable internal to a function.  */
-
-static GTY(()) int var_labelno;
-
 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 void
 lhd_set_decl_assembler_name (tree decl)
@@ -151,38 +158,31 @@ lhd_set_decl_assembler_name (tree decl)
      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
      VAR_DECLs for variables with static storage duration need a real
      DECL_ASSEMBLER_NAME.  */
-  if (TREE_CODE (decl) == FUNCTION_DECL
-      || (TREE_CODE (decl) == VAR_DECL
-	  && (TREE_STATIC (decl)
-	      || DECL_EXTERNAL (decl)
-	      || TREE_PUBLIC (decl))))
+  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
+	      || (TREE_CODE (decl) == VAR_DECL
+		  && (TREE_STATIC (decl)
+		      || DECL_EXTERNAL (decl)
+		      || TREE_PUBLIC (decl))));
+  
+  /* By default, assume the name to use in assembly code is the same
+     as that used in the source language.  (That's correct for C, and
+     GCC used to set DECL_ASSEMBLER_NAME to the same value as
+     DECL_NAME in build_decl, so this choice provides backwards
+     compatibility with existing front-ends.
+      
+     Can't use just the variable's own name for a variable whose scope
+     is less than the whole compilation.  Concatenate a distinguishing
+     number - we use the DECL_UID.  */
+  if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
+    SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+  else
     {
-      /* By default, assume the name to use in assembly code is the
-	 same as that used in the source language.  (That's correct
-	 for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
-	 value as DECL_NAME in build_decl, so this choice provides
-	 backwards compatibility with existing front-ends.  
-
-         Can't use just the variable's own name for a variable whose
-	 scope is less than the whole compilation.  Concatenate a
-	 distinguishing number.  */
-      if (!TREE_PUBLIC (decl) && DECL_CONTEXT (decl))
-	{
-	  const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
-	  char *label;
-	  
-	  ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
-	  var_labelno++;
-	  SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
-	}
-      else
-	SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+      const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+      char *label;
+      
+      ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
     }
-  else
-    /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
-       these DECLs -- unless they're in language-dependent code, in
-       which case set_decl_assembler_name hook should handle things.  */
-    abort ();
 }
 
 /* By default we always allow bit-field based optimizations.  */
@@ -192,37 +192,33 @@ lhd_can_use_bit_fields_p (void)
   return true;
 }
 
-/* Provide a default routine to clear the binding stack.  This is used
-   by languages that don't need to do anything special.  */
-void
-lhd_clear_binding_stack (void)
+/* Type promotion for variable arguments.  */
+tree
+lhd_type_promotes_to (tree ARG_UNUSED (type))
 {
-  while (! (*lang_hooks.decls.global_bindings_p) ())
-    poplevel (0, 0, 0);
+  gcc_unreachable ();
 }
 
-/* Type promotion for variable arguments.  */
-tree
-lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
+/* Registration of machine- or os-specific builtin types.  */
+void
+lhd_register_builtin_type (tree ARG_UNUSED (type),
+			   const char * ARG_UNUSED (name))
 {
-  abort ();
 }
 
 /* Invalid use of an incomplete type.  */
 void
-lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
+lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
 {
-  if (TREE_CODE (type) == ERROR_MARK)
-    return;
-
-  abort ();
+  gcc_assert (TREE_CODE (type) == ERROR_MARK);
+  return;
 }
 
 /* Provide a default routine for alias sets that always returns -1.  This
    is used by languages that don't need to do anything special.  */
 
 HOST_WIDE_INT
-lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
+lhd_get_alias_set (tree ARG_UNUSED (t))
 {
   return -1;
 }
@@ -231,7 +227,7 @@ lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
    used by languages that haven't deal with alias sets yet.  */
 
 HOST_WIDE_INT
-hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
+hook_get_alias_set_0 (tree ARG_UNUSED (t))
 {
   return 0;
 }
@@ -239,38 +235,62 @@ hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
 /* This is the default expand_expr function.  */
 
 rtx
-lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
-		 enum machine_mode mm ATTRIBUTE_UNUSED,
-		 int em ATTRIBUTE_UNUSED)
+lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
+		 enum machine_mode ARG_UNUSED (mm),
+		 int ARG_UNUSED (em),
+		 rtx * ARG_UNUSED (a))
+{
+  gcc_unreachable ();
+}
+
+/* The default language-specific function for expanding a decl.  After
+   the language-independent cases are handled, this function will be
+   called.  If this function is not defined, it is assumed that
+   declarations other than those for variables and labels do not require
+   any RTL generation.  */
+
+int
+lhd_expand_decl (tree ARG_UNUSED (t))
 {
-  abort ();
+  return 0;
 }
 
 /* This is the default decl_printable_name function.  */
 
 const char *
-lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
+lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 {
+  gcc_assert (decl && DECL_NAME (decl));
   return IDENTIFIER_POINTER (DECL_NAME (decl));
 }
 
+/* This compares two types for equivalence ("compatible" in C-based languages).
+   This routine should only return 1 if it is sure.  It should not be used
+   in contexts where erroneously returning 0 causes problems.  */
+
+int
+lhd_types_compatible_p (tree x, tree y)
+{
+  return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
+}
+
 /* 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 nonzero
-   when the function is called.  */
+   0, so that generic handling isn't attempted.  The generic handling
+   cannot deal with language-specific tree codes, so make sure it is
+   set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
+   nonzero when the function is called.  */
 
 tree
 lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 				 int *subtrees ATTRIBUTE_UNUSED,
 				 walk_tree_fn func ATTRIBUTE_UNUSED,
 				 void *data ATTRIBUTE_UNUSED,
-				 void *htab ATTRIBUTE_UNUSED)
+				 struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 {
   return NULL_TREE;
 }
@@ -315,16 +335,6 @@ lhd_tree_inlining_add_pending_fn_decls (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
-lhd_tree_inlining_tree_chain_matters_p (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.  */
 
@@ -338,28 +348,6 @@ lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 	      || 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
-lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
-					      void *dm ATTRIBUTE_UNUSED,
-					      int *ndp ATTRIBUTE_UNUSED,
-					      tree return_slot_addr ATTRIBUTE_UNUSED)
-{
-  if (return_slot_addr)
-    return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
-		   return_slot_addr);
-  else
-    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.  */
@@ -395,7 +383,8 @@ lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 tree
 lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
 					     tree value,
-					     tree fndecl ATTRIBUTE_UNUSED)
+					     tree fndecl ATTRIBUTE_UNUSED,
+					     int argnum ATTRIBUTE_UNUSED)
 {
   return value;
 }
@@ -425,29 +414,29 @@ lhd_tree_dump_type_quals (tree t)
 tree
 lhd_expr_size (tree exp)
 {
-  if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
+  if (DECL_P (exp)
       && DECL_SIZE_UNIT (exp) != 0)
     return DECL_SIZE_UNIT (exp);
   else
     return size_in_bytes (TREE_TYPE (exp));
 }
-/* lang_hooks.decl_uninit: Find out if a variable is uninitialized based
-   on DECL_INITIAL.  */
 
-bool
-lhd_decl_uninit (tree t ATTRIBUTE_UNUSED)
+/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
+
+int
+lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
+		   tree *post_p ATTRIBUTE_UNUSED)
 {
-  return false;
+  return GS_UNHANDLED;
 }
 
 /* lang_hooks.tree_size: Determine the size of a tree with code C,
-   which is a language-specific tree code in category 'x'.  The
-   default expects never to be called.  */
+   which is a language-specific tree code in category tcc_constant or
+   tcc_exceptional.  The default expects never to be called.  */
 size_t
 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 {
-  abort ();
-  return 0;
+  gcc_unreachable ();
 }
 
 /* Return true if decl, which is a function decl, may be called by a
@@ -459,6 +448,14 @@ lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
   return true;
 }
 
+/* Return the COMDAT group into which DECL should be placed.  */
+
+const char *
+lhd_comdat_group (tree decl)
+{
+  return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+}
+
 /* lang_hooks.decls.final_write_globals: perform final processing on
    global variables.  */
 void
@@ -468,7 +465,7 @@ write_global_declarations (void)
      Really output inline functions that must actually be callable
      and have not been output so far.  */
 
-  tree globals = (*lang_hooks.decls.getdecls) ();
+  tree globals = lang_hooks.decls.getdecls ();
   int len = list_length (globals);
   tree *vec = xmalloc (sizeof (tree) * len);
   int i;
@@ -481,10 +478,10 @@ write_global_declarations (void)
     vec[len - i - 1] = decl;
 
   wrapup_global_declarations (vec, len);
-
   check_global_declarations (vec, len);
+  emit_debug_global_declarations (vec, len);
 
-    /* Clean up.  */
+  /* Clean up.  */
   free (vec);
 }
 
@@ -507,19 +504,18 @@ lhd_print_error_function (diagnostic_context *context, const char *file)
       pp_set_prefix (context->printer, new_prefix);
 
       if (current_function_decl == NULL)
-	pp_printf (context->printer, "At top level:");
+	pp_printf (context->printer, _("At top level:"));
       else
 	{
 	  if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 	    pp_printf
-	      (context->printer, "In member function `%s':",
-	       (*lang_hooks.decl_printable_name) (current_function_decl, 2));
+	      (context->printer, _("In member function %qs:"),
+	       lang_hooks.decl_printable_name (current_function_decl, 2));
 	  else
 	    pp_printf
-	      (context->printer, "In function `%s':",
-	       (*lang_hooks.decl_printable_name) (current_function_decl, 2));
+	      (context->printer, _("In function %qs:"),
+	       lang_hooks.decl_printable_name (current_function_decl, 2));
 	}
-      pp_newline (context->printer);
 
       diagnostic_set_last_function (context);
       pp_flush (context->printer);
@@ -528,4 +524,29 @@ lhd_print_error_function (diagnostic_context *context, const char *file)
     }
 }
 
-#include "gt-langhooks.h"
+tree
+lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
+			    int *walk_subtrees ATTRIBUTE_UNUSED,
+			    tree decl ATTRIBUTE_UNUSED)
+{
+  return NULL;
+}
+
+tree
+lhd_make_node (enum tree_code code)
+{
+  return make_node (code);
+}
+
+HOST_WIDE_INT
+lhd_to_target_charset (HOST_WIDE_INT c)
+{
+  return c;
+}
+
+tree
+lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
+		  bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
+{
+  return expr;
+}