Add some patches against basesrc gcc implementing the "if-exists"

function in the specs file.  Enables the linker to pick
up crti.o and crtn.o if they exist.

4 files changed, 527 insertions, 3 deletions

diff --git a/lang/gcc/Makefile b/lang/gcc/Makefile
index 85410c93cc3..c3d3e71b3c6 100644
--- a/lang/gcc/Makefile
+++ b/lang/gcc/Makefile
@@ -1,7 +1,7 @@
-# $NetBSD: Makefile,v 1.65 2003/07/06 14:28:08 seb Exp $
+# $NetBSD: Makefile,v 1.66 2003/07/12 08:53:40 jtb Exp $
 
 DISTNAME=		gcc-2.95.3
-PKGREVISION=		3
+PKGREVISION=		4
 CATEGORIES=		lang
 MASTER_SITES=		${MASTER_SITE_GNU:=gcc/}
 
diff --git a/lang/gcc/distinfo b/lang/gcc/distinfo
index 24bf75083dc..55b94f0d4c2 100644
--- a/lang/gcc/distinfo
+++ b/lang/gcc/distinfo
@@ -1,4 +1,4 @@
-$NetBSD: distinfo,v 1.19 2003/07/04 16:27:24 seb Exp $
+$NetBSD: distinfo,v 1.20 2003/07/12 08:53:40 jtb Exp $
 
 SHA1 (gcc-2.95.3.tar.gz) = 535d27038d161c0e7c2662702e11a48aa97ef622
 Size (gcc-2.95.3.tar.gz) = 12911721 bytes
@@ -9,3 +9,5 @@ SHA1 (patch-ab) = 0a9df2c9abb9a3965c085769eb09a6912f894388
 SHA1 (patch-ac) = f42b5ab389c3a51991e61cdb7533875003308001
 SHA1 (patch-ad) = 2fb8cda55220bd202a4b7948277d00f293718caf
 SHA1 (patch-ae) = b9721d3e89a93736b926e1efcfb9d0fb4904277f
