--- /dev/null
+#! /bin/sh -e
+
+# All lines beginning with `# DP:' are a description of the patch.
+# DP: Fix for complex math on alpha
+
+if [ $# -eq 3 -a "$2" = '-d' ]; then
+ pdir="-d $3"
+elif [ $# -ne 1 ]; then
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+fi
+case "$1" in
+ -patch) patch $pdir -f --no-backup-if-mismatch -p1 < $0;;
+ -unpatch) patch $pdir -f --no-backup-if-mismatch -R -p1 < $0;;
+ *)
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+esac
+exit 0
+
+(from Joel Klecker's original message):
+
+ I've tested this patch with building glibc and it enables it to compile, I
+ haven't been able to test the resulting binaries yet, however. I assume
+ this will fix the g77 problems too.
+
+ * flow.c (insn_dead_p): Don't kill part of a complex number.
+ * emit-rtl.c (gen_lowpart_common): Handle narrow complex reg values.
+ (gen_highpart): Likewise.
+ * calls.c (expand_call): Narrow complex variable uses two regs.
+ * alpha/alpha.h (ALPHA_ARG_SIZE): Likewise.
+ (HARD_REGNO_NREGS): Likewise.
+
+diff -ur gcc-2.95.2/gcc/calls.c gcc-2.95.2.patched/gcc/calls.c
+--- gcc-2.95.2/gcc/calls.c Fri May 7 21:58:39 1999
++++ gcc-2.95.2.patched/gcc/calls.c Sat Feb 19 14:26:21 2000
+@@ -1499,6 +1499,11 @@
+ validize_mem (args[i].value), nregs,
+ args[i].mode);
+
++ /* Indicate two regs used to hold a short complex arg. */
++ if (GET_MODE_CLASS (args[i].mode) == MODE_COMPLEX_FLOAT
++ && GET_MODE_SIZE (args[i].mode) <= UNITS_PER_WORD)
++ nregs = 2;
++
+ /* Handle calls that pass values in multiple non-contiguous
+ locations. The Irix 6 ABI has examples of this. */
+ if (GET_CODE (reg) == PARALLEL)
+diff -ur gcc-2.95.2/gcc/config/alpha/alpha.h gcc-2.95.2.patched/gcc/config/alpha/alpha.h
+--- gcc-2.95.2/gcc/config/alpha/alpha.h Fri Jun 25 01:09:12 1999
++++ gcc-2.95.2.patched/gcc/config/alpha/alpha.h Sat Feb 19 14:28:45 2000
+@@ -622,7 +622,10 @@
+ but can be less for certain modes in special long registers. */
+
+ #define HARD_REGNO_NREGS(REGNO, MODE) \
+- ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
++ ((GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
++ && GET_MODE_SIZE (MODE) <= UNITS_PER_WORD) \
++ ? 2 \
++ : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
+
+ /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
+ On Alpha, the integer registers can hold any mode. The floating-point
+@@ -1070,12 +1073,16 @@
+ #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) (CUM) = 0
+
+ /* Define intermediate macro to compute the size (in registers) of an argument
+- for the Alpha. */
++ for the Alpha.
++ A short complex arg takes two registers. */
+
+ #define ALPHA_ARG_SIZE(MODE, TYPE, NAMED) \
+-((MODE) != BLKmode \
+- ? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \
+- : (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
++ ((GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
++ && GET_MODE_SIZE (MODE) <= UNITS_PER_WORD) \
++ ? 2 \
++ : ((MODE) != BLKmode \
++ ? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \
++ : (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
+
+ /* Update the data in CUM to advance over an argument
+ of mode MODE and data type TYPE.
+diff -ur gcc-2.95.2/gcc/emit-rtl.c gcc-2.95.2.patched/gcc/emit-rtl.c
+--- gcc-2.95.2/gcc/emit-rtl.c Wed Aug 11 03:28:52 1999
++++ gcc-2.95.2.patched/gcc/emit-rtl.c Sat Feb 19 14:31:19 2000
+@@ -749,6 +749,15 @@
+ && ! HARD_REGNO_MODE_OK (REGNO (x) + word, mode)
+ && HARD_REGNO_MODE_OK (REGNO (x), GET_MODE (x)))
+ return 0;
++ else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_COMPLEX_FLOAT
++ && GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
++ && REGNO (x) < FIRST_PSEUDO_REGISTER)
++ {
++ if (REG_FUNCTION_VALUE_P (x))
++ return gen_rtx (SUBREG, mode, x, 0);
++ else
++ return gen_rtx (REG, mode, REGNO (x));
++ }
+ else if (REGNO (x) < FIRST_PSEUDO_REGISTER
+ /* integrate.c can't handle parts of a return value register. */
+ && (! REG_FUNCTION_VALUE_P (x)
+@@ -972,11 +981,6 @@
+ {
+ if (GET_CODE (x) == CONCAT && GET_MODE (XEXP (x, 0)) == mode)
+ return XEXP (x, 0);
+- else if (WORDS_BIG_ENDIAN
+- && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
+- && REG_P (x)
+- && REGNO (x) < FIRST_PSEUDO_REGISTER)
+- fatal ("Unable to access real part of complex value in a hard register on this target");
+ else if (WORDS_BIG_ENDIAN)
+ return gen_highpart (mode, x);
+ else
+@@ -995,11 +999,6 @@
+ return XEXP (x, 1);
+ else if (WORDS_BIG_ENDIAN)
+ return gen_lowpart (mode, x);
+- else if (!WORDS_BIG_ENDIAN
+- && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
+- && REG_P (x)
+- && REGNO (x) < FIRST_PSEUDO_REGISTER)
+- fatal ("Unable to access imaginary part of complex value in a hard register on this target");
+ else
+ return gen_highpart (mode, x);
+ }
+@@ -1134,6 +1133,16 @@
+ word = ((GET_MODE_SIZE (GET_MODE (x))
+ - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
+ / UNITS_PER_WORD);
++
++ if (GET_MODE_CLASS (GET_MODE (x)) == MODE_COMPLEX_FLOAT
++ && GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
++ && REGNO (x) < FIRST_PSEUDO_REGISTER)
++ {
++ if (REG_FUNCTION_VALUE_P (x))
++ return gen_rtx (SUBREG, mode, x, 1);
++ else
++ return gen_rtx (REG, mode, REGNO (x) + 1);
++ }
+
+ if (REGNO (x) < FIRST_PSEUDO_REGISTER
+ /* integrate.c can't handle parts of a return value register. */
+diff -ur gcc-2.95.2/gcc/flow.c gcc-2.95.2.patched/gcc/flow.c
+--- gcc-2.95.2/gcc/flow.c Wed Aug 4 03:09:48 1999
++++ gcc-2.95.2.patched/gcc/flow.c Sat Feb 19 14:34:02 2000
+@@ -2995,6 +2995,10 @@
+ while (--n > 0)
+ if (REGNO_REG_SET_P (needed, regno+n))
+ return 0;
++
++ /* Don't allow part of a complex number to be deleted. */
++ if (GET_MODE_CLASS (GET_MODE (r)) == MODE_COMPLEX_FLOAT)
++ return 0;
+ }
+
+ return 1;
+
+
--- /dev/null
+# DP: Make bootstrap: restartable at any point
+# DP: From: Donn Terry <donn@interix.com>
+
+Make bootstrap: restartable at any point.
+
+This is in response to a discussion on this topic. This is "take 2" |
+which should work with parallel builds, though I haven't tested that. |
+
+When doing a make bootstrap, it's hard to know (at least when
+not throughly versed in the process details) how to restart
+after making a fix. In general, retyping "make bootstrap"
+will do the wrong thing (particularly if the host and target
+compilers object files are incompatible!)
+
+This change keeps track of the stages completed. The old
+bootstrap2[234] (and *-lean) targets are rewritten, but work the
+same.
+
+I've tested this by doing a make bootstrap (on CVS sources as of |
+last night) and by typing 'make bootstrap' after it's done, |
+in which case it thinks a moment and does nothing. (Which is exactly
+the right answer.)
+
+I've also done a complete regression, with no surprises. |
+
+I tested whether stopping/restarting at a few arbitrary points along the
+way works with older sources, but haven't tested it real recently,
+except to do a ^C halfway through a testbuild at one point. |
+Again, if it works at all, it should work as well as it ever did.
+I specficially did test it during the period where make bootstrap
+wasn't succeeding for me, and it helped a LOT in being able to pick up
+where I left off.
+
+An interesting side-effect: make bootstrap-lean after a make bootstrap |
+JUST cleans out stage1, with no unwanted consequences. |
+
+
+Fri May 28 15:27:02 1999 Donn Terry (donn@interix.com)
+ * Makefile.in: restructure bootstrap stages to allow
+ clean restart after failure.
+
+diff -urP egcs.source.old/gcc/Makefile.in egcs.source/gcc/Makefile.in
+--- egcs.source.old/gcc/Makefile.in Sun May 23 13:39:21 1999
++++ egcs.source/gcc/Makefile.in Thu May 27 16:59:42 1999
+@@ -2360,6 +2360,8 @@ clean: mostlyclean intl.clean lang.clean
+ rm -rf `echo $(MULTILIB_OPTIONS) | sed -e 's/\// /g'`; \
+ fi ; fi
+ -rm -fr stage1 stage2 stage3 stage4
++ -rm -f boot_stage_a boot_stage_b boot_stage_c boot_stage_d
++ -rm -f boot_stage_e boot_stage_f
+
+ # Delete all files that users would normally create
+ # while building and installing GCC.
+@@ -2924,33 +2926,83 @@ diff:
+ $(LANG_DIFF_EXCLUDES) \
+ gcc-$(oldversion) gcc-$(version) > gcc-$(oldversion)-$(version).diff
+
+-bootstrap bootstrap-lean: force
++
+ # Only build the C compiler for stage1, because that is the only one that
+ # we can guarantee will build with the native compiler, and also it is the
+ # only thing useful for building stage2.
+- $(MAKE) CC="$(CC)" libdir=$(libdir) LANGUAGES="$(BOOT_LANGUAGES)"
+- $(MAKE) stage1
++boot_stage_a:
++ +$(MAKE) CC="$(CC)" libdir=$(libdir) LANGUAGES="$(BOOT_LANGUAGES)"
++ touch boot_stage_a
++ echo ---------------------- stage a complete ---------------------
++
++boot_stage_b:
++ +$(MAKE) stage1
++ touch boot_stage_b
++ echo ---------------------- stage b complete ---------------------
++
+ # This used to define ALLOCA as empty, but that would lead to bad results
+ # for a subsequent `make install' since that would not have ALLOCA empty.
+ # To prevent `make install' from compiling alloca.o and then relinking cc1
+ # because alloca.o is newer, we permit these recursive makes to compile
+ # alloca.o. Then cc1 is newer, so it won't have to be relinked.
+- $(MAKE) CC="stage1/xgcc$(exeext) -Bstage1/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage1/ LANGUAGES="$(LANGUAGES)"
+- $(MAKE) stage2
+- -if test $@ = bootstrap-lean; then rm -rf stage1; else true; fi
+- $(MAKE) CC="stage2/xgcc$(exeext) -Bstage2/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage2/ LANGUAGES="$(LANGUAGES)"
++boot_stage_c:
++ +$(MAKE) CC="stage1/xgcc$(exeext) -Bstage1/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage1/ LANGUAGES="$(LANGUAGES)"
++ touch boot_stage_c
++ echo ---------------------- stage c complete ---------------------
+
+-bootstrap2 bootstrap2-lean: force
+- $(MAKE) CC="stage1/xgcc$(exeext) -Bstage1/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage1/ LANGUAGES="$(LANGUAGES)"
+- $(MAKE) stage2
+- -if test $@ = bootstrap2-lean; then rm -rf stage1; else true; fi
+- $(MAKE) CC="stage2/xgcc$(exeext) -Bstage2/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage2/ LANGUAGES="$(LANGUAGES)"
++boot_stage_d:
++ +$(MAKE) stage2
++ touch boot_stage_d
++ echo ---------------------- stage d complete ---------------------
+
+-bootstrap3 bootstrap3-lean: force
+- $(MAKE) CC="stage2/xgcc$(exeext) -Bstage2/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage2/ LANGUAGES="$(LANGUAGES)"
++boot_stage_e:
++ +$(MAKE) CC="stage2/xgcc$(exeext) -Bstage2/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage2/ LANGUAGES="$(LANGUAGES)"
++ touch boot_stage_e
++ echo ---------------------- stage e complete ---------------------
++
++# Only bootstrap4 uses stage f.
++boot_stage_f:
++ +$(MAKE) CC="stage3/xgcc$(exeext) -Bstage3/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage3/ LANGUAGES="$(LANGUAGES)"
++ touch boot_stage_f
++ echo ---------------------- stage f complete ---------------------
++
++boot_clean_stage1:
++ rm -rf stage1
++
++# This next little bit is the way it is for parallel builds. It's simply
++# a chain of stages which DO have to be done sequentially.
++
++bootstrap_a: boot_stage_a
++bootstrap_b: bootstrap_a boot_stage_b
++bootstrap_c: bootstrap_b boot_stage_c
++bootstrap_d: bootstrap_c boot_stage_d
++bootstrap_e: bootstrap_d boot_stage_e
++bootstrap: force bootstrap_e
++
++bootstrap-lean_a: boot_stage_a
++bootstrap-lean_b: bootstrap-lean_a boot_stage_b
++bootstrap-lean_c: bootstrap-lean_b boot_stage_c
++bootstrap-lean_d: bootstrap-lean_c boot_stage_d
++bootstrap-lean_e: bootstrap-lean_d boot_clean_stage1
++bootstrap-lean_f: bootstrap-lean_e boot_stage_e
++bootstrap-lean: force bootstrap-lean_f
++
++bootstrap2_c: boot_stage_c
++bootstrap2_d: bootstrap2_c boot_stage_d
++bootstrap2_e: bootstrap2_d boot_stage_e
++bootstrap2: force bootstrap2_e
++
++bootstrap2-lean_c: boot_stage_c
++bootstrap2-lean_d: bootstrap2-lean_c boot_stage_d
++bootstrap2-lean_e: bootstrap2-lean_d boot_clean_stage1
++bootstrap2-lean_f: bootstrap2-lean_e boot_stage_e
++bootstrap2-lean: force bootstrap2-lean_f
++
++bootstrap3 bootstrap3-lean: force boot_stage_e
++
++# Only bootstrap4 uses stage f.
++bootstrap4 bootstrap4-lean: force boot_stage_f
+
+-bootstrap4 bootstrap4-lean: force
+- $(MAKE) CC="stage3/xgcc$(exeext) -Bstage3/ -B$(build_tooldir)/bin/" CFLAGS="$(WARN_CFLAGS) $(BOOT_CFLAGS)" LDFLAGS="$(BOOT_LDFLAGS)" libdir=$(libdir) STAGE_PREFIX=stage3/ LANGUAGES="$(LANGUAGES)"
+
+ # Compare the object files in the current directory with those in the
+ # stage2 directory.
--- /dev/null
+# DP: On Sparc, message forwarding in the GNUstep framework
+# DP: (gstep-base) relies on this patch. I didn't experience any side
+# DP: effects of this "workaround" on a sparc Solaris platform. However
+# DP: this workaround affects the all compilers of the egcs package.
+
+From: Richard Henderson <rth@dot.cygnus.com>
+To: Matthias.Klose@cs.tu-berlin.de, scottc@net-community.com
+Subject: Re: patch for expand_builtin_apply for sparc architecture
+Date: Mon, 16 Feb 1998 05:11:32 -0800
+
+In article <199802160833.JAA11275.cygnus.egcs.bugs@gargleblaster.cs.tu-berlin.de>,
+Matthias Klose <Matthias.Klose@cs.tu-berlin.de> wrote:
+>The following patch fixes the generation of an 'unimp 4095'
+>instruction for the expansion of __builtin_apply on the sparc
+>architecture; fix by Scott Christley (<scottc@net-community.com>), but
+>doesn't seem to be submitted to the the egcs list.
+
+You'll have to submit a test case and an explanation of why you think
+this is correct. The Sparc32 ABI calls for an unimp instruction to
+be emitted following calls to functions that return structures. The
+0-4095 immediate is commentary, but that's all the room in that field
+so we cannot simply remove the mask.
+
+My guess is that it is yet another example of why __builtin_apply
+is inadequate for the needs of all but completely stack-based calling
+conventions and should not be used.
+
+
+r~
+
+diff -c gcc/config/sparc/sparc.md~ gcc/config/sparc/sparc.md
+*** gcc/config/sparc/sparc.md~ Mon Nov 16 12:31:32 1998
+--- gcc/config/sparc/sparc.md Mon Nov 16 12:35:56 1998
+***************
+*** 7294,7299 ****
+--- 7294,7300 ----
+ Why cannot we have delay slots filled if it were a CALL? */
+
+ if (! TARGET_ARCH64 && INTVAL (operands[3]) != 0)
++ #if 0
+ emit_jump_insn
+ (gen_rtx_PARALLEL (VOIDmode,
+ gen_rtvec (3,
+***************
+*** 7302,7307 ****
+--- 7303,7318 ----
+ GEN_INT (INTVAL (operands[3]) & 0xfff),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_REG (Pmode, 15)))));
++ #else
++ emit_jump_insn
++ (gen_rtx_PARALLEL (VOIDmode,
++ gen_rtvec (3,
++ gen_rtx_SET (VOIDmode, pc_rtx,
++ XEXP (operands[0], 0)),
++ operands[3],
++ gen_rtx_CLOBBER (VOIDmode,
++ gen_rtx_REG (Pmode, 15)))));
++ #endif
+ else
+ emit_jump_insn
+ (gen_rtx_PARALLEL (VOIDmode,
--- /dev/null
+# DP: Handle DOS newlines after backslashes.
+# DP: Patch from http://www.cygnus.com/ml/egcs/1999-Jan/0784.html
+
+--- gcc/cccp.c.orig Thu Jun 24 15:11:40 1999
++++ gcc/cccp.c Mon Aug 9 12:21:55 1999
+@@ -1023,7 +1023,8 @@
+ retrying if necessary. If MAX_READ_LEN is defined, read at most
+ that bytes at a time. Return a negative value if an error occurs,
+ otherwise return the actual number of bytes read,
+- which must be LEN unless end-of-file was reached. */
++ which may be < LEN if CRs have been skipped, though we try not to do
++ that. */
+
+ static int
+ safe_read (desc, ptr, len)
+@@ -1032,6 +1033,7 @@
+ int len;
+ {
+ int left, rcount, nchars;
++ char *rptr;
+
+ left = len;
+ while (left > 0) {
+@@ -1051,8 +1053,20 @@
+ }
+ if (nchars == 0)
+ break;
+- ptr += nchars;
++
++ /* CRLF pairs, found with Unix when processing DOS files,
++ throw off backslash-newline removal.
++ Therefore, CRs are thrown away here. */
+ left -= nchars;
++ rptr = ptr;
++ while(nchars--)
++ {
++ if(*rptr == '\r' && *(rptr+1) == '\n')
++ left++;
++ else
++ *ptr++ = *rptr;
++ rptr++;
++ }
+ }
+ return len - left;
+ }
+@@ -2085,8 +2099,8 @@
+ for (;;) {
+ cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
+ if (cnt < 0) goto perror; /* error! */
++ if (cnt == 0) break; /* End of file */
+ size += cnt;
+- if (size != bsize) break; /* End of file */
+ bsize *= 2;
+ fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
+ }
+@@ -5024,6 +5038,8 @@
+ map_list_ptr->map_list_map = ptr;
+
+ while ((ch = getc (f)) != '\n')
++ if (ch == '\r')
++ continue;
+ if (ch == EOF)
+ break;
+ }
+@@ -5256,9 +5272,9 @@
+ i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
+ if (i < 0)
+ goto nope; /* error! */
+- st_size += i;
+- if (st_size != bsize)
++ if (i == 0)
+ break; /* End of file */
++ st_size += i;
+ bsize *= 2;
+ fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
+ }
--- /dev/null
+# DP: cpp.texi: add a node documenting macro varargs.
+
+Sat Aug 7 14:56:50 1999 Matthias Klose <doko@cs.tu-berlin.de>
+
+ * cpp.texi: cpp.texi: add a node documenting macro varargs (copied
+ from extend.texi.
+
+--- gcc/cpp.texi~ Wed May 19 13:22:57 1999
++++ gcc/cpp.texi Sat Aug 7 14:53:42 1999
+@@ -542,6 +542,7 @@
+ * Simple Macros:: Macros that always expand the same way.
+ * Argument Macros:: Macros that accept arguments that are substituted
+ into the macro expansion.
++* Macro Varargs:: Macros with variable number of arguments.
+ * Predefined:: Predefined macros that are always available.
+ * Stringification:: Macro arguments converted into string constants.
+ * Concatenation:: Building tokens from parts taken from macro arguments.
+@@ -645,7 +646,7 @@
+ that the result of its expansion is checked for more macro names.
+ @xref{Cascaded Macros}.
+
+-@node Argument Macros, Predefined, Simple Macros, Macros
++@node Argument Macros, Macro Varargs, Simple Macros, Macros
+ @subsection Macros with Arguments
+ @cindex macros with argument
+ @cindex arguments in macro definitions
+@@ -799,7 +800,68 @@
+ the left parenthesis; it's the @emph{definition} where it matters whether
+ there is a space.
+
+-@node Predefined, Stringification, Argument Macros, Macros
++@node Macro Varargs, Predefined, Argument Macros, Macros
++@subsection Macros with Variable Numbers of Arguments
++@cindex variable number of arguments
++@cindex macro with variable arguments
++@cindex rest argument (in macro)
++
++In GNU C, a macro can accept a variable number of arguments, much as a
++function can. The syntax for defining the macro looks much like that
++used for a function. Here is an example:
++
++@example
++#define eprintf(format, args...) \
++ fprintf (stderr, format , ## args)
++@end example
++
++Here @code{args} is a @dfn{rest argument}: it takes in zero or more
++arguments, as many as the call contains. All of them plus the commas
++between them form the value of @code{args}, which is substituted into
++the macro body where @code{args} is used. Thus, we have this expansion:
++
++@example
++eprintf ("%s:%d: ", input_file_name, line_number)
++@expansion{}
++fprintf (stderr, "%s:%d: " , input_file_name, line_number)
++@end example
++
++@noindent
++Note that the comma after the string constant comes from the definition
++of @code{eprintf}, whereas the last comma comes from the value of
++@code{args}.
++
++The reason for using @samp{##} is to handle the case when @code{args}
++matches no arguments at all. In this case, @code{args} has an empty
++value. In this case, the second comma in the definition becomes an
++embarrassment: if it got through to the expansion of the macro, we would
++get something like this:
++
++@example
++fprintf (stderr, "success!\n" , )
++@end example
++
++@noindent
++which is invalid C syntax. @samp{##} gets rid of the comma, so we get
++the following instead:
++
++@example
++fprintf (stderr, "success!\n")
++@end example
++
++This is a special feature of the GNU C preprocessor: @samp{##} before a
++rest argument that is empty discards the preceding sequence of
++non-whitespace characters from the macro definition. (If another macro
++argument precedes, none of it is discarded.)
++
++It might be better to discard the last preprocessor token instead of the
++last preceding sequence of non-whitespace characters; in fact, we may
++someday change this feature to do so. We advise you to write the macro
++definition so that the preceding sequence of non-whitespace characters
++is just a single token, so that the meaning will not change if we change
++the definition of this feature.
++
++@node Predefined, Stringification, Macro Varargs, Macros
+ @subsection Predefined Macros
+
+ @cindex predefined macros
--- /dev/null
+diff -urN gcc-2.95.3.org/gcc/config/i386/linux.h gcc-2.95.3/gcc/config/i386/linux.h
+--- gcc-2.95.3.org/gcc/config/i386/linux.h Mon Mar 19 19:35:22 2001
++++ gcc-2.95.3/gcc/config/i386/linux.h Mon Mar 19 19:36:46 2001
+@@ -234,3 +234,21 @@
+ } \
+ } while (0)
+ #endif
++
++#if defined(__PIC__) && defined (USE_GNULIBC_1)
++/* This is a kludge. The i386 GNU/Linux dynamic linker needs ___brk_addr,
++ __environ and atexit (). We have to make sure they are in the .dynsym
++ section. We accomplish it by making a dummy call here. This
++ code is never reached. */
++
++#define CRT_END_INIT_DUMMY \
++ do \
++ { \
++ extern void *___brk_addr; \
++ extern char **__environ; \
++ \
++ ___brk_addr = __environ; \
++ atexit (0); \
++ } \
++ while (0)
++#endif
+diff -urN gcc-2.95.3.org/gcc/crtstuff.c gcc-2.95.3/gcc/crtstuff.c
+--- gcc-2.95.3.org/gcc/crtstuff.c Mon Mar 19 19:35:22 2001
++++ gcc-2.95.3/gcc/crtstuff.c Mon Mar 19 19:37:56 2001
+@@ -379,20 +379,8 @@
+ FORCE_INIT_SECTION_ALIGN;
+ #endif
+ asm (TEXT_SECTION_ASM_OP);
+-
+-/* This is a kludge. The i386 GNU/Linux dynamic linker needs ___brk_addr,
+- __environ and atexit (). We have to make sure they are in the .dynsym
+- section. We accomplish it by making a dummy call here. This
+- code is never reached. */
+-
+-#if defined(__linux__) && defined(__PIC__) && defined(__i386__)
+- {
+- extern void *___brk_addr;
+- extern char **__environ;
+-
+- ___brk_addr = __environ;
+- atexit ();
+- }
++#ifdef CRT_END_INIT_DUMMY
++ CRT_END_INIT_DUMMY;
+ #endif
+ }
+
--- /dev/null
+# DP: set the default architecture to i386; even if gcc is configured
+# DP: with i386-linux, it builds with Pentium instructions, tuned for i386.
+
+From: Joel Klecker <jk@espy.org>
+To: Matthias Klose <doko@cs.tu-berlin.de>
+Subject: Re: gcc: forwarded message from Markus F.X.J. Oberhumer
+Date: Wed, 11 Aug 1999 08:48:54 -0700
+
+Found it, and fixed it.
+
+--- gcc/config/i386/i386.c~ Sat Aug 14 19:35:24 1999
++++ gcc/config/i386/i386.c Sat Aug 14 19:37:00 1999
+@@ -291,7 +291,7 @@
+
+ if (ix86_arch_string == 0)
+ {
+- ix86_arch_string = PROCESSOR_PENTIUM_STRING;
++ ix86_arch_string = PROCESSOR_DEFAULT_STRING;
+ if (ix86_cpu_string == 0)
+ ix86_cpu_string = PROCESSOR_DEFAULT_STRING;
+ }
+@@ -308,7 +308,7 @@
+ if (i == ptt_size)
+ {
+ error ("bad value (%s) for -march= switch", ix86_arch_string);
+- ix86_arch_string = PROCESSOR_PENTIUM_STRING;
++ ix86_arch_string = PROCESSOR_DEFAULT_STRING;
+ ix86_arch = PROCESSOR_DEFAULT;
+ }
+
--- /dev/null
+#! /bin/sh -e
+
+if [ $# -eq 3 -a "$2" = '-d' ]; then
+ pdir="-d $3"
+elif [ $# -ne 1 ]; then
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+fi
+case "$1" in
+ -patch) patch $pdir -f --no-backup-if-mismatch -p0 -l < $0;;
+ -unpatch) patch $pdir -f --no-backup-if-mismatch -R -p0 -l < $0;;
+ *)
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+esac
+exit 0
+
+Patch: gcj -vs- iconv
+
+To: Gcc Patch List <gcc-patches at gcc dot gnu dot org>
+Subject: Patch: gcj -vs- iconv
+From: Tom Tromey <tromey at cygnus dot com>
+Date: 06 Mar 2000 14:39:01 -0700
+Reply-To: tromey at cygnus dot com
+
+# DP: This patch changes gcj to use iconv(), when available, to read Java
+# DP: source files. It adds a new `--encoding' option that lets the user
+# DP: choose what encoding to use. For systems without iconv(), gcj still
+# DP: assumes that the input is UTF-8, but it no longer ignores encoding
+# DP: errors.
+# DP:
+# DP: This patch does have one minor problem, which is that if --encoding is
+# DP: not specified we default to UTF-8 instead of the encoding the user has
+# DP: chosen (as part of his locale). I don't know how to find that
+# DP: information. Anyway, that is an addition which shouldn't affect
+# DP: whether or not this patch goes in, since this patch doesn't make the
+# DP: situation any worse than it is right now.
+
+Alex, I'm not sure I really understand how the parser context stack
+works, so it is possible that some of my changes there are wrong.
+Could you look at it? Is this ok to check in?
+# DP:
+# DP: This fixes PR gcj/33; I can now compile a Latin-1 encoded file on my
+# DP: PPC Linux box with `gcj --encoding=Latin1 ...'.
+
+2000-03-06 Tom Tromey <tromey@cygnus.com>
+
+ Fix for PR gcj/33:
+ * jv-scan.c (help): Document --encoding.
+ (options): Added `encoding' entry.
+ (OPT_ENCODING): New define.
+ (main): Handle --encoding.
+ * lang-options.h: Document --classpath, --CLASSPATH, --main, and
+ --encoding.
+ * jcf-parse.c (parse_source_file): Correctly call java_init_lex.
+ Added `finput' argument.
+ * java-tree.h (current_encoding): Declare.
+ * parse.y (java_parser_context_restore_global): Don't restore
+ `finput'.
+ (java_parser_context_save_global): Don't set `finput' field.
+ (java_pop_parser_context): Don't restore `finput'. Free old lexer
+ if required.
+ * lang.c (current_encoding): New global.
+ (lang_decode_option): Recognize `-fencoding='.
+ (finish_parse): Don't close finput.
+ * parse.h (struct parser_ctxt): Removed `finput' and
+ `unget_utf8_value' fields. Added `lexer' field.
+ (java_init_lex): Fixed declaration.
+ * lex.c (java_new_lexer): New function.
+ (java_destroy_lexer): Likewise.
+ (java_read_char): Added `lex' argument. Handle iconv case.
+ (java_read_unicode): Added `lex' argument. Count backslashes in
+ lexer structure.
+ (java_init_lex): Added `finput' and `encoding' arguments. Set
+ `lexer' field in ctxp.
+ (BAD_UTF8_VALUE): Removed.
+ * lex.h: Include <iconv.h> if HAVE_ICONV defined.
+ (java_lexer): New structure.
+ (UNGETC): Removed.
+ (GETC): Removed.
+ (DEFAULT_ENCODING): New define.
+ (java_destroy_lexer): Declare.
+
+Tom
+
+--- gcc/java/java-tree.h.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/java-tree.h Sat Apr 8 23:03:56 2000
+@@ -141,6 +141,9 @@
+ extern int flag_not_overriding;
+ extern int flag_static_local_jdk1_1;
+
++/* Encoding used for source files. */
++extern char *current_encoding;
++
+ /* The Java .class file that provides main_class; the main input file. */
+ extern struct JCF *current_jcf;
+
+--- gcc/java/jcf-parse.c.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/jcf-parse.c Sat Apr 8 23:05:39 2000
+@@ -84,7 +84,7 @@
+ static tree give_name_to_class PROTO ((JCF *jcf, int index));
+ static void parse_zip_file_entries PROTO ((void));
+ static void process_zip_dir PROTO ((void));
+-static void parse_source_file PROTO ((tree));
++static void parse_source_file PARAMS ((tree, FILE *));
+ static void jcf_parse_source PROTO ((void));
+ static int jcf_figure_file_type PROTO ((JCF *));
+ static int find_in_current_zip PROTO ((char *, struct JCF **));
+@@ -570,6 +570,7 @@
+ jcf_parse_source ()
+ {
+ tree file;
++ FILE *finput;
+
+ java_parser_context_save_global ();
+ java_push_parser_context ();
+@@ -580,7 +581,7 @@
+ if (!(finput = fopen (input_filename, "r")))
+ fatal ("input file `%s' just disappeared - jcf_parse_source",
+ input_filename);
+- parse_source_file (file);
++ parse_source_file (file, finput);
+ if (fclose (finput))
+ fatal ("can't close input file `%s' stream - jcf_parse_source",
+ input_filename);
+@@ -741,8 +742,9 @@
+ /* Parse a source file, as pointed by the current value of INPUT_FILENAME. */
+
+ static void
+-parse_source_file (file)
++parse_source_file (file, finput)
+ tree file;
++ FILE *finput;
+ {
+ int save_error_count = java_error_count;
+ /* Mark the file as parsed */
+@@ -750,7 +752,9 @@
+
+ lang_init_source (1); /* Error msgs have no method prototypes */
+
+- java_init_lex (); /* Initialize the parser */
++ /* Initialize the parser */
++ java_init_lex (finput,
++ current_encoding ? current_encoding : DEFAULT_ENCODING);
+ java_parse_abort_on_error ();
+
+ java_parse (); /* Parse and build partial tree nodes. */
+@@ -778,6 +782,7 @@
+ int several_files = 0;
+ char *list = strdup (input_filename), *next;
+ tree node, current_file_list = NULL_TREE;
++ FILE *finput;
+
+ do
+ {
+@@ -888,7 +893,7 @@
+ case JCF_SOURCE:
+ java_push_parser_context ();
+ java_parser_context_save_global ();
+- parse_source_file (name);
++ parse_source_file (name, finput);
+ java_parser_context_restore_global ();
+ java_pop_parser_context (1);
+ break;
+--- gcc/java/jv-scan.c.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/jv-scan.c Sat Apr 8 23:11:41 2000
+@@ -53,6 +53,7 @@
+ {
+ int i = 1;
+ char *output_file = NULL;
++ char *encoding = NULL;
+ long ft;
+
+ exec_name = argv[0];
+@@ -73,6 +74,14 @@
+ argv [i] = NULL;
+ }
+
++ /* file encoding */
++ else if (!strcmp (argv [i], "--encoding") && i+1 < argc)
++ {
++ argv [i] = NULL;
++ encoding = argv [++i];
++ argv [i] = NULL;
++ }
++
+ /* Print the name of the class that contains main */
+ else if (!strcmp (argv [i], "--print-main"))
+ flag_find_main = 1;
+@@ -116,7 +125,7 @@
+ input_filename = argv [i];
+ if ( (finput = fopen (argv [i], "r")) )
+ {
+- java_init_lex ();
++ java_init_lex (finput, encoding ? encoding : DEFAULT_ENCODING);
+ yyparse ();
+ if (ftell (out) != ft)
+ fputc ('\n', out);
+--- gcc/java/lang-options.h.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/lang-options.h Sat Apr 8 23:03:56 2000
+@@ -39,8 +39,10 @@
+ { "-M", "Print dependencies to stdout" },
+ { "-MM", "Print dependencies to stdout" },
+ #endif /* ! USE_CPPLIB */
+- { "-fclasspath", "Set class path and suppress system path" },
+- { "-fCLASSPATH", "Set class path" },
++ { "--classpath", "Set class path and suppress system path" },
++ { "--CLASSPATH", "Set class path" },
++ { "--main", "Choose class whose main method should be used" },
++ { "--encoding", "Choose input encoding (default is UTF-8)" },
+ { "-I", "Add directory to class path" },
+ { "-foutput-class-dir", "Directory where class files should be written" },
+ { "-Wredundant-modifiers",
+--- gcc/java/lang.c.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/lang.c Sat Apr 8 23:03:56 2000
+@@ -105,6 +105,9 @@
+ /* When non zero, warns that final local are treated as non final. */
+ int flag_static_local_jdk1_1 = 0;
+
++/* The encoding of the source file. */
++char *current_encoding = NULL;
++
+ /* From gcc/flags.h, and indicates if exceptions are turned on or not. */
+
+ extern int flag_new_exceptions;
+@@ -172,6 +175,13 @@
+ return 1;
+ }
+ #undef ARG
++#define ARG "-fencoding="
++ if (strncmp (p, ARG, sizeof (ARG) - 1) == 0)
++ {
++ current_encoding = p + sizeof (ARG) - 1;
++ return 1;
++ }
++#undef ARG
+
+ if (p[0] == '-' && p[1] == 'f')
+ {
+@@ -252,7 +262,9 @@
+ return 0;
+ }
+
++/* Global open file. */
+ FILE *finput;
++
+ char *
+ init_parse (filename)
+ char *filename;
+@@ -313,7 +326,6 @@
+ void
+ finish_parse ()
+ {
+- fclose (finput);
+ jcf_dependency_write ();
+ }
+
+--- gcc/java/lex.c.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/lex.c Sat Apr 8 23:14:41 2000
+@@ -24,15 +24,15 @@
+ The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+ /* It defines java_lex (yylex) that reads a Java ASCII source file
+-possibly containing Unicode escape sequence or utf8 encoded characters
+-and returns a token for everything found but comments, white spaces
+-and line terminators. When necessary, it also fills the java_lval
+-(yylval) union. It's implemented to be called by a re-entrant parser
+-generated by Bison.
+-
+-The lexical analysis conforms to the Java grammar described in "The
+-Java(TM) Language Specification. J. Gosling, B. Joy, G. Steele.
+-Addison Wesley 1996" (http://java.sun.com/docs/books/jls/html/3.doc.html) */
++ possibly containing Unicode escape sequence or utf8 encoded
++ characters and returns a token for everything found but comments,
++ white spaces and line terminators. When necessary, it also fills
++ the java_lval (yylval) union. It's implemented to be called by a
++ re-entrant parser generated by Bison.
++
++ The lexical analysis conforms to the Java grammar described in "The
++ Java(TM) Language Specification. J. Gosling, B. Joy, G. Steele.
++ Addison Wesley 1996" (http://java.sun.com/docs/books/jls/html/3.doc.html) */
+
+ #include "keyword.h"
+
+@@ -55,15 +55,18 @@
+ static int java_parse_doc_section PROTO ((unicode_t));
+ static void java_parse_end_comment PROTO ((unicode_t));
+ static unicode_t java_get_unicode PROTO (());
+-static unicode_t java_read_unicode PROTO ((int, int *));
+-static void java_store_unicode PROTO ((struct java_line *, unicode_t, int));
+-static unicode_t java_read_char PROTO (());
++static unicode_t java_read_unicode PARAMS ((java_lexer *, int, int *));
++static void java_store_unicode PARAMS ((struct java_line *, unicode_t, int));
++static unicode_t java_read_char PARAMS ((java_lexer *));
+ static void java_allocate_new_line PROTO (());
+ static void java_unget_unicode PROTO (());
+ static unicode_t java_sneak_unicode PROTO (());
++java_lexer *java_new_lexer PARAMS ((FILE *, const char *));
+
+ void
+-java_init_lex ()
++java_init_lex (finput, encoding)
++ FILE *finput;
++ const char *encoding;
+ {
+ #ifndef JC1_LITE
+ int java_lang_imported = 0;
+@@ -108,9 +111,9 @@
+ ctxp->lineno = lineno = 0;
+ ctxp->p_line = NULL;
+ ctxp->c_line = NULL;
+- ctxp->unget_utf8_value = 0;
+ ctxp->minus_seen = 0;
+ ctxp->java_error_flag = 0;
++ ctxp->lexer = java_new_lexer (finput, encoding);
+ }
+
+ static char *
+@@ -188,22 +191,142 @@
+ ctxp->c_line->white_space_only = 1;
+ }
+
+-#define BAD_UTF8_VALUE 0xFFFE
++/* Create a new lexer object. */
++java_lexer *
++java_new_lexer (finput, encoding)
++ FILE *finput;
++ const char *encoding;
++{
++ java_lexer *lex = (java_lexer *) xmalloc (sizeof (java_lexer));
++ int enc_error = 0;
++
++ lex->finput = finput;
++ lex->bs_count = 0;
++ lex->unget_value = 0;
++
++#ifdef HAVE_ICONV
++ lex->handle = iconv_open ("UCS-2", encoding);
++ if (lex->handle == (iconv_t) -1)
++ {
++ /* FIXME: we should give a nice error based on errno here. */
++ enc_error = 1;
++ }
++ lex->first = -1;
++ lex->last = -1;
++#else /* HAVE_ICONV */
++ if (strcmp (encoding, DEFAULT_ENCODING))
++ enc_error = 1;
++#endif /* HAVE_ICONV */
++
++ if (enc_error)
++ fatal ("unknown encoding: `%s'", encoding);
++
++ return lex;
++}
++
++void
++java_destroy_lexer (lex)
++ java_lexer *lex;
++{
++ fclose (lex->finput);
++#ifdef HAVE_ICONV
++ iconv_close (lex->handle);
++#endif
++ free (lex);
++}
+
+ static unicode_t
+-java_read_char ()
++java_read_char (lex)
++ java_lexer *lex;
+ {
+- int c;
+- int c1, c2;
++ if (lex->unget_value)
++ {
++ unicode_t r = lex->unget_value;
++ lex->unget_value = 0;
++ return r;
++ }
++
++#ifdef HAVE_ICONV
++ {
++ char out[2];
++ size_t ir, inbytesleft, in_save, out_count;
++ char *inp, *outp;
+
+- if (ctxp->unget_utf8_value)
++ while (1)
+ {
+- int to_return = ctxp->unget_utf8_value;
+- ctxp->unget_utf8_value = 0;
+- return (to_return);
++ /* See if we need to read more data. If FIRST == 0 then the
++ previous conversion attempt ended in the middle of a
++ character at the end of the buffer. Otherwise we only have
++ to read if the buffer is empty. */
++ if (lex->first == 0 || lex->first >= lex->last)
++ {
++ int r;
++
++ if (lex->first >= lex->last)
++ {
++ lex->first = 0;
++ lex->last = 0;
++ }
++ if (feof (lex->finput))
++ return UEOF;
++ r = fread (&lex->buffer[lex->last], 1,
++ sizeof (lex->buffer) - lex->last,
++ lex->finput);
++ lex->last += r;
+ }
+
+- c = GETC ();
++ inbytesleft = lex->last - lex->first;
++
++ if (inbytesleft == 0)
++ {
++ /* We've tried to read and there is nothing left. */
++ return UEOF;
++ }
++
++ in_save = inbytesleft;
++ out_count = 2;
++ inp = &lex->buffer[lex->first];
++ outp = out;
++ ir = iconv (lex->handle, (const char **) &inp, &inbytesleft,
++ &outp, &out_count);
++ lex->first += in_save - inbytesleft;
++
++ if (out_count == 0)
++ {
++ /* Success. We assume that UCS-2 is big-endian. This
++ appears to be an ok assumption. */
++ unicode_t result;
++ result = (((unsigned char) out[0]) << 8) | (unsigned char) out[1];
++ return result;
++ }
++
++ if (ir == (size_t) -1)
++ {
++ if (errno == EINVAL)
++ {
++ /* This is ok. This means that the end of our buffer
++ is in the middle of a character sequence. We just
++ move the valid part of the buffer to the beginning
++ to force a read. */
++ /* We use bcopy() because it should work for
++ overlapping strings. Use memmove() instead... */
++ bcopy (&lex->buffer[lex->first], &lex->buffer[0],
++ lex->last - lex->first);
++ lex->last -= lex->first;
++ lex->first = 0;
++ }
++ else
++ {
++ /* A more serious error. */
++ java_lex_error ("unrecognized character in input stream", 0);
++ }
++ }
++ }
++ }
++#else /* HAVE_ICONV */
++ {
++ int c, c1, c2;
++ c = getc (lex->finput);
+
+ if (c < 128)
+ return (unicode_t)c;
+@@ -213,17 +336,17 @@
+ {
+ if ((c & 0xe0) == 0xc0)
+ {
+- c1 = GETC ();
++ c1 = getc (lex->finput);
+ if ((c1 & 0xc0) == 0x80)
+ return (unicode_t)(((c &0x1f) << 6) + (c1 & 0x3f));
+ c = c1;
+ }
+ else if ((c & 0xf0) == 0xe0)
+ {
+- c1 = GETC ();
++ c1 = getc (lex->finput);
+ if ((c1 & 0xc0) == 0x80)
+ {
+- c2 = GETC ();
++ c2 = getc (lex->finput);
+ if ((c2 & 0xc0) == 0x80)
+ return (unicode_t)(((c & 0xf) << 12) +
+ (( c1 & 0x3f) << 6) + (c2 & 0x3f));
+@@ -233,14 +356,15 @@
+ else
+ c = c1;
+ }
+- /* We looked for a UTF8 multi-byte sequence (since we saw an initial
+- byte with the high bit set), but found invalid bytes instead.
+- If the most recent byte was Ascii (and not EOF), we should
+- unget it, in case it was a comment terminator or other delimitor. */
+- if ((c & 0x80) == 0)
+- UNGETC (c);
+- return BAD_UTF8_VALUE;
++
++ /* We simply don't support invalid characters. */
++ java_lex_error ("malformed UTF-8 character", 0);
++ }
+ }
++#endif /* HAVE_ICONV */
++
++ /* We only get here on error. */
++ return UEOF;
+ }
+
+ static void
+@@ -261,56 +385,54 @@
+ }
+
+ static unicode_t
+-java_read_unicode (term_context, unicode_escape_p)
++java_read_unicode (lex, term_context, unicode_escape_p)
++ java_lexer *lex;
+ int term_context;
+ int *unicode_escape_p;
+ {
+ unicode_t c;
+- long i, base;
+
+- c = java_read_char ();
++ c = java_read_char (lex);
+ *unicode_escape_p = 0;
+
+ if (c != '\\')
+- return ((term_context ? c :
+- java_lineterminator (c) ? '\n' : (unicode_t)c));
+-
+- /* Count the number of preceeding '\' */
+- for (base = ftell (finput), i = base-2; c == '\\';)
+ {
+- fseek (finput, i--, SEEK_SET);
+- c = java_read_char (); /* Will fail if reading utf8 stream. FIXME */
++ lex->bs_count = 0;
++ return (term_context ? c : (java_lineterminator (c)
++ ? '\n'
++ : (unicode_t) c));
+ }
+- fseek (finput, base, SEEK_SET);
+- if ((base-i-3)%2 == 0) /* If odd number of \ seen */
++
++ ++lex->bs_count;
++ if ((lex->bs_count) % 2 == 1)
+ {
+- c = java_read_char ();
++ /* Odd number of \ seen. */
++ c = java_read_char (lex);
+ if (c == 'u')
+ {
+- unsigned short unicode = 0;
++ unicode_t unicode = 0;
+ int shift = 12;
+ /* Next should be 4 hex digits, otherwise it's an error.
+ The hex value is converted into the unicode, pushed into
+ the Unicode stream. */
+ for (shift = 12; shift >= 0; shift -= 4)
+ {
+- if ((c = java_read_char ()) == UEOF)
++ if ((c = java_read_char (lex)) == UEOF)
+ return UEOF;
+ if (c >= '0' && c <= '9')
+ unicode |= (unicode_t)((c-'0') << shift);
+ else if ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
+ unicode |= (unicode_t)((10+(c | 0x20)-'a') << shift);
+ else
+- java_lex_error
+- ("Non hex digit in Unicode escape sequence", 0);
++ java_lex_error ("Non hex digit in Unicode escape sequence", 0);
+ }
+ *unicode_escape_p = 1;
+- return (term_context ? unicode :
+- (java_lineterminator (c) ? '\n' : unicode));
++ return (term_context
++ ? unicode : (java_lineterminator (c) ? '\n' : unicode));
+ }
+- ctxp->unget_utf8_value = c;
++ lex->unget_value = c;
+ }
+- return (unicode_t)'\\';
++ return (unicode_t) '\\';
+ }
+
+ static unicode_t
+@@ -325,7 +447,7 @@
+ for (;;)
+ {
+ int unicode_escape_p;
+- c = java_read_unicode (0, &unicode_escape_p);
++ c = java_read_unicode (ctxp->lexer, 0, &unicode_escape_p);
+ java_store_unicode (ctxp->c_line, c, unicode_escape_p);
+ if (ctxp->c_line->white_space_only
+ && !JAVA_WHITE_SPACE_P (c) && c!='\n')
+@@ -346,7 +468,7 @@
+ int unicode_escape_p;
+ if (c == '\n') /* CR */
+ {
+- if ((c = java_read_unicode (1, &unicode_escape_p)) != '\r')
++ if ((c = java_read_unicode (ctxp->lexer, 1, &unicode_escape_p)) != '\r')
+ {
+ ctxp->c_line->ahead [0] = c;
+ ctxp->c_line->unicode_escape_ahead_p = unicode_escape_p;
+@@ -355,7 +477,7 @@
+ }
+ else if (c == '\r') /* LF */
+ {
+- if ((c = java_read_unicode (1, &unicode_escape_p)) != '\n')
++ if ((c = java_read_unicode (ctxp->lexer, 1, &unicode_escape_p)) != '\n')
+ {
+ ctxp->c_line->ahead [0] = c;
+ ctxp->c_line->unicode_escape_ahead_p = unicode_escape_p;
+--- gcc/java/lex.h.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/lex.h Sat Apr 8 23:03:56 2000
+@@ -35,6 +35,13 @@
+ /* A Unicode character, as read from the input file */
+ typedef unsigned short unicode_t;
+
++#ifdef HAVE_ICONV
++#include <iconv.h>
++#endif /* HAVE_ICONV */
++
++/* Default encoding to use if no encoding is specified. */
++#define DEFAULT_ENCODING "UTF-8"
++
+ /* Debug macro to print-out what we match */
+ #ifdef JAVA_LEX_DEBUG
+ #ifdef JAVA_LEX_DEBUG_CHAR
+@@ -96,12 +103,38 @@
+ int col;
+ } java_lc;
+
++typedef struct java_lexer
++{
++ /* The file from which we're reading. */
++ FILE *finput;
++
++ /* Number of consecutive backslashes we've read. */
++ int bs_count;
++
++ /* If nonzero, a value that was pushed back. */
++ unicode_t unget_value;
++
++#ifdef HAVE_ICONV
++ /* The handle for the iconv converter we're using. */
++ iconv_t handle;
++
++ /* Bytes we've read from the file but have not sent to iconv. */
++ char buffer[1024];
++
++ /* Index of first valid character in buffer, -1 if no valid
++ characters. */
++ int first;
++
++ /* Index of last valid character in buffer, plus one. -1 if no
++ valid characters in buffer. */
++ int last;
++#endif /* HAVE_ICONV */
++} java_lexer;
+
+-#define JAVA_LINE_MAX 80
++/* Destroy a lexer object. */
++extern void java_destroy_lexer PARAMS ((java_lexer *));
+
+-/* Macro to read and unread bytes */
+-#define UNGETC(c) ungetc(c, finput)
+-#define GETC() getc(finput)
++#define JAVA_LINE_MAX 80
+
+ /* Build a location compound integer */
+ #define BUILD_LOCATION() ((ctxp->elc.line << 12) | (ctxp->elc.col & 0xfff))
+--- gcc/java/parse.h.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/parse.h Sat Apr 8 23:15:36 2000
+@@ -586,12 +586,11 @@
+ struct parser_ctxt {
+
+ char *filename; /* Current filename */
+- FILE *finput; /* Current file input stream */
+ struct parser_ctxt *next;
+
++ java_lexer *lexer; /* Current lexer state */
+ struct java_line *p_line, *c_line; /* Previous and current line */
+ java_lc elc; /* Error's line column info */
+- unicode_t unget_utf8_value; /* An unget utf8 value */
+ int ccb_indent; /* Keep track of {} indent, lexer */
+ int first_ccb_indent1; /* First { at ident level 1 */
+ int last_ccb_indent1; /* Last } at ident level 1 */
+@@ -668,7 +667,7 @@
+ /* Always in use, no matter what you compile */
+ void java_push_parser_context PROTO ((void));
+ void java_pop_parser_context PROTO ((int));
+-void java_init_lex PROTO ((void));
++void java_init_lex PARAMS ((FILE *, const char *));
+ extern void java_parser_context_save_global PROTO ((void));
+ extern void java_parser_context_restore_global PROTO ((void));
+ int yyparse PROTO ((void));
+--- gcc/java/parse.y.orig Sat Apr 8 23:03:03 2000
++++ gcc/java/parse.y Sat Apr 8 23:03:56 2000
+@@ -2347,7 +2347,6 @@
+ java_push_parser_context ();
+ extra_ctxp_pushed_p = 1;
+ }
+- ctxp->finput = finput;
+ ctxp->lineno = lineno;
+ ctxp->current_class = current_class;
+ ctxp->filename = input_filename;
+@@ -2357,7 +2356,6 @@
+ void
+ java_parser_context_restore_global ()
+ {
+- finput = ctxp->finput;
+ lineno = ctxp->lineno;
+ current_class = ctxp->current_class;
+ input_filename = ctxp->filename;
+@@ -2386,9 +2384,12 @@
+ next->incomplete_class = ctxp->incomplete_class;
+ next->gclass_list = ctxp->gclass_list;
+ lineno = ctxp->lineno;
+- finput = ctxp->finput;
+ current_class = ctxp->current_class;
+ }
++
++ /* If the old and new lexers differ, then free the old one. */
++ if (ctxp->lexer && next && ctxp->lexer != next->lexer)
++ java_destroy_lexer (ctxp->lexer);
+
+ /* Set the single import class file flag to 0 for the current list
+ of imported things */
--- /dev/null
+Changes for GCC version 2.95.1 for GNU Pascal 2.1
+
+Before applying these diffs, go to the directory gcc-2.95.1
+and use the command
+
+ patch -p1
+
+feeding it the following diffs as input.
+
+*** gcc-2.95.1/gcc/expr.c.orig Thu Jul 1 00:59:55 1999
+--- gcc-2.95.1/gcc/expr.c Sun Oct 24 14:01:38 1999
+*************** store_constructor (exp, target, cleared)
+*** 4430,4435 ****
+--- 4430,4444 ----
+
+ domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
+ domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
++
++ #ifdef GPC
++ /* Align the set. */
++ if (set_alignment)
++ domain_min = size_binop (MINUS_EXPR, domain_min,
++ size_binop (TRUNC_MOD_EXPR, domain_min,
++ size_int (set_alignment)));
++ #endif /* GPC */
++
+ bitlength = size_binop (PLUS_EXPR,
+ size_binop (MINUS_EXPR, domain_max, domain_min),
+ size_one_node);
+*************** store_constructor (exp, target, cleared)
+*** 4444,4450 ****
+--- 4453,4461 ----
+ if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
+ || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
+ {
++ #ifndef GPC
+ int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
++ #endif /* not GPC */
+ enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
+ char *bit_buffer = (char *) alloca (nbits);
+ HOST_WIDE_INT word = 0;
+*************** store_constructor (exp, target, cleared)
+*** 4456,4462 ****
+--- 4467,4477 ----
+ {
+ if (bit_buffer[ibit])
+ {
++ #ifdef GPC
++ if (set_words_big_endian)
++ #else /* not GPC */
+ if (BYTES_BIG_ENDIAN)
++ #endif /* not GPC */
+ word |= (1 << (set_word_size - 1 - bit_pos));
+ else
+ word |= 1 << bit_pos;
+*************** store_constructor (exp, target, cleared)
+*** 4570,4575 ****
+--- 4585,4596 ----
+ else
+ #endif
+ {
++ #ifdef GPC
++ /* The language-specific run time library must provide
++ a suitable `__setbits()' function whose action coincides
++ with the values of `set_word_size', `set_alignment', and
++ `set_words_big_endian'. */
++ #endif /* GPC */
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
+ 0, VOIDmode, 4, XEXP (targetx, 0), Pmode,
+ bitlength_rtx, TYPE_MODE (sizetype),
+*** gcc-2.95.1/gcc/stor-layout.c.orig Thu Mar 11 14:56:20 1999
+--- gcc-2.95.1/gcc/stor-layout.c Wed Oct 27 16:39:10 1999
+*************** int maximum_field_alignment;
+*** 53,58 ****
+--- 53,69 ----
+ May be overridden by front-ends. */
+ int set_alignment = 0;
+
++ #ifdef GPC
++ /* The word size of a bitstring or (power-)set value, in bits.
++ Must be non-zero.
++ May be overridden by front-ends. */
++ int set_word_size = BITS_PER_UNIT;
++
++ /* If non-zero, bits in (power-)sets start with the highest bit.
++ May be overridden by front-ends. */
++ int set_words_big_endian /*= BYTES_BIG_ENDIAN*/; /* @@@ Needn't be a constant! */
++ #endif /* GPC */
++
+ static tree layout_record PROTO((tree));
+ static void layout_union PROTO((tree));
+ \f
+*************** static tree pending_sizes;
+*** 65,70 ****
+--- 76,88 ----
+
+ int immediate_size_expand;
+
++ #ifdef GPC
++ /* Nonzero means that the size of a type may vary
++ within one function context. */
++
++ int size_volatile = 0;
++ #endif /* GPC */
++
+ tree
+ get_pending_sizes ()
+ {
+*************** variable_size (size)
+*** 102,108 ****
+--- 120,131 ----
+ || global_bindings_p () < 0 || contains_placeholder_p (size))
+ return size;
+
++ #ifdef GPC
++ if (! size_volatile)
++ size = save_expr (size);
++ #else /* not GPC */
+ size = save_expr (size);
++ #endif
+
+ if (global_bindings_p ())
+ {
+*************** variable_size (size)
+*** 119,125 ****
+--- 142,152 ----
+ Also, we would like to pass const0_rtx here, but don't have it. */
+ expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0),
+ VOIDmode, 0);
++ #ifdef GPC
++ else if (! size_volatile)
++ #else /* not GPC */
+ else
++ #endif
+ pending_sizes = tree_cons (NULL_TREE, size, pending_sizes);
+
+ return size;
+*************** layout_type (type)
+*** 1040,1045 ****
+--- 1067,1086 ----
+ abort();
+ else
+ {
++ #ifdef GPC
++ int alignment = set_alignment ? set_alignment : set_word_size;
++ int lower_bound = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type)));
++ int upper_bound = TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
++ int size_in_bits, rounded_size;
++ if (set_alignment)
++ size_in_bits = upper_bound - (lower_bound / alignment) * alignment + 1;
++ else
++ size_in_bits
++ = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
++ - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
++ rounded_size
++ = ((size_in_bits + alignment - 1) / alignment) * alignment;
++ #else /* not GPC */
+ #ifndef SET_WORD_SIZE
+ #define SET_WORD_SIZE BITS_PER_WORD
+ #endif
+*************** layout_type (type)
+*** 1049,1054 ****
+--- 1090,1096 ----
+ - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
+ int rounded_size
+ = ((size_in_bits + alignment - 1) / alignment) * alignment;
++ #endif /* not GPC */
+ if (rounded_size > alignment)
+ TYPE_MODE (type) = BLKmode;
+ else
+*** gcc-2.95.1/gcc/tree.c.orig Wed Sep 29 19:41:05 1999
+--- gcc-2.95.1/gcc/tree.c Tue Oct 19 00:04:25 1999
+*************** get_set_constructor_bits (init, buffer,
+*** 4986,4991 ****
+--- 4986,4998 ----
+ HOST_WIDE_INT domain_min
+ = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))));
+ tree non_const_bits = NULL_TREE;
++
++ #ifdef GPC
++ /* Align the set. */
++ if (set_alignment)
++ domain_min -= domain_min % set_alignment;
++ #endif /* GPC */
++
+ for (i = 0; i < bit_size; i++)
+ buffer[i] = 0;
+
+*************** get_set_constructor_bytes (init, buffer,
+*** 5038,5045 ****
+--- 5045,5056 ----
+ int wd_size;
+ {
+ int i;
++ #ifdef GPC
++ int bit_size = wd_size * BITS_PER_UNIT;
++ #else /* not GPC */
+ int set_word_size = BITS_PER_UNIT;
+ int bit_size = wd_size * set_word_size;
++ #endif /* not GPC */
+ int bit_pos = 0;
+ unsigned char *bytep = buffer;
+ char *bit_buffer = (char *) alloca(bit_size);
+*************** get_set_constructor_bytes (init, buffer,
+*** 5050,5055 ****
+--- 5061,5084 ----
+
+ for (i = 0; i < bit_size; i++)
+ {
++ #ifdef GPC
++ if (bit_buffer[i])
++ {
++ int k = bit_pos / BITS_PER_UNIT;
++ if (WORDS_BIG_ENDIAN)
++ k = set_word_size / BITS_PER_UNIT - 1 - k;
++ if (set_words_big_endian)
++ bytep[k] |= (1 << (BITS_PER_UNIT - 1 - bit_pos % BITS_PER_UNIT));
++ else
++ bytep[k] |= 1 << (bit_pos % BITS_PER_UNIT);
++ }
++ bit_pos++;
++ if (bit_pos >= set_word_size)
++ {
++ bit_pos = 0;
++ bytep += set_word_size / BITS_PER_UNIT;
++ }
++ #else /* not GPC */
+ if (bit_buffer[i])
+ {
+ if (BYTES_BIG_ENDIAN)
+*************** get_set_constructor_bytes (init, buffer,
+*** 5060,5065 ****
+--- 5089,5095 ----
+ bit_pos++;
+ if (bit_pos >= set_word_size)
+ bit_pos = 0, bytep++;
++ #endif /* not GPC */
+ }
+ return non_const_bits;
+ }
+*** gcc-2.95.1/gcc/tree.h.orig Mon Oct 18 12:19:46 1999
+--- gcc-2.95.1/gcc/tree.h Mon Oct 18 12:36:04 1999
+*************** extern int maximum_field_alignment;
+*** 1630,1635 ****
+--- 1630,1643 ----
+ /* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
+ extern int set_alignment;
+
++ #ifdef GPC
++ /* The word size of a bitstring or (power-)set value, in bits. */
++ extern int set_word_size;
++
++ /* If non-zero, bits in (power-)sets start with the highest bit. */
++ extern int set_words_big_endian;
++ #endif /* GPC */
++
+ /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
+ by making the last node in X point to Y.
+ Returns X, except if X is 0 returns Y. */
+*** gcc-2.95.1/gcc/tree.def.orig Mon May 17 09:21:12 1999
+--- gcc-2.95.1/gcc/tree.def Tue Oct 26 04:16:43 1999
+*************** DEFTREECODE (WITH_CLEANUP_EXPR, "with_cl
+*** 490,528 ****
+ DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
+
+ /* The following two codes are used in languages that have types where
+! the position and/or sizes of fields vary from object to object of the
+! same type, i.e., where some other field in the object contains a value
+! that is used in the computation of another field's offset or size.
+!
+! For example, a record type with a discriminant in Ada is such a type.
+! This mechanism is also used to create "fat pointers" for unconstrained
+! array types in Ada; the fat pointer is a structure one of whose fields is
+! a pointer to the actual array type and the other field is a pointer to a
+! template, which is a structure containing the bounds of the array. The
+! bounds in the type pointed to by the first field in the fat pointer refer
+! to the values in the template.
+!
+! These "self-references" are doing using a PLACEHOLDER_EXPR. This is a
+! node that will later be replaced with the object being referenced. Its type
+! is that of the object and selects which object to use from a chain of
+! references (see below).
+!
+! When we wish to evaluate a size or offset, we check it is contains a
+! placeholder. If it does, we construct a WITH_RECORD_EXPR that contains
+! both the expression we wish to evaluate and an expression within which the
+! object may be found. The latter expression is the object itself in
+! the simple case of an Ada record with discriminant, but it can be the
+! array in the case of an unconstrained array.
+!
+! In the latter case, we need the fat pointer, because the bounds of the
+! array can only be accessed from it. However, we rely here on the fact that
+! the expression for the array contains the dereference of the fat pointer
+! that obtained the array pointer.
+
+ Accordingly, when looking for the object to substitute in place of
+ a PLACEHOLDER_EXPR, we look down the first operand of the expression
+! passed as the second operand to WITH_RECORD_EXPR until we find something
+! of the desired type or reach a constant. */
+
+ /* Denotes a record to later be supplied with a WITH_RECORD_EXPR when
+ evaluating this expression. The type of this expression is used to
+--- 490,547 ----
+ DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1)
+
+ /* The following two codes are used in languages that have types where
+! some field in an object of the type contains a value that is used in
+! the computation of another field's offset or size and/or the size of
+! the type. The positions and/or sizes of fields can vary from object
+! to object of the same type or even for one and the same object within
+! its scope.
+!
+! Record types with discriminants in Ada or schema types in Pascal are
+! examples of such types. This mechanism is also used to create "fat
+! pointers" for unconstrained array types in Ada; the fat pointer is a
+! structure one of whose fields is a pointer to the actual array type
+! and the other field is a pointer to a template, which is a structure
+! containing the bounds of the array. The bounds in the type pointed
+! to by the first field in the fat pointer refer to the values in the
+! template.
+!
+! When you wish to construct such a type you need "self-references"
+! that allow you to reference the object having this type from the
+! TYPE node, i.e. without having a variable instantiating this type.
+!
+! Such a "self-references" is done using a PLACEHOLDER_EXPR. This is
+! a node that will later be replaced with the object being referenced.
+! Its type is that of the object and selects which object to use from
+! a chain of references (see below). No other slots are used in the
+! PLACEHOLDER_EXPR.
+!
+! For example, if your type FOO is a RECORD_TYPE with a field BAR,
+! and you need the value of <variable>.BAR to calculate TYPE_SIZE
+! (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR
+! whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with
+! the PLACEHOLDER_EXPR as the first operand (which has the correct
+! type). Later, when the size is needed in the program, the back-end
+! will find this PLACEHOLDER_EXPR and generate code to calculate the
+! actual size at run-time. In the following, we describe how this
+! calculation is done.
+!
+! When we wish to evaluate a size or offset, we check whether it
+! contains a PLACEHOLDER_EXPR. If it does, we construct a
+! WITH_RECORD_EXPR that contains both the expression we wish to
+! evaluate and an expression within which the object may be found.
+! The latter expression is the object itself in the simple case of an
+! Ada record with discriminant, but it can be the array in the case of
+! an unconstrained array.
+!
+! In the latter case, we need the fat pointer, because the bounds of
+! the array can only be accessed from it. However, we rely here on the
+! fact that the expression for the array contains the dereference of
+! the fat pointer that obtained the array pointer.
+
+ Accordingly, when looking for the object to substitute in place of
+ a PLACEHOLDER_EXPR, we look down the first operand of the expression
+! passed as the second operand to WITH_RECORD_EXPR until we find
+! something of the desired type or reach a constant. */
+
+ /* Denotes a record to later be supplied with a WITH_RECORD_EXPR when
+ evaluating this expression. The type of this expression is used to
--- /dev/null
+--- gcc-2.95.1.orig/gcc/cpp.texi Tue May 18 01:37:18 1999
++++ gcc-2.95.1/gcc/cpp.texi Thu Aug 19 12:46:15 1999
+@@ -3,9 +3,9 @@
+ @settitle The C Preprocessor
+
+ @ifinfo
+-@dircategory Programming
++@dircategory Programming tools:
+ @direntry
+-* Cpp: (cpp). The GNU C preprocessor.
++* Cpp: (cpp). The GNU C preprocessor
+ @end direntry
+ @end ifinfo
+
+--- gcc-2.95.1.orig/gcc/f/g77.texi Mon Jun 21 13:58:54 1999
++++ gcc-2.95.1/gcc/f/g77.texi Thu Aug 19 12:46:15 1999
+@@ -71,9 +71,9 @@
+ @c @end tex
+
+ @ifinfo
+-@dircategory Programming
++@dircategory Programming tools:
+ @direntry
+-* g77: (g77). The GNU Fortran compiler.
++* g77: (g77). The GNU Fortran compiler
+ @end direntry
+ @ifset INTERNALS
+ @ifset USING
+--- gcc-2.95.1.orig/gcc/gcc.texi Mon Aug 9 08:47:01 1999
++++ gcc-2.95.1/gcc/gcc.texi Thu Aug 19 12:47:17 1999
+@@ -80,9 +80,9 @@
+ @c @end tex
+
+ @ifinfo
+-@dircategory Programming
++@dircategory Programming tools:
+ @direntry
+-* gcc: (gcc). The GNU Compiler Collection.
++* gcc: (gcc). The GNU Compiler Collection
+ @end direntry
+ @ifset INTERNALS
+ @ifset USING
+--- gcc-2.95.1.orig/gcc/ch/chill.texi Wed Dec 16 21:59:05 1998
++++ gcc-2.95.1/gcc/ch/chill.texi Wed Sep 22 22:39:09 1999
+@@ -5,9 +5,10 @@
+
+ @ifinfo
+ @format
+-START-INFO-DIR-ENTRY
+-* Chill:: Chill compiler
+-END-INFO-DIR-ENTRY
++@dircategory Programming tools:
++@direntry
++* Chill: (chill). Chill compiler
++@end direntry
+ @end format
+ @end ifinfo
+
--- /dev/null
+#! /bin/sh -e
+
+# DP: Find header file for Boehm garbage collector.
+
+if [ $# -eq 3 -a "$2" = '-d' ]; then
+ pdir="-d $3"
+elif [ $# -ne 1 ]; then
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+fi
+case "$1" in
+ -patch) patch $pdir -f --no-backup-if-mismatch -p0 < $0;;
+ -unpatch) patch $pdir -f --no-backup-if-mismatch -R -p0 < $0;;
+ *)
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+esac
+exit 0
+
+*** libobjc/Makefile.in~ Tue Nov 10 15:25:36 1998
+--- libobjc/Makefile.in Tue Nov 10 13:16:08 1998
+***************
+*** 65,71 ****
+ -I$(srcdir)/$(MULTISRCTOP)../gcc/config -I$(MULTIBUILDTOP)../../gcc \
+ -I$(srcdir)/$(MULTISRCTOP)../include
+
+! OBJC_GCFLAGS=-DOBJC_WITH_GC=1
+ OBJC_THREAD_FILE=thr-@OBJC_THREAD_FILE@
+
+ .SUFFIXES:
+--- 65,71 ----
+ -I$(srcdir)/$(MULTISRCTOP)../gcc/config -I$(MULTIBUILDTOP)../../gcc \
+ -I$(srcdir)/$(MULTISRCTOP)../include
+
+! OBJC_GCFLAGS=-I/usr/include/gc -DOBJC_WITH_GC=1
+ OBJC_THREAD_FILE=thr-@OBJC_THREAD_FILE@
+
+ .SUFFIXES:
--- /dev/null
+/*
+From: Richard Kettlewell <rjk@sfere.greenend.org.uk>
+To: submit@bugs.debian.org
+Subject: Bug#46550: basic_string<wchar_t> can't be instantiated
+Date: Sun, 3 Oct 1999 22:49:50 +0100
+
+Package: libstdc++2.9-dev
+Version: 2.91.60-5
+
+Hi,
+
+This ought to work, but it doesn't:
+
+------------------------------------------------------------------------
+lyonesse$ cat t.cc
+*/
+
+#include <string>
+
+template basic_string<wchar_t>;
+
+/*
+lyonesse$ c++ -c t.cc
+/usr/include/g++-2/std/bastring.h: In method `const __wchar_t * basic_string<__wchar_t,string_char_traits<__wchar_t>,__default_alloc_template<true,0> >::c_str<__wchar_t, string_char_traits<__wchar_t>, alloc>() const':
+t.cc:3: instantiated from here
+/usr/include/g++-2/std/bastring.h:301: return to `const __wchar_t *' from `char *'
+lyonesse$
+------------------------------------------------------------------------
+
+# DP: Here is a patch to /usr/include/g++-2/std/bastring.h which makes it
+# DP: work for me (though note that I have not tested the c_str() method as
+# DP: such):
+
+------------------------------------------------------------------------
+--- libstdc++/std/bastring.h.orig Sun Oct 3 22:32:06 1999
++++ libstdc++/std/bastring.h Sun Oct 3 22:36:17 1999
+@@ -332,7 +332,8 @@
+
+ public:
+ const charT* c_str () const
+- { if (length () == 0) return ""; terminate (); return data (); }
++ { const charT* null_str = "";
++ if (length () == 0) return null_str; terminate (); return data (); }
+ void resize (size_type n, charT c);
+ void resize (size_type n)
+ { resize (n, eos ()); }
--- /dev/null
+# DP: Throw exception instead of aborting when out of memory
+
+From: inaky@peloncho.fis.ucm.es
+To: submit@bugs.debian.org
+Subject: Bug#42622: libstdc++2.10-dev: stl_alloc.h: malloc_alloc out of memory handling abort()s instead of using exceptions
+Date: Sat, 7 Aug 1999 04:31:58 +0200
+
+Package: libstdc++2.10-dev
+Version: 1:2.95-2
+Severity: important
+
+ Hi
+
+ While coding some proof-of-concepts I've come around using a
+vector<> of a big lot of elements. Wanted to push the limits and try
+to recover possible failures. No way. The program was aborting on the
+library's own.
+
+ That should not do. You want exceptions to be able to dictate
+how the program should behave on error situations. The thing is at
+stl_alloc.h, instead of throwing an exception on OOM, it was printing
+the message "out of memory" to stderr and aborting. It is also
+prepared for doing it via exceptions, so I think it should be the
+default way.
+
+ I think that behaviour should be made extensible to the whole
+libstdc++ library, as as far as I know, exception support in GCC is
+mature enough as to handle it [and I hope so :)]. That's the only way
+to fully control a program's flow. Libraries should not dictate what
+to do on error [I'm sure I'm not telling you anything new].
+
+ The changes to make stl_alloc work ok with exceptions are:
+
+--- libstdc++/stl/stl_alloc.h~ Fri May 7 12:13:28 1999
++++ libstdc++/stl/stl_alloc.h Sat Aug 7 04:16:22 1999
+@@ -38,7 +38,7 @@
+ // The allocation primitives are intended to allocate individual objects,
+ // not larger arenas as with the original STL allocators.
+
+-#if 0
++#ifdef __STL_USE_EXCEPTIONS
+ # include <new>
+ # define __THROW_BAD_ALLOC throw bad_alloc()
+ #elif !defined(__THROW_BAD_ALLOC)
+
+ Thanks, anyway, for such nice packages for GCC & Co.
+
+ Your happy Debian user,
+
+-- System Information
+Debian Release: potato
+Kernel Version: Linux jovian 2.2.7 #1 mar ago 3 02:24:40 CEST 1999 i586 unknown
+
+Versions of the packages libstdc++2.10-dev depends on:
+ii g++ 2.95-2 The GNU C++ compiler.
+ii libc6-dev 2.1.2-0pre4 GNU C Library: Development libraries and hea
+ii libstdc++2.10 2.95-2 The GNU stdc++ library
--- /dev/null
+# DP: enable definition of wstring type, if __ENABLE_WSTRING is defined.
+
+--- libstdc++/string~ Sat Feb 20 13:21:49 1999
++++ libstdc++/string Sun Dec 5 16:35:27 1999
+@@ -7,7 +7,9 @@
+
+ extern "C++" {
+ typedef basic_string <char> string;
+-// typedef basic_string <wchar_t> wstring;
++#ifdef __ENABLE_WSTRING
++typedef basic_string <wchar_t> wstring;
++#endif
+ } // extern "C++"
+
+ #endif
--- /dev/null
+diff -ur gcc-2.95.1.orig/libstdc++/config/linux.ml gcc-2.95.1/libstdc++/config/linux.ml
+--- gcc-2.95.1.orig/libstdc++/config/linux.ml Sun Aug 30 23:18:46 1998
++++ gcc-2.95.1/libstdc++/config/linux.ml Thu Aug 19 20:13:06 1999
+@@ -1,10 +1,5 @@
+ # Elf with shared libm, so we can link it into the shared libstdc++.
+
+-ARLIB = libstdc++-$(LIBSTDCXX_INTERFACE)$(LIBC_INTERFACE)$(CXX_INTERFACE)-$(VERSION).a
+-MARLINK = libstdc++$(LIBC_INTERFACE)$(CXX_INTERFACE).a.$(LIBSTDCXX_INTERFACE)
+-SHLIB = libstdc++-$(LIBSTDCXX_INTERFACE)$(LIBC_INTERFACE)$(CXX_INTERFACE)-$(VERSION).so
+-MSHLINK = libstdc++$(LIBC_INTERFACE)$(CXX_INTERFACE).so.$(LIBSTDCXX_INTERFACE)
+-
+ LIBS = $(ARLIB) marlink $(ARLINK) $(SHLIB) mshlink $(SHLINK)
+ SHFLAGS = -Wl,-soname,$(MSHLINK)
+ SHDEPS = -lm
+diff -ur gcc-2.95.1.orig/libstdc++/configure.in gcc-2.95.1/libstdc++/configure.in
+--- gcc-2.95.1.orig/libstdc++/configure.in Tue Jun 8 01:28:10 1999
++++ gcc-2.95.1/libstdc++/configure.in Thu Aug 19 20:15:53 1999
+@@ -193,7 +193,7 @@
+ if test x${enable_version_specific_runtime_libs} = xyes; then
+ gxx_include_dir='${libsubdir}/include/g++'
+ else
+- gxx_include_dir='${prefix}/include/g++'-${libstdcxx_interface}
++ gxx_include_dir='${prefix}/include/g++'
+ fi
+ fi
+
+--- gcc-2.95.1/libstdc++/Makefile.in~ Thu Aug 5 10:00:40 1999
++++ gcc-2.95.1/libstdc++/Makefile.in Fri Aug 20 15:22:06 1999
+@@ -30,8 +30,8 @@
+ memory numeric pthread_alloc queue rope set slist stack utility \
+ vector fstream iomanip iostream strstream iosfwd bitset valarray
+
+-ARLIB = libstdc++.a.$(VERSION)
+-ARLINK = libstdc++.a
++ARLIB = libstdc++.a
++ARLINK = libstdc++.a.$(VERSION)
+ MARLINK = libstdc++.a.`echo $(VERSION) | sed 's/\([0-9]*[.][0-9]*\).*/\1/'`
+ SHLIB = libstdc++.so.$(VERSION)
+ SHARLIB = libstdc++-sh.a
--- /dev/null
+# DP: Two patches by Andreas Schwab to fix -fpic and loop optimization.
+# DP: Another patch by Andreas Schwab to fix %a5 restauration in some cases.
+
+------------------------------------------------------------------------------
+--- gcc/config/m68k/m68k.c~ Mon Aug 2 06:51:08 1999
++++ gcc/config/m68k/m68k.c Fri Oct 22 11:47:09 1999
+@@ -356,7 +356,7 @@
+ mask &= ~ (1 << (15 - FRAME_POINTER_REGNUM));
+ num_saved_regs--;
+ }
+- if (flag_pic && regs_ever_live[PIC_OFFSET_TABLE_REGNUM])
++ if (flag_pic && current_function_uses_pic_offset_table)
+ {
+ mask |= 1 << (15 - PIC_OFFSET_TABLE_REGNUM);
+ num_saved_regs++;
+@@ -493,7 +493,10 @@
+ for (regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno++)
+ if (regs_ever_live[regno] && ! call_used_regs[regno])
+ return 0;
+-
++
++ if (flag_pic && current_function_uses_pic_offset_table)
++ return 0;
++
+ return 1;
+ }
+
+@@ -568,7 +571,7 @@
+ nregs++;
+ mask |= 1 << regno;
+ }
+- if (flag_pic && regs_ever_live[PIC_OFFSET_TABLE_REGNUM])
++ if (flag_pic && current_function_uses_pic_offset_table)
+ {
+ nregs++;
+ mask |= 1 << PIC_OFFSET_TABLE_REGNUM;
+@@ -1334,8 +1337,6 @@
+ gen_rtx_PLUS (Pmode,
+ pic_offset_table_rtx, orig));
+ current_function_uses_pic_offset_table = 1;
+- if (reload_in_progress)
+- regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
+ RTX_UNCHANGING_P (pic_ref) = 1;
+ emit_move_insn (reg, pic_ref);
+ return reg;
+--- gcc/loop.c~ Fri Jun 25 06:38:11 1999
++++ gcc/loop.c Fri Oct 22 11:45:16 1999
+@@ -4046,11 +4046,11 @@
+ in-between when biv_toal_increment returns nonzero both times
+ but we test it here in case some day some real cfg analysis
+ gets used to set always_computable. */
+- && ((loop_insn_first_p (bl2->biv->insn, bl->biv->insn)
+- && no_labels_between_p (bl2->biv->insn, bl->biv->insn))
+- || (! reg_used_between_p (bl->biv->src_reg, bl->biv->insn,
+- bl2->biv->insn)
+- && no_jumps_between_p (bl->biv->insn, bl2->biv->insn)))
++ && (loop_insn_first_p (bl2->biv->insn, bl->biv->insn)
++ ? no_labels_between_p (bl2->biv->insn, bl->biv->insn)
++ : (! reg_used_between_p (bl->biv->src_reg, bl->biv->insn,
++ bl2->biv->insn)
++ && no_jumps_between_p (bl->biv->insn, bl2->biv->insn)))
+ && validate_change (bl->biv->insn,
+ &SET_SRC (single_set (bl->biv->insn)),
+ copy_rtx (src), 0))
--- /dev/null
+# DP: Document exit codes.
+
+Wed Oct 20 22:55:23 1999 Matthias Klose <doko@debian.org>
+
+ * gcc.1: Document exit codes.
+
+--- gcc/gcc.1.orig Thu Oct 21 12:52:54 1999
++++ gcc/gcc.1 Thu Oct 21 12:53:15 1999
+@@ -4141,6 +4141,11 @@
+ if available, else
+ .B /tmp\c
+ \&).
++.SH "EXIT STATUS"
++Normally the exit status is 0, if compilation or link edit are successful,
++and nonzero else. The option
++.B -Werror
++treats each warning as an error.
+ .SH "SEE ALSO"
+ cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
+ .br
--- /dev/null
+diff -urN gcc-2.95.3.test1.org/gcc/Makefile.in gcc-2.95.3.test1/gcc/Makefile.in
+--- gcc-2.95.3.test1.org/gcc/Makefile.in Wed Jan 3 20:34:29 2001
++++ gcc-2.95.3.test1/gcc/Makefile.in Wed Jan 3 20:37:33 2001
+@@ -368,6 +368,9 @@
+ # libgcc1-test target (must also be overridable for a target)
+ LIBGCC1_TEST = libgcc1-test
+
++# The libgcc symbol versioning map.
++LIBGCC_MAP=
++
+ # List of extra executables that should be compiled for this target machine
+ # that are used for compiling from source code to object code.
+ # The rules for compiling them should be in the t-* file for the machine.
+@@ -838,14 +841,14 @@
+ # Note that we can compile enquire using the cross-compiler just built,
+ # although we can't run it on this machine.
+ all.cross: native gcc-cross specs stmp-headers $(STMP_FIXPROTO) $(LIBGCC) \
+- $(LIBGCC1_TEST) $(EXTRA_PARTS) lang.all.cross doc
++ $(LIBGCC_MAP) $(LIBGCC1_TEST) $(EXTRA_PARTS) lang.all.cross doc
+ # This is what to compile if making gcc with a cross-compiler.
+ all.build: native xgcc$(exeext) cpp$(exeext) $(EXTRA_PARTS) lang.all.build
+ # This is what must be made before installing GCC and converting libraries.
+ start.encap: native xgcc$(exeext) cpp$(exeext) specs $(LIBGCC1) \
+ xlimits.h lang.start.encap
+ # These can't be made until after GCC can run.
+-rest.encap: stmp-headers $(STMP_FIXPROTO) $(LIBGCC) $(EXTRA_PARTS) lang.rest.encap
++rest.encap: stmp-headers $(STMP_FIXPROTO) $(LIBGCC) $(LIBGCC_MAP) $(EXTRA_PARTS) lang.rest.encap
+ # This is what is made with the host's compiler
+ # whether making a cross compiler or not.
+ native: config.status auto-host.h intl.all $(LANGUAGES) \
+@@ -860,7 +863,7 @@
+
+ # On the target machine, finish building a cross compiler.
+ # This does the things that can't be done on the host machine.
+-rest.cross: $(LIBGCC) specs
++rest.cross: $(LIBGCC) $(LIBGCC_MAP) specs
+
+ # Verify that it works to compile and link libgcc1-test.
+ # If it does, then there are sufficient replacements for libgcc1.a.
+@@ -2353,7 +2356,7 @@
+ # Using unprotoize.c is not quite right in the first place,
+ # but what better way is there?
+ -rm -f libgcc.a libgcc1.a libgcc1-asm.a libgcc2.a libgcc2.ready
+- -rm -f libgcc1.null
++ -rm -f libgcc1.null libgcc.map
+ -rm -f *.dvi
+ -rm -f */*.dvi
+ -if [ -f md.pre-cpp ]; then \
+@@ -2526,6 +2529,12 @@
+ $(INSTALL_DATA) specs $(libsubdir)/specs; \
+ chmod a-x $(libsubdir)/specs; \
+ fi
++# Install libgcc.map if it exists.
++ -if [ -n "$(LIBGCC_MAP)" -a -f libgcc.map ] ; then \
++ rm -f $(libsubdir)/libgcc.map; \
++ $(INSTALL_DATA) libgcc.map $(libsubdir)/libgcc.map; \
++ chmod a-x $(libsubdir)/libgcc.map; \
++ fi
+ # Install protoize if it was compiled.
+ -if [ -f protoize$(exeext) ]; \
+ then \
+@@ -3032,7 +3041,10 @@
+ do \
+ if [ -d stage1/$$dir ] ; then true ; else mkdir stage1/$$dir ; fi ; \
+ done
+- -mv $(STAGESTUFF) stage1
++ -for i in $(STAGESTUFF) ; \
++ do \
++ mv $$i stage1 ; \
++ done
+ -mv intl/*$(objext) stage1/intl
+ # Copy as/ld if they exist to stage dir, so that running xgcc from the stage
+ # dir will work properly.
+@@ -3041,6 +3053,10 @@
+ -if [ -f collect-ld$(exeext) ] ; then $(LN_S) ../collect-ld$(exeext) stage1 ; else true ; fi
+ -rm -f stage1/libgcc.a
+ -cp libgcc.a stage1
++ -if [ -n "$(LIBGCC_MAP)" -a -f libgcc.map ] ; then \
++ rm -f stage1/libgcc.map; \
++ cp libgcc.map stage1; \
++ fi
+ -if $(RANLIB_TEST_FOR_TARGET) ; then \
+ $(RANLIB_FOR_TARGET) stage1/libgcc.a; \
+ else true; fi
+@@ -3056,7 +3072,10 @@
+ do \
+ if [ -d stage2/$$dir ] ; then true ; else mkdir stage2/$$dir ; fi ; \
+ done
+- -mv $(STAGESTUFF) stage2
++ -for i in $(STAGESTUFF) ; \
++ do \
++ mv $$i stage2 ; \
++ done
+ -mv intl/*$(objext) stage2/intl
+ # Copy as/ld if they exist to stage dir, so that running xgcc from the stage
+ # dir will work properly.
+@@ -3065,6 +3084,10 @@
+ -if [ -f collect-ld ] ; then $(LN_S) ../collect-ld$(exeext) stage2 ; else true ; fi
+ -rm -f stage2/libgcc.a
+ -cp libgcc.a stage2
++ -if [ -n "$(LIBGCC_MAP)" -a -f libgcc.map ] ; then \
++ rm -f stage2/libgcc.map; \
++ cp libgcc.map stage2; \
++ fi
+ -if $(RANLIB_TEST_FOR_TARGET) ; then \
+ $(RANLIB_FOR_TARGET) stage2/libgcc.a; \
+ else true; fi
+@@ -3080,7 +3103,10 @@
+ do \
+ if [ -d stage3/$$dir ] ; then true ; else mkdir stage3/$$dir ; fi ; \
+ done
+- -mv $(STAGESTUFF) stage3
++ -for i in $(STAGESTUFF) ; \
++ do \
++ mv $$i stage3 ; \
++ done
+ -mv intl/*$(objext) stage3/intl
+ # Copy as/ld if they exist to stage dir, so that running xgcc from the stage
+ # dir will work properly.
+@@ -3089,6 +3115,10 @@
+ -if [ -f collect-ld$(exeext) ] ; then $(LN_S) ../collect-ld$(exeext) stage3 ; else true ; fi
+ -rm -f stage3/libgcc.a
+ -cp libgcc.a stage3
++ -if [ -n "$(LIBGCC_MAP)" -a -f libgcc.map ] ; then \
++ rm -f stage3/libgcc.map; \
++ cp libgcc.map stage3; \
++ fi
+ -if $(RANLIB_TEST_FOR_TARGET) ; then \
+ $(RANLIB_FOR_TARGET) stage3/libgcc.a; \
+ else true; fi
+@@ -3104,7 +3134,10 @@
+ do \
+ if [ -d stage4/$$dir ] ; then true ; else mkdir stage4/$$dir ; fi ; \
+ done
+- -mv $(STAGESTUFF) stage4
++ -for i in $(STAGESTUFF) ; \
++ do \
++ mv $$i stage4 ; \
++ done
+ -mv intl/*$(objext) stage4/intl
+ # Copy as/ld if they exist to stage dir, so that running xgcc from the stage
+ # dir will work properly.
+@@ -3113,6 +3146,10 @@
+ -if [ -f collect-ld$(exeext) ] ; then $(LN_S) ../collect-ld$(exeext) stage4 ; else true ; fi
+ -rm -f stage4/libgcc.a
+ -cp libgcc.a stage4
++ -if [ -n "$(LIBGCC_MAP)" -a -f libgcc.map ] ; then \
++ rm -f stage4/libgcc.map; \
++ cp libgcc.map stage4; \
++ fi
+ -if $(RANLIB_TEST_FOR_TARGET) ; then \
+ $(RANLIB_FOR_TARGET) stage4/libgcc.a; \
+ else true; fi
+@@ -3196,3 +3233,9 @@
+ echo "#endif" >> t-float.h-cross
+ mv t-float.h-cross float.h-cross
+
++# Rule to generate the libgcc symbol versioning map.
++libgcc.map:
++ echo "GCC.INTERNAL {" > $@
++ echo " local:" >> $@
++ $(EXTRACT_LIBGCC) >> $@
++ echo "};" >> $@
+diff -urN gcc-2.95.3.test1.org/gcc/config/i386/i386.md gcc-2.95.3.test1/gcc/config/i386/i386.md
+--- gcc-2.95.3.test1.org/gcc/config/i386/i386.md Wed Jan 3 20:34:36 2001
++++ gcc-2.95.3.test1/gcc/config/i386/i386.md Wed Jan 3 20:35:21 2001
+@@ -1345,7 +1345,8 @@
+ else if ((reload_in_progress | reload_completed) == 0
+ && GET_CODE (operands[0]) != MEM
+ && GET_CODE (operands[1]) == CONST_DOUBLE
+- && !standard_80387_constant_p (operands[1]))
++ && ((flag_pic && flag_omit_frame_pointer)
++ || ! standard_80387_constant_p (operands[1])))
+ {
+ operands[1] = validize_mem (force_const_mem (SFmode, operands[1]));
+ }
+@@ -1473,7 +1474,8 @@
+ else if ((reload_in_progress | reload_completed) == 0
+ && GET_CODE (operands[0]) != MEM
+ && GET_CODE (operands[1]) == CONST_DOUBLE
+- && !standard_80387_constant_p (operands[1]))
++ && ((flag_pic && flag_omit_frame_pointer)
++ || ! standard_80387_constant_p (operands[1])))
+ {
+ operands[1] = validize_mem (force_const_mem (DFmode, operands[1]));
+ }
+@@ -1601,7 +1603,8 @@
+ else if ((reload_in_progress | reload_completed) == 0
+ && GET_CODE (operands[0]) != MEM
+ && GET_CODE (operands[1]) == CONST_DOUBLE
+- && !standard_80387_constant_p (operands[1]))
++ && ((flag_pic && flag_omit_frame_pointer)
++ || ! standard_80387_constant_p (operands[1])))
+ {
+ operands[1] = validize_mem (force_const_mem (XFmode, operands[1]));
+ }
+diff -urN gcc-2.95.3.test1.org/gcc/config/linux.h gcc-2.95.3.test1/gcc/config/linux.h
+--- gcc-2.95.3.test1.org/gcc/config/linux.h Wed Jan 3 20:34:33 2001
++++ gcc-2.95.3.test1/gcc/config/linux.h Wed Jan 3 20:35:22 2001
+@@ -103,7 +103,7 @@
+ %{!profile:%{!ggdb:-lc} %{ggdb:-lg}}}"
+ #else
+ #define LIB_SPEC \
+- "%{shared: -lc} \
++ "%{shared: -lc --version-script libgcc.map%s} \
+ %{!shared: %{mieee-fp:-lieee} %{pthread:-lpthread} \
+ %{profile:-lc_p} %{!profile: -lc}}"
+ #endif
+diff -urN gcc-2.95.3.test1.org/gcc/config/t-linux gcc-2.95.3.test1/gcc/config/t-linux
+--- gcc-2.95.3.test1.org/gcc/config/t-linux Wed Jan 3 20:34:33 2001
++++ gcc-2.95.3.test1/gcc/config/t-linux Wed Jan 3 20:35:22 2001
+@@ -14,3 +14,17 @@
+ LIBGCC1 =
+ CROSS_LIBGCC1 =
+ LIBGCC1_TEST =
++
++# Make glocal functions in libgcc.a local to the shared library with
++# symbol versioning.
++LIBGCC_MAP=libgcc.map
++# This list has to be maintained manually. It should cover the libgcc
++# functions, which can be safely made local to a shared library, on
++# all Linux platforms.
++LIBGCC_MAP_LIST=__ashldi3 __ashrdi3 __builtin_saveregs __clear_cache \
++ __cmpdi2 __divdi3 __dummy __eprintf __ffsdi2 __fixdfdi __fixsfdi \
++ __fixunsdfdi __fixunsdfsi __fixunssfdi __fixunssfsi __fixunsxfdi \
++ __fixunsxfsi __fixxfdi __floatdidf __floatdisf __floatdixf \
++ __gcc_bcmp __lshrdi3 __moddi3 __muldi3 __negdi2 __pure_virtual \
++ __ucmpdi2 __udiv_w_sdiv __udivdi3 __udivmoddi4 __umoddi3
++EXTRACT_LIBGCC=for s in $(LIBGCC_MAP_LIST); do echo " $$s;"; done
+diff -urN gcc-2.95.3.test1.org/gcc/f/Make-lang.in gcc-2.95.3.test1/gcc/f/Make-lang.in
+--- gcc-2.95.3.test1.org/gcc/f/Make-lang.in Wed Jan 3 20:34:42 2001
++++ gcc-2.95.3.test1/gcc/f/Make-lang.in Wed Jan 3 20:35:22 2001
+@@ -212,7 +212,7 @@
+
+ f77.all.build: g77$(exeext)
+ f77.all.cross: g77-cross$(exeext)
+-f77.start.encap: g77$(exeext)
++f77.start.encap: g77$(exeext) $(srcdir)/f/intdoc.texi
+ f77.rest.encap:
+
+ f77.info: f/g77.info
+diff -urN gcc-2.95.3.test1.org/libf2c/Makefile.in gcc-2.95.3.test1/libf2c/Makefile.in
+--- gcc-2.95.3.test1.org/libf2c/Makefile.in Wed Jan 3 20:34:47 2001
++++ gcc-2.95.3.test1/libf2c/Makefile.in Wed Jan 3 20:35:22 2001
+@@ -61,18 +61,18 @@
+ # Quote this way so that it can be used to set shell variables too.
+ # Currently no use for PICFLAG, RUNTESTFLAGS -- check usage.
+ FLAGS_TO_PASS= \
+- CC='$(CC)' \
+- CFLAGS='$(CFLAGS)' \
+- CPPFLAGS='$(CPPFLAGS)' \
+- AR='$(AR)' \
+- RANLIB='$(RANLIB)' \
+- PICFLAG='$(PICFLAG)' \
+- RUNTESTFLAGS='$(RUNTESTFLAGS)' \
+- prefix='$(prefix)' \
+- exec_prefix='$(exec_prefix)' \
+- libdir='$(libdir)' \
+- libsubdir='$(libsubdir)' \
+- tooldir='$(tooldir)'
++ "CC=$(CC)" \
++ "CFLAGS=$(CFLAGS)" \
++ "CPPFLAGS=$(CPPFLAGS)" \
++ "AR=$(AR)" \
++ "RANLIB=$(RANLIB)" \
++ "PICFLAG=$(PICFLAG)" \
++ "RUNTESTFLAGS=$(RUNTESTFLAGS)" \
++ "prefix=$(prefix)" \
++ "exec_prefix=$(exec_prefix)" \
++ "libdir=$(libdir)" \
++ "libsubdir=$(libsubdir)" \
++ "tooldir=$(tooldir)"
+
+ LIBG2C = libg2c.a
+
--- /dev/null
+#! /bin/sh -e
+
+if [ $# -eq 3 -a "$2" = '-d' ]; then
+ pdir="-d $3"
+elif [ $# -ne 1 ]; then
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+fi
+case "$1" in
+ -patch) patch $pdir -f --no-backup-if-mismatch -p0 < $0;;
+ -unpatch) patch $pdir -f --no-backup-if-mismatch -R -p0 < $0;;
+ *)
+ echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
+ exit 1
+esac
+exit 0
+
+# append the patch here and adjust the -p? flag in the patch calls.
+
+From: Jim Kingdon <kingdon@redhat.com>
+To: rth@cygnus.com
+CC: gcc-patches@gcc.gnu.org
+Subject: Re: patch to make -Wpointer-arith work with glibc 2.1.2pre3
+Date: Tue, 21 Sep 1999 15:50:20 -0400
+
+Richard Henderson writes:
+
+> This could all be tidied a bit by creating a couple of macros near
+> the beginning of c-parse.in to do the encoding and decoding. Also,
+> setting the type of `extension' means $<itype>1 can be written $1.
+
+Here you go (sorry for the delay, I plead hurricanes and other
+causes).
+
+Let me know if you still aren't happy :-).
+
+# DP: Wed Sep 1 09:12:02 1999 Jim Kingdon <http://developer.redhat.com>
+# DP:
+# DP: * c-parse.in: save and restore warn_pointer_arith on __extension__
+# DP: along with pedantic.
+# DP: (SAVE_WARN_FLAGS, RESTORE_WARN_FLAGS): Added.
+# DP: Set the type of extension to itype rather than $<itype>1 kludge.
+# DP: * extend.texi (Alternate Keywords): Adjust documentation.
+
+Index: c-parse.in
+===================================================================
+RCS file: /cvs/egcs/egcs/gcc/c-parse.in,v
+retrieving revision 1.23
+diff -u -r1.23 c-parse.in
+--- gcc/c-parse.in 1999/09/07 05:47:29 1.23
++++ gcc/c-parse.in 1999/09/21 19:05:43
+@@ -185,6 +185,8 @@
+ %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
+ %type <ttype> identifiers_or_typenames
+
++%type <itype> extension
++
+ %type <itype> setspecs
+
+ %type <ends_in_label> lineno_stmt_or_label lineno_stmt_or_labels stmt_or_label
+@@ -227,6 +229,15 @@
+ /* 1 if we explained undeclared var errors. */
+ static int undeclared_variable_notice;
+
++/* For __extension__, save/restore the warning flags which are
++ controlled by __extension__. */
++#define SAVE_WARN_FLAGS() (pedantic | (warn_pointer_arith << 1))
++#define RESTORE_WARN_FLAGS(val) \
++ do { \
++ pedantic = val & 1; \
++ warn_pointer_arith = (val >> 1) & 1; \
++ } while (0)
++
+ ifobjc
+ /* Objective-C specific information */
+
+@@ -297,7 +308,7 @@
+ else
+ error ("argument of `asm' is not a constant string"); }
+ | extension extdef
+- { pedantic = $<itype>1; }
++ { RESTORE_WARN_FLAGS ($1); }
+ ;
+
+ datadef:
+@@ -438,7 +449,7 @@
+ /* __extension__ turns off -pedantic for following primary. */
+ | extension cast_expr %prec UNARY
+ { $$ = $2;
+- pedantic = $<itype>1; }
++ RESTORE_WARN_FLAGS ($1); }
+ | unop cast_expr %prec UNARY
+ { $$ = build_unary_op ($1, $2, 0);
+ overflow_warning ($$); }
+@@ -1002,7 +1013,7 @@
+ | declmods ';'
+ { pedwarn ("empty declaration"); }
+ | extension decl
+- { pedantic = $<itype>1; }
++ { RESTORE_WARN_FLAGS ($1); }
+ ;
+
+ /* Declspecs which contain at least one type specifier or typedef name.
+@@ -1607,7 +1618,7 @@
+ { $$ = NULL_TREE; }
+ | extension component_decl
+ { $$ = $2;
+- pedantic = $<itype>1; }
++ RESTORE_WARN_FLAGS ($1); }
+ ;
+
+ components:
+@@ -2441,8 +2452,9 @@
+
+ extension:
+ EXTENSION
+- { $<itype>$ = pedantic;
+- pedantic = 0; }
++ { $$ = SAVE_WARN_FLAGS();
++ pedantic = 0;
++ warn_pointer_arith = 0; }
+ ;
+ \f
+ ifobjc
--- /dev/null
+# DP: Add descriptions to rs6000.h and sysv4.h to quench warnings.
+# DP: by Franz Sirl
+
+Index: gcc/config/rs6000/rs6000.h
+--- rs6000.h 1999/06/09 15:59:37 1.49.4.1
++++ gcc/config/rs6000/rs6000.h 1999/06/12 18:55:36
+@@ -352,46 +352,81 @@ extern int target_flags;
+ #endif
+
+ #define TARGET_SWITCHES \
+- {{"power", MASK_POWER | MASK_MULTIPLE | MASK_STRING}, \
++ {{"power", MASK_POWER | MASK_MULTIPLE | MASK_STRING, \
++ "Use POWER instruction set"}, \
+ {"power2", (MASK_POWER | MASK_MULTIPLE | MASK_STRING \
+- | MASK_POWER2)}, \
+- {"no-power2", - MASK_POWER2}, \
++ | MASK_POWER2), \
++ "Use POWER2 instruction set"}, \
++ {"no-power2", - MASK_POWER2, \
++ "Do not use POWER2 instruction set"}, \
+ {"no-power", - (MASK_POWER | MASK_POWER2 | MASK_MULTIPLE \
+- | MASK_STRING)}, \
+- {"powerpc", MASK_POWERPC}, \
++ | MASK_STRING), \
++ "Do not use POWER instruction set"}, \
++ {"powerpc", MASK_POWERPC, \
++ "Use PowerPC instruction set"}, \
+ {"no-powerpc", - (MASK_POWERPC | MASK_PPC_GPOPT \
+- | MASK_PPC_GFXOPT | MASK_POWERPC64)}, \
+- {"powerpc-gpopt", MASK_POWERPC | MASK_PPC_GPOPT}, \
+- {"no-powerpc-gpopt", - MASK_PPC_GPOPT}, \
+- {"powerpc-gfxopt", MASK_POWERPC | MASK_PPC_GFXOPT}, \
+- {"no-powerpc-gfxopt", - MASK_PPC_GFXOPT}, \
+- {"powerpc64", MASK_POWERPC64}, \
+- {"no-powerpc64", - MASK_POWERPC64}, \
+- {"new-mnemonics", MASK_NEW_MNEMONICS}, \
+- {"old-mnemonics", -MASK_NEW_MNEMONICS}, \
++ | MASK_PPC_GFXOPT | MASK_POWERPC64), \
++ "Do not use PowerPC instruction set"}, \
++ {"powerpc-gpopt", MASK_POWERPC | MASK_PPC_GPOPT, \
++ "Use PowerPC General Purpose group optional instructions"},\
++ {"no-powerpc-gpopt", - MASK_PPC_GPOPT, \
++ "Don't use PowerPC General Purpose group optional instructions"},\
++ {"powerpc-gfxopt", MASK_POWERPC | MASK_PPC_GFXOPT, \
++ "Use PowerPC Graphics group optional instructions"},\
++ {"no-powerpc-gfxopt", - MASK_PPC_GFXOPT, \
++ "Don't use PowerPC Graphics group optional instructions"},\
++ {"powerpc64", MASK_POWERPC64, \
++ "Use PowerPC-64 instruction set"}, \
++ {"no-powerpc64", - MASK_POWERPC64, \
++ "Don't use PowerPC-64 instruction set"}, \
++ {"new-mnemonics", MASK_NEW_MNEMONICS, \
++ "Use new mnemonics for PowerPC architecture"}, \
++ {"old-mnemonics", -MASK_NEW_MNEMONICS, \
++ "Use old mnemonics for PowerPC architecture"}, \
+ {"full-toc", - (MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC \
+- | MASK_MINIMAL_TOC)}, \
+- {"fp-in-toc", - MASK_NO_FP_IN_TOC}, \
+- {"no-fp-in-toc", MASK_NO_FP_IN_TOC}, \
+- {"sum-in-toc", - MASK_NO_SUM_IN_TOC}, \
+- {"no-sum-in-toc", MASK_NO_SUM_IN_TOC}, \
+- {"minimal-toc", MASK_MINIMAL_TOC}, \
+- {"minimal-toc", - (MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC)}, \
+- {"no-minimal-toc", - MASK_MINIMAL_TOC}, \
+- {"hard-float", - MASK_SOFT_FLOAT}, \
+- {"soft-float", MASK_SOFT_FLOAT}, \
+- {"multiple", MASK_MULTIPLE | MASK_MULTIPLE_SET}, \
+- {"no-multiple", - MASK_MULTIPLE}, \
+- {"no-multiple", MASK_MULTIPLE_SET}, \
+- {"string", MASK_STRING | MASK_STRING_SET}, \
+- {"no-string", - MASK_STRING}, \
+- {"no-string", MASK_STRING_SET}, \
+- {"update", - MASK_NO_UPDATE}, \
+- {"no-update", MASK_NO_UPDATE}, \
+- {"fused-madd", - MASK_NO_FUSED_MADD}, \
+- {"no-fused-madd", MASK_NO_FUSED_MADD}, \
++ | MASK_MINIMAL_TOC), \
++ "no description yet"}, \
++ {"fp-in-toc", - MASK_NO_FP_IN_TOC, \
++ "Place floating point constants in TOC"}, \
++ {"no-fp-in-toc", MASK_NO_FP_IN_TOC, \
++ "Don't place floating point constants in TOC"}, \
++ {"sum-in-toc", - MASK_NO_SUM_IN_TOC, \
++ "Place symbol+offset constants in TOC"}, \
++ {"no-sum-in-toc", MASK_NO_SUM_IN_TOC, \
++ "Don't place symbol+offset constants in TOC"}, \
++ {"minimal-toc", MASK_MINIMAL_TOC, \
++ "no description yet"}, \
++ {"minimal-toc", - (MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC), \
++ "no description yet"}, \
++ {"no-minimal-toc", - MASK_MINIMAL_TOC, \
++ "no description yet"}, \
++ {"hard-float", - MASK_SOFT_FLOAT, \
++ "Use hardware fp"}, \
++ {"soft-float", MASK_SOFT_FLOAT, \
++ "Do not use hardware fp"}, \
++ {"multiple", MASK_MULTIPLE | MASK_MULTIPLE_SET, \
++ "Generate load/store multiple instructions"}, \
++ {"no-multiple", - MASK_MULTIPLE, \
++ "Do not generate load/store multiple instructions"},\
++ {"no-multiple", MASK_MULTIPLE_SET, \
++ "Do not generate load/store multiple instructions"},\
++ {"string", MASK_STRING | MASK_STRING_SET, \
++ "Generate string instructions for block moves"},\
++ {"no-string", - MASK_STRING, \
++ "Do not generate string instructions for block moves"},\
++ {"no-string", MASK_STRING_SET, \
++ "Do not generate string instructions for block moves"},\
++ {"update", - MASK_NO_UPDATE, \
++ "Generate load/store with update instructions"},\
++ {"no-update", MASK_NO_UPDATE, \
++ "Do not generate load/store with update instructions"},\
++ {"fused-madd", - MASK_NO_FUSED_MADD, \
++ "Generate fused multiply/add instructions"}, \
++ {"no-fused-madd", MASK_NO_FUSED_MADD, \
++ "Don't generate fused multiply/add instructions"},\
+ SUBTARGET_SWITCHES \
+- {"", TARGET_DEFAULT}}
++ {"", TARGET_DEFAULT, \
++ ""}}
+
+ #define TARGET_DEFAULT (MASK_POWER | MASK_MULTIPLE | MASK_STRING)
+
+@@ -449,13 +484,13 @@ extern enum processor_type rs6000_cpu;
+ #define SUBTARGET_OPTIONS
+ #endif
+
+-#define TARGET_OPTIONS \
+-{ \
+- {"cpu=", &rs6000_select[1].string}, \
+- {"tune=", &rs6000_select[2].string}, \
+- {"debug-", &rs6000_debug_name}, \
+- {"debug=", &rs6000_debug_name}, \
+- SUBTARGET_OPTIONS \
++#define TARGET_OPTIONS \
++{ \
++ {"cpu=", &rs6000_select[1].string, "Use features of and schedule code for given CPU" },\
++ {"tune=", &rs6000_select[2].string, "Schedule code for given CPU" }, \
++ {"debug-", &rs6000_debug_name, "Enable debug output" }, \
++ {"debug=", &rs6000_debug_name, "Enable debug output" }, \
++ SUBTARGET_OPTIONS \
+ }
+
+ /* rs6000_select[0] is reserved for the default cpu defined via --with-cpu */
+Index: gcc/config/rs6000/sysv4.h
+--- sysv4.h 1999/05/28 02:46:56 1.19.4.1
++++ gcc/config/rs6000/sysv4.h 1999/06/12 18:55:38
+@@ -66,39 +66,39 @@ extern enum rs6000_sdata_type rs6000_sda
+ the same as -mminimal-toc. */
+ #undef SUBTARGET_SWITCHES
+ #define SUBTARGET_SWITCHES \
+- { "bit-align", -MASK_NO_BITFIELD_TYPE }, \
+- { "no-bit-align", MASK_NO_BITFIELD_TYPE }, \
+- { "strict-align", MASK_STRICT_ALIGN }, \
+- { "no-strict-align", -MASK_STRICT_ALIGN }, \
+- { "relocatable", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC }, \
+- { "no-relocatable", -MASK_RELOCATABLE }, \
+- { "relocatable-lib", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC }, \
+- { "no-relocatable-lib", -MASK_RELOCATABLE }, \
+- { "little-endian", MASK_LITTLE_ENDIAN }, \
+- { "little", MASK_LITTLE_ENDIAN }, \
+- { "big-endian", -MASK_LITTLE_ENDIAN }, \
+- { "big", -MASK_LITTLE_ENDIAN }, \
+- { "no-toc", 0 }, \
+- { "toc", MASK_MINIMAL_TOC }, \
+- { "full-toc", MASK_MINIMAL_TOC }, \
+- { "prototype", MASK_PROTOTYPE }, \
+- { "no-prototype", -MASK_PROTOTYPE }, \
+- { "no-traceback", 0 }, \
+- { "eabi", MASK_EABI }, \
+- { "no-eabi", -MASK_EABI }, \
+- { "regnames", MASK_REGNAMES }, \
+- { "no-regnames", -MASK_REGNAMES }, \
+- { "sdata", 0 }, \
+- { "no-sdata", 0 }, \
+- { "sim", 0 }, \
+- { "ads", 0 }, \
+- { "yellowknife", 0 }, \
+- { "mvme", 0 }, \
+- { "emb", 0 }, \
+- { "solaris-cclib", 0 }, \
+- { "shlib", 0 }, \
+- EXTRA_SUBTARGET_SWITCHES \
+- { "newlib", 0 },
++ { "bit-align", -MASK_NO_BITFIELD_TYPE, "Align to the base type of the bitfield." },\
++ { "no-bit-align", MASK_NO_BITFIELD_TYPE, "Don't align to the base type of the bitfield." },\
++ { "strict-align", MASK_STRICT_ALIGN, "Don't assume that unaligned accesses are handled by the system" },\
++ { "no-strict-align", -MASK_STRICT_ALIGN, "Assume that unaligned accesses are handled by the system" },\
++ { "relocatable", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC, "Produce code relocatable at runtime." },\
++ { "no-relocatable", -MASK_RELOCATABLE, "Don't produce code relocatable at runtime." },\
++ { "relocatable-lib", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC, "Produce code relocatable at runtime." },\
++ { "no-relocatable-lib", -MASK_RELOCATABLE, "Don't produce code relocatable at runtime." },\
++ { "little-endian", MASK_LITTLE_ENDIAN, "Produce little endian code." }, \
++ { "little", MASK_LITTLE_ENDIAN, "Produce little endian code." }, \
++ { "big-endian", -MASK_LITTLE_ENDIAN, "Produce big endian code." }, \
++ { "big", -MASK_LITTLE_ENDIAN, "Produce big endian code." }, \
++ { "no-toc", 0, "no description yet" }, \
++ { "toc", MASK_MINIMAL_TOC, "no description yet" }, \
++ { "full-toc", MASK_MINIMAL_TOC, "no description yet" }, \
++ { "prototype", MASK_PROTOTYPE, "no description yet" }, \
++ { "no-prototype", -MASK_PROTOTYPE, "no description yet" }, \
++ { "no-traceback", 0, "no description yet" }, \
++ { "eabi", MASK_EABI, "Use EABI." }, \
++ { "no-eabi", -MASK_EABI, "Don't use EABI." }, \
++ { "regnames", MASK_REGNAMES, "Use alternate register names." }, \
++ { "no-regnames", -MASK_REGNAMES, "Don't use alternate register names." },\
++ { "sdata", 0, "no description yet" }, \
++ { "no-sdata", 0, "no description yet" }, \
++ { "sim", 0, "Link with libsim.a, libc.a and sim-crt0.o." }, \
++ { "ads", 0, "Link with libads.a, libc.a and crt0.o." }, \
++ { "yellowknife", 0, "Link with libyk.a, libc.a and crt0.o." }, \
++ { "mvme", 0, "Link with libmvme.a, libc.a and crt0.o." }, \
++ { "emb", 0, "Set the PPC_EMB bit in the ELF flags header" }, \
++ { "solaris-cclib", 0, "no description yet" }, \
++ { "shlib", 0, "no description yet" }, \
++ EXTRA_SUBTARGET_SWITCHES \
++ { "newlib", 0, "no description yet" },
+
+ /* This is meant to be redefined in the host dependent files */
+ #define EXTRA_SUBTARGET_SWITCHES
+@@ -111,8 +111,8 @@ extern const char *rs6000_abi_name;
+ extern const char *rs6000_sdata_name;
+
+ #define SUBTARGET_OPTIONS \
+- { "call-", &rs6000_abi_name}, \
+- { "sdata=", &rs6000_sdata_name}
++ { "call-", &rs6000_abi_name, "Select ABI calling convention." }, \
++ { "sdata=", &rs6000_sdata_name, "Select method for sdata handling." }
+
+ /* Max # of bytes for variables to automatically be put into the .sdata
+ or .sdata2 sections. */
--- /dev/null
+# DP: Add "Internal compiler error:" before some errors
+# DP: by Franz Sirl
+
+Index: gcc/toplev.c
+--- toplev.c 1999/05/20 10:40:05 1.185.4.1
++++ gcc/toplev.c 1999/06/12 18:55:32
+@@ -1467,6 +1467,8 @@ fatal_insn VPROTO((const char *msgid, rt
+ #endif
+ va_list ap;
+
++ error ("Internal compiler error:");
++
+ VA_START (ap, insn);
+
+ #ifndef ANSI_PROTOTYPES
+@@ -1943,6 +1945,8 @@ fatal VPROTO((const char *msgid, ...))
+ const char *msgid;
+ #endif
+ va_list ap;
++
++ error ("Internal compiler error:");
+
+ VA_START (ap, msgid);
+
--- /dev/null
+# DP: Makes it so sparc32 remains binary compatible with older releases
+
+--- gcc/crtstuff.c.orig Mon Apr 26 20:11:08 1999
++++ gcc/crtstuff.c Mon Apr 26 20:12:28 1999
+@@ -89,11 +89,12 @@
+
+ /* References to __register_frame_info and __deregister_frame_info should
+ be weak in this file if at all possible. */
+-extern void __register_frame_info (void *, struct object *)
+- TARGET_ATTRIBUTE_WEAK;
++extern void __register_frame_info (void *, struct object *);
+
+-extern void *__deregister_frame_info (void *)
+- TARGET_ATTRIBUTE_WEAK;
++extern void *__deregister_frame_info (void *);
++/* DEBIAN/SPARC - Changed the references to the
++ * previous for binary compatibility reasons
++ */
+
+ /* Provide default definitions for the pseudo-ops used to switch to the
+ .ctors and .dtors sections.
--- /dev/null
+diff -urN gcc-2.95.3.org/gcc/configure.in gcc-2.95.3/gcc/configure.in
+--- gcc-2.95.3.org/gcc/configure.in Thu Jun 14 13:36:24 2001
++++ gcc-2.95.3/gcc/configure.in Thu Jun 14 13:38:17 2001
+@@ -294,6 +294,7 @@
+
+ # Determine the host, build, and target systems
+ AC_CANONICAL_SYSTEM
++AC_ARG_PROGRAM
+
+ # Find the native compiler
+ AC_PROG_CC
projects / packages / gcc2.git / commitdiff