X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flanghooks.c;h=e93204240eeec628f400f2cb7b116370639ffa95;hb=d9c7d5f72f086e52db9148b87d7007fa4ef7d7f0;hp=2bc91481eee5fa764769b628959947014abda780;hpb=e2e9c55bf5046ef8b472712c739cef7f63f68d89;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/langhooks.c b/gcc/langhooks.c
index 2bc91481eee..e93204240ee 100644
--- a/gcc/langhooks.c
+++ b/gcc/langhooks.c
@@ -1,5 +1,5 @@
 /* Default language-specific hooks.
-   Copyright 2001, 2002 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Alexandre Oliva  <aoliva@redhat.com>
 
 This file is part of GCC.
@@ -25,51 +25,59 @@ Boston, MA 02111-1307, USA.  */
 #include "tm.h"
 #include "toplev.h"
 #include "tree.h"
-#include "c-tree.h"
 #include "tree-inline.h"
+#include "tree-gimple.h"
 #include "rtl.h"
 #include "insn-config.h"
 #include "integrate.h"
 #include "flags.h"
 #include "langhooks.h"
 #include "langhooks-def.h"
+#include "ggc.h"
+#include "diagnostic.h"
 
 /* Do nothing; in many cases the default hook.  */
 
 void
-lhd_do_nothing ()
+lhd_do_nothing (void)
 {
 }
 
 /* Do nothing (tree).  */
 
 void
-lhd_do_nothing_t (t)
-     tree t ATTRIBUTE_UNUSED;
+lhd_do_nothing_t (tree ARG_UNUSED (t))
 {
 }
 
 /* Do nothing (int).  */
 
 void