+SHA1 (patch-af) = 72d27bfecb2633a1f184cfe9cc8b1194c0d57dfe
+SHA1 (patch-ag) = bb4d84561d20d2379a71a442b8711b2c54cf4bf2
diff --git a/lang/gcc/patches/patch-af b/lang/gcc/patches/patch-af
new file mode 100644
index 00000000000..844a0630ffa
--- /dev/null
+++ b/lang/gcc/patches/patch-af
@@ -0,0 +1,161 @@
+$NetBSD: patch-af,v 1.9 2003/07/12 08:53:40 jtb Exp $
+
+--- ../gcc-2.95.3/gcc/config/netbsd.h
++++ ../gcc-2.95.3/gcc/config/netbsd.h.orig
+@@ -36,10 +36,13 @@
+ 
+ 
+ /* Provide a CPP_SPEC appropriate for NetBSD.  Current we just deal with
+-   the GCC option `-posix'.  */
++   the GCC option `-posix'.  We also deal with -pthread, which is required
++   for the 2.95.3 STL to work.  */
+ 
+ #undef CPP_SPEC
+-#define CPP_SPEC "%(cpp_cpu) %{posix:-D_POSIX_SOURCE}"
++#define CPP_SPEC \
++  "%(cpp_cpu) %{posix:-D_POSIX_SOURCE} \
++   %{pthread:-D_REENTRANT -D_PTHREADS}"
+ 
+ /* Provide an ASM_SPEC appropriate for NetBSD.  Currently we only deal
+    with the options for generating PIC code.  */
+@@ -54,7 +57,8 @@
+ 
+ #undef LIB_SPEC
+ #define LIB_SPEC							\
+-  "%{posix:%{!p:%{!pg:-lposix}}%{p:-lposix_p}%{pg:-lposix_p}}		\
++  "%{pthread:%{!p:%{!pg:-lpthread}}%{p:-lpthread_p}%{pg:-lpthread_p}}	\
++   %{posix:%{!p:%{!pg:-lposix}}%{p:-lposix_p}%{pg:-lposix_p}}		\
+    %{!shared:%{!symbolic:%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}}"
+ 
+ /* Provide a LIBGCC_SPEC appropriate for NetBSD.  We also want to exclude
+@@ -64,7 +68,7 @@
+ #ifdef  NETBSD_NATIVE
+ #define LIBGCC_SPEC "%{!symbolic:%{!shared:%{!p:%{!pg:-lgcc}}}%{shared:-lgcc_pic}%{p:-lgcc_p}%{pg:-lgcc_p}}"
+ #else
+-#define LIBGCC_SPEC "%{!shared:%{!symbolic:-lgcc}}"
++#define LIBGCC_SPEC "%{!symbolic:%{!shared:-lgcc}%{shared:-lgcc_pic}}"
+ #endif
+ 
+ /* #ifdef NETBSD_AOUT */
+@@ -147,6 +151,96 @@
+ #define ASM_DECLARE_RESULT(FILE, RESULT)
+ #endif
+ 
++/* NetBSD a.out support begins here. */
++
++#ifndef NETBSD_ELF
++
++#undef DWARF_DEBUGGING_INFO	/* XXX */
++#undef DWARF2_DEBUGGING_INFO	/* XXX */
++
++/* Write the extra assembler code needed to declare a function properly.
++   Some svr4 assemblers need to also have something extra said about the
++   function's return value.  We allow for that here.  */
++
++#undef ASM_DECLARE_FUNCTION_NAME
++#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)			\
++  do {									\
++    fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);				\
++    assemble_name (FILE, NAME);						\
++    putc (',', FILE);							\
++    fprintf (FILE, TYPE_OPERAND_FMT, "function");			\
++    putc ('\n', FILE);							\
++    ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));			\
++    ASM_OUTPUT_LABEL(FILE, NAME);					\
++  } while (0)
++
++/* Write the extra assembler code needed to declare an object properly.  */
++
++#undef ASM_DECLARE_OBJECT_NAME
++#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)			\
++  do {									\
++    fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);				\
++    assemble_name (FILE, NAME);						\
++    putc (',', FILE);							\
++    fprintf (FILE, TYPE_OPERAND_FMT, "object");				\
++    putc ('\n', FILE);							\
++    size_directive_output = 0;						\
++    if (!flag_inhibit_size_directive && DECL_SIZE (DECL))		\
++      {									\
++	size_directive_output = 1;					\
++	fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);				\
++	assemble_name (FILE, NAME);					\
++	fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL)));	\
++      }									\
++    ASM_OUTPUT_LABEL(FILE, NAME);					\
++  } while (0)
++
++/* Output the size directive for a decl in rest_of_decl_compilation
++   in the case where we did not do so before the initializer.
++   Once we find the error_mark_node, we know that the value of
++   size_directive_output was set
++   by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
++
++#undef ASM_FINISH_DECLARE_OBJECT
++#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)	 \
++do {									 \
++     char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);			 \
++     if (!flag_inhibit_size_directive && DECL_SIZE (DECL)		 \
++         && ! AT_END && TOP_LEVEL					 \
++	 && DECL_INITIAL (DECL) == error_mark_node			 \
++	 && !size_directive_output)					 \
++       {								 \
++	 size_directive_output = 1;					 \
++	 fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);			 \
++	 assemble_name (FILE, name);					 \
++	 fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
++       }								 \
++   } while (0)
++
++/* This is how to declare the size of a function.  */
++
++#undef ASM_DECLARE_FUNCTION_SIZE
++#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)			\
++  do {									\
++    if (!flag_inhibit_size_directive)					\
++      {									\
++        char label[256];						\
++	static int labelno;						\
++	labelno++;							\
++	ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);		\
++	ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);		\
++	fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);				\
++	assemble_name (FILE, (FNAME));					\
++        fprintf (FILE, ",");						\
++	assemble_name (FILE, label);					\
++        fprintf (FILE, "-");						\
++	assemble_name (FILE, (FNAME));					\
++	putc ('\n', FILE);						\
++      }									\
++  } while (0)
++
++#endif
++
+ /* NetBSD ELF support begins here. */
+ 
+ #ifdef NETBSD_ELF
+@@ -167,6 +261,7 @@
+      %{!pg: \
+         %{p:gcrt0%O%s} \
+         %{!p:crt0%O%s}}} \
++   %:if-exists(crti%O%s) \
+    %{!shared:crtbegin%O%s} %{shared:crtbeginS%O%s}"
+ 
+ /* Provide an ENDFILE_SPEC appropriate for NetBSD ELF targets.  Here we
+@@ -175,13 +270,14 @@
+ 
+ #undef ENDFILE_SPEC
+ #define	ENDFILE_SPEC \
+- "%{!shared:crtend%O%s} %{shared:crtendS%O%s}"
++ "%{!shared:crtend%O%s} %{shared:crtendS%O%s} \
++  %:if-exists(crtn%O%s)"
+ 
+ /* Provide a LINK_SPEC appropriate for a NetBSD ELF target.  */
+ 
+ #undef LINK_SPEC
+ #define	LINK_SPEC \
+- "%{assert*} \
++ "%{assert*} %{R*} \
+   %{shared:-shared} \
+   %{!shared: \
+     -dc -dp \
diff --git a/lang/gcc/patches/patch-ag b/lang/gcc/patches/patch-ag
new file mode 100644
index 00000000000..078ebbb920f
--- /dev/null
+++ b/lang/gcc/patches/patch-ag
@@ -0,0 +1,361 @@
+$NetBSD: patch-ag,v 1.8 2003/07/12 08:53:40 jtb Exp $
+
+--- ../gcc-2.95.3/gcc/gcc.c.orig
++++ ../gcc-2.95.3/gcc/gcc.c
+@@ -189,9 +189,13 @@
+ static void clear_failure_queue PROTO((void));
+ static int check_live_switch	PROTO((int, int));
+ static const char *handle_braces PROTO((const char *));
++static const struct spec_function *lookup_spec_function PROTO((const char *));
++static const char *eval_spec_function PROTO((const char *, const char *));
++static const char *handle_spec_function PROTO((const char *));
+ static char *save_string	PROTO((const char *, int));
+ extern int do_spec		PROTO((const char *));
+ static int do_spec_1		PROTO((const char *, int, const char *));
++static int do_spec_2		PROTO((const char *));
+ static const char *find_file	PROTO((const char *));
+ static int is_directory		PROTO((const char *, const char *, int));
+ static void validate_switches	PROTO((const char *));
+@@ -216,6 +220,7 @@
+ static void process_command		PROTO ((int, char **));
+ static int execute			PROTO ((void));
+ static void unused_prefix_warnings	PROTO ((struct path_prefix *));
++static void alloc_args			PROTO ((void));
+ static void clear_args			PROTO ((void));
+ static void fatal_error			PROTO ((int));
+ 
+@@ -231,6 +236,8 @@
+ /* Number of extra output files that lang_specific_pre_link may generate. */
+ extern int lang_specific_extra_outfiles;
+ 
++static const char *if_exists_spec_function PROTO ((int, const char **));
++
+ /* Specs are strings containing lines, each of which (if not blank)
+ is made up of a program name, and arguments separated by spaces.
+ The program name must be exact and start from root, since no path
+@@ -335,6 +342,12 @@
+  %*	substitute the variable part of a matched option.  (See below.)
+ 	Note that each comma in the substituted string is replaced by
+ 	a single space.
++ %:function(args)
++	Call the named function FUNCTION, passing it ARGS.  ARGS is
++	first processed as a nested spec string, then split into an
++	argument vector in the usual fashion.  The function returns
++	a string which is processed as if it had appeared literally
++	as part of the current spec.
+  %{S}   substitutes the -S switch, if that switch was given to CC.
+ 	If that switch was not specified, this substitutes nothing.
+ 	Here S is a metasyntactic variable.
+@@ -1162,6 +1175,24 @@
+ static struct spec_list *specs = (struct spec_list *)0;
+ 
+ 
++/* The mapping of a spec function name to the C function that
++   implements it.  */
++struct spec_function
++{
++  const char *name;
++  const char *(*func) PROTO ((int, const char **));
++};
++
++/* List of static spec functions.  */
++
++static const struct spec_function static_spec_functions[] =
++{
++  { "if-exists",		if_exists_spec_function },
++  { 0, 0 }
++};
++
++static int processing_spec_function;
++
+ /* Initialize the specs lookup routines.  */
+ 
+ static void
+@@ -1404,6 +1435,15 @@
+ 
+ static const char *multilib_dir;
+ 
++/* Allocate the argument vector.  */
++
++static void
++alloc_args ()
++{
++  argbuf_length = 10;
++  argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
++}
++
+ /* Clear out the vector of arguments (after a command is executed).  */
+ 
+ static void
+@@ -2211,6 +2251,9 @@
+ 
+   struct command *commands;	/* each command buffer with above info.  */
+ 
++  if (processing_spec_function)
++    abort ();
++
+   /* Count # of piped commands.  */
+   for (n_commands = 1, i = 0; i < argbuf_index; i++)
+     if (strcmp (argbuf[i], "|") == 0)
+@@ -3360,14 +3403,7 @@
+ {
+   int value;
+ 
+-  clear_args ();
+-  arg_going = 0;
+-  delete_this_arg = 0;
+-  this_is_output_file = 0;
+-  this_is_library_file = 0;
+-  input_from_pipe = 0;
+-
+-  value = do_spec_1 (spec, 0, NULL_PTR);
++  value = do_spec_2 (spec);
+ 
+   /* Force out any unfinished command.
+      If -pipe, this forces out the last command if it ended in `|'.  */
+@@ -3383,6 +3419,20 @@
+   return value;
+ }
+ 
++static int
++do_spec_2 (spec)
++     const char *spec;
++{
++  clear_args ();
++  arg_going = 0;
++  delete_this_arg = 0;
++  this_is_output_file = 0;
++  this_is_library_file = 0;
++  input_from_pipe = 0;
++
++  return do_spec_1 (spec, 0, NULL_PTR);
++}
++
+ /* Process the sub-spec SPEC as a portion of a larger spec.
+    This is like processing a whole spec except that we do
+    not initialize at the beginning and we do not supply a
+@@ -4068,6 +4118,12 @@
+ 	      return -1;
+ 	    break;
+ 
++	  case ':':
++	    p = handle_spec_function (p);
++	    if (p == 0)
++	      return -1;
++	    break;
++
+ 	  case '%':
+ 	    obstack_1grow (&obstack, '%');
+ 	    break;
+@@ -4222,7 +4278,173 @@
+ 	arg_going = 1;
+       }
+ 
+-  return 0;		/* End of string */
++  /* End of string.  If we are processing a spec function, we need to
++     end any pending argument.  */
++  if (processing_spec_function && arg_going)
++    {
++      obstack_1grow (&obstack, 0);
++      string = obstack_finish (&obstack);
++      if (this_is_library_file)
++	string = find_file (string);
++      store_arg (string, delete_this_arg, this_is_output_file);
++      if (this_is_output_file)
++	outfiles[input_file_number] = string;
++      arg_going = 0;
++    }
++
++  return 0;
++}
++
++/* Look up a spec function.  */
++
++static const struct spec_function *
++lookup_spec_function (name)
++     const char *name;
++{
++  static const struct spec_function * const spec_function_tables[] =
++  {
++    static_spec_functions,
++  };
++  const struct spec_function *sf;
++  unsigned int i;
++
++  for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
++    {
++      for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
++	if (strcmp (sf->name, name) == 0)
++	  return sf;
++    }
++
++  return NULL;
++}
++
++/* Evaluate a spec function.  */
++
++static const char *
++eval_spec_function (func, args)
++     const char *func, *args;
++{
++  const struct spec_function *sf;
++  const char *funcval;
++
++  /* Saved spec processing context.  */
++  int save_argbuf_index;
++  int save_argbuf_length;
++  char **save_argbuf;
++
++  int save_arg_going;
++  int save_delete_this_arg;
++  int save_this_is_output_file;
++  int save_this_is_library_file;
++  int save_input_from_pipe;
++
++
++  sf = lookup_spec_function (func);
++  if (sf == NULL)
++    fatal ("unknown spec function `%s'", func);
++
++  /* Push the spec processing context.  */
++  save_argbuf_index = argbuf_index;
++  save_argbuf_length = argbuf_length;
++  save_argbuf = argbuf;
++
++  save_arg_going = arg_going;
++  save_delete_this_arg = delete_this_arg;
++  save_this_is_output_file = this_is_output_file;
++  save_this_is_library_file = this_is_library_file;
++  save_input_from_pipe = input_from_pipe;
++
++  /* Create a new spec processing context, and build the function
++     arguments.  */
++
++  alloc_args ();
++  if (do_spec_2 (args) < 0)
++    fatal ("error in args to spec function `%s'", func);
++
++  /* argbuf_index is an index for the next argument to be inserted, and
++     so contains the count of the args already inserted.  */
++
++  funcval = (*sf->func) (argbuf_index, (const char **) argbuf);
++
++  /* Pop the spec processing context.  */
++  argbuf_index = save_argbuf_index;
++  argbuf_length = save_argbuf_length;
++  free (argbuf);
++  argbuf = save_argbuf;
++
++  arg_going = save_arg_going;
++  delete_this_arg = save_delete_this_arg;
++  this_is_output_file = save_this_is_output_file;
++  this_is_library_file = save_this_is_library_file;
++  input_from_pipe = save_input_from_pipe;
++
++  return funcval;
++}
++
++/* Handle a spec function call of the form:
++
++   %:function(args)
++
++   ARGS is processed as a spec in a separate context and split into an
++   argument vector in the normal fashion.  The function returns a string
++   containing a spec which we then process in the caller's context, or
++   NULL if no processing is required.  */
++
++static const char *
++handle_spec_function (p)
++     const char *p;
++{
++  char *func, *args;
++  const char *endp, *funcval;
++  int count;
++
++  processing_spec_function++;
++
++  /* Get the function name.  */
++  for (endp = p; *endp != '\0'; endp++)
++    {
++      if (*endp == '(')		/* ) */
++	break;
++      /* Only allow [A-Za-z0-9], -, and _ in function names.  */
++      if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
++	fatal ("malformed spec function name");
++    }
++  if (*endp != '(')		/* ) */
++    fatal ("no arguments for spec function");
++  func = save_string (p, endp - p);
++  p = ++endp;
++
++  /* Get the arguments.  */
++  for (count = 0; *endp != '\0'; endp++)
++    {
++      /* ( */
++      if (*endp == ')')
++	{
++	  if (count == 0)
++	    break;
++	  count--;
++	}
++      else if (*endp == '(')	/* ) */
++	count++;
++    }
++  /* ( */
++  if (*endp != ')')
++    fatal ("malformed spec function arguments");
++  args = save_string (p, endp - p);
++  p = ++endp;
++
++  /* p now points to just past the end of the spec function expression.  */
++
++  funcval = eval_spec_function (func, args);
++  if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
++    p = NULL;
++
++  free (func);
++  free (args);
++
++  processing_spec_function--;
++
++  return p;
+ }
+ 
+ /* Return 0 if we call do_spec_1 and that returns -1.  */
+@@ -4674,8 +4896,8 @@
+     signal (SIGPIPE, fatal_error);
+ #endif
+ 
+-  argbuf_length = 10;
+-  argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
++  /* Allocate the argument vector.  */
++  alloc_args ();
+ 
+   obstack_init (&obstack);
+ 
+@@ -5846,3 +6068,25 @@
+       ++p;
+     }
+ }
++
++/* if-exists built-in spec function.
++
++   Checks to see if the file specified by the absolute pathname in
++   ARGS exists.  Returns that pathname if found.
++
++   The usual use for this function is to check for a library file
++   (whose name has been expanded with %s).  */
++
++#define IS_ABSOLUTE_PATHNAME(cp)	((cp)[0] == '/')
++
++static const char *
++if_exists_spec_function (argc, argv)
++     int argc;
++     const char **argv;
++{
++  /* Must have only one argument.  */
++  if (argc == 1 && IS_ABSOLUTE_PATHNAME (argv[0]) && ! access (argv[0], R_OK))
++    return argv[0];
++
++  return NULL;
++}