Article View: gnu.gcc.help
Article #54233Diffs for Alpha Micro port of gcc
From: Ian Lance Taylor
Date: Sat, 15 Dec 1990 21:05
Date: Sat, 15 Dec 1990 21:05
2695 lines
90138 bytes
90138 bytes
Here is an annotated list of diffs to gcc 1.37.1 to get it to run on
the Alpha Micro computer. The Alpha Micro series of computers are 680x0
based, have no virtual memory, and run a proprietary operating system
called AMOS.
For each diff I have tried to explain why I made the change. Many of
these changes are not perfect solutions, but only the best I could
come up with at the time I made them. I have grouped the diffs
somewhat by topic, so not all the diffs for a single file are
together.
The tm-m68k.h and m68k.md files were massively modified, as AMOS
does not accept normal 680x0 assembler but uses its own syntax.
I have not included them in this post, but I'll be happy to send
them to anybody who's actually interested. This set of diffs will
give you the source code that I use on the Alpha Micro. If you
actually have an Alpha Micro and are interested in producing your
own copy of the compiler, I recommend getting in touch with me
to get my set of command files and support routines which are
not included here.
I put a little header message into each file I modified (as directed
by the GPL), but I eliminated it from this list of diffs since it's
not very interesting.
-----------------------------------------------------------------------------
The preprocessor had to be changed to support AMOS file specs, which
take the form DEV:[PROJ,PROG]FFFFFF.XXX, where DEV is the device name
(such as DSK0:, PROJ and PROG are the project,programmer number, both
of which are a single byte written in octal, FFFFFF is the file name
(six characters max) and XXX is the file extension (three characters
max). Alternatively, an ``ersatz name'' can be used, in which case
the file spec is EEEEEE:FFFFFF.XXX (i.e. the ersatz name represents
a particular device and project,programmer number).
Also, AMOS does not support pipes, so I made the preprocessor go
through some support routines for writing so that the output file
could be kept in memory if desired (a big win on the Alpha Micro). I
didn't include these routines here, since they're just Alpha Micro
specific, but I'll send them if you want them.
Many of the changes to the preprocessor follow the changes made
for the VAX.
*** gcc-1.37.1/cccp.c Fri Feb 9 13:35:47 1990
--- gcc-amos/cccp.c Fri Nov 30 23:26:00 1990
***************
*** 42,53 ****
--- 47,82 ----
#undef bzero
#undef bcmp
+ #ifndef __AMOS__ /* Don't include <sys/types.h> and <sys/stat.h> */
#include <sys/types.h>
#include <sys/stat.h>
+ #else /* __AMOS__ include <unistd.h> */
+ #include <unistd.h>
+ #undef bcopy
+ #undef bzero
+ #undef bcmp
+ #endif /* __AMOS__ include <unistd.h> */
#include <ctype.h>
#include <stdio.h>
#include <signal.h>
+ #ifdef __AMOS__ /* Include files, define macros */
+ #define index strchr
+ #define rindex strrchr
+ #include <stdlib.h>
+ #include <fcntl.h>
+ #include <string.h>
+ #include <time.h>
+ #undef open
+ #define open cccp_open
+ #undef write
+ #define write cccp_write
+ #undef fileno
+ #define fileno cccp_fileno
+ #undef freopen
+ #define freopen cccp_freopen
+ #define BSTRING
+ #else /* not __AMOS__ */
#ifndef VMS
#include <sys/file.h>
#ifndef USG
***************
*** 60,65 ****
--- 89,95 ----
#include <fcntl.h>
#endif /* USG */
#endif /* not VMS */
+ #endif /* not __AMOS__ */
/* VMS-specific definitions */
#ifdef VMS
***************
*** 251,256 ****
--- 281,292 ----
/* -I directories are added to the end, then the defaults are added. */
struct file_name_list include_defaults[] =
{
+ #ifdef __AMOS__ /* define AMOS includes */
+ { &include_defaults[1], "MEM:" },
+ { &include_defaults[2], "RES:" },
+ { &include_defaults[3], "[???,0]" },
+ { 0, GCC_INCLUDE_DIR }
+ #else /* not __AMOS__ */
#ifndef VMS
{ &include_defaults[1], GCC_INCLUDE_DIR },
{ &include_defaults[2], "/usr/include" },
***************
*** 260,270 ****
--- 296,312 ----
{ &include_defaults[2], "SYS$SYSROOT:[SYSLIB.]" }, /* VAX-11 "C" includes */
{ 0, "" }, /* This makes normal VMS filespecs work OK */
#endif /* VMS */
+ #endif /* not __AMOS__ */
};
/* These are used instead of the above, for C++. */
struct file_name_list cplusplus_include_defaults[] =
{
+ #ifdef __AMOS__ /* define AMOS C++ includes */
+ { &cplusplus_include_defaults[1], "[???,0]" },
+ { &cplusplus_include_defaults[2], GPLUSPLUS_INCLUDE_DIR },
+ { 0, GCC_INCLUDE_DIR }
+ #else /* not __AMOS__ */
#ifndef VMS
/* Pick up GNU C++ specific include files. */
{ &cplusplus_include_defaults[1], GPLUSPLUS_INCLUDE_DIR },
***************
*** 278,283 ****
--- 320,326 ----
{ &cplusplus_include_defaults[3], "SYS$SYSROOT:[SYSLIB.]" },
{ 0, "" }, /* This makes normal VMS filespecs work OK */
#endif /* VMS */
+ #endif /* not __AMOS__ */
};
struct file_name_list *include = 0; /* First dir to search */
***************
*** 510,520 ****
--- 553,565 ----
/* Handler for SIGPIPE. */
+ #ifdef SIGPIPE /* not defined on __AMOS__ */
static void
pipe_closed ()
{
fatal ("output pipe has been closed");
}
+ #endif
int
main (argc, argv)
***************
*** 570,576 ****
--- 615,645 ----
*s = '\0';
}
#endif
+ #ifdef __AMOS__ /* Clean up progname */
+ {
+ /* Remove directories from PROGNAME. */
+ char *s;
+ extern char *rindex ();
+ progname = savestring (argv[0]);
+
+ if ((s = rindex (progname, ']'))
+ && *(s + 1) == '\0')
+ if (s = rindex (progname, '['))
+ {
+ *s = '\0';
+ s = (char *)0;
+ }
+
+ if (!s)
+ s = rindex (progname, ':');
+ if (s)
+ strcpy (progname, s+1);
+ if (s = rindex (progname, '.'))
+ *s = '\0';
+ }
+ #endif
+
in_fname = NULL;
out_fname = NULL;
***************
*** 588,594 ****
--- 657,665 ----
cplusplus = 1;
#endif
+ #ifdef SIGPIPE /* not defined on __AMOS__ */
signal (SIGPIPE, pipe_closed);
+ #endif
#ifndef VMS
max_include_len
***************
*** 2320,2326 ****
--- 2391,2401 ----
FILE_BUF *op;
{
char *buf;
+ #ifdef __AMOS__ /* Use time_t rather than long */
+ time_t t;
+ #else
long t;
+ #endif
int i, len;
int true_indepth;
FILE_BUF *ip = NULL;
***************
*** 2503,2508 ****
--- 2578,2586 ----
and put it in front of the search list. */
dsp[0].next = stackp;
stackp = dsp;
+ #ifdef __AMOS__ /* Back up to ersatz name */
+ ep = rindex (nam, ':');
+ #else /* not __AMOS__ */
#ifndef VMS
ep = rindex (nam, '/');
#else /* VMS */
***************
*** 2511,2516 ****
--- 2589,2595 ----
if (ep == NULL) ep = rindex (nam, ':');
if (ep != NULL) ep++;
#endif /* VMS */
+ #endif /* not __AMOS__ */
if (ep != NULL) {
n = ep - nam;
dsp[0].fname = (char *) alloca (n + 1);
***************
*** 2561,2567 ****
--- 2640,2650 ----
/* If specified file name is absolute, just open it. */
+ #ifdef __AMOS__ /* If ersatz name, file is absolute */
+ if (memchr (fbeg, ':', flen) != NULL) {
+ #else /* not __AMOS__ */
if (*fbeg == '/') {
+ #endif /* not __AMOS__ */
strncpy (fname, fbeg, flen);
fname[flen] = 0;
f = open (fname, O_RDONLY, 0666);
***************
*** 2572,2578 ****
--- 2655,2663 ----
for (; stackp; stackp = stackp->next) {
if (stackp->fname) {
strcpy (fname, stackp->fname);
+ #ifndef __AMOS__ /* Don't put in / at end of directory */
strcat (fname, "/");
+ #endif /* not __AMOS__ */
fname[strlen (fname) + flen] = 0;
} else {
fname[0] = 0;
***************
*** 2589,2594 ****
--- 2674,2683 ----
strncpy (fname, fbeg, flen);
fname[flen] = 0;
}
+ #else /* not VMS */
+ #ifdef __AMOS__ /* Fix up the AMOS include file name */
+ hack_amos_include_specification (fname);
+ #endif /* __AMOS__ */
#endif /* VMS */
if ((f = open (fname, O_RDONLY, 0666)) >= 0)
break;
***************
*** 4751,4758 ****
--- 4840,4849 ----
{
int i;
FILE_BUF *ip = NULL;
+ #ifndef __AMOS__ /* Don't use sys_nerr */
extern int errno, sys_nerr;
extern char *sys_errlist[];
+ #endif
for (i = indepth; i >= 0; i--)
if (instack[i].fname != NULL) {
***************
*** 4763,4772 ****
--- 4854,4867 ----
if (ip != NULL)
fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
+ #ifndef __AMOS__ /* Don't use sys_nerr */
if (errno < sys_nerr)
fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
else
fprintf (stderr, "%s: undocumented I/O error\n", name);
+ #else /* __AMOS__ don't use sys_nerr */
+ perror (name);
+ #endif /* __AMOS__ */
errors++;
return 0;
***************
*** 5388,5401 ****
--- 5483,5503 ----
perror_with_name (name)
char *name;
{
+ #ifndef __AMOS__ /* perror_with_name */
extern int errno, sys_nerr;
extern char *sys_errlist[];
+ #endif __AMOS__ /* perror_with_name */
fprintf (stderr, "%s: ", progname);
+ #ifndef __AMOS__ /* perror_with_name */
if (errno < sys_nerr)
fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
else
fprintf (stderr, "%s: undocumented I/O error\n", name);
+ #else /* __AMOS__ (perror_with_name) */
+ perror (name);
+ #endif /* __AMOS__ (perror_with_name) */
+
errors++;
}
***************
*** 5423,5429 ****
--- 5525,5533 ----
xmalloc (size)
int size;
{
+ #ifndef __AMOS__ /* Don't extern malloc */
extern char *malloc ();
+ #endif
register char *ptr = malloc (size);
if (ptr != 0) return (ptr);
memory_full ();
***************
*** 5435,5441 ****
--- 5539,5547 ----
char *old;
int size;
{
+ #ifndef __AMOS__ /* Don't extern realloc */
extern char *realloc ();
+ #endif
register char *ptr = realloc (old, size);
if (ptr != 0) return (ptr);
memory_full ();
***************
*** 5446,5452 ****
--- 5552,5560 ----
xcalloc (number, size)
int number, size;
{
+ #ifndef __AMOS__ /* Don't extern malloc */
extern char *malloc ();
+ #endif
register int total = number * size;
register char *ptr = malloc (total);
if (ptr != 0) {
***************
*** 5635,5637 ****
--- 5743,5785 ----
}
#endif /* VMS */
+
+ #ifdef __AMOS__ /* hack_amos_include_specification */
+ /* Change AMOS include specifications to handle [???,0] */
+
+ #undef write
+ #undef TRUE
+ #undef FALSE
+ #include <moncal.h>
+
+ hack_amos_include_specification (fname)
+ char *fname;
+ {
+ char *q;
+
+ q = fname;
+ while ((q = strchr (q, '?')) != (char *)0)
+ {
+ if (q[0] == '?'
+ && q[1] == '?'
+ && q[2] == '?')
+ {
+ int iproj = jobidx()->jobusr >> 8;
+
+ q[0] = ((iproj >> 6) ) + '0';
+ q[1] = ((iproj >> 3) & 07) + '0';
+ q[2] = ((iproj ) & 07) + '0';
+ if (q[0] == '0')
+ {
+ int c = 1;
+
+ if (q[1] == '0')
+ c = 2;
+ strcpy(q, q + c);
+ }
+ return;
+ }
+ }
+ }
+
+ #endif /* __AMOS__ hack_amos_include_specification */
-----------------------------------------------------------------------------
The Alpha Micro does not store bytes in the normal (for the 680x0)
big-endian order, but instead stores the bytes swapped within the
words (thus 0x01020304 is stored in memory as 02010403). This caused
many problems.
The compiler accesses elements of a structure by using the extract bit
field routines. This caused problems when extracting a bit field
which spanned a byte boundary, since the code had to do one thing when
the value was in a register and another when the value was in memory.
Rather than try to deal with both possibilities, I forced all
structures to remain in memory, eliminating the usual method of
returning small structures in registers. I still have not tried to
get the 68020 bitfield instructions to work; most Alpha Micros have
only a 68000 anyhow, so this was not a high priority. In general, I
don't think my handling of this issue was very good; the major point
in its favor is that it does generate working code, which the
unmodified compiler did not.
I defined the following macros in tm-amos.h:
/* On the Alpha Micro, bytes within an integer are stored as 3 4 1 2
where 1 is the LSB and 4 is the MSB and the order is from low memory
to high memory. Thus the Alpha Micro is neither a big endian nor a
little endian machine, so we use special macros to access submodes. */
/* Signal this situation */
#define MEM_CROSSED_BYTES
/* Find the offset of SUBMODSIZE within MODESIZE. Neither will be larger
than UNITS_PER_WORD.
A definition for a normal 68000 would be
#define MEM_SUBREG_OFFSET(MODESIZE, SUBMODESIZE) \
((MODESIZE) - (SUBMODESIZE))
A definition for a little endian machine would be
#define MEM_SUBREG_OFFSET(MODESIZE, SUBMODESIZE) 0
We always return zero except for a byte or short within a word, for
which we return 2. */
#define MEM_SUBREG_OFFSET(MODESIZE, SUBMODESIZE) \
((MODESIZE) < UNITS_PER_WORD ? 0 : \
((SUBMODESIZE) <= (UNITS_PER_WORD / 2) ? (UNITS_PER_WORD / 2) : \
0))
/* Find the high part of size SUBMODESIZE within MODESIZE. */
#define MEM_HIGH_SUBREG_OFFSET(MODESIZE, SUBMODESIZE) \
((SUBMODESIZE) == 1 ? ((MODESIZE) == 1 ? 0 : 1) : 0)
*** gcc-1.37.1/stor-layout.c Wed Jan 17 13:21:06 1990
--- gcc-amos/stor-layout.c Fri Nov 30 23:28:06 1990
***************
*** 382,387 ****
--- 382,388 ----
if (DECL_SIZE (decl))
bitsize = TREE_INT_CST_LOW (DECL_SIZE (decl)) * DECL_SIZE_UNIT (decl);
+ #ifndef MEM_CROSSED_BYTES /* Don't try to put structs in regs if odd order */
/* See if we can use a scalar mode such as QImode or SImode
in place of BLKmode or a packed byte mode. */
/* Conditions are: a fixed size that is correct for another mode
***************
*** 406,411 ****
--- 407,413 ----
bitsize = GET_MODE_BITSIZE (xmode);
}
}
+ #endif /* not MEM_CROSSED_BYTES */
/* Don't let more than one word of an aggregate occupy one register,
since then the SUBREG used to access the high part would malfunction.
***************
*** 850,855 ****
--- 852,858 ----
TYPE_SEP_UNIT (type) = TYPE_SIZE_UNIT (element);
TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
TYPE_MODE (type) = BLKmode;
+ #ifndef MEM_CROSSED_BYTES /* Don't try to pack structs into regs */
if (TYPE_SIZE (type) != 0
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
/* BLKmode elements force BLKmode aggregate;
***************
*** 866,871 ****
--- 869,875 ----
= agg_mode (TREE_INT_CST_LOW (TYPE_SIZE (type))
* TYPE_SIZE_UNIT (type));
}
+ #endif /* not MEM_CROSSED_BYTES */
break;
}
***************
*** 872,877 ****
--- 876,882 ----
case RECORD_TYPE:
layout_record (type);
TYPE_MODE (type) = BLKmode;
+ #ifndef MEM_CROSSED_BYTES /* Don't put structs in regs */
if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
/* If structure's known alignment is less than
what the scalar mode would need, and it matters,
***************
*** 905,915 ****
--- 910,922 ----
* TYPE_SIZE_UNIT (type));
record_lose: ;
}
+ #endif /* not MEM_CROSSED_BYTES */
break;
case UNION_TYPE:
layout_union (type);
TYPE_MODE (type) = BLKmode;
+ #ifndef MEM_CROSSED_BYTES /* Don't put structs in regs */
if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
/* If structure's known alignment is less than
what the scalar mode would need, and it matters,
***************
*** 933,938 ****
--- 940,946 ----
* TYPE_SIZE_UNIT (type));
union_lose: ;
}
+ #endif /* not MEM_CROSSED_BYTES */
break;
case FUNCTION_TYPE:
*** gcc-1.37.1/expmed.c Fri Oct 13 01:37:39 1989
--- gcc-amos/expmed.c Fri Nov 30 23:26:46 1990
***************
*** 102,107 ****
--- 109,118 ----
return value;
}
+ #ifdef MEM_CROSSED_BYTES /* On AMOS force everything to memory */
+ if (GET_CODE (op0) != MEM)
+ abort ();
+ #endif /* MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* If OP0 is a register, BITPOS must count within a word.
But as we have it, it counts within whatever size OP0 now has.
***************
*** 382,388 ****
--- 393,467 ----
BITPOS is the starting bit number within OP0.
(OP0's mode may actually be narrower than MODE.) */
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte ordering */
+ /* We really have to work to handle this case */
+ if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (QImode)
+ && (bitpos != 0
+ || bitsize != total_bits))
+ {
+ total_bits = BITS_PER_UNIT;
+ op0 = change_address (op0, QImode,
+ plus_constant (XEXP (op0, 0),
+ bitpos / BITS_PER_UNIT));
+ mode = QImode;
+ bitpos = bitpos % BITS_PER_UNIT;
+
+ /* While the value is larger than a byte, process each byte
+ individually. */
+ while (bitpos + bitsize > BITS_PER_UNIT)
+ {
+ int bitsize_1;
+ rtx part1;
+
+ bitsize_1 = BITS_PER_UNIT - bitpos;
+ bitsize = bitsize - bitsize_1;
#ifdef BYTES_BIG_ENDIAN
+ /* PART1 gets the more significant part. */
+ if (GET_CODE (value) == CONST_INT)
+ {
+ part1 = gen_rtx (CONST_INT, VOIDmode,
+ (unsigned) (INTVAL (value)) >> bitsize);
+ value = gen_rtx (CONST_INT, VOIDmode,
+ (unsigned) (INTVAL (value)) & ((1 << bitsize) - 1));
+ }
+ else
+ {
+ value = force_reg (SImode, value);
+ part1 = extract_fixed_bit_field (SImode, value, 0, bitsize_1,
+ BITS_PER_WORD - bitsize - bitsize_1,
+ 0, 1, 1);
+ value = extract_fixed_bit_field (SImode, value, 0, bitsize,
+ BITS_PER_WORD - bitsize, 0, 1, 1);
+ }
+ #else
+ /* PART1 gets the less significant part. */
+ if (GET_CODE (value) == CONST_INT)
+ {
+ part1 = gen_rtx (CONST_INT, VOIDmode,
+ (unsigned) (INTVAL (value)) & ((1 << bitsize_1) - 1));
+ value = gen_rtx (CONST_INT, VOIDmode,
+ (unsigned) (INTVAL (value)) >> bitsize_1);
+ }
+ else
+ {
+ value = force_reg (SImode, value);
+ part1 = extract_fixed_bit_field (SImode, value, 0, bitsize_1, 0, 0, 1, 1);
+ value = extract_fixed_bit_field (SImode, value, 0, bitsize,
+ bitsize_1, 0, 1, 1);
+ }
+ #endif
+ /* Store PART1 into the first byte. */
+ store_fixed_bit_field (op0, 0, bitsize_1, bitpos, part1, 1);
+
+ op0 = change_address (op0, QImode,
+ plus_constant (XEXP (op0, 0), 1));
+
+ bitpos = 0;
+ }
+ }
+ #endif /* MEM_CROSSED_BYTES */
+
+ #ifdef BYTES_BIG_ENDIAN
/* BITPOS is the distance between our msb
and that of the containing datum.
Convert it to the distance from the lsb. */
***************
*** 499,504 ****
--- 578,587 ----
}
else
{
+ #ifdef MEM_CROSSED_BYTES /* This only works in a register */
+ /* Is SImode correct here? */
+ value = force_reg (SImode, value);
+ #endif
part1 = extract_fixed_bit_field (SImode, value, 0, bitsize_1,
BITS_PER_WORD - bitsize, 0, 1, valalign);
part2 = extract_fixed_bit_field (SImode, value, 0, bitsize_2,
***************
*** 517,522 ****
--- 600,608 ----
{
part1 = extract_fixed_bit_field (SImode, value, 0, bitsize_1, 0,
0, 1, valalign);
+ #ifdef MEM_CROSSED_BYTES /* We need this in a register */
+ value = force_reg (SImode, value);
+ #endif
part2 = extract_fixed_bit_field (SImode, value, 0, bitsize_2,
bitsize_1, 0, 1, valalign);
}
***************
*** 585,590 ****
--- 671,680 ----
op0 = SUBREG_REG (op0);
}
+ #ifdef MEM_CROSSED_BYTES /* This code only handles memory */
+ if (GET_CODE (op0) != MEM)
+ abort();
+ #endif /* MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* If OP0 is a register, BITPOS must count within a word.
But as we have it, it counts within whatever size OP0 now has.
***************
*** 963,968 ****
--- 1053,1125 ----
}
mode = GET_MODE (op0);
+
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte ordering */
+ if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (QImode)
+ && GET_CODE (op0) == MEM
+ && (bitpos != 0
+ || bitsize != total_bits))
+ {
+ int bitsize_1, bitsize_left;
+ rtx part1, result;
+
+ op0 = change_address (op0, QImode,
+ plus_constant (XEXP (op0, 0),
+ bitpos / BITS_PER_UNIT));
+ bitpos = bitpos % BITS_PER_UNIT;
+
+ bitsize_left = bitsize;
+
+ result = 0;
+
+ while (bitsize_left > 0)
+ {
+ /* BITSIZE_1 is size of the part in the first byte. */
+ bitsize_1 = BITS_PER_UNIT - bitpos;
+ if (bitsize_1 > bitsize_left)
+ bitsize_1 = bitsize_left;
+ /* BITSIZE_LEFT is size of the rest (in the following bytes). */
+ bitsize_left = bitsize_left - bitsize_1;
+
+ /* Get the part of the bit field from the first byte. */
+ part1 = extract_fixed_bit_field (SImode, op0, 0, bitsize_1, bitpos,
+ 0, 1, align);
+
+ /* Offset op0 by 1 byte to get to the following one. */
+ op0 = change_address (op0, QImode,
+ plus_constant (XEXP (op0, 0), 1));
+
+ /* Shift the more significant part up to fit above the other part. */
+ #ifdef BYTES_BIG_ENDIAN
+ part1 = expand_shift (LSHIFT_EXPR, SImode, part1,
+ build_int_2 (bitsize_left, 0), 0, 1);
+ #else
+ if (result != 0)
+ result = expand_shift (LSHIFT_EXPR, SImode, result,
+ build_int_2 (bitsize_1, 0), 0, 1);
+ #endif
+
+ /* Combine the two parts with bitwise or. This works
+ because we extracted both parts as unsigned bit fields. */
+ if (result != 0)
+ result = expand_binop (SImode, ior_optab, part1, result, 0, 1,
+ OPTAB_LIB_WIDEN);
+ else
+ result = part1;
+
+ bitpos = 0;
+ }
+
+ /* Unsigned bit field: we are done. */
+ if (unsignedp)
+ return result;
+ /* Signed bit field: sign-extend with two arithmetic shifts. */
+ result = expand_shift (LSHIFT_EXPR, SImode, result,
+ build_int_2 (BITS_PER_WORD - bitsize, 0), 0, 0);
+ return expand_shift (RSHIFT_EXPR, SImode, result,
+ build_int_2 (BITS_PER_WORD - bitsize, 0), 0, 0);
+ }
+ #endif /* MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* BITPOS is the distance between our msb and that of OP0.
*** gcc-1.37.1/combine.c Sat Dec 16 18:17:50 1989
--- gcc-amos/combine.c Fri Nov 30 23:26:13 1990
***************
*** 1001,1006 ****
--- 1005,1017 ----
if that would change the meaning of the address. */
if (mode_dependent_address_p (XEXP (to, 0)))
return gen_rtx (CLOBBER, VOIDmode, const0_rtx);
+ #ifdef MEM_CROSSED_BYTES /* on AMOS, bytes are in a strange order */
+ if (GET_MODE_SIZE (GET_MODE (x)) < UNITS_PER_WORD)
+ endian_offset += MEM_SUBREG_OFFSET
+ (min (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (to))),
+ GET_MODE_SIZE (GET_MODE (x)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
if (GET_MODE_SIZE (GET_MODE (x)) < UNITS_PER_WORD)
endian_offset += UNITS_PER_WORD - GET_MODE_SIZE (GET_MODE (x));
***************
*** 1007,1012 ****
--- 1018,1024 ----
if (GET_MODE_SIZE (GET_MODE (to)) < UNITS_PER_WORD)
endian_offset -= UNITS_PER_WORD - GET_MODE_SIZE (GET_MODE (to));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
if (!undobuf.storage)
undobuf.storage = (char *) oballoc (0);
/* Note if the plus_constant doesn't make a valid address
***************
*** 1927,1932 ****
--- 1949,1960 ----
offset = (max (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
- max (GET_MODE_SIZE (mode), UNITS_PER_WORD));
#endif
+ #ifdef MEM_CROSSED_BYTES /* on AMOS, byte ordering is strange */
+ offset += MEM_SUBREG_OFFSET (min (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (x))),
+ min (UNITS_PER_WORD,
+ GET_MODE_SIZE (mode)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* Adjust the address so that the address-after-the-data
is unchanged. */
***************
*** 1933,1938 ****
--- 1961,1967 ----
offset -= (min (UNITS_PER_WORD, GET_MODE_SIZE (mode))
- min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
return gen_rtx (MEM, mode, plus_constant (XEXP (x, 0),
offset));
}
*** gcc-1.37.1/emit-rtl.c Fri Feb 2 17:51:21 1990
--- gcc-amos/emit-rtl.c Fri Nov 30 23:26:40 1990
***************
*** 383,388 ****
--- 387,398 ----
offset = (max (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
- max (GET_MODE_SIZE (mode), UNITS_PER_WORD));
#endif
+ #ifdef MEM_CROSSED_BYTES /* AMOS byte ordering is strange */
+ offset += MEM_SUBREG_OFFSET (min (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (x))),
+ min (UNITS_PER_WORD,
+ GET_MODE_SIZE (mode)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* Adjust the address so that the address-after-the-data
is unchanged. */
***************
*** 389,394 ****
--- 399,405 ----
offset -= (min (UNITS_PER_WORD, GET_MODE_SIZE (mode))
- min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
}
else if (GET_CODE (x) == SUBREG)
***************
*** 426,431 ****
--- 437,449 ----
offset = (max (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
- max (GET_MODE_SIZE (mode), UNITS_PER_WORD));
#endif
+ #ifdef MEM_CROSSED_BYTES /* AMOS byte ordering is strange */
+ if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
+ offset += MEM_HIGH_SUBREG_OFFSET
+ (min (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (x))),
+ GET_MODE_SIZE (mode));
+ #else /* not MEM_CROSSED_BYTES */
#ifndef BYTES_BIG_ENDIAN
if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
offset -= (GET_MODE_SIZE (mode)
***************
*** 432,437 ****
--- 450,456 ----
- min (UNITS_PER_WORD,
GET_MODE_SIZE (GET_MODE (x))));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
}
else if (GET_CODE (x) == REG)
*** gcc-1.37.1/expr.c Mon Jan 1 20:03:49 1990
--- gcc-amos/expr.c Wed Dec 5 18:49:33 1990
***************
*** 547,552 ****
--- 551,557 ----
emit_move_insn (to, from);
return;
}
+ #ifndef MEM_CROSSED_BYTES /* AMOS strange byte ordering */
#ifndef BYTES_BIG_ENDIAN
else if (GET_CODE (from) == MEM)
{
***************
*** 558,563 ****
--- 563,569 ----
}
}
#endif /* not BYTES_BIG_ENDIAN */
+ #endif /* not MEM_CROSSED_BYTES */
}
#endif /* 0 */
*** gcc-1.37.1/final.c Sat Dec 9 09:17:52 1989
--- gcc-amos/final.c Fri Nov 30 23:26:49 1990
***************
*** 1147,1156 ****
--- 1151,1174 ----
else if (GET_CODE (y) == MEM)
{
register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte ordering */
+ /* I think this can be either a normal SUBREG or a paradoxical
+ one, and we have to distinguish the two cases because
+ the first argument to MEM_SUBREG_OFFSET must be the enclosing
+ mode, and because for a paradoxical SUBREG we are actually
+ undoing an adjustment we made earlier. */
+ int xsize = min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)));
+ int ysize = min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y)));
+ if (xsize < ysize)
+ offset += MEM_SUBREG_OFFSET (ysize, xsize);
+ else
+ offset -= MEM_SUBREG_OFFSET (xsize, ysize);
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
offset -= (min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
- min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
PUT_CODE (x, MEM);
MEM_VOLATILE_P (x) = MEM_VOLATILE_P (y);
XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
*** gcc-1.37.1/integrate.c Sun Feb 18 12:42:10 1990
--- gcc-amos/integrate.c Fri Nov 30 23:27:17 1990
***************
*** 1573,1581 ****
--- 1595,1612 ----
copy = parm_map[index];
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte ordering */
+ if (GET_CODE (copy) == MEM
+ && GET_MODE_SIZE (GET_MODE (copy)) < UNITS_PER_WORD)
+ offset -= MEM_SUBREG_OFFSET (UNITS_PER_WORD,
+ GET_MODE_SIZE (copy));
+ #endif /* MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* Subtract from OFFSET the offset of where
the actual parm value would start. */
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (GET_CODE (copy) != MEM)
+ #endif /* MEM_CROSSED_BYTES */
if (GET_MODE_SIZE (GET_MODE (copy)) < UNITS_PER_WORD)
offset
-= (UNITS_PER_WORD
*** gcc-1.37.1/reload.c Mon Feb 5 17:07:20 1990
--- gcc-amos/reload.c Fri Nov 30 23:27:44 1990
***************
*** 2281,2290 ****
--- 2291,2311 ----
{
int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
rtx addr;
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (GET_MODE_SIZE (GET_MODE (x)) < UNITS_PER_WORD)
+ {
+ int regsize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
+ if (regsize > UNITS_PER_WORD)
+ regsize = UNITS_PER_WORD;
+ offset += MEM_SUBREG_OFFSET (regsize,
+ GET_MODE_SIZE (GET_MODE (x)));
+ }
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
offset += (GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
- GET_MODE_SIZE (GET_MODE (x)));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
addr = plus_constant (reg_equiv_address[regno], offset);
x = gen_rtx (MEM, GET_MODE (x), addr);
find_reloads_address (GET_MODE (x), 0,
*** gcc-1.37.1/reload1.c Mon Feb 5 23:17:52 1990
--- gcc-amos/reload1.c Fri Nov 30 23:27:51 1990
***************
*** 1318,1323 ****
--- 1322,1336 ----
{
/* No known place to spill from => no slot to reuse. */
x = assign_stack_local (GET_MODE (regno_reg_rtx[i]), total_size);
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (inherent_size < UNITS_PER_WORD)
+ x = gen_rtx (MEM, GET_MODE (regno_reg_rtx[i]),
+ plus_constant
+ (XEXP (x, 0),
+ - MEM_SUBREG_OFFSET (min (total_size,
+ UNITS_PER_WORD),
+ inherent_size)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* Cancel the big-endian correction done in assign_stack_local.
Get the address of the beginning of the slot.
***************
*** 1327,1332 ****
--- 1340,1346 ----
plus_constant (XEXP (x, 0),
inherent_size - total_size));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
}
/* Reuse a stack slot if possible. */
else if (spill_stack_slot[from_reg] != 0
***************
*** 1350,1355 ****
--- 1364,1378 ----
}
/* Make a slot with that size. */
x = assign_stack_local (mode, total_size);
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
+ x = gen_rtx (MEM, mode,
+ plus_constant
+ (XEXP (x, 0),
+ - MEM_SUBREG_OFFSET (min (total_size,
+ UNITS_PER_WORD),
+ GET_MODE_SIZE (mode))));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* Cancel the big-endian correction done in assign_stack_local.
Get the address of the beginning of the slot.
***************
*** 1359,1368 ****
--- 1382,1400 ----
plus_constant (XEXP (x, 0),
GET_MODE_SIZE (mode) - total_size));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
spill_stack_slot[from_reg] = x;
spill_stack_slot_width[from_reg] = total_size;
}
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (inherent_size < UNITS_PER_WORD)
+ x = gen_rtx (MEM, GET_MODE (regno_reg_rtx[i]),
+ plus_constant (XEXP (x, 0),
+ MEM_SUBREG_OFFSET (min (total_size,
+ UNITS_PER_WORD),
+ inherent_size)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
/* On a big endian machine, the "address" of the slot
is the address of the low part that fits its inherent mode. */
***************
*** 1371,1376 ****
--- 1403,1409 ----
plus_constant (XEXP (x, 0),
total_size - inherent_size));
#endif /* BYTES_BIG_ENDIAN */
+ #endif /* MEM_CROSSED_BYTES */
addr = XEXP (x, 0);
*** gcc-1.37.1/stmt.c Mon Jan 1 19:53:29 1990
--- gcc-amos/stmt.c Fri Nov 30 23:28:04 1990
***************
*** 3251,3260 ****
--- 3255,3270 ----
/* On a big-endian machine, if we are allocating more space than we will use,
use the least significant bytes of those that are allocated. */
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (mode != BLKmode && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
+ bigend_correction = MEM_SUBREG_OFFSET (MIN (size, UNITS_PER_WORD),
+ GET_MODE_SIZE (mode));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
if (mode != BLKmode)
bigend_correction = size - GET_MODE_SIZE (mode);
#endif
+ #endif /* not MEM_CROSSED_BYTES */
#ifdef FRAME_GROWS_DOWNWARD
frame_offset -= size;
***************
*** 3653,3662 ****
--- 3663,3678 ----
enum machine_mode mode = GET_MODE (x);
rtx saved, result;
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ offset += MEM_SUBREG_OFFSET
+ (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))),
+ MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
offset += (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
- MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
addr = plus_constant (addr, offset);
if (memory_address_p (mode, addr))
return change_address (SUBREG_REG (x), mode, addr);
***************
*** 3846,3851 ****
--- 3862,3874 ----
if (GET_CODE (XEXP (bitfield, 0)) == SUBREG)
{
offset += SUBREG_WORD (XEXP (bitfield, 0)) * UNITS_PER_WORD;
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ offset += MEM_SUBREG_OFFSET
+ (MIN (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (memref))),
+ MIN (UNITS_PER_WORD,
+ GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0)))));
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
offset -= (MIN (UNITS_PER_WORD,
GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0))))
***************
*** 3852,3857 ****
--- 3875,3881 ----
- MIN (UNITS_PER_WORD,
GET_MODE_SIZE (GET_MODE (memref))));
#endif
+ #endif /* not MEM_CROSSED_BYTES */
}
memref = gen_rtx (MEM,
***************
*** 4288,4293 ****
--- 4312,4326 ----
if (nominal_mode != BLKmode && nominal_mode != passed_mode
&& stack_parm != 0)
{
+ #ifdef MEM_CROSSED_BYTES /* AMOS strange byte order */
+ if (GET_MODE_SIZE (nominal_mode) < UNITS_PER_WORD)
+ {
+ stack_offset.constant
+ += MEM_SUBREG_OFFSET (GET_MODE_SIZE (passed_mode),
+ GET_MODE_SIZE (nominal_mode));
+ stack_offset_rtx = ARGS_SIZE_RTX (stack_offset);
+ }
+ #else /* not MEM_CROSSED_BYTES */
#ifdef BYTES_BIG_ENDIAN
if (GET_MODE_SIZE (nominal_mode) < UNITS_PER_WORD)
{
***************
*** 4297,4302 ****
--- 4330,4336 ----
stack_offset_rtx = ARGS_SIZE_RTX (stack_offset);
}
#endif
+ #endif /* not MEM_CROSSED_BYTES */
stack_parm
= gen_rtx (MEM, nominal_mode,
-----------------------------------------------------------------------------
The library was provided by the Alpha Micro library had bugs, was very
inefficient, and only preserved three registers each time it was
called. I chose to write my own set of library routines, which
eventually expanded into a complete ANSI C library for the Alpha
Micro. This meant that I could compile every single piece of C code,
which meant that I could completely control the calling sequence. I
took the opportunity to implement parameter passing in registers.
This uncovered several bugs, as the existing code appeared to assume
that the stack pointer only grew upward and that the first stack
argument to a function could be pushed on the stack first, neither of
which are true on the 68000.
There was another bug in the loop.c code, which is explained in the
comment. There was also a problem with taking the address of a
parameter passed in a register to an inline function, which I did
not solve; I merely inserted a warning for this case. I expect
that these bugs have already been found by other people, as they
would occur on any CPU with register parameters.
*** gcc-1.37.1/expr.c Mon Jan 1 20:03:49 1990
--- gcc-amos/expr.c Wed Dec 5 18:49:33 1990
***************
*** 1495,1500 ****
--- 1501,1509 ----
int inc;
int count;
rtx *regvec;
+ #ifdef __AMOS__ /* Support PUSH_ARGS_REVERSED */
+ int *partialvec;
+ #endif /* __AMOS__ Support PUSH_ARGS_REVERSED */
rtx argblock = 0;
CUMULATIVE_ARGS args_so_far;
struct arg { rtx value; enum machine_mode mode; };
***************
*** 1582,1587 ****
--- 1591,1614 ----
INIT_CUMULATIVE_ARGS (args_so_far, (tree)0);
+ #ifdef __AMOS__ /* Support PUSH_ARGS_REVERSED */
+ partialvec = (int *) alloca (nargs * sizeof (int));
+
+ for (count = 0, argnum = 0; count < nargs; count++, argnum++)
+ {
+ register enum machine_mode mode = argvec[argnum].mode;
+
+ regvec[argnum] = FUNCTION_ARG (args_so_far, mode, (tree)0, 1);
+ #ifdef FUNCTION_ARG_PARTIAL_NREGS
+ partialvec[argnum] = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode,
+ (tree)0, 1);
+ #else
+ partialvec[argnum] = 0;
+ #endif
+ FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
+ }
+ #endif /* __AMOS__ Support PUSH_ARGS_REVERSED */
+
#ifdef PUSH_ARGS_REVERSED
inc = -1;
argnum = nargs - 1;
***************
*** 1595,1604 ****
--- 1622,1655 ----
{
register enum machine_mode mode = argvec[argnum].mode;
register rtx val = argvec[argnum].value;
+ #ifndef __AMOS__ /* Support PUSH_ARGS_REVERSED */
rtx reg;
int partial;
+ #endif /* not __AMOS__ Support PUSH_ARGS_REVERSED */
int arg_size;
+ #ifdef __AMOS__ /* Support PUSH_ARGS_REVERSED */
+ if (regvec[argnum] != 0 && partialvec[argnum] == 0)
+ emit_move_insn (regvec[argnum], val);
+ else
+ emit_push_insn (val, mode, 0, 0, partialvec[argnum], regvec[argnum],
+ 0, argblock,
+ gen_rtx (CONST_INT, VOIDmode, args_size));
+
+ /* Compute size of stack space used by this argument. */
+ if (regvec[argnum] == 0 || partialvec[argnum] != 0)
+ arg_size = GET_MODE_SIZE (mode);
+ else
+ arg_size = 0;
+ if (partialvec[argnum] != 0)
+ arg_size
+ -= ((partialvec[argnum] * UNITS_PER_WORD)
+ / (PARM_BOUNDARY / BITS_PER_UNIT)
+ * (PARM_BOUNDARY / BITS_PER_UNIT));
+
+ args_size += arg_size;
+ NO_DEFER_POP;
+ #else /* not __AMOS__ Support PUSH_ARGS_REVERSED */
reg = FUNCTION_ARG (args_so_far, mode, (tree)0, 1);
regvec[argnum] = reg;
#ifdef FUNCTION_ARG_PARTIAL_NREGS
***************
*** 1627,1632 ****
--- 1678,1684 ----
args_size += arg_size;
NO_DEFER_POP;
FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
+ #endif /* not __AMOS__ Support PUSH_ARGS_REVERSED */
}
/* For version 1.37, try deleting this entirely. */
***************
*** 4091,4098 ****
--- 4201,4213 ----
for a structure value address. */
&& TREE_PURPOSE (p) != error_mark_node)
{
+ #ifdef __AMOS__ /* I think this change is need for PUSH_ARGS_REVERSED */
args[i].reg = FUNCTION_ARG (args_so_far, TYPE_MODE (type), type,
+ (num_actuals - i - 1) < n_named_args);
+ #else /* not __AMOS__ */
+ args[i].reg = FUNCTION_ARG (args_so_far, TYPE_MODE (type), type,
i < n_named_args);
+ #endif /* not __AMOS__ */
/* If this argument needs more than the usual parm alignment, do
extrinsic padding to reach that alignment. */
***************
*** 4126,4134 ****
--- 4241,4255 ----
#ifdef FUNCTION_ARG_PARTIAL_NREGS
args[i].partial
+ #ifdef __AMOS__ /* Another change for PUSH_ARGS_REVERSED */
= FUNCTION_ARG_PARTIAL_NREGS (args_so_far,
TYPE_MODE (type), type,
+ (num_actuals - i - 1) < n_named_args);
+ #else /* not __AMOS__ */
+ = FUNCTION_ARG_PARTIAL_NREGS (args_so_far,
+ TYPE_MODE (type), type,
i < n_named_args);
+ #endif /* not __AMOS__ */
#endif
}
***************
*** 4218,4225 ****
--- 4339,4351 ----
/* Increment ARGS_SO_FAR, which has info about which arg-registers
have been used, etc. */
+ #ifdef __AMOS__ /* Another change for PUSH_ARGS_REVERSED */
FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
+ (num_actuals - i - 1) < n_named_args);
+ #else /* not __AMOS__ */
+ FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
i < n_named_args);
+ #endif /* not __AMOS__ */
}
/* If we would have to push a partially-in-regs parm
*** gcc-1.37.1/loop.c Thu Jan 25 21:20:14 1990
--- gcc-amos/loop.c Fri Nov 30 23:29:02 1990
***************
*** 1169,1175 ****
--- 1169,1191 ----
So delete it and stick the fn address right
into the call insn. Since the moved insns
won't be cse'd, that does no harm. */
+ #ifdef __AMOS__ /* Fix for register parameters */
+ /* The old code (below) is wrong if we are
+ using register parameters, because there
+ will be USE insns between the SET insn and
+ the CALL_INSN; we must skip these before
+ doing the test. */
+ rtx skip;
+
+ for (skip = NEXT_INSN (temp); skip != p;
+ skip = NEXT_INSN (skip))
+ if (GET_CODE (skip) != INSN
+ || GET_CODE (PATTERN (skip)) != USE)
+ break;
+ if (GET_CODE (skip) == CALL_INSN
+ #else /* ! __AMOS__ Fix for register parameters */
if (GET_CODE (NEXT_INSN (temp)) == CALL_INSN
+ #endif /* ! __AMOS__ Fix for register parameters */
&& GET_CODE (body) == SET
&& GET_CODE (SET_DEST (body)) == REG
&& (n = find_reg_note (temp, REG_EQUIV, 0)))
*** gcc-1.37.1/integrate.c Sun Feb 18 12:42:10 1990
--- gcc-amos/integrate.c Fri Nov 30 23:27:17 1990
***************
*** 171,176 ****
--- 175,192 ----
|| TREE_CODE (TREE_TYPE (parms)) == UNION_TYPE)
&& GET_CODE (DECL_RTL (parms)) == MEM)
return "address of an aggregate parameter is used; cannot be inline";
+ #ifdef __AMOS__ /* No inline if address of reg parameter taken */
+ /* The compiler doesn't seem to handle taking the address of
+ of a register parameter to an inline function. Rather than trying
+ to fix the bug, we just catch it here.
+ The problem seems to be that an insn is generated to copy the
+ register into a stack slot, but the insn is one of those which
+ copy parameters into registers, and so is not saved by
+ save_for_inline. */
+ if (TREE_ADDRESSABLE (parms)
+ && DECL_OFFSET (parms) < 0)
+ return "cannot inline function which takes address of register parameter";
+ #endif /* No inline if address of reg parameter taken */
}
if (!TREE_INLINE (fndecl) && get_max_uid () > max_insns)
***************
*** 782,788 ****
--- 798,810 ----
#endif
}
if (offset)
+ #ifdef FRAME_GROWS_DOWNWARD
+ /* The AMOS frame grows downward, so offset will be negative here.
+ The old code didn't seem to handle this. */
+ parm_map[(- INTVAL (offset)) / UNITS_PER_WORD] = arg_vec[i];
+ #else /* ! FRAME_GROWS_DOWNWARD */
parm_map[INTVAL (offset) / UNITS_PER_WORD] = arg_vec[i];
+ #endif /* ! FRAME_GROWS_DOWNWARD */
else if (TREE_TYPE (formal) != error_mark_node)
abort ();
}
-----------------------------------------------------------------------------
Since the Alpha Micro does not support virtual memory, all references
to the program segment must be PC relative and all references to the
data segment must be relative to an address register (conventionally
a5; on the 68000 the maximum data segment is 64K). I chose to support
the PC relative addressing by changing the machine description file to
force all symbolic constants to be reloaded through movsi, where I
handled all the various cases (actually the call instructions also
accept symbolic constants as arguments, although the treatment there
is simpler). References to the data segment are handled by code I put
into expr.c to explicitly add a5.
This meant that the machine description code had to know what segment
a symbol was in, so I introduced two flags to the SYMBOL_REF RTL code:
SYMBOL_DSECT_P, which is true if the symbol is in the data segment,
and SYMBOL_OFFSET_P, which is true if the symbol has already has a5
added to it. Setting these values up correctly causes a lot of extra
work in varasm.c, including adding an element to the
constant_descriptor structure to represent the segment of the constant
(constants initialized to program or data segment addresses cannot
appear in the program segment, but must be put into the data segment).
A general PC relative reference on the 68000 can be fairly inefficient,
as it requires computing the offset and then getting the address in
two separate instructions (since the 68000 only supports 16-bit
program relative offsets). I wrote the linker that we use on the
Alpha Micro, so I had the machine description code insert special
symbols to allow the linker to detect a PC-relative reference and
optimize it to use the 16-bit version if possible. This is turned
on by the -mlabels switch. The -mlabels switch also causes all
function addresses to be marked by prepending the string ``.gcc.fn''
to the symbol, for reasons having to do with runtime libraries as
supported by my linker; this is bit too complex and far afield
to explain here, I think, although as usual if you really want to know
you can write and ask me.
The other relevant switch is -mshortcalls, which causes the compiler
to assume that the total program size is less than 64K so it can
always use 16-bit relative addressing.
Here is the code for movsi from the machine description file. This
uses the peculiar Alpha Micro assembler syntax, but the general idea
should be clear enough.
;; General case of fullword move. The register constraints
;; force integer constants in range for a moveq to be reloaded
;; if they are headed for memory.
;; We have to support moving symbol addresses into data registers and
;; general memory locations, unfortunately.
(define_insn "movsi"
[(set (match_operand:SI 0 "general_operand" "=gm,da,a,!*d*m")
(match_operand:SI 1 "general_operand" "damK,n,i,s"))]
""
"*
{
if (GET_CODE (operands[1]) == CONST_INT)
{
if (operands[1] == const0_rtx
&& (DATA_REG_P (operands[0])
|| GET_CODE (operands[0]) == MEM))
return \"clr%.l %0\";
else if (DATA_REG_P (operands[0])
&& INTVAL (operands[1]) < 128
&& INTVAL (operands[1]) >= -128)
{
#ifdef AMOS_ASM
return \"mov %1,%0\";
#else
#ifdef MOTOROLA
return \"moveq%.l %1,%0\";
#else
return \"moveq %1,%0\";
#endif
#endif
}
else if (ADDRESS_REG_P (operands[0])
&& INTVAL (operands[1]) < 0x8000
&& INTVAL (operands[1]) >= -0x8000)
#ifdef AMOS_ASM
return \"mov%.w %1,%0\";
#else
return \"move%.w %1,%0\";
#endif
else if (push_operand (operands[0], SImode)
&& INTVAL (operands[1]) < 0x8000
&& INTVAL (operands[1]) >= -0x8000)
return \"pea %a1\";
}
#ifdef __AMOS__
else if (GET_CODE (operands[1]) == SYMBOL_REF
&& (! SYMBOL_DSECT_P (operands[1])
|| ! SYMBOL_OFFSET_P (operands[1])))
{
char *s = XSTR (operands[1], 0);
if (SYMBOL_DSECT_P (operands[1]))
{
if (push_operand (operands[0], SImode))
return \"pea %a1(a5)\";
else if (ADDRESS_REG_P (operands[0]))
return \"lea %0,%a1(a5)\";
else if (DATA_REG_P (operands[0]))
return \"mov a5,%0\;lea a5,%a1(a5)\;xch a5,%0\";
else
return \"mov a5,d7\;lea a5,%a1(a5)\;xch a5,d7\;mov d7,%0\";
}
else if (s[0] == '*'
&& s[1] == 'L'
&& (s[2] == '.' || s[3] == '.'))
{
/* Assume that local labels are within 32K */
if (TARGET_LABELS)
{
fprintf (asm_out_file, \"\\t.gcc.local.\");
if (push_operand (operands[0], SImode))
fprintf (asm_out_file, \"pea\");
else if (ADDRESS_REG_P (operands[0]))
fprintf (asm_out_file, \"lea\");
else if (DATA_REG_P (operands[0]))
fprintf (asm_out_file, \"dlea\");
else
fprintf (asm_out_file, \"glea\");
fprintf (asm_out_file, \" = 1\\n\");
}
if (push_operand (operands[0], SImode))
return \"pea %a1\";
else if (ADDRESS_REG_P (operands[0]))
return \"lea %0,%a1\";
else if (DATA_REG_P (operands[0]))
return \"mov a5,%0\;lea a5,%a1\;xch a5,%0\";
else
return \"mov a5,d7\;lea a5,%a1\;xch a5,d7\;mov d7,%0\";
}
else
{
int ilab;
/* For long call get the label out before the linker label. */
if (! TARGET_SHORTCALLS && ! TARGET_68020)
{
static int i;
ilab = ++i * 3;
fprintf (asm_out_file, \"%d$:\", ilab);
}
if (TARGET_LABELS)
{
fprintf (asm_out_file, \"\\t.gcc.\");
if (TARGET_SHORTCALLS)
fprintf (asm_out_file, \"short.\");
else if (TARGET_68020)
fprintf (asm_out_file, \"68020.\");
else
fprintf (asm_out_file, \"long.\");
if (push_operand (operands[0], SImode))
fprintf (asm_out_file, \"pea\");
else if (ADDRESS_REG_P (operands[0]))
fprintf (asm_out_file, \"lea\");
else if (DATA_REG_P (operands[0]))
fprintf (asm_out_file, \"dlea\");
else
fprintf (asm_out_file, \"glea\");
fprintf (asm_out_file, \" = 1\\n\");
}
if (TARGET_SHORTCALLS)
{
if (push_operand (operands[0], SImode))
return \"pea %a1-32768(a3)\";
else if (ADDRESS_REG_P (operands[0]))
return \"lea %0,%a1-32768(a3)\";
else if (DATA_REG_P (operands[0]))
return \"mov a5,%0\;lea a5,%a1-32768(a3)\;xch a5,%0\";
else
return \"mov a5,d7\;lea a5,%a1-32768(a3)\;xch a5,d7\;mov d7,%0\";
}
else if (TARGET_68020)
{
if (push_operand (operands[0], SImode))
return \"pea ||%a1\";
else if (ADDRESS_REG_P (operands[0]))
return \"lea %0,||%a1\";
else if (DATA_REG_P (operands[0]))
return \"mov a5,%0\;lea a5,||%a1\;xch a5,%0\";
else
return \"mov a5,d7\;lea a5,||%a1\;xch a5,d7\;mov d7,%0\";
}
else
{
rtx xoperands[2];
fprintf (asm_out_file, \"\\tmov #\", ilab);
assemble_name (asm_out_file, s);
fprintf (asm_out_file, \"-%d$,d7\\n\", ilab);
xoperands[0] = operands[0];
xoperands[1] = gen_rtx (CONST_INT, VOIDmode, ilab);
if (push_operand (operands[0], SImode))
{
output_asm_insn (\"pea %P1[d7]\", xoperands);
return \"\";
}
else if (ADDRESS_REG_P (operands[0]))
{
output_asm_insn (\"lea %0,%P1[d7]\", xoperands);
return \"\";
}
else if (DATA_REG_P (operands[0]))
{
output_asm_insn (\"mov a5,%0\;lea a5,%P1[d7]\", xoperands);
return \"xch a5,%0\";
}
else
{
/* The technique used above won't work clobbers d7.
This is the same number of clock cycles as starting
with xch a5,d7 and is fewer instructions. */
output_asm_insn (\"pea %P1[d7]\", xoperands);
return \"pop %0\";
}
}
}
}
#else
else if ((GET_CODE (operands[1]) == SYMBOL_REF
|| GET_CODE (operands[1]) == CONST)
&& push_operand (operands[0], SImode))
return \"pea %a1\";
else if ((GET_CODE (operands[1]) == SYMBOL_REF
|| GET_CODE (operands[1]) == CONST)
&& ADDRESS_REG_P (operands[0]))
return \"lea %a1,%0\";
#endif
#ifdef AMOS_ASM
return \"mov %1,%0\";
#else
return \"move%.l %1,%0\";
#endif
}")
*** gcc-1.37.1/rtl.h Fri Dec 15 07:30:36 1989
--- gcc-amos/rtl.h Sat Dec 1 01:08:48 1990
***************
*** 423,428 ****
--- 423,435 ----
/* 1 in a SYMBOL_REF if it addresses this function's constants pool. */
#define CONSTANT_POOL_ADDRESS_P(RTX) ((RTX)->unchanging)
+ #ifdef __AMOS__
+ /* Record whether a SYMBOL_REF is in the data segment. */
+ #define SYMBOL_DSECT_P(RTX) ((RTX)->volatil)
+ /* Record whether a SYMBOL_REF has already been offset. */
+ #define SYMBOL_OFFSET_P(RTX) ((RTX)->in_struct)
+ #endif
+
/* For an INLINE_HEADER rtx, FIRST_FUNCTION_INSN is the first insn
of the function that is not involved in copying parameters to
pseudo-registers. FIRST_PARM_INSN is the very first insn of
*** gcc-1.37.1/expr.c Mon Jan 1 20:03:49 1990
--- gcc-amos/expr.c Wed Dec 5 18:49:33 1990
***************
*** 2166,2171 ****
--- 2218,2226 ----
rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
rtx original_target = target;
int ignore = target == const0_rtx;
+ #ifdef __AMOS__ /* We need flag_just_decl to avoid adding a5 to variables */
+ extern int flag_just_decl;
+ #endif
/* Don't use hard regs as subtargets, because the combiner
can only handle pseudo regs. */
***************
*** 2214,2219 ****
--- 2269,2329 ----
&& GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
return change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
XEXP (DECL_RTL (exp), 0));
+
+ #ifdef __AMOS__ /* Handle a reference to a variable */
+ /* References to functions are handled by special code in md.txt.
+ For a variable, we have to offset the symbol by register a5. */
+ if (! flag_just_decl
+ && code == VAR_DECL
+ && GET_CODE (DECL_RTL (exp)) == MEM
+ && GET_CODE (XEXP (DECL_RTL (exp), 0)) == SYMBOL_REF)
+ {
+ rtx old, new;
+
+ old = XEXP (DECL_RTL (exp), 0);
+ /* If this symbol is not in the DSECT area, something has gone
+ wrong. All variables should be found there, and the bit
+ should have been set in varasm. SYMBOL_DSECT_P is checked
+ by the machine description to decide how to output the
+ symbol. */
+ if (! SYMBOL_DSECT_P (old))
+ abort ();
+ /* Make a new SYMBOL_REF so that we can mark it as having
+ already been offset. */
+ new = gen_rtx (SYMBOL_REF, GET_MODE (old), XSTR (old, 0));
+ CONSTANT_POOL_ADDRESS_P (new) = CONSTANT_POOL_ADDRESS_P (old);
+ SYMBOL_DSECT_P (new) = 1;
+ SYMBOL_OFFSET_P (new) = 1;
+ return gen_rtx (MEM, DECL_MODE (exp),
+ gen_rtx (PLUS, Pmode,
+ gen_rtx (REG, Pmode, 015),
+ new));
+ }
+ /* If -mlabels is set, then turn any references to function foo
+ into a reference to .gcc.fnaddr.foo. This allows us to
+ distinguish taking the address of a function from calling the
+ function. It also means that we will not cse calls and
+ addresses together, but that's tough. */
+ if (TARGET_LABELS
+ && ! flag_just_decl
+ && code == FUNCTION_DECL
+ && GET_CODE (DECL_RTL (exp)) == MEM
+ && GET_CODE (XEXP (DECL_RTL (exp), 0)) == SYMBOL_REF)
+ {
+ rtx sym;
+ char *znew, *zold, *zuse;
+
+ sym = XEXP (DECL_RTL (exp), 0);
+ zold = XSTR (sym, 0);
+ znew = alloca (strlen (zold) + 15);
+ strcpy (znew, ".gcc.fnaddr.");
+ strcat (znew, zold);
+ zuse = IDENTIFIER_POINTER (get_identifier (znew));
+ return gen_rtx (MEM, DECL_MODE (exp),
+ gen_rtx (SYMBOL_REF, GET_MODE (sym), zuse));
+ }
+ #endif /* __AMOS__ Offset variable */
+
if (GET_CODE (DECL_RTL (exp)) == MEM
&& modifier != EXPAND_CONST_ADDRESS)
{
*** gcc-1.37.1/varasm.c Sun Dec 24 11:51:48 1989
--- gcc-amos/varasm.c Fri Nov 30 23:28:44 1990
***************
*** 64,69 ****
--- 68,77 ----
extern FILE *asm_out_file;
+ #ifdef __AMOS__ /* The code in expr.c needs to know if it should add a5 */
+ int flag_just_decl;
+ #endif /* __AMOS__ */
+
static char *compare_constant_1 ();
static void record_constant_1 ();
void assemble_name ();
***************
*** 260,265 ****
--- 268,280 ----
DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
gen_rtx (SYMBOL_REF, Pmode, name));
+ #ifdef __AMOS__ /* Mark symbol as being in the data section */
+ /* This is NOT correct on other systems. It should really
+ depend on whatever SELECT_SECTION does; on AMOS it always
+ selects the data section for variables. */
+ SYMBOL_DSECT_P (XEXP (DECL_RTL (decl), 0))
+ = TREE_CODE (decl) == VAR_DECL;
+ #endif
if (TREE_VOLATILE (decl))
MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
if (TREE_READONLY (decl))
***************
*** 631,636 ****
--- 646,655 ----
strcpy (namestring, name);
x = gen_rtx (SYMBOL_REF, Pmode, namestring);
+ #ifdef __AMOS__ /* Mark symbol as being in the data section */
+ if (! in_text_section ())
+ SYMBOL_DSECT_P (x) = 1;
+ #endif
ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
return x;
}
***************
*** 864,869 ****
--- 883,891 ----
struct constant_descriptor
{
struct constant_descriptor *next;
+ #ifdef __AMOS__ /* We need to know if the label is in the data segment */
+ int section;
+ #endif
char *label;
char contents[1];
};
***************
*** 1079,1085 ****
--- 1101,1110 ----
int buf;
obstack_grow (&permanent_obstack, &ptr, sizeof ptr);
+ #ifdef __AMOS__ /* Reserve space for section */
obstack_grow (&permanent_obstack, &buf, sizeof buf);
+ #endif
+ obstack_grow (&permanent_obstack, &buf, sizeof buf);
record_constant_1 (exp);
return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
}
***************
*** 1181,1188 ****
--- 1206,1219 ----
The const_hash_table records which constants already have label strings. */
static char *
+ #ifdef __AMOS__ /* We need to get the section as well */
+ get_or_assign_label (exp, sect)
+ tree exp;
+ int *sect;
+ #else
get_or_assign_label (exp)
tree exp;
+ #endif
{
register int hash, i, align;
register struct constant_descriptor *desc;
***************
*** 1201,1207 ****
--- 1232,1245 ----
for (desc = const_hash_table[hash]; desc; desc = desc->next)
if (compare_constant (exp, desc))
+ #ifdef __AMOS__ /* Return the section */
+ {
+ *sect = desc->section;
+ return desc->label;
+ }
+ #else
return desc->label;
+ #endif
/* No constant equal to EXP is known to have been output.
Make a constant descriptor to enter EXP in the hash table.
***************
*** 1225,1230 ****
--- 1263,1273 ----
text_section ();
#endif
+ #ifdef __AMOS__ /* Set the section and return it */
+ desc->section = in_section;
+ *sect = in_section;
+ #endif
+
/* Align the location counter as required by EXP's data type. */
#ifdef CONSTANT_ALIGNMENT
align = CONSTANT_ALIGNMENT (TREE_CODE (exp), TYPE_ALIGN (TREE_TYPE (exp)));
***************
*** 1279,1285 ****
--- 1322,1338 ----
if (TREE_PERMANENT (exp))
end_temporary_allocation ();
+ #ifdef __AMOS__ /* Get section for symbol and mark it */
+ {
+ int sect;
+
+ def = gen_rtx (SYMBOL_REF, Pmode, get_or_assign_label (exp, §));
+ if (sect != in_text)
+ SYMBOL_DSECT_P (def) = 1;
+ }
+ #else
def = gen_rtx (SYMBOL_REF, Pmode, get_or_assign_label (exp));
+ #endif
TREE_CST_RTL (exp)
= gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
***************
*** 1459,1465 ****
--- 1512,1521 ----
decode_rtx_const (mode, x, &value);
obstack_grow (saveable_obstack, &ptr, sizeof ptr);
+ #ifdef __AMOS__ /* Make room for the section */
obstack_grow (saveable_obstack, &buf, sizeof buf);
+ #endif
+ obstack_grow (saveable_obstack, &buf, sizeof buf);
/* Record constant contents. */
obstack_grow (saveable_obstack, &value, sizeof value);
***************
*** 1521,1526 ****
--- 1577,1586 ----
text_section ();
#endif
+ #ifdef __AMOS__ /* Set the section for the constant */
+ desc->section = in_section;
+ #endif
+
/* Align the location counter as required by EXP's data type. */
align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
***************
*** 1599,1604 ****
--- 1659,1669 ----
def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, desc->label));
+ #ifdef __AMOS__ /* Set whether in data section (actually never will be) */
+ if (desc->section != in_text)
+ SYMBOL_DSECT_P (XEXP (def, 0)) = 1;
+ #endif
+
RTX_UNCHANGING_P (def) = 1;
/* Mark the symbol_ref as belonging to this constants pool. */
CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
***************
*** 1744,1750 ****
--- 1809,1821 ----
}
#endif /* no ASM_OUTPUT_DOUBLE_INT */
+ #ifdef __AMOS__ /* tell expr.c not to add a5 to variables */
+ flag_just_decl = 1;
+ #endif /* __AMOS__ don't add a5 */
x = expand_expr (exp, 0, VOIDmode, EXPAND_SUM);
+ #ifdef __AMOS__ /* tell expr.c not to add a5 to variables */
+ flag_just_decl = 0;
+ #endif /* __AMOS__ don't add a5 */
if (size == 1)
------------------------------------------------------------------------------
The RTL generated by the expr.c diff above explicitly mentions a5
(which is a fixed register). We have to prevent the reload code
from deciding to use a5 as a spill register, or as the destination
of an add or subtract.
*** gcc-1.37.1/reload.c Mon Feb 5 17:07:20 1990
--- gcc-amos/reload.c Fri Nov 30 23:27:44 1990
***************
*** 648,653 ****
--- 652,660 ----
if (reg_renumber[regno] >= 0)
regno = reg_renumber[regno];
if (regno < FIRST_PSEUDO_REGISTER
+ #ifdef __AMOS__ /* AMOS code can refer to a fixed reg; don't use it */
+ && ! fixed_regs[regno]
+ #endif /* __AMOS__ */
/* A fixed reg that can overlap other regs better not be used
for reloading in any way. */
#ifdef OVERLAPPING_REGNO_P
***************
*** 678,683 ****
--- 685,693 ----
if (reg_renumber[regno] >= 0)
regno = reg_renumber[regno];
if (regno < FIRST_PSEUDO_REGISTER
+ #ifdef __AMOS__ /* AMOS code can have a fixed reg; don't use it */
+ && ! fixed_regs[regno]
+ #endif /* __AMOS__ */
&& ! refers_to_regno_p (regno,
regno + HARD_REGNO_NREGS (regno, GET_MODE (in)),
out, 0)
*** gcc-1.37.1/reload1.c Mon Feb 5 23:17:52 1990
--- gcc-amos/reload1.c Fri Nov 30 23:27:51 1990
***************
*** 1606,1612 ****
--- 1639,1650 ----
preferring those used less often. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ #ifdef __AMOS__ /* AMOS code may use fixed regs; don't use them here */
+ if (regs_ever_live[hard_reg_n_uses[i].regno] != 0
+ && ! fixed_regs[hard_reg_n_uses[i].regno])
+ #else /* not __AMOS__ don't use fixed regs */
if (regs_ever_live[hard_reg_n_uses[i].regno] != 0)
+ #endif /* __AMOS__ don't use fixed regs */
potential_reload_regs[o++] = hard_reg_n_uses[i].regno;
#if 0
---------------------------------------------------------------------------
Various minor changes were made to toplev.c to handle AMOS file names,
time calculation, and other stuff. All debugging output is eliminated,
as there is nothing on AMOS which could use it anyhow.
*** gcc-1.37.1/toplev.c Wed Dec 6 12:58:49 1989
--- gcc-amos/toplev.c Fri Nov 30 23:28:16 1990
***************
*** 28,35 ****
--- 32,46 ----
#include <signal.h>
#include <setjmp.h>
+ #ifndef __AMOS__ /* Don't include non-existent header files */
#include <sys/types.h>
#include <sys/stat.h>
+ #else /* __AMOS__ Get AMOS header files */
+ #include <time.h>
+ #undef bcopy
+ #undef bcmp
+ #include <unistd.h>
+ #endif /* __AMOS__ Get AMOS header files */
#ifdef USG
#undef FLOAT
***************
*** 41,50 ****
--- 52,63 ----
#undef FFS /* Some systems define this in param.h. */
#else
#ifndef VMS
+ #ifndef __AMOS__ /* Don't include non-existent header files */
#include <sys/time.h>
#include <sys/resource.h>
#endif
#endif
+ #endif
#include "input.h"
#include "tree.h"
***************
*** 94,99 ****
--- 107,115 ----
/* Current line number in real source file. */
+ #ifdef __AMOS__ /* lineno is defined both here and in cptab.c */
+ extern
+ #endif /* __AMOS__ make lineno extern */
int lineno;
/* Stack of currently pending input files. */
***************
*** 376,381 ****
--- 392,398 ----
int
gettime ()
{
+ #ifndef __AMOS__ /* AMOS doesn't need to define any variables for gettime */
#ifdef USG
struct tms tms;
#else
***************
*** 391,400 ****
--- 408,421 ----
} vms_times;
#endif
#endif
+ #endif /* not __AMOS__ */
if (quiet_flag)
return 0;
+ #ifdef __AMOS__ /* Get the CPU time used in microseconds */
+ return (clock() * 1000000) / CLK_TCK;
+ #else /* not __AMOS__ (CPU time) */
#ifdef USG
times (&tms);
return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
***************
*** 408,413 ****
--- 429,435 ----
return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
#endif
#endif
+ #endif /* not __AMOS__ (CPU time) */
}
#define TIMEVAR(VAR, BODY) \
***************
*** 502,508 ****
--- 524,532 ----
if (! quiet_flag)
{
fprintf (stderr, " %s", DECL_PRINT_NAME (decl));
+ #ifndef __AMOS__ /* Avoid calling fflush on AMOS */
fflush (stderr);
+ #endif
need_error_newline = 1;
last_error_function = current_function_decl;
}
***************
*** 850,855 ****
--- 874,880 ----
longjmp (float_handler, 1);
}
+ #ifndef __AMOS__ /* __AMOS__ doesn't define SIGPIPE */
/* Handler for SIGPIPE. */
static void
***************
*** 857,862 ****
--- 882,888 ----
{
fatal ("output pipe has been closed");
}
+ #endif /* not __AMOS__ (SIGPIPE handler) */
/* Compile an entire file of output from cpp, named NAME.
Write a file of assembly output and various debugging dumps. */
***************
*** 871,878 ****
--- 897,920 ----
int name_specified = name != 0;
+ #ifdef __AMOS__ /* Set up dump_base_name with a file name AMOS can use */
+ if (name == 0)
+ dump_base_name = "gccdmp";
+ else
+ {
+ char *dot;
+
+ dump_base_name = (char *) xmalloc (strlen(name) + 1);
+ strcpy (dump_base_name, name);
+ dot = dump_base_name;
+ while (*dot && *dot != '.')
+ dot++;
+ *dot = '\0';
+ }
+ #else /* not __AMOS__: get dump_base_name easily */
if (dump_base_name == 0)
dump_base_name = name ? name : "gccdump";
+ #endif /* not __AMOS__: get dump_base_name easily */
dump_base_name_length = strlen (dump_base_name);
parse_time = 0;
***************
*** 927,933 ****
--- 969,979 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .jmp to .jump */
+ strcat (dumpname, ".jmp");
+ #else /* not __AMOS__ .jump */
strcat (dumpname, ".jump");
+ #endif /* not __AMOS__ .jump */
jump_opt_dump_file = fopen (dumpname, "w");
if (jump_opt_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 949,955 ****
--- 995,1005 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .loop to .loo */
+ strcat (dumpname, ".loo");
+ #else /* not __AMOS__ .loo */
strcat (dumpname, ".loop");
+ #endif /* not __AMOS__ .loo */
loop_dump_file = fopen (dumpname, "w");
if (loop_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 957,966 ****
/* If flow dump desired, open the output file. */
if (flow_dump)
! {
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
strcat (dumpname, ".flow");
flow_dump_file = fopen (dumpname, "w");
if (flow_dump_file == 0)
pfatal_with_name (dumpname);
--- 1007,1020 ----
/* If flow dump desired, open the output file. */
if (flow_dump)
! {
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .flow to .flo */
+ strcat(dumpname, ".flo");
+ #else /* not __AMOS__ .flo */
strcat (dumpname, ".flow");
+ #endif /* not __AMOS__ .flo */
flow_dump_file = fopen (dumpname, "w");
if (flow_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 971,977 ****
--- 1025,1035 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .combine to .cmb */
+ strcat (dumpname, ".cmb");
+ #else /* not __AMOS__ .cmb */
strcat (dumpname, ".combine");
+ #endif /* not __AMOS__ .cmb */
combine_dump_file = fopen (dumpname, "w");
if (combine_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 982,988 ****
--- 1040,1050 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .lreg to .lrg */
+ strcat (dumpname, ".lrg");
+ #else /* not __AMOS__ .lrg */
strcat (dumpname, ".lreg");
+ #endif /* not __AMOS__ .lrg */
local_reg_dump_file = fopen (dumpname, "w");
if (local_reg_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 993,999 ****
--- 1055,1065 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .greg to .grg */
+ strcat (dumpname, ".grg");
+ #else /* not __AMOS__ .grg */
strcat (dumpname, ".greg");
+ #endif /* not __AMOS__ .grg */
global_reg_dump_file = fopen (dumpname, "w");
if (global_reg_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 1004,1010 ****
--- 1070,1080 ----
{
register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
strcpy (dumpname, dump_base_name);
+ #ifdef __AMOS__ /* Change .jump2 to .jm2 */
+ strcat (dumpname, ".jm2");
+ #else /* not __AMOS__ .jm2 */
strcat (dumpname, ".jump2");
+ #endif /* not __AMOS__ .jm2 */
jump2_opt_dump_file = fopen (dumpname, "w");
if (jump2_opt_dump_file == 0)
pfatal_with_name (dumpname);
***************
*** 1077,1082 ****
--- 1147,1153 ----
ASM_IDENTIFY_GCC (asm_out_file);
#endif
+ #ifndef __AMOS__ /* Don't do symbol stuff on AMOS--don't call symout_init */
/* If GDB symbol table desired, open the GDB symbol output file. */
if (write_symbols == GDB_DEBUG)
{
***************
*** 1094,1099 ****
--- 1165,1171 ----
sym_file_name = dumpname;
symout_init (sym_file_name, asm_out_file, main_input_filename);
}
+ #endif /* not __AMOS__ don't call symout_init */
/* If dbx symbol table desired, initialize writing it
and output the predefined types. */
***************
*** 1205,1210 ****
--- 1277,1283 ----
});
#endif
+ #ifndef __AMOS__ /* Don't link in symbol stuff on AMOS */
/* Do gdb symbols */
if (write_symbols == GDB_DEBUG)
TIMEVAR (symout_time,
***************
*** 1215,1220 ****
--- 1288,1294 ----
symout_top_blocks (globals, gettags ());
symout_finish (name, statbuf.st_ctime);
});
+ #endif
/* Output some stuff at end of file if nec. */
***************
*** 1272,1277 ****
--- 1346,1352 ----
if (! quiet_flag)
{
fprintf (stderr,"\n");
+ #ifndef __AMOS__ /* We're not really interested in these times */
print_time ("parse", parse_time);
print_time ("integration", integration_time);
print_time ("jump", jump_time);
***************
*** 1286,1291 ****
--- 1361,1367 ----
print_time ("varconst", varconst_time);
print_time ("symout", symout_time);
print_time ("dump", dump_time);
+ #endif /* not __AMOS__ skip printing the times */
}
}
***************
*** 1341,1346 ****
--- 1417,1423 ----
if (top_level)
{
+ #ifndef __AMOS__ /* Don't link in symbol stuff on AMOS */
if (write_symbols == GDB_DEBUG)
{
TIMEVAR (symout_time,
***************
*** 1352,1357 ****
--- 1429,1435 ----
});
}
else
+ #endif /* not __AMOS__ don't dump symbol stuff */
/* Clean out the temporary type list, since the types will go away. */
get_temporary_types ();
}
***************
*** 1681,1689 ****
--- 1759,1770 ----
write_symbols, optimize, 0);
final_end_function (insns, asm_out_file,
write_symbols, optimize);
+ #ifndef __AMOS__ /* Don't fflush on AMOS */
fflush (asm_out_file);
+ #endif /* not __AMOS__ (don't fflush) */
});
+ #ifndef __AMOS__ /* Never write GDB symbols on AMOS */
/* Write GDB symbols if requested */
if (write_symbols == GDB_DEBUG)
***************
*** 1700,1705 ****
--- 1781,1787 ----
});
}
else
+ #endif /* not __AMOS__ don't write GDB symbols */
get_temporary_types ();
/* Write DBX symbols if requested */
***************
*** 1744,1752 ****
--- 1826,1846 ----
save_argc = argc;
save_argv = argv;
+ #ifdef __AMOS__ /* Get the program name on AMOS */
+ progname = (char *) xmalloc (strlen (argv[0]) + 1);
+ strcpy (progname, argv[0]);
+ for (p = progname; *p && *p != ':'; p++)
+ ;
+ if (*p)
+ progname = p + 1;
+ for (p = progname; *p && *p != '.'; p++)
+ ;
+ *p = '\0';
+ #else /* not __AMOS__ get the program name a normal way */
p = argv[0] + strlen (argv[0]);
while (p != argv[0] && p[-1] != '/') --p;
progname = p;
+ #endif /* not __AMOS__ get progname */
#ifdef RLIMIT_STACK
/* Get rid of any avoidable limit on stack size. */
***************
*** 1762,1768 ****
--- 1856,1864 ----
signal (SIGFPE, float_signal);
+ #ifndef __AMOS__ /* AMOS doesn't define SIGPIPE */
signal (SIGPIPE, pipe_closed);
+ #endif /* not __AMOS__ (no SIGPIPE) */
/* Initialize whether `char' is signed. */
flag_signed_char = DEFAULT_SIGNED_CHAR;
***************
*** 1994,1999 ****
--- 2090,2096 ----
compile_file (filename);
+ #ifndef __AMOS__ /* Can't print memory on AMOS */
#ifndef USG
#ifndef VMS
if (print_mem_flag)
***************
*** 2009,2014 ****
--- 2106,2112 ----
}
#endif /* not VMS */
#endif /* not USG */
+ #endif /* not __AMOS__ */
if (errorcount)
exit (FATAL_EXIT_CODE);
{
----------------------------------------------------------------------------
The lack of virtual memory means that the compiler can run out of
memory at any time, so I forced all calls to malloc to go through
xmalloc instead.
*** gcc-1.37.1/optabs.c Sun Jan 7 00:51:52 1990
--- gcc-amos/optabs.c Fri Nov 30 23:27:32 1990
***************
*** 1404,1410 ****
--- 1408,1418 ----
enum rtx_code code;
{
int i;
+ #ifdef __AMOS__ /* call xmalloc instead of malloc */
+ optab op = (optab) xmalloc (sizeof (struct optab));
+ #else /* not __AMOS__ call xmalloc instead of malloc */
optab op = (optab) malloc (sizeof (struct optab));
+ #endif /* not __AMOS__ call xmalloc instead of malloc */
op->code = code;
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
----------------------------------------------------------------------------
My linker uses a database to record where each symbol is defined.
This means that a symbol can only be defined in a single file. This
forced me to add extern to several declarations.
*** gcc-1.37.1/output.h Mon Jul 17 16:22:12 1989
--- gcc-amos/output.h Sat Dec 1 01:08:51 1990
***************
*** 37,42 ****
--- 42,50 ----
/* When outputting assembler code, indicates which alternative
of the constraints was actually satisfied. */
+ #ifdef __AMOS__ /* Make which_alternative an extern */
+ extern
+ #endif /* __AMOS__ */
int which_alternative;
/* When outputting delayed branch sequences, this rtx holds the
***************
*** 45,82 ****
--- 53,114 ----
insn output code.
This variable is defined in final.c. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
rtx final_sequence;
/* Nonzero if function being compiled pops its args on return.
May affect compilation of return insn or of function epilogue. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_pops_args;
/* Nonzero if function being compiled needs to be given an address
where the value should be stored. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_returns_struct;
/* Nonzero if function being compiled needs to
return the address of where it has put a structure value. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_returns_pcc_struct;
/* Nonzero if function being compiled needs to be passed a static chain. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_needs_context;
/* Nonzero if function being compiled can call setjmp. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_calls_setjmp;
/* Nonzero if function being compiled can call alloca,
either as a subroutine or builtin. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_calls_alloca;
/* Nonzero if the current function returns a pointer type */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_returns_pointer;
/* If function's args have a fixed size, this is that size, in bytes.
***************
*** 83,95 ****
--- 115,136 ----
Otherwise, it is -1.
May affect compilation of return insn or of function epilogue. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_args_size;
/* # bytes the prologue should push and pretend that the caller pushed them.
The prologue must do this, but only if parms can be passed in registers. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
int current_function_pretend_args_size;
/* Name of function now being compiled. */
+ #ifdef __AMOS__ /* AMOS needs extern */
+ extern
+ #endif /* __AMOS__ */
char *current_function_name;
------------------------------------------------------------------------------
I found an optimization that significantly improved the code generated
for testing an unsigned bitfield with length 1 on the 68000. Without
this fix it loaded the bitfield into a register and used shifts and ands.
With this fix it simply uses the btst instruction.
*** gcc-1.37.1/combine.c Sat Dec 16 18:17:50 1989
--- gcc-amos/combine.c Fri Nov 30 23:26:13 1990
***************
*** 1498,1503 ****
--- 1510,1525 ----
&& ((unsigned) INTVAL (XEXP (SET_SRC (x), 1))
< (1 << (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (SET_SRC (x), 0), 0))) - 1))))
SUBST (XEXP (SET_SRC (x), 0), XEXP (XEXP (SET_SRC (x), 0), 0));
+ #ifdef __AMOS__ /* Simplify (set (cc0) (sign_extend:M FOO)) */
+ /* (set (cc0) (sign_extend:M FOO)) is created by references to
+ bitfields that are only 1 bit. We can simplify this to
+ (set (cc0) FOO). */
+ if (SET_DEST (x) == cc0_rtx
+ && (GET_CODE (SET_SRC (x)) == ZERO_EXTEND
+ || GET_CODE (SET_SRC (x)) == SIGN_EXTEND)
+ && next_insn_tests_no_inequality (subst_insn))
+ SUBST (SET_SRC (x), XEXP (SET_SRC (x), 0));
+ #endif /* __AMOS__ Simplify (set (cc0) (sign_extend:M FOO)) */
break;
case AND:
----------------------------------------------------------------------------
We have found the following warning to be very useful in our development
environment. It issues a warning whenever an externally visible function
is defined with no prototype in scope; this ensures that the appropriate
header file is included to check that the prototype matches the actual
definition. It avoids checking the function main. It is currently
turned on by -Wstrict-prototypes.
*** gcc-1.37.1/c-decl.c Mon Feb 12 02:57:58 1990
--- gcc-amos/c-decl.c Fri Nov 30 23:28:28 1990
***************
*** 993,998 ****
--- 997,1015 ----
}
return t;
}
+
+ #ifdef __AMOS__ /* Warn for functions with no prototypes */
+ /* If this is a function definition for which no prototype has
+ been seen, maybe give a warning, unless it's static. */
+ if (t == 0
+ && TREE_CODE (x) == FUNCTION_DECL
+ && ! TREE_EXTERNAL (x)
+ && TREE_PUBLIC (x)
+ && warn_strict_prototypes
+ && strcmp (IDENTIFIER_POINTER (name), "main"))
+ warning_with_decl (x,
+ "%s: no prototype for externally visible function definition");
+ #endif /* __AMOS__ warn if no prototype */
/* If declaring a type as a typedef, and the type has no known
typedef name, install this TYPE_DECL as its typedef name. */
-----------------------------------------------------------------------------
Flushing a file on AMOS is very slow. It requires closing the file and
reopening it for append. Therefore, I took it out of much code,
exchanging more speed for less error-trapping.
*** gcc-1.37.1/gencodes.c Thu Sep 7 23:17:44 1989
--- gcc-amos/gencodes.c Fri Nov 30 23:28:45 1990
***************
*** 149,154 ****
--- 149,156 ----
printf ("#endif /* MAX_INSN_CODE */\n");
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genconfig.c gcc-amos/genconfig.c
*** gcc-1.37.1/genconfig.c Thu Sep 7 23:17:57 1989
--- gcc-amos/genconfig.c Fri Nov 30 23:28:45 1990
***************
*** 252,259 ****
--- 252,265 ----
gen_peephole (desc);
}
+ #ifdef __AMOS__
+ /* 1 more than needed for this md file, for the sake of asm constructs. */
+ /* On the Alpha Micro, we need the data space badly. */
+ printf ("\n#define MAX_RECOG_OPERANDS %d\n", max_recog_operands_flag + 2);
+ #else
/* 3 more than needed for this md file, for the sake of asm constructs. */
printf ("\n#define MAX_RECOG_OPERANDS %d\n", max_recog_operands_flag + 4);
+ #endif
if (max_dup_operands_flag == 0)
max_dup_operands_flag = 1;
***************
*** 262,267 ****
--- 268,275 ----
if (register_constraint_flag)
printf ("#define REGISTER_CONSTRAINTS\n");
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genemit.c gcc-amos/genemit.c
*** gcc-1.37.1/genemit.c Thu Sep 7 23:18:12 1989
--- gcc-amos/genemit.c Fri Nov 30 23:28:46 1990
***************
*** 475,480 ****
--- 475,482 ----
}
}
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genextract.c gcc-amos/genextract.c
*** gcc-1.37.1/genextract.c Sun Sep 24 01:26:59 1989
--- gcc-amos/genextract.c Fri Nov 30 23:28:47 1990
***************
*** 343,348 ****
--- 343,350 ----
printf ("{\n if (INSN_CODE (insn) == -1) fatal_insn_not_found (insn);\n");
printf (" (*insn_extract_fn[INSN_CODE (insn)]) (PATTERN (insn));\n}\n");
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genflags.c gcc-amos/genflags.c
*** gcc-1.37.1/genflags.c Thu Sep 7 23:18:05 1989
--- gcc-amos/genflags.c Fri Nov 30 23:28:47 1990
***************
*** 133,138 ****
--- 133,140 ----
gen_insn (desc);
}
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genoutput.c gcc-amos/genoutput.c
*** gcc-1.37.1/genoutput.c Mon Sep 11 20:44:23 1989
--- gcc-amos/genoutput.c Fri Nov 30 23:28:49 1990
***************
*** 770,776 ****
--- 770,778 ----
output_epilogue ();
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genpeep.c gcc-amos/genpeep.c
*** gcc-1.37.1/genpeep.c Thu Sep 7 23:18:26 1989
--- gcc-amos/genpeep.c Fri Nov 30 23:28:50 1990
***************
*** 432,437 ****
--- 432,439 ----
printf ("rtx peep_operand[%d];\n", max_opno + 1);
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
diff -c gcc-1.37.1/genrecog.c gcc-amos/genrecog.c
*** gcc-1.37.1/genrecog.c Thu Sep 7 23:18:33 1989
--- gcc-amos/genrecog.c Fri Nov 30 23:28:52 1990
***************
*** 1090,1095 ****
--- 1090,1097 ----
write_tree (tree, "", 0, "", 1);
printf (" ret0: return -1;\n}\n");
+ #ifndef __AMOS__ /* Don't fflush */
fflush (stdout);
+ #endif
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
}
Technical Details
Message-ID:
<9012162035.AA00827@uunet.uu.net>Path:
arc1-ca.pugleaf.net!gmdzi!unido!mcsun!uunet!tut.cis.ohio-state.edu!UUNET.UU.NET!airs!ianShow Full Headers
Complete Article Headers
X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: 11318c,199f9c859176d044,start X-Google-Attributes: gid11318c,public X-Google-ArrivalTime: 1990-12-15 13:05:50 PST Path: arc1-ca.pugleaf.net!gmdzi!unido!mcsun!uunet!tut.cis.ohio-state.edu!UUNET.UU.NET!airs!ian From: airs!ian@UUNET.UU.NET (Ian Lance Taylor) Newsgroups: gnu.gcc.help Subject: Diffs for Alpha Micro port of gcc Message-ID: <9012162035.AA00827@uunet.uu.net> Date: 15 Dec 90 21:05:50 GMT Sender: daemon@tut.cis.ohio-state.edu Distribution: gnu Organization: Gnus Not Usenet Lines: 2695