/* BFD back-end for s-record objects.
|
/* BFD back-end for s-record objects.
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
|
Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
MA 02110-1301, USA. */
|
MA 02110-1301, USA. */
|
|
|
|
|
/* SUBSECTION
|
/* SUBSECTION
|
S-Record handling
|
S-Record handling
|
|
|
DESCRIPTION
|
DESCRIPTION
|
|
|
Ordinary S-Records cannot hold anything but addresses and
|
Ordinary S-Records cannot hold anything but addresses and
|
data, so that's all that we implement.
|
data, so that's all that we implement.
|
|
|
The only interesting thing is that S-Records may come out of
|
The only interesting thing is that S-Records may come out of
|
order and there is no header, so an initial scan is required
|
order and there is no header, so an initial scan is required
|
to discover the minimum and maximum addresses used to create
|
to discover the minimum and maximum addresses used to create
|
the vma and size of the only section we create. We
|
the vma and size of the only section we create. We
|
arbitrarily call this section ".text".
|
arbitrarily call this section ".text".
|
|
|
When bfd_get_section_contents is called the file is read
|
When bfd_get_section_contents is called the file is read
|
again, and this time the data is placed into a bfd_alloc'd
|
again, and this time the data is placed into a bfd_alloc'd
|
area.
|
area.
|
|
|
Any number of sections may be created for output, we save them
|
Any number of sections may be created for output, we save them
|
up and output them when it's time to close the bfd.
|
up and output them when it's time to close the bfd.
|
|
|
An s record looks like:
|
An s record looks like:
|
|
|
EXAMPLE
|
EXAMPLE
|
S<type><length><address><data><checksum>
|
S<type><length><address><data><checksum>
|
|
|
DESCRIPTION
|
DESCRIPTION
|
Where
|
Where
|
o length
|
o length
|
is the number of bytes following upto the checksum. Note that
|
is the number of bytes following upto the checksum. Note that
|
this is not the number of chars following, since it takes two
|
this is not the number of chars following, since it takes two
|
chars to represent a byte.
|
chars to represent a byte.
|
o type
|
o type
|
is one of:
|
is one of:
|
0) header record
|
0) header record
|
1) two byte address data record
|
1) two byte address data record
|
2) three byte address data record
|
2) three byte address data record
|
3) four byte address data record
|
3) four byte address data record
|
7) four byte address termination record
|
7) four byte address termination record
|
8) three byte address termination record
|
8) three byte address termination record
|
9) two byte address termination record
|
9) two byte address termination record
|
|
|
o address
|
o address
|
is the start address of the data following, or in the case of
|
is the start address of the data following, or in the case of
|
a termination record, the start address of the image
|
a termination record, the start address of the image
|
o data
|
o data
|
is the data.
|
is the data.
|
o checksum
|
o checksum
|
is the sum of all the raw byte data in the record, from the length
|
is the sum of all the raw byte data in the record, from the length
|
upwards, modulo 256 and subtracted from 255.
|
upwards, modulo 256 and subtracted from 255.
|
|
|
SUBSECTION
|
SUBSECTION
|
Symbol S-Record handling
|
Symbol S-Record handling
|
|
|
DESCRIPTION
|
DESCRIPTION
|
Some ICE equipment understands an addition to the standard
|
Some ICE equipment understands an addition to the standard
|
S-Record format; symbols and their addresses can be sent
|
S-Record format; symbols and their addresses can be sent
|
before the data.
|
before the data.
|
|
|
The format of this is:
|
The format of this is:
|
($$ <modulename>
|
($$ <modulename>
|
(<space> <symbol> <address>)*)
|
(<space> <symbol> <address>)*)
|
$$
|
$$
|
|
|
so a short symbol table could look like:
|
so a short symbol table could look like:
|
|
|
EXAMPLE
|
EXAMPLE
|
$$ flash.x
|
$$ flash.x
|
$$ flash.c
|
$$ flash.c
|
_port6 $0
|
_port6 $0
|
_delay $4
|
_delay $4
|
_start $14
|
_start $14
|
_etext $8036
|
_etext $8036
|
_edata $8036
|
_edata $8036
|
_end $8036
|
_end $8036
|
$$
|
$$
|
|
|
DESCRIPTION
|
DESCRIPTION
|
We allow symbols to be anywhere in the data stream - the module names
|
We allow symbols to be anywhere in the data stream - the module names
|
are always ignored. */
|
are always ignored. */
|
|
|
#include "sysdep.h"
|
#include "sysdep.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "libbfd.h"
|
#include "libbfd.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "safe-ctype.h"
|
#include "safe-ctype.h"
|
|
|
|
|
/* Macros for converting between hex and binary. */
|
/* Macros for converting between hex and binary. */
|
|
|
static const char digs[] = "0123456789ABCDEF";
|
static const char digs[] = "0123456789ABCDEF";
|
|
|
#define NIBBLE(x) hex_value(x)
|
#define NIBBLE(x) hex_value(x)
|
#define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
|
#define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
|
#define TOHEX(d, x, ch) \
|
#define TOHEX(d, x, ch) \
|
d[1] = digs[(x) & 0xf]; \
|
d[1] = digs[(x) & 0xf]; \
|
d[0] = digs[((x)>>4)&0xf]; \
|
d[0] = digs[((x)>>4)&0xf]; \
|
ch += ((x) & 0xff);
|
ch += ((x) & 0xff);
|
#define ISHEX(x) hex_p(x)
|
#define ISHEX(x) hex_p(x)
|
|
|
/* The maximum number of address+data+crc bytes on a line is FF. */
|
/* The maximum number of address+data+crc bytes on a line is FF. */
|
#define MAXCHUNK 0xff
|
#define MAXCHUNK 0xff
|
|
|
/* Default size for a CHUNK. */
|
/* Default size for a CHUNK. */
|
#define DEFAULT_CHUNK 16
|
#define DEFAULT_CHUNK 16
|
|
|
/* The number of data bytes we actually fit onto a line on output.
|
/* The number of data bytes we actually fit onto a line on output.
|
This variable can be modified by objcopy's --srec-len parameter.
|
This variable can be modified by objcopy's --srec-len parameter.
|
For a 0x75 byte record you should set --srec-len=0x70. */
|
For a 0x75 byte record you should set --srec-len=0x70. */
|
unsigned int Chunk = DEFAULT_CHUNK;
|
unsigned int Chunk = DEFAULT_CHUNK;
|
|
|
/* The type of srec output (free or forced to S3).
|
/* The type of srec output (free or forced to S3).
|
This variable can be modified by objcopy's --srec-forceS3
|
This variable can be modified by objcopy's --srec-forceS3
|
parameter. */
|
parameter. */
|
bfd_boolean S3Forced = FALSE;
|
bfd_boolean S3Forced = FALSE;
|
|
|
/* When writing an S-record file, the S-records can not be output as
|
/* When writing an S-record file, the S-records can not be output as
|
they are seen. This structure is used to hold them in memory. */
|
they are seen. This structure is used to hold them in memory. */
|
|
|
struct srec_data_list_struct
|
struct srec_data_list_struct
|
{
|
{
|
struct srec_data_list_struct *next;
|
struct srec_data_list_struct *next;
|
bfd_byte *data;
|
bfd_byte *data;
|
bfd_vma where;
|
bfd_vma where;
|
bfd_size_type size;
|
bfd_size_type size;
|
};
|
};
|
|
|
typedef struct srec_data_list_struct srec_data_list_type;
|
typedef struct srec_data_list_struct srec_data_list_type;
|
|
|
/* When scanning the S-record file, a linked list of srec_symbol
|
/* When scanning the S-record file, a linked list of srec_symbol
|
structures is built to represent the symbol table (if there is
|
structures is built to represent the symbol table (if there is
|
one). */
|
one). */
|
|
|
struct srec_symbol
|
struct srec_symbol
|
{
|
{
|
struct srec_symbol *next;
|
struct srec_symbol *next;
|
const char *name;
|
const char *name;
|
bfd_vma val;
|
bfd_vma val;
|
};
|
};
|
|
|
/* The S-record tdata information. */
|
/* The S-record tdata information. */
|
|
|
typedef struct srec_data_struct
|
typedef struct srec_data_struct
|
{
|
{
|
srec_data_list_type *head;
|
srec_data_list_type *head;
|
srec_data_list_type *tail;
|
srec_data_list_type *tail;
|
unsigned int type;
|
unsigned int type;
|
struct srec_symbol *symbols;
|
struct srec_symbol *symbols;
|
struct srec_symbol *symtail;
|
struct srec_symbol *symtail;
|
asymbol *csymbols;
|
asymbol *csymbols;
|
}
|
}
|
tdata_type;
|
tdata_type;
|
|
|
/* Initialize by filling in the hex conversion array. */
|
/* Initialize by filling in the hex conversion array. */
|
|
|
static void
|
static void
|
srec_init (void)
|
srec_init (void)
|
{
|
{
|
static bfd_boolean inited = FALSE;
|
static bfd_boolean inited = FALSE;
|
|
|
if (! inited)
|
if (! inited)
|
{
|
{
|
inited = TRUE;
|
inited = TRUE;
|
hex_init ();
|
hex_init ();
|
}
|
}
|
}
|
}
|
|
|
/* Set up the S-record tdata information. */
|
/* Set up the S-record tdata information. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_mkobject (bfd *abfd)
|
srec_mkobject (bfd *abfd)
|
{
|
{
|
tdata_type *tdata;
|
tdata_type *tdata;
|
|
|
srec_init ();
|
srec_init ();
|
|
|
tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
|
tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
|
if (tdata == NULL)
|
if (tdata == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
abfd->tdata.srec_data = tdata;
|
abfd->tdata.srec_data = tdata;
|
tdata->type = 1;
|
tdata->type = 1;
|
tdata->head = NULL;
|
tdata->head = NULL;
|
tdata->tail = NULL;
|
tdata->tail = NULL;
|
tdata->symbols = NULL;
|
tdata->symbols = NULL;
|
tdata->symtail = NULL;
|
tdata->symtail = NULL;
|
tdata->csymbols = NULL;
|
tdata->csymbols = NULL;
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Read a byte from an S record file. Set *ERRORPTR if an error
|
/* Read a byte from an S record file. Set *ERRORPTR if an error
|
occurred. Return EOF on error or end of file. */
|
occurred. Return EOF on error or end of file. */
|
|
|
static int
|
static int
|
srec_get_byte (bfd *abfd, bfd_boolean *errorptr)
|
srec_get_byte (bfd *abfd, bfd_boolean *errorptr)
|
{
|
{
|
bfd_byte c;
|
bfd_byte c;
|
|
|
if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
|
if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
|
{
|
{
|
if (bfd_get_error () != bfd_error_file_truncated)
|
if (bfd_get_error () != bfd_error_file_truncated)
|
*errorptr = TRUE;
|
*errorptr = TRUE;
|
return EOF;
|
return EOF;
|
}
|
}
|
|
|
return (int) (c & 0xff);
|
return (int) (c & 0xff);
|
}
|
}
|
|
|
/* Report a problem in an S record file. FIXME: This probably should
|
/* Report a problem in an S record file. FIXME: This probably should
|
not call fprintf, but we really do need some mechanism for printing
|
not call fprintf, but we really do need some mechanism for printing
|
error messages. */
|
error messages. */
|
|
|
static void
|
static void
|
srec_bad_byte (bfd *abfd,
|
srec_bad_byte (bfd *abfd,
|
unsigned int lineno,
|
unsigned int lineno,
|
int c,
|
int c,
|
bfd_boolean error)
|
bfd_boolean error)
|
{
|
{
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
if (! error)
|
if (! error)
|
bfd_set_error (bfd_error_file_truncated);
|
bfd_set_error (bfd_error_file_truncated);
|
}
|
}
|
else
|
else
|
{
|
{
|
char buf[10];
|
char buf[10];
|
|
|
if (! ISPRINT (c))
|
if (! ISPRINT (c))
|
sprintf (buf, "\\%03o", (unsigned int) c);
|
sprintf (buf, "\\%03o", (unsigned int) c);
|
else
|
else
|
{
|
{
|
buf[0] = c;
|
buf[0] = c;
|
buf[1] = '\0';
|
buf[1] = '\0';
|
}
|
}
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B:%d: Unexpected character `%s' in S-record file\n"),
|
(_("%B:%d: Unexpected character `%s' in S-record file\n"),
|
abfd, lineno, buf);
|
abfd, lineno, buf);
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
}
|
}
|
}
|
}
|
|
|
/* Add a new symbol found in an S-record file. */
|
/* Add a new symbol found in an S-record file. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
|
srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
|
{
|
{
|
struct srec_symbol *n;
|
struct srec_symbol *n;
|
|
|
n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
|
n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
|
if (n == NULL)
|
if (n == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
n->name = name;
|
n->name = name;
|
n->val = val;
|
n->val = val;
|
|
|
if (abfd->tdata.srec_data->symbols == NULL)
|
if (abfd->tdata.srec_data->symbols == NULL)
|
abfd->tdata.srec_data->symbols = n;
|
abfd->tdata.srec_data->symbols = n;
|
else
|
else
|
abfd->tdata.srec_data->symtail->next = n;
|
abfd->tdata.srec_data->symtail->next = n;
|
abfd->tdata.srec_data->symtail = n;
|
abfd->tdata.srec_data->symtail = n;
|
n->next = NULL;
|
n->next = NULL;
|
|
|
++abfd->symcount;
|
++abfd->symcount;
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Read the S record file and turn it into sections. We create a new
|
/* Read the S record file and turn it into sections. We create a new
|
section for each contiguous set of bytes. */
|
section for each contiguous set of bytes. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_scan (bfd *abfd)
|
srec_scan (bfd *abfd)
|
{
|
{
|
int c;
|
int c;
|
unsigned int lineno = 1;
|
unsigned int lineno = 1;
|
bfd_boolean error = FALSE;
|
bfd_boolean error = FALSE;
|
bfd_byte *buf = NULL;
|
bfd_byte *buf = NULL;
|
size_t bufsize = 0;
|
size_t bufsize = 0;
|
asection *sec = NULL;
|
asection *sec = NULL;
|
char *symbuf = NULL;
|
char *symbuf = NULL;
|
|
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
|
goto error_return;
|
goto error_return;
|
|
|
while ((c = srec_get_byte (abfd, &error)) != EOF)
|
while ((c = srec_get_byte (abfd, &error)) != EOF)
|
{
|
{
|
/* We only build sections from contiguous S-records, so if this
|
/* We only build sections from contiguous S-records, so if this
|
is not an S-record, then stop building a section. */
|
is not an S-record, then stop building a section. */
|
if (c != 'S' && c != '\r' && c != '\n')
|
if (c != 'S' && c != '\r' && c != '\n')
|
sec = NULL;
|
sec = NULL;
|
|
|
switch (c)
|
switch (c)
|
{
|
{
|
default:
|
default:
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
|
|
case '\n':
|
case '\n':
|
++lineno;
|
++lineno;
|
break;
|
break;
|
|
|
case '\r':
|
case '\r':
|
break;
|
break;
|
|
|
case '$':
|
case '$':
|
/* Starting a module name, which we ignore. */
|
/* Starting a module name, which we ignore. */
|
while ((c = srec_get_byte (abfd, &error)) != '\n'
|
while ((c = srec_get_byte (abfd, &error)) != '\n'
|
&& c != EOF)
|
&& c != EOF)
|
;
|
;
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
++lineno;
|
++lineno;
|
break;
|
break;
|
|
|
case ' ':
|
case ' ':
|
do
|
do
|
{
|
{
|
bfd_size_type alc;
|
bfd_size_type alc;
|
char *p, *symname;
|
char *p, *symname;
|
bfd_vma symval;
|
bfd_vma symval;
|
|
|
/* Starting a symbol definition. */
|
/* Starting a symbol definition. */
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
&& (c == ' ' || c == '\t'))
|
&& (c == ' ' || c == '\t'))
|
;
|
;
|
|
|
if (c == '\n' || c == '\r')
|
if (c == '\n' || c == '\r')
|
break;
|
break;
|
|
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
alc = 10;
|
alc = 10;
|
symbuf = (char *) bfd_malloc (alc + 1);
|
symbuf = (char *) bfd_malloc (alc + 1);
|
if (symbuf == NULL)
|
if (symbuf == NULL)
|
goto error_return;
|
goto error_return;
|
|
|
p = symbuf;
|
p = symbuf;
|
|
|
*p++ = c;
|
*p++ = c;
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
&& ! ISSPACE (c))
|
&& ! ISSPACE (c))
|
{
|
{
|
if ((bfd_size_type) (p - symbuf) >= alc)
|
if ((bfd_size_type) (p - symbuf) >= alc)
|
{
|
{
|
char *n;
|
char *n;
|
|
|
alc *= 2;
|
alc *= 2;
|
n = (char *) bfd_realloc (symbuf, alc + 1);
|
n = (char *) bfd_realloc (symbuf, alc + 1);
|
if (n == NULL)
|
if (n == NULL)
|
goto error_return;
|
goto error_return;
|
p = n + (p - symbuf);
|
p = n + (p - symbuf);
|
symbuf = n;
|
symbuf = n;
|
}
|
}
|
|
|
*p++ = c;
|
*p++ = c;
|
}
|
}
|
|
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
*p++ = '\0';
|
*p++ = '\0';
|
symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
|
symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
|
if (symname == NULL)
|
if (symname == NULL)
|
goto error_return;
|
goto error_return;
|
strcpy (symname, symbuf);
|
strcpy (symname, symbuf);
|
free (symbuf);
|
free (symbuf);
|
symbuf = NULL;
|
symbuf = NULL;
|
|
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
while ((c = srec_get_byte (abfd, &error)) != EOF
|
&& (c == ' ' || c == '\t'))
|
&& (c == ' ' || c == '\t'))
|
;
|
;
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
/* Skip a dollar sign before the hex value. */
|
/* Skip a dollar sign before the hex value. */
|
if (c == '$')
|
if (c == '$')
|
{
|
{
|
c = srec_get_byte (abfd, &error);
|
c = srec_get_byte (abfd, &error);
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
}
|
}
|
|
|
symval = 0;
|
symval = 0;
|
while (ISHEX (c))
|
while (ISHEX (c))
|
{
|
{
|
symval <<= 4;
|
symval <<= 4;
|
symval += NIBBLE (c);
|
symval += NIBBLE (c);
|
c = srec_get_byte (abfd, &error);
|
c = srec_get_byte (abfd, &error);
|
if (c == EOF)
|
if (c == EOF)
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
}
|
}
|
|
|
if (! srec_new_symbol (abfd, symname, symval))
|
if (! srec_new_symbol (abfd, symname, symval))
|
goto error_return;
|
goto error_return;
|
}
|
}
|
while (c == ' ' || c == '\t')
|
while (c == ' ' || c == '\t')
|
;
|
;
|
|
|
if (c == '\n')
|
if (c == '\n')
|
++lineno;
|
++lineno;
|
else if (c != '\r')
|
else if (c != '\r')
|
{
|
{
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
break;
|
break;
|
|
|
case 'S':
|
case 'S':
|
{
|
{
|
file_ptr pos;
|
file_ptr pos;
|
char hdr[3];
|
char hdr[3];
|
unsigned int bytes;
|
unsigned int bytes;
|
bfd_vma address;
|
bfd_vma address;
|
bfd_byte *data;
|
bfd_byte *data;
|
unsigned char check_sum;
|
unsigned char check_sum;
|
|
|
/* Starting an S-record. */
|
/* Starting an S-record. */
|
|
|
pos = bfd_tell (abfd) - 1;
|
pos = bfd_tell (abfd) - 1;
|
|
|
if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
|
if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
|
goto error_return;
|
goto error_return;
|
|
|
if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
|
if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
|
{
|
{
|
if (! ISHEX (hdr[1]))
|
if (! ISHEX (hdr[1]))
|
c = hdr[1];
|
c = hdr[1];
|
else
|
else
|
c = hdr[2];
|
c = hdr[2];
|
srec_bad_byte (abfd, lineno, c, error);
|
srec_bad_byte (abfd, lineno, c, error);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
check_sum = bytes = HEX (hdr + 1);
|
check_sum = bytes = HEX (hdr + 1);
|
if (bytes * 2 > bufsize)
|
if (bytes * 2 > bufsize)
|
{
|
{
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
|
buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
|
if (buf == NULL)
|
if (buf == NULL)
|
goto error_return;
|
goto error_return;
|
bufsize = bytes * 2;
|
bufsize = bytes * 2;
|
}
|
}
|
|
|
if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
|
if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
|
goto error_return;
|
goto error_return;
|
|
|
/* Ignore the checksum byte. */
|
/* Ignore the checksum byte. */
|
--bytes;
|
--bytes;
|
|
|
address = 0;
|
address = 0;
|
data = buf;
|
data = buf;
|
switch (hdr[0])
|
switch (hdr[0])
|
{
|
{
|
case '0':
|
case '0':
|
case '5':
|
case '5':
|
/* Prologue--ignore the file name, but stop building a
|
/* Prologue--ignore the file name, but stop building a
|
section at this point. */
|
section at this point. */
|
sec = NULL;
|
sec = NULL;
|
break;
|
break;
|
|
|
case '3':
|
case '3':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = HEX (data);
|
address = HEX (data);
|
data += 2;
|
data += 2;
|
--bytes;
|
--bytes;
|
/* Fall through. */
|
/* Fall through. */
|
case '2':
|
case '2':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
--bytes;
|
--bytes;
|
/* Fall through. */
|
/* Fall through. */
|
case '1':
|
case '1':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
bytes -= 2;
|
bytes -= 2;
|
|
|
if (sec != NULL
|
if (sec != NULL
|
&& sec->vma + sec->size == address)
|
&& sec->vma + sec->size == address)
|
{
|
{
|
/* This data goes at the end of the section we are
|
/* This data goes at the end of the section we are
|
currently building. */
|
currently building. */
|
sec->size += bytes;
|
sec->size += bytes;
|
}
|
}
|
else
|
else
|
{
|
{
|
char secbuf[20];
|
char secbuf[20];
|
char *secname;
|
char *secname;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
flagword flags;
|
flagword flags;
|
|
|
sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
|
sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
|
amt = strlen (secbuf) + 1;
|
amt = strlen (secbuf) + 1;
|
secname = (char *) bfd_alloc (abfd, amt);
|
secname = (char *) bfd_alloc (abfd, amt);
|
strcpy (secname, secbuf);
|
strcpy (secname, secbuf);
|
flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
|
flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
|
sec = bfd_make_section_with_flags (abfd, secname, flags);
|
sec = bfd_make_section_with_flags (abfd, secname, flags);
|
if (sec == NULL)
|
if (sec == NULL)
|
goto error_return;
|
goto error_return;
|
sec->vma = address;
|
sec->vma = address;
|
sec->lma = address;
|
sec->lma = address;
|
sec->size = bytes;
|
sec->size = bytes;
|
sec->filepos = pos;
|
sec->filepos = pos;
|
}
|
}
|
|
|
while (bytes > 0)
|
while (bytes > 0)
|
{
|
{
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
data += 2;
|
data += 2;
|
bytes--;
|
bytes--;
|
}
|
}
|
check_sum = 255 - (check_sum & 0xff);
|
check_sum = 255 - (check_sum & 0xff);
|
if (check_sum != HEX (data))
|
if (check_sum != HEX (data))
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B:%d: Bad checksum in S-record file\n"),
|
(_("%B:%d: Bad checksum in S-record file\n"),
|
abfd, lineno);
|
abfd, lineno);
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
break;
|
break;
|
|
|
case '7':
|
case '7':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = HEX (data);
|
address = HEX (data);
|
data += 2;
|
data += 2;
|
/* Fall through. */
|
/* Fall through. */
|
case '8':
|
case '8':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
/* Fall through. */
|
/* Fall through. */
|
case '9':
|
case '9':
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
check_sum += HEX (data);
|
check_sum += HEX (data);
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
|
|
/* This is a termination record. */
|
/* This is a termination record. */
|
abfd->start_address = address;
|
abfd->start_address = address;
|
|
|
check_sum = 255 - (check_sum & 0xff);
|
check_sum = 255 - (check_sum & 0xff);
|
if (check_sum != HEX (data))
|
if (check_sum != HEX (data))
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B:%d: Bad checksum in S-record file\n"),
|
(_("%B:%d: Bad checksum in S-record file\n"),
|
abfd, lineno);
|
abfd, lineno);
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
goto error_return;
|
goto error_return;
|
}
|
}
|
|
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (error)
|
if (error)
|
goto error_return;
|
goto error_return;
|
|
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
|
|
return TRUE;
|
return TRUE;
|
|
|
error_return:
|
error_return:
|
if (symbuf != NULL)
|
if (symbuf != NULL)
|
free (symbuf);
|
free (symbuf);
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
/* Check whether an existing file is an S-record file. */
|
/* Check whether an existing file is an S-record file. */
|
|
|
static const bfd_target *
|
static const bfd_target *
|
srec_object_p (bfd *abfd)
|
srec_object_p (bfd *abfd)
|
{
|
{
|
void * tdata_save;
|
void * tdata_save;
|
bfd_byte b[4];
|
bfd_byte b[4];
|
|
|
srec_init ();
|
srec_init ();
|
|
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|
|| bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
|
|| bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
|
return NULL;
|
return NULL;
|
|
|
if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
|
if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
|
{
|
{
|
bfd_set_error (bfd_error_wrong_format);
|
bfd_set_error (bfd_error_wrong_format);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
tdata_save = abfd->tdata.any;
|
tdata_save = abfd->tdata.any;
|
if (! srec_mkobject (abfd) || ! srec_scan (abfd))
|
if (! srec_mkobject (abfd) || ! srec_scan (abfd))
|
{
|
{
|
if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
|
if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
|
bfd_release (abfd, abfd->tdata.any);
|
bfd_release (abfd, abfd->tdata.any);
|
abfd->tdata.any = tdata_save;
|
abfd->tdata.any = tdata_save;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (abfd->symcount > 0)
|
if (abfd->symcount > 0)
|
abfd->flags |= HAS_SYMS;
|
abfd->flags |= HAS_SYMS;
|
|
|
return abfd->xvec;
|
return abfd->xvec;
|
}
|
}
|
|
|
/* Check whether an existing file is an S-record file with symbols. */
|
/* Check whether an existing file is an S-record file with symbols. */
|
|
|
static const bfd_target *
|
static const bfd_target *
|
symbolsrec_object_p (bfd *abfd)
|
symbolsrec_object_p (bfd *abfd)
|
{
|
{
|
void * tdata_save;
|
void * tdata_save;
|
char b[2];
|
char b[2];
|
|
|
srec_init ();
|
srec_init ();
|
|
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|
|| bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
|
|| bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
|
return NULL;
|
return NULL;
|
|
|
if (b[0] != '$' || b[1] != '$')
|
if (b[0] != '$' || b[1] != '$')
|
{
|
{
|
bfd_set_error (bfd_error_wrong_format);
|
bfd_set_error (bfd_error_wrong_format);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
tdata_save = abfd->tdata.any;
|
tdata_save = abfd->tdata.any;
|
if (! srec_mkobject (abfd) || ! srec_scan (abfd))
|
if (! srec_mkobject (abfd) || ! srec_scan (abfd))
|
{
|
{
|
if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
|
if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
|
bfd_release (abfd, abfd->tdata.any);
|
bfd_release (abfd, abfd->tdata.any);
|
abfd->tdata.any = tdata_save;
|
abfd->tdata.any = tdata_save;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (abfd->symcount > 0)
|
if (abfd->symcount > 0)
|
abfd->flags |= HAS_SYMS;
|
abfd->flags |= HAS_SYMS;
|
|
|
return abfd->xvec;
|
return abfd->xvec;
|
}
|
}
|
|
|
/* Read in the contents of a section in an S-record file. */
|
/* Read in the contents of a section in an S-record file. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
|
srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
|
{
|
{
|
int c;
|
int c;
|
bfd_size_type sofar = 0;
|
bfd_size_type sofar = 0;
|
bfd_boolean error = FALSE;
|
bfd_boolean error = FALSE;
|
bfd_byte *buf = NULL;
|
bfd_byte *buf = NULL;
|
size_t bufsize = 0;
|
size_t bufsize = 0;
|
|
|
if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
|
if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
|
goto error_return;
|
goto error_return;
|
|
|
while ((c = srec_get_byte (abfd, &error)) != EOF)
|
while ((c = srec_get_byte (abfd, &error)) != EOF)
|
{
|
{
|
bfd_byte hdr[3];
|
bfd_byte hdr[3];
|
unsigned int bytes;
|
unsigned int bytes;
|
bfd_vma address;
|
bfd_vma address;
|
bfd_byte *data;
|
bfd_byte *data;
|
|
|
if (c == '\r' || c == '\n')
|
if (c == '\r' || c == '\n')
|
continue;
|
continue;
|
|
|
/* This is called after srec_scan has already been called, so we
|
/* This is called after srec_scan has already been called, so we
|
ought to know the exact format. */
|
ought to know the exact format. */
|
BFD_ASSERT (c == 'S');
|
BFD_ASSERT (c == 'S');
|
|
|
if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
|
if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
|
goto error_return;
|
goto error_return;
|
|
|
BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
|
BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
|
|
|
bytes = HEX (hdr + 1);
|
bytes = HEX (hdr + 1);
|
|
|
if (bytes * 2 > bufsize)
|
if (bytes * 2 > bufsize)
|
{
|
{
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
|
buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
|
if (buf == NULL)
|
if (buf == NULL)
|
goto error_return;
|
goto error_return;
|
bufsize = bytes * 2;
|
bufsize = bytes * 2;
|
}
|
}
|
|
|
if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
|
if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
|
goto error_return;
|
goto error_return;
|
|
|
address = 0;
|
address = 0;
|
data = buf;
|
data = buf;
|
switch (hdr[0])
|
switch (hdr[0])
|
{
|
{
|
default:
|
default:
|
BFD_ASSERT (sofar == section->size);
|
BFD_ASSERT (sofar == section->size);
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
return TRUE;
|
return TRUE;
|
|
|
case '3':
|
case '3':
|
address = HEX (data);
|
address = HEX (data);
|
data += 2;
|
data += 2;
|
--bytes;
|
--bytes;
|
/* Fall through. */
|
/* Fall through. */
|
case '2':
|
case '2':
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
--bytes;
|
--bytes;
|
/* Fall through. */
|
/* Fall through. */
|
case '1':
|
case '1':
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
bytes -= 2;
|
bytes -= 2;
|
|
|
if (address != section->vma + sofar)
|
if (address != section->vma + sofar)
|
{
|
{
|
/* We've come to the end of this section. */
|
/* We've come to the end of this section. */
|
BFD_ASSERT (sofar == section->size);
|
BFD_ASSERT (sofar == section->size);
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Don't consider checksum. */
|
/* Don't consider checksum. */
|
--bytes;
|
--bytes;
|
|
|
while (bytes-- != 0)
|
while (bytes-- != 0)
|
{
|
{
|
contents[sofar] = HEX (data);
|
contents[sofar] = HEX (data);
|
data += 2;
|
data += 2;
|
++sofar;
|
++sofar;
|
}
|
}
|
|
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (error)
|
if (error)
|
goto error_return;
|
goto error_return;
|
|
|
BFD_ASSERT (sofar == section->size);
|
BFD_ASSERT (sofar == section->size);
|
|
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
|
|
return TRUE;
|
return TRUE;
|
|
|
error_return:
|
error_return:
|
if (buf != NULL)
|
if (buf != NULL)
|
free (buf);
|
free (buf);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
/* Get the contents of a section in an S-record file. */
|
/* Get the contents of a section in an S-record file. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_get_section_contents (bfd *abfd,
|
srec_get_section_contents (bfd *abfd,
|
asection *section,
|
asection *section,
|
void * location,
|
void * location,
|
file_ptr offset,
|
file_ptr offset,
|
bfd_size_type count)
|
bfd_size_type count)
|
{
|
{
|
if (count == 0)
|
if (count == 0)
|
return TRUE;
|
return TRUE;
|
|
|
if (offset + count < count
|
if (offset + count < count
|
|| offset + count > section->size)
|
|| offset + count > section->size)
|
{
|
{
|
bfd_set_error (bfd_error_invalid_operation);
|
bfd_set_error (bfd_error_invalid_operation);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (section->used_by_bfd == NULL)
|
if (section->used_by_bfd == NULL)
|
{
|
{
|
section->used_by_bfd = bfd_alloc (abfd, section->size);
|
section->used_by_bfd = bfd_alloc (abfd, section->size);
|
if (section->used_by_bfd == NULL)
|
if (section->used_by_bfd == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
if (! srec_read_section (abfd, section,
|
if (! srec_read_section (abfd, section,
|
(bfd_byte *) section->used_by_bfd))
|
(bfd_byte *) section->used_by_bfd))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
|
memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
|
(size_t) count);
|
(size_t) count);
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Set the architecture. We accept an unknown architecture here. */
|
/* Set the architecture. We accept an unknown architecture here. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
|
srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
|
{
|
{
|
if (arch != bfd_arch_unknown)
|
if (arch != bfd_arch_unknown)
|
return bfd_default_set_arch_mach (abfd, arch, mach);
|
return bfd_default_set_arch_mach (abfd, arch, mach);
|
|
|
abfd->arch_info = & bfd_default_arch_struct;
|
abfd->arch_info = & bfd_default_arch_struct;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* We have to save up all the Srecords for a splurge before output. */
|
/* We have to save up all the Srecords for a splurge before output. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_set_section_contents (bfd *abfd,
|
srec_set_section_contents (bfd *abfd,
|
sec_ptr section,
|
sec_ptr section,
|
const void * location,
|
const void * location,
|
file_ptr offset,
|
file_ptr offset,
|
bfd_size_type bytes_to_do)
|
bfd_size_type bytes_to_do)
|
{
|
{
|
tdata_type *tdata = abfd->tdata.srec_data;
|
tdata_type *tdata = abfd->tdata.srec_data;
|
srec_data_list_type *entry;
|
srec_data_list_type *entry;
|
|
|
entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
|
entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
|
if (entry == NULL)
|
if (entry == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
if (bytes_to_do
|
if (bytes_to_do
|
&& (section->flags & SEC_ALLOC)
|
&& (section->flags & SEC_ALLOC)
|
&& (section->flags & SEC_LOAD))
|
&& (section->flags & SEC_LOAD))
|
{
|
{
|
bfd_byte *data;
|
bfd_byte *data;
|
|
|
data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
|
data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
|
if (data == NULL)
|
if (data == NULL)
|
return FALSE;
|
return FALSE;
|
memcpy ((void *) data, location, (size_t) bytes_to_do);
|
memcpy ((void *) data, location, (size_t) bytes_to_do);
|
|
|
/* Ff S3Forced is TRUE then always select S3 records,
|
/* Ff S3Forced is TRUE then always select S3 records,
|
regardless of the siez of the addresses. */
|
regardless of the siez of the addresses. */
|
if (S3Forced)
|
if (S3Forced)
|
tdata->type = 3;
|
tdata->type = 3;
|
else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
|
else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
|
; /* The default, S1, is OK. */
|
; /* The default, S1, is OK. */
|
else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
|
else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
|
&& tdata->type <= 2)
|
&& tdata->type <= 2)
|
tdata->type = 2;
|
tdata->type = 2;
|
else
|
else
|
tdata->type = 3;
|
tdata->type = 3;
|
|
|
entry->data = data;
|
entry->data = data;
|
entry->where = section->lma + offset;
|
entry->where = section->lma + offset;
|
entry->size = bytes_to_do;
|
entry->size = bytes_to_do;
|
|
|
/* Sort the records by address. Optimize for the common case of
|
/* Sort the records by address. Optimize for the common case of
|
adding a record to the end of the list. */
|
adding a record to the end of the list. */
|
if (tdata->tail != NULL
|
if (tdata->tail != NULL
|
&& entry->where >= tdata->tail->where)
|
&& entry->where >= tdata->tail->where)
|
{
|
{
|
tdata->tail->next = entry;
|
tdata->tail->next = entry;
|
entry->next = NULL;
|
entry->next = NULL;
|
tdata->tail = entry;
|
tdata->tail = entry;
|
}
|
}
|
else
|
else
|
{
|
{
|
srec_data_list_type **look;
|
srec_data_list_type **look;
|
|
|
for (look = &tdata->head;
|
for (look = &tdata->head;
|
*look != NULL && (*look)->where < entry->where;
|
*look != NULL && (*look)->where < entry->where;
|
look = &(*look)->next)
|
look = &(*look)->next)
|
;
|
;
|
entry->next = *look;
|
entry->next = *look;
|
*look = entry;
|
*look = entry;
|
if (entry->next == NULL)
|
if (entry->next == NULL)
|
tdata->tail = entry;
|
tdata->tail = entry;
|
}
|
}
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Write a record of type, of the supplied number of bytes. The
|
/* Write a record of type, of the supplied number of bytes. The
|
supplied bytes and length don't have a checksum. That's worked out
|
supplied bytes and length don't have a checksum. That's worked out
|
here. */
|
here. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_record (bfd *abfd,
|
srec_write_record (bfd *abfd,
|
unsigned int type,
|
unsigned int type,
|
bfd_vma address,
|
bfd_vma address,
|
const bfd_byte *data,
|
const bfd_byte *data,
|
const bfd_byte *end)
|
const bfd_byte *end)
|
{
|
{
|
char buffer[2 * MAXCHUNK + 6];
|
char buffer[2 * MAXCHUNK + 6];
|
unsigned int check_sum = 0;
|
unsigned int check_sum = 0;
|
const bfd_byte *src = data;
|
const bfd_byte *src = data;
|
char *dst = buffer;
|
char *dst = buffer;
|
char *length;
|
char *length;
|
bfd_size_type wrlen;
|
bfd_size_type wrlen;
|
|
|
*dst++ = 'S';
|
*dst++ = 'S';
|
*dst++ = '0' + type;
|
*dst++ = '0' + type;
|
|
|
length = dst;
|
length = dst;
|
dst += 2; /* Leave room for dst. */
|
dst += 2; /* Leave room for dst. */
|
|
|
switch (type)
|
switch (type)
|
{
|
{
|
case 3:
|
case 3:
|
case 7:
|
case 7:
|
TOHEX (dst, (address >> 24), check_sum);
|
TOHEX (dst, (address >> 24), check_sum);
|
dst += 2;
|
dst += 2;
|
case 8:
|
case 8:
|
case 2:
|
case 2:
|
TOHEX (dst, (address >> 16), check_sum);
|
TOHEX (dst, (address >> 16), check_sum);
|
dst += 2;
|
dst += 2;
|
case 9:
|
case 9:
|
case 1:
|
case 1:
|
case 0:
|
case 0:
|
TOHEX (dst, (address >> 8), check_sum);
|
TOHEX (dst, (address >> 8), check_sum);
|
dst += 2;
|
dst += 2;
|
TOHEX (dst, (address), check_sum);
|
TOHEX (dst, (address), check_sum);
|
dst += 2;
|
dst += 2;
|
break;
|
break;
|
|
|
}
|
}
|
for (src = data; src < end; src++)
|
for (src = data; src < end; src++)
|
{
|
{
|
TOHEX (dst, *src, check_sum);
|
TOHEX (dst, *src, check_sum);
|
dst += 2;
|
dst += 2;
|
}
|
}
|
|
|
/* Fill in the length. */
|
/* Fill in the length. */
|
TOHEX (length, (dst - length) / 2, check_sum);
|
TOHEX (length, (dst - length) / 2, check_sum);
|
check_sum &= 0xff;
|
check_sum &= 0xff;
|
check_sum = 255 - check_sum;
|
check_sum = 255 - check_sum;
|
TOHEX (dst, check_sum, check_sum);
|
TOHEX (dst, check_sum, check_sum);
|
dst += 2;
|
dst += 2;
|
|
|
*dst++ = '\r';
|
*dst++ = '\r';
|
*dst++ = '\n';
|
*dst++ = '\n';
|
wrlen = dst - buffer;
|
wrlen = dst - buffer;
|
|
|
return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
|
return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_header (bfd *abfd)
|
srec_write_header (bfd *abfd)
|
{
|
{
|
unsigned int len = strlen (abfd->filename);
|
unsigned int len = strlen (abfd->filename);
|
|
|
/* I'll put an arbitrary 40 char limit on header size. */
|
/* I'll put an arbitrary 40 char limit on header size. */
|
if (len > 40)
|
if (len > 40)
|
len = 40;
|
len = 40;
|
|
|
return srec_write_record (abfd, 0, (bfd_vma) 0,
|
return srec_write_record (abfd, 0, (bfd_vma) 0,
|
(bfd_byte *) abfd->filename,
|
(bfd_byte *) abfd->filename,
|
(bfd_byte *) abfd->filename + len);
|
(bfd_byte *) abfd->filename + len);
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_section (bfd *abfd,
|
srec_write_section (bfd *abfd,
|
tdata_type *tdata,
|
tdata_type *tdata,
|
srec_data_list_type *list)
|
srec_data_list_type *list)
|
{
|
{
|
unsigned int octets_written = 0;
|
unsigned int octets_written = 0;
|
bfd_byte *location = list->data;
|
bfd_byte *location = list->data;
|
|
|
/* Validate number of data bytes to write. The srec length byte
|
/* Validate number of data bytes to write. The srec length byte
|
counts the address, data and crc bytes. S1 (tdata->type == 1)
|
counts the address, data and crc bytes. S1 (tdata->type == 1)
|
records have two address bytes, S2 (tdata->type == 2) records
|
records have two address bytes, S2 (tdata->type == 2) records
|
have three, and S3 (tdata->type == 3) records have four.
|
have three, and S3 (tdata->type == 3) records have four.
|
The total length can't exceed 255, and a zero data length will
|
The total length can't exceed 255, and a zero data length will
|
spin for a long time. */
|
spin for a long time. */
|
if (Chunk == 0)
|
if (Chunk == 0)
|
Chunk = 1;
|
Chunk = 1;
|
else if (Chunk > MAXCHUNK - tdata->type - 2)
|
else if (Chunk > MAXCHUNK - tdata->type - 2)
|
Chunk = MAXCHUNK - tdata->type - 2;
|
Chunk = MAXCHUNK - tdata->type - 2;
|
|
|
while (octets_written < list->size)
|
while (octets_written < list->size)
|
{
|
{
|
bfd_vma address;
|
bfd_vma address;
|
unsigned int octets_this_chunk = list->size - octets_written;
|
unsigned int octets_this_chunk = list->size - octets_written;
|
|
|
if (octets_this_chunk > Chunk)
|
if (octets_this_chunk > Chunk)
|
octets_this_chunk = Chunk;
|
octets_this_chunk = Chunk;
|
|
|
address = list->where + octets_written / bfd_octets_per_byte (abfd);
|
address = list->where + octets_written / bfd_octets_per_byte (abfd);
|
|
|
if (! srec_write_record (abfd,
|
if (! srec_write_record (abfd,
|
tdata->type,
|
tdata->type,
|
address,
|
address,
|
location,
|
location,
|
location + octets_this_chunk))
|
location + octets_this_chunk))
|
return FALSE;
|
return FALSE;
|
|
|
octets_written += octets_this_chunk;
|
octets_written += octets_this_chunk;
|
location += octets_this_chunk;
|
location += octets_this_chunk;
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_terminator (bfd *abfd, tdata_type *tdata)
|
srec_write_terminator (bfd *abfd, tdata_type *tdata)
|
{
|
{
|
return srec_write_record (abfd, 10 - tdata->type,
|
return srec_write_record (abfd, 10 - tdata->type,
|
abfd->start_address, NULL, NULL);
|
abfd->start_address, NULL, NULL);
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_symbols (bfd *abfd)
|
srec_write_symbols (bfd *abfd)
|
{
|
{
|
/* Dump out the symbols of a bfd. */
|
/* Dump out the symbols of a bfd. */
|
int i;
|
int i;
|
int count = bfd_get_symcount (abfd);
|
int count = bfd_get_symcount (abfd);
|
|
|
if (count)
|
if (count)
|
{
|
{
|
bfd_size_type len;
|
bfd_size_type len;
|
asymbol **table = bfd_get_outsymbols (abfd);
|
asymbol **table = bfd_get_outsymbols (abfd);
|
|
|
len = strlen (abfd->filename);
|
len = strlen (abfd->filename);
|
if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
|
if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
|
|| bfd_bwrite (abfd->filename, len, abfd) != len
|
|| bfd_bwrite (abfd->filename, len, abfd) != len
|
|| bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
|
|| bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
|
return FALSE;
|
return FALSE;
|
|
|
for (i = 0; i < count; i++)
|
for (i = 0; i < count; i++)
|
{
|
{
|
asymbol *s = table[i];
|
asymbol *s = table[i];
|
if (! bfd_is_local_label (abfd, s)
|
if (! bfd_is_local_label (abfd, s)
|
&& (s->flags & BSF_DEBUGGING) == 0)
|
&& (s->flags & BSF_DEBUGGING) == 0)
|
{
|
{
|
/* Just dump out non debug symbols. */
|
/* Just dump out non debug symbols. */
|
char buf[43], *p;
|
char buf[43], *p;
|
|
|
len = strlen (s->name);
|
len = strlen (s->name);
|
if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2
|
if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2
|
|| bfd_bwrite (s->name, len, abfd) != len)
|
|| bfd_bwrite (s->name, len, abfd) != len)
|
return FALSE;
|
return FALSE;
|
|
|
sprintf_vma (buf + 2, (s->value
|
sprintf_vma (buf + 2, (s->value
|
+ s->section->output_section->lma
|
+ s->section->output_section->lma
|
+ s->section->output_offset));
|
+ s->section->output_offset));
|
p = buf + 2;
|
p = buf + 2;
|
while (p[0] == '0' && p[1] != 0)
|
while (p[0] == '0' && p[1] != 0)
|
p++;
|
p++;
|
len = strlen (p);
|
len = strlen (p);
|
p[len] = '\r';
|
p[len] = '\r';
|
p[len + 1] = '\n';
|
p[len + 1] = '\n';
|
*--p = '$';
|
*--p = '$';
|
*--p = ' ';
|
*--p = ' ';
|
len += 4;
|
len += 4;
|
if (bfd_bwrite (p, len, abfd) != len)
|
if (bfd_bwrite (p, len, abfd) != len)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
}
|
}
|
if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
|
if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
internal_srec_write_object_contents (bfd *abfd, int symbols)
|
internal_srec_write_object_contents (bfd *abfd, int symbols)
|
{
|
{
|
tdata_type *tdata = abfd->tdata.srec_data;
|
tdata_type *tdata = abfd->tdata.srec_data;
|
srec_data_list_type *list;
|
srec_data_list_type *list;
|
|
|
if (symbols)
|
if (symbols)
|
{
|
{
|
if (! srec_write_symbols (abfd))
|
if (! srec_write_symbols (abfd))
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (! srec_write_header (abfd))
|
if (! srec_write_header (abfd))
|
return FALSE;
|
return FALSE;
|
|
|
/* Now wander though all the sections provided and output them. */
|
/* Now wander though all the sections provided and output them. */
|
list = tdata->head;
|
list = tdata->head;
|
|
|
while (list != (srec_data_list_type *) NULL)
|
while (list != (srec_data_list_type *) NULL)
|
{
|
{
|
if (! srec_write_section (abfd, tdata, list))
|
if (! srec_write_section (abfd, tdata, list))
|
return FALSE;
|
return FALSE;
|
list = list->next;
|
list = list->next;
|
}
|
}
|
return srec_write_terminator (abfd, tdata);
|
return srec_write_terminator (abfd, tdata);
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
srec_write_object_contents (bfd *abfd)
|
srec_write_object_contents (bfd *abfd)
|
{
|
{
|
return internal_srec_write_object_contents (abfd, 0);
|
return internal_srec_write_object_contents (abfd, 0);
|
}
|
}
|
|
|
static bfd_boolean
|
static bfd_boolean
|
symbolsrec_write_object_contents (bfd *abfd)
|
symbolsrec_write_object_contents (bfd *abfd)
|
{
|
{
|
return internal_srec_write_object_contents (abfd, 1);
|
return internal_srec_write_object_contents (abfd, 1);
|
}
|
}
|
|
|
static int
|
static int
|
srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
|
srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
|
struct bfd_link_info *info ATTRIBUTE_UNUSED)
|
struct bfd_link_info *info ATTRIBUTE_UNUSED)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the amount of memory needed to read the symbol table. */
|
/* Return the amount of memory needed to read the symbol table. */
|
|
|
static long
|
static long
|
srec_get_symtab_upper_bound (bfd *abfd)
|
srec_get_symtab_upper_bound (bfd *abfd)
|
{
|
{
|
return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
|
return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
|
}
|
}
|
|
|
/* Return the symbol table. */
|
/* Return the symbol table. */
|
|
|
static long
|
static long
|
srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
|
srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
|
{
|
{
|
bfd_size_type symcount = bfd_get_symcount (abfd);
|
bfd_size_type symcount = bfd_get_symcount (abfd);
|
asymbol *csymbols;
|
asymbol *csymbols;
|
unsigned int i;
|
unsigned int i;
|
|
|
csymbols = abfd->tdata.srec_data->csymbols;
|
csymbols = abfd->tdata.srec_data->csymbols;
|
if (csymbols == NULL && symcount != 0)
|
if (csymbols == NULL && symcount != 0)
|
{
|
{
|
asymbol *c;
|
asymbol *c;
|
struct srec_symbol *s;
|
struct srec_symbol *s;
|
|
|
csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
|
csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
|
if (csymbols == NULL)
|
if (csymbols == NULL)
|
return -1;
|
return -1;
|
abfd->tdata.srec_data->csymbols = csymbols;
|
abfd->tdata.srec_data->csymbols = csymbols;
|
|
|
for (s = abfd->tdata.srec_data->symbols, c = csymbols;
|
for (s = abfd->tdata.srec_data->symbols, c = csymbols;
|
s != NULL;
|
s != NULL;
|
s = s->next, ++c)
|
s = s->next, ++c)
|
{
|
{
|
c->the_bfd = abfd;
|
c->the_bfd = abfd;
|
c->name = s->name;
|
c->name = s->name;
|
c->value = s->val;
|
c->value = s->val;
|
c->flags = BSF_GLOBAL;
|
c->flags = BSF_GLOBAL;
|
c->section = bfd_abs_section_ptr;
|
c->section = bfd_abs_section_ptr;
|
c->udata.p = NULL;
|
c->udata.p = NULL;
|
}
|
}
|
}
|
}
|
|
|
for (i = 0; i < symcount; i++)
|
for (i = 0; i < symcount; i++)
|
*alocation++ = csymbols++;
|
*alocation++ = csymbols++;
|
*alocation = NULL;
|
*alocation = NULL;
|
|
|
return symcount;
|
return symcount;
|
}
|
}
|
|
|
static void
|
static void
|
srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
|
srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
|
asymbol *symbol,
|
asymbol *symbol,
|
symbol_info *ret)
|
symbol_info *ret)
|
{
|
{
|
bfd_symbol_info (symbol, ret);
|
bfd_symbol_info (symbol, ret);
|
}
|
}
|
|
|
static void
|
static void
|
srec_print_symbol (bfd *abfd,
|
srec_print_symbol (bfd *abfd,
|
void * afile,
|
void * afile,
|
asymbol *symbol,
|
asymbol *symbol,
|
bfd_print_symbol_type how)
|
bfd_print_symbol_type how)
|
{
|
{
|
FILE *file = (FILE *) afile;
|
FILE *file = (FILE *) afile;
|
|
|
switch (how)
|
switch (how)
|
{
|
{
|
case bfd_print_symbol_name:
|
case bfd_print_symbol_name:
|
fprintf (file, "%s", symbol->name);
|
fprintf (file, "%s", symbol->name);
|
break;
|
break;
|
default:
|
default:
|
bfd_print_symbol_vandf (abfd, (void *) file, symbol);
|
bfd_print_symbol_vandf (abfd, (void *) file, symbol);
|
fprintf (file, " %-5s %s",
|
fprintf (file, " %-5s %s",
|
symbol->section->name,
|
symbol->section->name,
|
symbol->name);
|
symbol->name);
|
}
|
}
|
}
|
}
|
|
|
#define srec_close_and_cleanup _bfd_generic_close_and_cleanup
|
#define srec_close_and_cleanup _bfd_generic_close_and_cleanup
|
#define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
|
#define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
|
#define srec_new_section_hook _bfd_generic_new_section_hook
|
#define srec_new_section_hook _bfd_generic_new_section_hook
|
#define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
|
#define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
|
#define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
|
#define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
|
#define srec_get_lineno _bfd_nosymbols_get_lineno
|
#define srec_get_lineno _bfd_nosymbols_get_lineno
|
#define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
|
#define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
|
#define srec_find_inliner_info _bfd_nosymbols_find_inliner_info
|
#define srec_find_inliner_info _bfd_nosymbols_find_inliner_info
|
#define srec_make_empty_symbol _bfd_generic_make_empty_symbol
|
#define srec_make_empty_symbol _bfd_generic_make_empty_symbol
|
#define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
|
#define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
|
#define srec_read_minisymbols _bfd_generic_read_minisymbols
|
#define srec_read_minisymbols _bfd_generic_read_minisymbols
|
#define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
|
#define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
|
#define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
|
#define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
|
#define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
|
#define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
|
#define srec_bfd_relax_section bfd_generic_relax_section
|
#define srec_bfd_relax_section bfd_generic_relax_section
|
#define srec_bfd_gc_sections bfd_generic_gc_sections
|
#define srec_bfd_gc_sections bfd_generic_gc_sections
|
#define srec_bfd_merge_sections bfd_generic_merge_sections
|
#define srec_bfd_merge_sections bfd_generic_merge_sections
|
#define srec_bfd_is_group_section bfd_generic_is_group_section
|
#define srec_bfd_is_group_section bfd_generic_is_group_section
|
#define srec_bfd_discard_group bfd_generic_discard_group
|
#define srec_bfd_discard_group bfd_generic_discard_group
|
#define srec_section_already_linked _bfd_generic_section_already_linked
|
#define srec_section_already_linked _bfd_generic_section_already_linked
|
#define srec_bfd_define_common_symbol bfd_generic_define_common_symbol
|
#define srec_bfd_define_common_symbol bfd_generic_define_common_symbol
|
#define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
|
#define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
|
#define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
|
#define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
|
#define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
|
#define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
|
#define srec_bfd_link_just_syms _bfd_generic_link_just_syms
|
#define srec_bfd_link_just_syms _bfd_generic_link_just_syms
|
#define srec_bfd_final_link _bfd_generic_final_link
|
#define srec_bfd_final_link _bfd_generic_final_link
|
#define srec_bfd_link_split_section _bfd_generic_link_split_section
|
#define srec_bfd_link_split_section _bfd_generic_link_split_section
|
|
|
const bfd_target srec_vec =
|
const bfd_target srec_vec =
|
{
|
{
|
"srec", /* Name. */
|
"srec", /* Name. */
|
bfd_target_srec_flavour,
|
bfd_target_srec_flavour,
|
BFD_ENDIAN_UNKNOWN, /* Target byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
|
(HAS_RELOC | EXEC_P | /* Object flags. */
|
(HAS_RELOC | EXEC_P | /* Object flags. */
|
HAS_LINENO | HAS_DEBUG |
|
HAS_LINENO | HAS_DEBUG |
|
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
|
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
|
(SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
|
(SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
|
| SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
|
| SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
|
0, /* Leading underscore. */
|
0, /* Leading underscore. */
|
' ', /* AR_pad_char. */
|
' ', /* AR_pad_char. */
|
16, /* AR_max_namelen. */
|
16, /* AR_max_namelen. */
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */
|
|
|
{
|
{
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
srec_object_p, /* bfd_check_format. */
|
srec_object_p, /* bfd_check_format. */
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
},
|
},
|
{
|
{
|
bfd_false,
|
bfd_false,
|
srec_mkobject,
|
srec_mkobject,
|
_bfd_generic_mkarchive,
|
_bfd_generic_mkarchive,
|
bfd_false,
|
bfd_false,
|
},
|
},
|
{ /* bfd_write_contents. */
|
{ /* bfd_write_contents. */
|
bfd_false,
|
bfd_false,
|
srec_write_object_contents,
|
srec_write_object_contents,
|
_bfd_write_archive_contents,
|
_bfd_write_archive_contents,
|
bfd_false,
|
bfd_false,
|
},
|
},
|
|
|
BFD_JUMP_TABLE_GENERIC (srec),
|
BFD_JUMP_TABLE_GENERIC (srec),
|
BFD_JUMP_TABLE_COPY (_bfd_generic),
|
BFD_JUMP_TABLE_COPY (_bfd_generic),
|
BFD_JUMP_TABLE_CORE (_bfd_nocore),
|
BFD_JUMP_TABLE_CORE (_bfd_nocore),
|
BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
|
BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
|
BFD_JUMP_TABLE_SYMBOLS (srec),
|
BFD_JUMP_TABLE_SYMBOLS (srec),
|
BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
|
BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
|
BFD_JUMP_TABLE_WRITE (srec),
|
BFD_JUMP_TABLE_WRITE (srec),
|
BFD_JUMP_TABLE_LINK (srec),
|
BFD_JUMP_TABLE_LINK (srec),
|
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
|
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
|
|
|
NULL,
|
NULL,
|
|
|
NULL
|
NULL
|
};
|
};
|
|
|
const bfd_target symbolsrec_vec =
|
const bfd_target symbolsrec_vec =
|
{
|
{
|
"symbolsrec", /* Name. */
|
"symbolsrec", /* Name. */
|
bfd_target_srec_flavour,
|
bfd_target_srec_flavour,
|
BFD_ENDIAN_UNKNOWN, /* Target byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
|
BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
|
(HAS_RELOC | EXEC_P | /* Object flags. */
|
(HAS_RELOC | EXEC_P | /* Object flags. */
|
HAS_LINENO | HAS_DEBUG |
|
HAS_LINENO | HAS_DEBUG |
|
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
|
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
|
(SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
|
(SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
|
| SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
|
| SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
|
0, /* Leading underscore. */
|
0, /* Leading underscore. */
|
' ', /* AR_pad_char. */
|
' ', /* AR_pad_char. */
|
16, /* AR_max_namelen. */
|
16, /* AR_max_namelen. */
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
|
|
|
{
|
{
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
symbolsrec_object_p, /* bfd_check_format. */
|
symbolsrec_object_p, /* bfd_check_format. */
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
_bfd_dummy_target,
|
},
|
},
|
{
|
{
|
bfd_false,
|
bfd_false,
|
srec_mkobject,
|
srec_mkobject,
|
_bfd_generic_mkarchive,
|
_bfd_generic_mkarchive,
|
bfd_false,
|
bfd_false,
|
},
|
},
|
{ /* bfd_write_contents. */
|
{ /* bfd_write_contents. */
|
bfd_false,
|
bfd_false,
|
symbolsrec_write_object_contents,
|
symbolsrec_write_object_contents,
|
_bfd_write_archive_contents,
|
_bfd_write_archive_contents,
|
bfd_false,
|
bfd_false,
|
},
|
},
|
|
|
BFD_JUMP_TABLE_GENERIC (srec),
|
BFD_JUMP_TABLE_GENERIC (srec),
|
BFD_JUMP_TABLE_COPY (_bfd_generic),
|
BFD_JUMP_TABLE_COPY (_bfd_generic),
|
BFD_JUMP_TABLE_CORE (_bfd_nocore),
|
BFD_JUMP_TABLE_CORE (_bfd_nocore),
|
BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
|
BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
|
BFD_JUMP_TABLE_SYMBOLS (srec),
|
BFD_JUMP_TABLE_SYMBOLS (srec),
|
BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
|
BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
|
BFD_JUMP_TABLE_WRITE (srec),
|
BFD_JUMP_TABLE_WRITE (srec),
|
BFD_JUMP_TABLE_LINK (srec),
|
BFD_JUMP_TABLE_LINK (srec),
|
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
|
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
|
|
|
NULL,
|
NULL,
|
|
|
NULL
|
NULL
|
};
|
};
|
|
|