-lhd_do_nothing_i (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 (f)
-     struct function *f ATTRIBUTE_UNUSED;
+lhd_do_nothing_f (struct function * ARG_UNUSED (f))
 {
 }
 
 /* Do nothing (return the tree node passed).  */
 
 tree
-lhd_return_tree (t)
-     tree t;
+lhd_return_tree (tree t)
 {
   return t;
 }
@@ -77,27 +85,23 @@ lhd_return_tree (t)
 /* Do nothing (return NULL_TREE).  */
 
 tree
-lhd_return_null_tree (t)
-     tree t ATTRIBUTE_UNUSED;
+lhd_return_null_tree_v (void)
 {
   return NULL_TREE;
 }
 
-/* Do nothing; the default hook to decode an option.  */
+/* Do nothing (return NULL_TREE).  */
 
-int
-lhd_decode_option (argc, argv)
-     int argc ATTRIBUTE_UNUSED;
-     char **argv ATTRIBUTE_UNUSED;
+tree
+lhd_return_null_tree (tree ARG_UNUSED (t))
 {
-  return 0;
+  return NULL_TREE;
 }
 
 /* The default post options hook.  */
 
 bool
-lhd_post_options (pfilename)
-     const char **pfilename ATTRIBUTE_UNUSED;
+lhd_post_options (const char ** ARG_UNUSED (pfilename))
 {
   return false;
 }
@@ -105,46 +109,32 @@ lhd_post_options (pfilename)
 /* Called from by print-tree.c.  */
 
 void
-lhd_print_tree_nothing (file, node, indent)
-     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 (x, exp)
-     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 (t)
-     tree t ATTRIBUTE_UNUSED;
-{
-  return -1;
-}
-
 /* Called from staticp.  */
 
-int
-lhd_staticp (exp)
-     tree exp ATTRIBUTE_UNUSED;
+bool
+lhd_staticp (tree ARG_UNUSED (exp))
 {
-  return 0;
+  return false;
 }
 
 /* Called from check_global_declarations.  */
 
 bool
-lhd_warn_unused_global_decl (decl)
-     tree decl;
+lhd_warn_unused_global_decl (tree decl)
 {
   /* This is what used to exist in check_global_declarations.  Probably
      not many of these actually apply to non-C languages.  */
@@ -161,8 +151,7 @@ lhd_warn_unused_global_decl (decl)
 
 /* Set the DECL_ASSEMBLER_NAME for DECL.  */
 void
-lhd_set_decl_assembler_name (decl)
-     tree decl;
+lhd_set_decl_assembler_name (tree decl)
 {
   /* The language-independent code should never use the
      DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
@@ -173,12 +162,27 @@ lhd_set_decl_assembler_name (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.  */
-    SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (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
+	{
+	  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
@@ -188,32 +192,28 @@ lhd_set_decl_assembler_name (decl)
 
 /* By default we always allow bit-field based optimizations.  */
 bool
-lhd_can_use_bit_fields_p ()
+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 ()
-{
-  while (! (*lang_hooks.decls.global_bindings_p) ())
-    poplevel (0, 0, 0);
-}
-
 /* Type promotion for variable arguments.  */
 tree
-lhd_type_promotes_to (type)
-     tree type ATTRIBUTE_UNUSED;
+lhd_type_promotes_to (tree ARG_UNUSED (type))
 {
   abort ();
 }
 
+/* Registration of machine- or os-specific builtin types.  */
+void
+lhd_register_builtin_type (tree ARG_UNUSED (type),
+			   const char * ARG_UNUSED (name))
+{
+}
+
 /* Invalid use of an incomplete type.  */
 void
-lhd_incomplete_type_error (value, type)
-     tree value ATTRIBUTE_UNUSED, type;
+lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
 {
   if (TREE_CODE (type) == ERROR_MARK)
     return;
@@ -225,8 +225,7 @@ lhd_incomplete_type_error (value, type)
    is used by languages that don't need to do anything special.  */
 
 HOST_WIDE_INT
-lhd_get_alias_set (t)
-     tree t ATTRIBUTE_UNUSED;
+lhd_get_alias_set (tree ARG_UNUSED (t))
 {
   return -1;
 }
@@ -235,8 +234,7 @@ lhd_get_alias_set (t)
    used by languages that haven't deal with alias sets yet.  */
 
 HOST_WIDE_INT
-hook_get_alias_set_0 (t)
-     tree t ATTRIBUTE_UNUSED;
+hook_get_alias_set_0 (tree ARG_UNUSED (t))
 {
   return 0;
 }
@@ -244,25 +242,44 @@ hook_get_alias_set_0 (t)
 /* This is the default expand_expr function.  */
 
 rtx
-lhd_expand_expr (t, r, mm, em)
-     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))
 {
   abort ();
 }
 
+/* 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))
+{
+  return 0;
+}
+
 /* This is the default decl_printable_name function.  */
 
 const char *
-lhd_decl_printable_name (decl, verbosity)
-     tree decl;
-     int verbosity ATTRIBUTE_UNUSED;
+lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 {
   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
@@ -275,12 +292,11 @@ lhd_decl_printable_name (decl, verbosity)
    when the function is called.  */
 
 tree
-lhd_tree_inlining_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;
+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)
 {
   return NULL_TREE;
 }
@@ -290,8 +306,7 @@ lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab)
    inlining a given function.  */
 
 int
-lhd_tree_inlining_cannot_inline_tree_fn (fnp)
-     tree *fnp;
+lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
 {
   if (flag_really_no_inline
       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
@@ -305,8 +320,7 @@ lhd_tree_inlining_cannot_inline_tree_fn (fnp)
    if it would exceed inlining limits.  */
 
 int
-lhd_tree_inlining_disregard_inline_limits (fn)
-     tree fn;
+lhd_tree_inlining_disregard_inline_limits (tree fn)
 {
   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
     return 1;
@@ -322,30 +336,16 @@ lhd_tree_inlining_disregard_inline_limits (fn)
    returned.  */
 
 tree
-lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn)
-     void *vafnp ATTRIBUTE_UNUSED;
-     tree pfn;
+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 (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
-lhd_tree_inlining_auto_var_in_fn_p (var, fn)
-     tree var, fn;
+lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
 {
   return (DECL_P (var) && DECL_CONTEXT (var) == fn
 	  && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
@@ -354,37 +354,12 @@ lhd_tree_inlining_auto_var_in_fn_p (var, 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 (res, fn, caller,
-					      dm, ndp, return_slot_addr)
-     tree res, fn, 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.  */
 
 int
-lhd_tree_inlining_anon_aggr_type_p (t)
-     tree t ATTRIBUTE_UNUSED;
+lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
 {
   return 0;
 }
@@ -398,15 +373,13 @@ lhd_tree_inlining_anon_aggr_type_p (t)
    avoid infinite recursion.  */
 
 int
-lhd_tree_inlining_start_inlining (fn)
-     tree fn ATTRIBUTE_UNUSED;
+lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
 {
   return 1;
 }
 
 void
-lhd_tree_inlining_end_inlining (fn)
-     tree fn ATTRIBUTE_UNUSED;
+lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
 {
 }
 
@@ -414,10 +387,10 @@ lhd_tree_inlining_end_inlining (fn)
    language-specific conversion before assigning VALUE to PARM.  */
 
 tree
-lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
-     tree parm ATTRIBUTE_UNUSED;
-     tree value;
-     tree fndecl ATTRIBUTE_UNUSED;
+lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
+					     tree value,
+					     tree fndecl ATTRIBUTE_UNUSED,
+					     int argnum ATTRIBUTE_UNUSED)
 {
   return value;
 }
@@ -427,9 +400,7 @@ lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
    second argument.  */
 
 bool
-lhd_tree_dump_dump_tree (di, t)
-     void *di ATTRIBUTE_UNUSED;
-     tree t ATTRIBUTE_UNUSED;
+lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 {
   return false;
 }
@@ -438,8 +409,7 @@ lhd_tree_dump_dump_tree (di, t)
    language-specific way.  */
 
 int
-lhd_tree_dump_type_quals (t)
-     tree t;
+lhd_tree_dump_type_quals (tree t)
 {
   return TYPE_QUALS (t);
 }
@@ -448,8 +418,7 @@ lhd_tree_dump_type_quals (t)
    in a language-specific way.  Returns a tree for the size in bytes.  */
 
 tree
-lhd_expr_size (exp)
-     tree exp;
+lhd_expr_size (tree exp)
 {
   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
       && DECL_SIZE_UNIT (exp) != 0)
@@ -458,12 +427,20 @@ lhd_expr_size (exp)
     return size_in_bytes (TREE_TYPE (exp));
 }
 
+/* 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 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.  */
 size_t
-lhd_tree_size (c)
-     enum tree_code c ATTRIBUTE_UNUSED;
+lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
 {
   abort ();
   return 0;
@@ -473,8 +450,7 @@ lhd_tree_size (c)
    sibcall.  */
 
 bool
-lhd_decl_ok_for_sibcall (decl)
-     tree decl ATTRIBUTE_UNUSED;
+lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
 {
   return true;
 }
@@ -482,15 +458,15 @@ lhd_decl_ok_for_sibcall (decl)
 /* lang_hooks.decls.final_write_globals: perform final processing on
    global variables.  */
 void
-write_global_declarations ()
+write_global_declarations (void)
 {
   /* Really define vars that have had only a tentative definition.
      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 = (tree *) xmalloc (sizeof (tree) * len);
+  tree *vec = xmalloc (sizeof (tree) * len);
   int i;
   tree decl;
 
@@ -507,3 +483,56 @@ write_global_declarations ()
     /* Clean up.  */
   free (vec);
 }
+
+/* Called to perform language-specific initialization of CTX.  */
+void
+lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
+{
+}
+
+/* The default function to print out name of current function that caused
+   an error.  */
+void
+lhd_print_error_function (diagnostic_context *context, const char *file)
+{
+  if (diagnostic_last_function_changed (context))
+    {
+      const char *old_prefix = context->printer->prefix;
+      char *new_prefix = file ? file_name_as_prefix (file) : NULL;
+
+      pp_set_prefix (context->printer, new_prefix);
+
+      if (current_function_decl == NULL)
+	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));
+	  else
+	    pp_printf
+	      (context->printer, "In function `%s':",
+	       lang_hooks.decl_printable_name (current_function_decl, 2));
+	}
+
+      diagnostic_set_last_function (context);
+      pp_flush (context->printer);
+      context->printer->prefix = old_prefix;
+      free ((char*) new_prefix);
+    }
+}
+
+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);
+}