/* BFD back-end for s-record objects.
|
/* BFD back-end for s-record objects.
|
Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
|
Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
|
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 2 of the License, or
|
the Free Software Foundation; either version 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "bfd.h"
|
#include "bfd.h"
|
#include "sysdep.h"
|
#include "sysdep.h"
|
#include "libbfd.h"
|
#include "libbfd.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include <ctype.h>
|
#include <ctype.h>
|
|
|
static void srec_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
|
static void srec_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
|
static void srec_print_symbol
|
static void srec_print_symbol
|
PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
|
PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
|
static void srec_init PARAMS ((void));
|
static void srec_init PARAMS ((void));
|
static boolean srec_mkobject PARAMS ((bfd *));
|
static boolean srec_mkobject PARAMS ((bfd *));
|
static int srec_get_byte PARAMS ((bfd *, boolean *));
|
static int srec_get_byte PARAMS ((bfd *, boolean *));
|
static void srec_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
|
static void srec_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
|
static boolean srec_scan PARAMS ((bfd *));
|
static boolean srec_scan PARAMS ((bfd *));
|
static const bfd_target *srec_object_p PARAMS ((bfd *));
|
static const bfd_target *srec_object_p PARAMS ((bfd *));
|
static const bfd_target *symbolsrec_object_p PARAMS ((bfd *));
|
static const bfd_target *symbolsrec_object_p PARAMS ((bfd *));
|
static boolean srec_read_section PARAMS ((bfd *, asection *, bfd_byte *));
|
static boolean srec_read_section PARAMS ((bfd *, asection *, bfd_byte *));
|
|
|
static boolean srec_write_record PARAMS ((bfd *, int, bfd_vma,
|
static boolean srec_write_record PARAMS ((bfd *, int, bfd_vma,
|
const bfd_byte *,
|
const bfd_byte *,
|
const bfd_byte *));
|
const bfd_byte *));
|
static boolean srec_write_header PARAMS ((bfd *));
|
static boolean srec_write_header PARAMS ((bfd *));
|
static boolean srec_write_symbols PARAMS ((bfd *));
|
static boolean srec_write_symbols PARAMS ((bfd *));
|
static boolean srec_new_symbol PARAMS ((bfd *, const char *, bfd_vma));
|
static boolean srec_new_symbol PARAMS ((bfd *, const char *, bfd_vma));
|
static boolean srec_get_section_contents
|
static boolean srec_get_section_contents
|
PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
|
PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
|
static boolean srec_set_arch_mach
|
static boolean srec_set_arch_mach
|
PARAMS ((bfd *, enum bfd_architecture, unsigned long));
|
PARAMS ((bfd *, enum bfd_architecture, unsigned long));
|
static boolean srec_set_section_contents
|
static boolean srec_set_section_contents
|
PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
|
PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
|
static boolean internal_srec_write_object_contents PARAMS ((bfd *, int));
|
static boolean internal_srec_write_object_contents PARAMS ((bfd *, int));
|
static boolean srec_write_object_contents PARAMS ((bfd *));
|
static boolean srec_write_object_contents PARAMS ((bfd *));
|
static boolean symbolsrec_write_object_contents PARAMS ((bfd *));
|
static boolean symbolsrec_write_object_contents PARAMS ((bfd *));
|
static int srec_sizeof_headers PARAMS ((bfd *, boolean));
|
static int srec_sizeof_headers PARAMS ((bfd *, boolean));
|
static asymbol *srec_make_empty_symbol PARAMS ((bfd *));
|
static asymbol *srec_make_empty_symbol PARAMS ((bfd *));
|
static long srec_get_symtab_upper_bound PARAMS ((bfd *));
|
static long srec_get_symtab_upper_bound PARAMS ((bfd *));
|
static long srec_get_symtab PARAMS ((bfd *, asymbol **));
|
static long srec_get_symtab PARAMS ((bfd *, asymbol **));
|
|
|
/* 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)
|
|
|
/* Initialize by filling in the hex conversion array. */
|
/* Initialize by filling in the hex conversion array. */
|
|
|
static void
|
static void
|
srec_init ()
|
srec_init ()
|
{
|
{
|
static boolean inited = false;
|
static boolean inited = false;
|
|
|
if (inited == false)
|
if (inited == false)
|
{
|
{
|
inited = true;
|
inited = true;
|
hex_init ();
|
hex_init ();
|
}
|
}
|
}
|
}
|
|
|
/* The maximum number of bytes on a line is FF */
|
/* The maximum number of bytes on a line is FF */
|
#define MAXCHUNK 0xff
|
#define MAXCHUNK 0xff
|
/* The number of bytes we fit onto a line on output */
|
/* The number of bytes we fit onto a line on output */
|
#define CHUNK 16
|
#define CHUNK 16
|
|
|
/* 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;
|
|
|
static boolean srec_write_section PARAMS ((bfd *, tdata_type *,
|
static boolean srec_write_section PARAMS ((bfd *, tdata_type *,
|
srec_data_list_type *));
|
srec_data_list_type *));
|
static boolean srec_write_terminator PARAMS ((bfd *, tdata_type *));
|
static boolean srec_write_terminator PARAMS ((bfd *, tdata_type *));
|
|
|
/* Set up the S-record tdata information. */
|
/* Set up the S-record tdata information. */
|
|
|
static boolean
|
static boolean
|
srec_mkobject (abfd)
|
srec_mkobject (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
srec_init ();
|
srec_init ();
|
|
|
if (abfd->tdata.srec_data == NULL)
|
if (abfd->tdata.srec_data == NULL)
|
{
|
{
|
tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
|
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 (abfd, errorptr)
|
srec_get_byte (abfd, errorptr)
|
bfd *abfd;
|
bfd *abfd;
|
boolean *errorptr;
|
boolean *errorptr;
|
{
|
{
|
bfd_byte c;
|
bfd_byte c;
|
|
|
if (bfd_read (&c, 1, 1, abfd) != 1)
|
if (bfd_read (&c, 1, 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 (abfd, lineno, c, error)
|
srec_bad_byte (abfd, lineno, c, error)
|
bfd *abfd;
|
bfd *abfd;
|
unsigned int lineno;
|
unsigned int lineno;
|
int c;
|
int c;
|
boolean error;
|
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)
|
(_("%s:%d: Unexpected character `%s' in S-record file\n"),
|
(_("%s:%d: Unexpected character `%s' in S-record file\n"),
|
bfd_get_filename (abfd), lineno, buf);
|
bfd_get_filename (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 boolean
|
static boolean
|
srec_new_symbol (abfd, name, val)
|
srec_new_symbol (abfd, name, val)
|
bfd *abfd;
|
bfd *abfd;
|
const char *name;
|
const char *name;
|
bfd_vma val;
|
bfd_vma val;
|
{
|
{
|
struct srec_symbol *n;
|
struct srec_symbol *n;
|
|
|
n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
|
n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
|
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 boolean
|
static boolean
|
srec_scan (abfd)
|
srec_scan (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
int c;
|
int c;
|
unsigned int lineno = 1;
|
unsigned int lineno = 1;
|
boolean error = false;
|
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
|
{
|
{
|
unsigned int alc;
|
unsigned int 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 ((unsigned int) (p - symbuf) >= alc)
|
if ((unsigned int) (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 = bfd_alloc (abfd, p - symbuf);
|
symname = bfd_alloc (abfd, 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 (! 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;
|
|
|
/* Starting an S-record. */
|
/* Starting an S-record. */
|
|
|
pos = bfd_tell (abfd) - 1;
|
pos = bfd_tell (abfd) - 1;
|
|
|
if (bfd_read (hdr, 1, 3, abfd) != 3)
|
if (bfd_read (hdr, 1, 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;
|
}
|
}
|
|
|
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 (bytes * 2);
|
buf = (bfd_byte *) bfd_malloc (bytes * 2);
|
if (buf == NULL)
|
if (buf == NULL)
|
goto error_return;
|
goto error_return;
|
bufsize = bytes * 2;
|
bufsize = bytes * 2;
|
}
|
}
|
|
|
if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
|
if (bfd_read (buf, 1, 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':
|
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 (sec != NULL
|
if (sec != NULL
|
&& sec->vma + sec->_raw_size == address)
|
&& sec->vma + sec->_raw_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->_raw_size += bytes;
|
sec->_raw_size += bytes;
|
}
|
}
|
else
|
else
|
{
|
{
|
char secbuf[20];
|
char secbuf[20];
|
char *secname;
|
char *secname;
|
|
|
sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
|
sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
|
secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
|
secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
|
strcpy (secname, secbuf);
|
strcpy (secname, secbuf);
|
sec = bfd_make_section (abfd, secname);
|
sec = bfd_make_section (abfd, secname);
|
if (sec == NULL)
|
if (sec == NULL)
|
goto error_return;
|
goto error_return;
|
sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
|
sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
|
sec->vma = address;
|
sec->vma = address;
|
sec->lma = address;
|
sec->lma = address;
|
sec->_raw_size = bytes;
|
sec->_raw_size = bytes;
|
sec->filepos = pos;
|
sec->filepos = pos;
|
}
|
}
|
|
|
break;
|
break;
|
|
|
case '7':
|
case '7':
|
address = HEX (data);
|
address = HEX (data);
|
data += 2;
|
data += 2;
|
/* Fall through. */
|
/* Fall through. */
|
case '8':
|
case '8':
|
address = (address << 8) | HEX (data);
|
address = (address << 8) | HEX (data);
|
data += 2;
|
data += 2;
|
/* Fall through. */
|
/* Fall through. */
|
case '9':
|
case '9':
|
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;
|
|
|
/* This is a termination record. */
|
/* This is a termination record. */
|
abfd->start_address = address;
|
abfd->start_address = address;
|
|
|
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 (abfd)
|
srec_object_p (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
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_read (b, 1, 4, abfd) != 4)
|
|| bfd_read (b, 1, 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;
|
}
|
}
|
|
|
if (! srec_mkobject (abfd)
|
if (! srec_mkobject (abfd)
|
|| ! srec_scan (abfd))
|
|| ! srec_scan (abfd))
|
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 (abfd)
|
symbolsrec_object_p (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
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_read (b, 1, 2, abfd) != 2)
|
|| bfd_read (b, 1, 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;
|
}
|
}
|
|
|
if (! srec_mkobject (abfd)
|
if (! srec_mkobject (abfd)
|
|| ! srec_scan (abfd))
|
|| ! srec_scan (abfd))
|
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 boolean
|
static boolean
|
srec_read_section (abfd, section, contents)
|
srec_read_section (abfd, section, contents)
|
bfd *abfd;
|
bfd *abfd;
|
asection *section;
|
asection *section;
|
bfd_byte *contents;
|
bfd_byte *contents;
|
{
|
{
|
int c;
|
int c;
|
bfd_size_type sofar = 0;
|
bfd_size_type sofar = 0;
|
boolean error = false;
|
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_read (hdr, 1, 3, abfd) != 3)
|
if (bfd_read (hdr, 1, 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 (bytes * 2);
|
buf = (bfd_byte *) bfd_malloc (bytes * 2);
|
if (buf == NULL)
|
if (buf == NULL)
|
goto error_return;
|
goto error_return;
|
bufsize = bytes * 2;
|
bufsize = bytes * 2;
|
}
|
}
|
|
|
if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
|
if (bfd_read (buf, 1, 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->_raw_size);
|
BFD_ASSERT (sofar == section->_raw_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->_raw_size);
|
BFD_ASSERT (sofar == section->_raw_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->_raw_size);
|
BFD_ASSERT (sofar == section->_raw_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 boolean
|
static boolean
|
srec_get_section_contents (abfd, section, location, offset, count)
|
srec_get_section_contents (abfd, section, location, offset, count)
|
bfd *abfd;
|
bfd *abfd;
|
asection *section;
|
asection *section;
|
PTR location;
|
PTR location;
|
file_ptr offset;
|
file_ptr offset;
|
bfd_size_type count;
|
bfd_size_type count;
|
{
|
{
|
if (section->used_by_bfd == NULL)
|
if (section->used_by_bfd == NULL)
|
{
|
{
|
section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
|
section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
|
if (section->used_by_bfd == NULL
|
if (section->used_by_bfd == NULL
|
&& section->_raw_size != 0)
|
&& section->_raw_size != 0)
|
return false;
|
return false;
|
|
|
if (! srec_read_section (abfd, section, section->used_by_bfd))
|
if (! srec_read_section (abfd, section, 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 boolean
|
static boolean
|
srec_set_arch_mach (abfd, arch, mach)
|
srec_set_arch_mach (abfd, arch, mach)
|
bfd *abfd;
|
bfd *abfd;
|
enum bfd_architecture arch;
|
enum bfd_architecture arch;
|
unsigned long mach;
|
unsigned long mach;
|
{
|
{
|
if (arch == bfd_arch_unknown)
|
if (arch == bfd_arch_unknown)
|
{
|
{
|
abfd->arch_info = &bfd_default_arch_struct;
|
abfd->arch_info = &bfd_default_arch_struct;
|
return true;
|
return true;
|
}
|
}
|
return bfd_default_set_arch_mach (abfd, arch, mach);
|
return bfd_default_set_arch_mach (abfd, arch, mach);
|
}
|
}
|
|
|
/* 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 boolean
|
static boolean
|
srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
|
srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
|
bfd *abfd;
|
bfd *abfd;
|
sec_ptr section;
|
sec_ptr section;
|
PTR location;
|
PTR 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;
|
register srec_data_list_type *entry;
|
register srec_data_list_type *entry;
|
|
|
entry = ((srec_data_list_type *)
|
entry = ((srec_data_list_type *)
|
bfd_alloc (abfd, sizeof (srec_data_list_type)));
|
bfd_alloc (abfd, sizeof (srec_data_list_type)));
|
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 *) bfd_alloc (abfd, bytes_to_do);
|
bfd_byte *data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
|
if (data == NULL)
|
if (data == NULL)
|
return false;
|
return false;
|
memcpy ((PTR) data, location, (size_t) bytes_to_do);
|
memcpy ((PTR) data, location, (size_t) bytes_to_do);
|
|
|
if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
|
if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
|
{
|
{
|
|
|
}
|
}
|
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
|
{
|
{
|
register srec_data_list_type **look;
|
register 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 boolean
|
static boolean
|
srec_write_record (abfd, type, address, data, end)
|
srec_write_record (abfd, type, address, data, end)
|
bfd *abfd;
|
bfd *abfd;
|
int type;
|
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[MAXCHUNK];
|
char buffer[MAXCHUNK];
|
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;
|
if (bfd_write ((PTR) buffer, 1, wrlen, abfd) != wrlen)
|
if (bfd_write ((PTR) buffer, 1, wrlen, abfd) != wrlen)
|
return false;
|
return false;
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
|
|
static boolean
|
static boolean
|
srec_write_header (abfd)
|
srec_write_header (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
bfd_byte buffer[MAXCHUNK];
|
bfd_byte buffer[MAXCHUNK];
|
bfd_byte *dst = buffer;
|
bfd_byte *dst = buffer;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* I'll put an arbitary 40 char limit on header size */
|
/* I'll put an arbitary 40 char limit on header size */
|
for (i = 0; i < 40 && abfd->filename[i]; i++)
|
for (i = 0; i < 40 && abfd->filename[i]; i++)
|
{
|
{
|
*dst++ = abfd->filename[i];
|
*dst++ = abfd->filename[i];
|
}
|
}
|
return srec_write_record (abfd, 0, 0, buffer, dst);
|
return srec_write_record (abfd, 0, 0, buffer, dst);
|
}
|
}
|
|
|
static boolean
|
static boolean
|
srec_write_section (abfd, tdata, list)
|
srec_write_section (abfd, tdata, list)
|
bfd *abfd;
|
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;
|
|
|
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 boolean
|
static boolean
|
srec_write_terminator (abfd, tdata)
|
srec_write_terminator (abfd, tdata)
|
bfd *abfd;
|
bfd *abfd;
|
tdata_type *tdata;
|
tdata_type *tdata;
|
{
|
{
|
bfd_byte buffer[2];
|
bfd_byte buffer[2];
|
|
|
return srec_write_record (abfd, 10 - tdata->type,
|
return srec_write_record (abfd, 10 - tdata->type,
|
abfd->start_address, buffer, buffer);
|
abfd->start_address, buffer, buffer);
|
}
|
}
|
|
|
|
|
|
|
static boolean
|
static boolean
|
srec_write_symbols (abfd)
|
srec_write_symbols (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
char buffer[MAXCHUNK];
|
char buffer[MAXCHUNK];
|
/* 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)
|
{
|
{
|
size_t len;
|
size_t len;
|
asymbol **table = bfd_get_outsymbols (abfd);
|
asymbol **table = bfd_get_outsymbols (abfd);
|
sprintf (buffer, "$$ %s\r\n", abfd->filename);
|
sprintf (buffer, "$$ %s\r\n", abfd->filename);
|
|
|
len = strlen (buffer);
|
len = strlen (buffer);
|
if (bfd_write (buffer, len, 1, abfd) != len)
|
if (bfd_write (buffer, len, 1, abfd) != len)
|
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 */
|
bfd_size_type l;
|
bfd_size_type l;
|
char buf2[40], *p;
|
char buf2[40], *p;
|
|
|
sprintf_vma (buf2,
|
sprintf_vma (buf2,
|
s->value + s->section->output_section->lma
|
s->value + s->section->output_section->lma
|
+ s->section->output_offset);
|
+ s->section->output_offset);
|
p = buf2;
|
p = buf2;
|
while (p[0] == '0' && p[1] != 0)
|
while (p[0] == '0' && p[1] != 0)
|
p++;
|
p++;
|
sprintf (buffer, " %s $%s\r\n", s->name, p);
|
sprintf (buffer, " %s $%s\r\n", s->name, p);
|
l = strlen (buffer);
|
l = strlen (buffer);
|
if (bfd_write (buffer, l, 1, abfd) != l)
|
if (bfd_write (buffer, l, 1, abfd) != l)
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
sprintf (buffer, "$$ \r\n");
|
sprintf (buffer, "$$ \r\n");
|
len = strlen (buffer);
|
len = strlen (buffer);
|
if (bfd_write (buffer, len, 1, abfd) != len)
|
if (bfd_write (buffer, len, 1, abfd) != len)
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
static boolean
|
static boolean
|
internal_srec_write_object_contents (abfd, symbols)
|
internal_srec_write_object_contents (abfd, symbols)
|
bfd *abfd;
|
bfd *abfd;
|
int symbols;
|
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 boolean
|
static boolean
|
srec_write_object_contents (abfd)
|
srec_write_object_contents (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
return internal_srec_write_object_contents (abfd, 0);
|
return internal_srec_write_object_contents (abfd, 0);
|
}
|
}
|
|
|
static boolean
|
static boolean
|
symbolsrec_write_object_contents (abfd)
|
symbolsrec_write_object_contents (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
return internal_srec_write_object_contents (abfd, 1);
|
return internal_srec_write_object_contents (abfd, 1);
|
}
|
}
|
|
|
/*ARGSUSED*/
|
/*ARGSUSED*/
|
static int
|
static int
|
srec_sizeof_headers (abfd, exec)
|
srec_sizeof_headers (abfd, exec)
|
bfd *abfd ATTRIBUTE_UNUSED;
|
bfd *abfd ATTRIBUTE_UNUSED;
|
boolean exec ATTRIBUTE_UNUSED;
|
boolean exec ATTRIBUTE_UNUSED;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static asymbol *
|
static asymbol *
|
srec_make_empty_symbol (abfd)
|
srec_make_empty_symbol (abfd)
|
bfd *abfd;
|
bfd *abfd;
|
{
|
{
|
asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
|
asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
|
if (new)
|
if (new)
|
new->the_bfd = abfd;
|
new->the_bfd = abfd;
|
return new;
|
return new;
|
}
|
}
|
|
|
/* 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 (abfd)
|
srec_get_symtab_upper_bound (abfd)
|
bfd *abfd;
|
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_get_symtab (abfd, alocation)
|
srec_get_symtab (abfd, alocation)
|
bfd *abfd;
|
bfd *abfd;
|
asymbol **alocation;
|
asymbol **alocation;
|
{
|
{
|
unsigned int symcount = bfd_get_symcount (abfd);
|
unsigned int 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)
|
if (csymbols == NULL)
|
{
|
{
|
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 && symcount != 0)
|
if (csymbols == NULL && symcount != 0)
|
return false;
|
return false;
|
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;
|
}
|
}
|
|
|
/*ARGSUSED*/
|
/*ARGSUSED*/
|
static void
|
static void
|
srec_get_symbol_info (ignore_abfd, symbol, ret)
|
srec_get_symbol_info (ignore_abfd, symbol, ret)
|
bfd *ignore_abfd ATTRIBUTE_UNUSED;
|
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);
|
}
|
}
|
|
|
/*ARGSUSED*/
|
/*ARGSUSED*/
|
static void
|
static void
|
srec_print_symbol (ignore_abfd, afile, symbol, how)
|
srec_print_symbol (ignore_abfd, afile, symbol, how)
|
bfd *ignore_abfd ATTRIBUTE_UNUSED;
|
bfd *ignore_abfd ATTRIBUTE_UNUSED;
|
PTR afile;
|
PTR 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 ((PTR) file, symbol);
|
bfd_print_symbol_vandf ((PTR) 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_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_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_reloc_upper_bound \
|
#define srec_get_reloc_upper_bound \
|
((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
|
((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
|
#define srec_canonicalize_reloc \
|
#define srec_canonicalize_reloc \
|
((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
|
((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
|
#define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
|
#define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
|
|
|
#define srec_get_section_contents_in_window \
|
#define srec_get_section_contents_in_window \
|
_bfd_generic_get_section_contents_in_window
|
_bfd_generic_get_section_contents_in_window
|
|
|
#define srec_bfd_get_relocated_section_contents \
|
#define srec_bfd_get_relocated_section_contents \
|
bfd_generic_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_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_add_symbols _bfd_generic_link_add_symbols
|
#define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
|
#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 (srec),
|
BFD_JUMP_TABLE_RELOCS (srec),
|
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,
|
|
|
(PTR) 0
|
(PTR) 0
|
};
|
};
|
|
|
|
|
|
|
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, /* hdrs */
|
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
|
|
|
{
|
{
|
_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 (srec),
|
BFD_JUMP_TABLE_RELOCS (srec),
|
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,
|
|
|
(PTR) 0
|
(PTR) 0
|
};
|
};
|
|
|
