/* BFD back-end for ieee-695 objects.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Written by Steve Chamberlain of Cygnus Support.
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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
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., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
+
#define KEEPMINUSPCININST 0
token (which is one byte in this lexicon) lookahead recursive decent
parser. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "ieee.h"
#include "libieee.h"
#include "safe-ctype.h"
+#include "libiberty.h"
struct output_buffer_struct
{
int buffer;
};
+static unsigned char *output_ptr_start;
+static unsigned char *output_ptr;
+static unsigned char *output_ptr_end;
+static unsigned char *input_ptr_start;
+static unsigned char *input_ptr;
+static unsigned char *input_ptr_end;
+static bfd *input_bfd;
+static bfd *output_bfd;
+static int output_buffer;
+
+
+static void block (void);
+
/* Functions for writing to ieee files in the strange way that the
standard requires. */
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%s: string too long (%d chars, max 65535)"),
bfd_get_filename (abfd), length);
bfd_set_error (bfd_error_invalid_operation);
standard requires. */
#define this_byte(ieee) *((ieee)->input_p)
-#define next_byte(ieee) ((ieee)->input_p++)
#define this_byte_and_next(ieee) (*((ieee)->input_p++))
+static bfd_boolean
+next_byte (common_header_type * ieee)
+{
+ ieee->input_p++;
+
+ return ieee->input_p < ieee->last_byte;
+}
+
static unsigned short
read_2bytes (common_header_type *ieee)
{
bfd_vma value,
asymbol *symbol,
bfd_boolean pcrel,
- unsigned int index)
+ unsigned int sindex)
{
unsigned int term_count = 0;
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%s: unrecognized symbol `%s' flags 0x%x"),
bfd_get_filename (abfd), bfd_asymbol_name (symbol),
symbol->flags);
/* Subtract the pc from here by asking for PC of this section. */
if (! ieee_write_byte (abfd, ieee_variable_P_enum)
|| ! ieee_write_byte (abfd,
- (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
+ (bfd_byte) (sindex + IEEE_SECTION_NUMBER_BASE))
|| ! ieee_write_byte (abfd, ieee_function_minus_enum))
return FALSE;
}
if (value >= 0 && value <= 127)
{
*value_ptr = value;
- next_byte (ieee);
- return TRUE;
+ return next_byte (ieee);
}
else if (value >= 0x80 && value <= 0x88)
{
unsigned int count = value & 0xf;
result = 0;
- next_byte (ieee);
+ if (! next_byte (ieee))
+ return FALSE;
while (count)
{
result = (result << 8) | this_byte_and_next (ieee);
static int
parse_i (common_header_type *ieee, bfd_boolean *ok)
{
- bfd_vma x;
+ bfd_vma x = 0;
*ok = parse_int (ieee, &x);
return x;
}
static bfd_vma
-must_parse_int (common_header_type *ieee)a
+must_parse_int (common_header_type *ieee)
{
- bfd_vma result;
+ bfd_vma result = 0;
BFD_ASSERT (parse_int (ieee, &result));
return result;
}
static ieee_symbol_index_type NOSYMBOL = {0, 0};
-static void
+static bfd_boolean
parse_expression (ieee_data_type *ieee,
bfd_vma *value,
ieee_symbol_index_type *symbol,
{
int section_n;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
*pcrel = TRUE;
section_n = must_parse_int (&(ieee->h));
+ (void) section_n;
PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
break;
}
+
case ieee_variable_L_enum:
/* L variable address of section N. */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
break;
+
case ieee_variable_R_enum:
/* R variable, logical address of section module. */
/* FIXME, this should be different to L. */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
break;
+
case ieee_variable_S_enum:
/* S variable, size in MAUS of section module. */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
PUSH (NOSYMBOL,
0,
ieee->section_table[must_parse_int (&(ieee->h))]->size);
break;
+
case ieee_variable_I_enum:
/* Push the address of variable n. */
{
ieee_symbol_index_type sy;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
sy.index = (int) must_parse_int (&(ieee->h));
sy.letter = 'I';
PUSH (sy, bfd_abs_section_ptr, 0);
}
break;
+
case ieee_variable_X_enum:
/* Push the address of external variable n. */
{
ieee_symbol_index_type sy;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+
sy.index = (int) (must_parse_int (&(ieee->h)));
sy.letter = 'X';
PUSH (sy, bfd_und_section_ptr, 0);
}
break;
+
case ieee_function_minus_enum:
{
bfd_vma value1, value2;
asection *section1, *section_dummy;
ieee_symbol_index_type sy;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
POP (sy, section1, value1);
POP (sy, section_dummy, value2);
PUSH (sy, section1 ? section1 : section_dummy, value2 - value1);
}
break;
+
case ieee_function_plus_enum:
{
bfd_vma value1, value2;
ieee_symbol_index_type sy1;
ieee_symbol_index_type sy2;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
POP (sy1, section1, value1);
POP (sy2, section2, value2);
value1 + value2);
}
break;
+
default:
{
bfd_vma va;
ieee_symbol_index_type sy1;
POP (sy1, section1, *extra);
+ (void) section1;
+ (void) sy1;
}
POP (*symbol, dummy, *value);
if (section)
*section = dummy;
-}
-
-#define ieee_seek(ieee, offset) \
- do \
- { \
- ieee->h.input_p = ieee->h.first_byte + offset; \
- ieee->h.last_byte = (ieee->h.first_byte \
- + ieee_part_after (ieee, offset)); \
- } \
- while (0)
+ return TRUE;
+}
#define ieee_pos(ieee) \
(ieee->h.input_p - ieee->h.first_byte)
return after;
}
+static bfd_boolean
+ieee_seek (ieee_data_type * ieee, file_ptr offset)
+{
+ /* PR 17512: file: 017-1157-0.004. */
+ if (offset < 0 || (bfd_size_type) offset >= ieee->h.total_amt)
+ {
+ ieee->h.input_p = ieee->h.first_byte + ieee->h.total_amt;
+ ieee->h.last_byte = ieee->h.input_p;
+ return FALSE;
+ }
+
+ ieee->h.input_p = ieee->h.first_byte + offset;
+ ieee->h.last_byte = (ieee->h.first_byte + ieee_part_after (ieee, offset));
+ return TRUE;
+}
+
static unsigned int last_index;
static char last_type; /* Is the index for an X or a D. */
last_index = 0xffffff;
ieee->symbol_table_full = TRUE;
- ieee_seek (ieee, offset);
+ if (! ieee_seek (ieee, offset))
+ return FALSE;
while (loop)
{
switch (this_byte (&(ieee->h)))
{
case ieee_nn_record:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
& prev_symbols_ptr,
symbol->symbol.udata.p = NULL;
symbol->symbol.flags = BSF_NO_FLAGS;
break;
+
case ieee_external_symbol_enum:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
&prev_symbols_ptr,
unsigned int symbol_name_index;
unsigned int symbol_type_index;
unsigned int symbol_attribute_def;
- bfd_vma value;
+ bfd_vma value = 0;
switch (read_2bytes (&ieee->h))
{
case ieee_attribute_record_enum:
symbol_name_index = must_parse_int (&(ieee->h));
symbol_type_index = must_parse_int (&(ieee->h));
+ (void) symbol_type_index;
symbol_attribute_def = must_parse_int (&(ieee->h));
switch (symbol_attribute_def)
{
parse_int (&ieee->h, &value);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: unimplemented ATI record %u for symbol %u"),
abfd, symbol_attribute_def, symbol_name_index);
bfd_set_error (bfd_error_bad_value);
parse_int (&ieee->h, &value);
if (value != 0x3f)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: unexpected ATN type %d in external part"),
abfd, (int) value);
bfd_set_error (bfd_error_bad_value);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unexpected type after ATN"), abfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
}
break;
+
case ieee_value_record_enum >> 8:
{
unsigned int symbol_name_index;
bfd_boolean pcrel_ignore;
unsigned int extra;
- next_byte (&(ieee->h));
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
symbol_name_index = must_parse_int (&(ieee->h));
- parse_expression (ieee,
- &symbol->symbol.value,
- &symbol_ignore,
- &pcrel_ignore,
- &extra,
- &symbol->symbol.section);
+ (void) symbol_name_index;
+ if (! parse_expression (ieee,
+ &symbol->symbol.value,
+ &symbol_ignore,
+ &pcrel_ignore,
+ &extra,
+ &symbol->symbol.section))
+ return FALSE;
/* Fully linked IEEE-695 files tend to give every symbol
an absolute value. Try to convert that back into a
bfd_vma size;
bfd_vma value;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+
/* Throw away the external reference index. */
(void) must_parse_int (&(ieee->h));
/* Fetch the default size if not resolved. */
break;
case ieee_external_reference_enum:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
&prev_reference_ptr,
}
static long
-ieee_get_symtab_upper_bound (abfd)
- bfd *abfd;
+ieee_get_symtab_upper_bound (bfd *abfd)
{
if (! ieee_slurp_symbol_table (abfd))
return -1;
}
static asection *
-get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int index)
+get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int sindex)
{
- if (index >= ieee->section_table_size)
+ if (sindex >= ieee->section_table_size)
{
unsigned int c, i;
asection **n;
c = ieee->section_table_size;
if (c == 0)
c = 20;
- while (c <= index)
+ while (c <= sindex)
c *= 2;
amt = c;
ieee->section_table_size = c;
}
- if (ieee->section_table[index] == (asection *) NULL)
+ if (ieee->section_table[sindex] == (asection *) NULL)
{
char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
asection *section;
if (!tmp)
return NULL;
- sprintf (tmp, " fsec%4d", index);
+ sprintf (tmp, " fsec%4d", sindex);
section = bfd_make_section (abfd, tmp);
- ieee->section_table[index] = section;
- section->flags = SEC_NO_FLAGS;
- section->target_index = index;
- ieee->section_table[index] = section;
+ ieee->section_table[sindex] = section;
+ section->target_index = sindex;
+ ieee->section_table[sindex] = section;
}
- return ieee->section_table[index];
+ return ieee->section_table[sindex];
}
-static void
+static bfd_boolean
ieee_slurp_sections (bfd *abfd)
{
ieee_data_type *ieee = IEEE_DATA (abfd);
{
bfd_byte section_type[3];
- ieee_seek (ieee, offset);
+ if (! ieee_seek (ieee, offset))
+ return FALSE;
+
while (TRUE)
{
switch (this_byte (&(ieee->h)))
asection *section;
unsigned int section_index;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section_index = must_parse_int (&(ieee->h));
section = get_section_entry (abfd, ieee, section_index);
{
/* AS Absolute section attributes. */
case 0xD3:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section_type[2] = this_byte (&(ieee->h));
switch (section_type[2])
{
case 0xD0:
/* Normal code. */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section->flags |= SEC_CODE;
break;
case 0xC4:
/* Normal data. */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section->flags |= SEC_DATA;
break;
case 0xD2:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
/* Normal rom data. */
section->flags |= SEC_ROM | SEC_DATA;
break;
switch (section_type[1])
{
case 0xD0: /* Normal code (CP). */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section->flags |= SEC_CODE;
break;
case 0xC4: /* Normal data (CD). */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section->flags |= SEC_DATA;
break;
case 0xD2: /* Normal rom data (CR). */
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section->flags |= SEC_ROM | SEC_DATA;
break;
default:
bfd_vma value;
asection *section;
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
section_index = must_parse_int (&ieee->h);
section = get_section_entry (abfd, ieee, section_index);
if (section_index > ieee->section_count)
(void) must_parse_int (&(ieee->h));
break;
default:
- return;
+ return TRUE;
}
}
break;
default:
- return;
+ return TRUE;
}
}
}
+
+ return TRUE;
}
/* Make a section for the debugging information, if any. We don't try
ieee_data_type *ieee = IEEE_DATA (abfd);
asection *sec;
file_ptr debug_end;
+ flagword flags;
if (ieee->w.r.debug_information_part == 0)
return TRUE;
- sec = bfd_make_section (abfd, ".debug");
+ flags = SEC_DEBUGGING | SEC_HAS_CONTENTS;
+ sec = bfd_make_section_with_flags (abfd, ".debug", flags);
if (sec == NULL)
return FALSE;
- sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS;
sec->filepos = ieee->w.r.debug_information_part;
debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
\f
/* Archive stuff. */
-const bfd_target *
+static const bfd_target *
ieee_archive_p (bfd *abfd)
{
char *library;
/* Ignore the return value here. It doesn't matter if we don't read
the entire buffer. We might have a very small ieee file. */
- bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
+ if (bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd) <= 0)
+ goto got_wrong_format_error;
ieee->h.first_byte = buffer;
ieee->h.input_p = buffer;
if (this_byte (&(ieee->h)) != Module_Beginning)
goto got_wrong_format_error;
- next_byte (&(ieee->h));
+ (void) next_byte (&(ieee->h));
+
library = read_id (&(ieee->h));
if (strcmp (library, "LIBRARY") != 0)
goto got_wrong_format_error;
ieee->element_count = 0;
ieee->element_index = 0;
- next_byte (&(ieee->h)); /* Drop the ad part. */
+ (void) next_byte (&(ieee->h)); /* Drop the ad part. */
must_parse_int (&(ieee->h)); /* And the two dummy numbers. */
must_parse_int (&(ieee->h));
ieee->h.first_byte = buffer;
ieee->h.input_p = buffer;
- next_byte (&(ieee->h)); /* Drop F8. */
- next_byte (&(ieee->h)); /* Drop 14. */
+ (void) next_byte (&(ieee->h)); /* Drop F8. */
+ if (! next_byte (&(ieee->h))) /* Drop 14. */
+ goto error_return;
must_parse_int (&(ieee->h)); /* Drop size of block. */
if (must_parse_int (&(ieee->h)) != 0)
return NULL;
}
-const bfd_target *
-ieee_object_p (bfd *abfd)
+static bfd_boolean
+ieee_mkobject (bfd *abfd)
{
- char *processor;
- unsigned int part;
- ieee_data_type *ieee;
- unsigned char buffer[300];
- ieee_data_type *save = IEEE_DATA (abfd);
bfd_size_type amt;
- abfd->tdata.ieee_data = 0;
- ieee_mkobject (abfd);
-
- ieee = IEEE_DATA (abfd);
- if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- goto fail;
- /* Read the first few bytes in to see if it makes sense. Ignore
- bfd_bread return value; The file might be very small. */
- bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
-
- ieee->h.input_p = buffer;
- if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
- goto got_wrong_format;
-
- ieee->read_symbols = FALSE;
- ieee->read_data = FALSE;
- ieee->section_count = 0;
- ieee->external_symbol_max_index = 0;
- ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
- ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
- ieee->external_reference_max_index = 0;
- ieee->h.abfd = abfd;
- ieee->section_table = NULL;
- ieee->section_table_size = 0;
-
- processor = ieee->mb.processor = read_id (&(ieee->h));
- if (strcmp (processor, "LIBRARY") == 0)
- goto got_wrong_format;
- ieee->mb.module_name = read_id (&(ieee->h));
- if (abfd->filename == (const char *) NULL)
- abfd->filename = ieee->mb.module_name;
-
- /* Determine the architecture and machine type of the object file. */
- {
- const bfd_arch_info_type *arch;
- char family[10];
+ output_ptr_start = NULL;
+ output_ptr = NULL;
+ output_ptr_end = NULL;
+ input_ptr_start = NULL;
+ input_ptr = NULL;
+ input_ptr_end = NULL;
+ input_bfd = NULL;
+ output_bfd = NULL;
+ output_buffer = 0;
+ amt = sizeof (ieee_data_type);
+ abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
+ return abfd->tdata.ieee_data != NULL;
+}
- /* IEEE does not specify the format of the processor identification
- string, so the compiler is free to put in it whatever it wants.
- We try here to recognize different processors belonging to the
- m68k family. Code for other processors can be added here. */
- if ((processor[0] == '6') && (processor[1] == '8'))
+static bfd_boolean
+do_one (ieee_data_type *ieee,
+ ieee_per_section_type *current_map,
+ unsigned char *location_ptr,
+ asection *s,
+ int iterations)
+{
+ switch (this_byte (&(ieee->h)))
+ {
+ case ieee_load_constant_bytes_enum:
{
- if (processor[2] == '3') /* 683xx integrated processors. */
- {
- switch (processor[3])
- {
- case '0': /* 68302, 68306, 68307 */
- case '2': /* 68322, 68328 */
- case '5': /* 68356 */
- strcpy (family, "68000"); /* MC68000-based controllers. */
- break;
-
- case '3': /* 68330, 68331, 68332, 68333,
- 68334, 68335, 68336, 68338 */
- case '6': /* 68360 */
- case '7': /* 68376 */
- strcpy (family, "68332"); /* CPU32 and CPU32+ */
- break;
+ unsigned int number_of_maus;
+ unsigned int i;
- case '4':
- if (processor[4] == '9') /* 68349 */
- strcpy (family, "68030"); /* CPU030 */
- else /* 68340, 68341 */
- strcpy (family, "68332"); /* CPU32 and CPU32+ */
- break;
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ number_of_maus = must_parse_int (&(ieee->h));
- default: /* Does not exist yet. */
- strcpy (family, "68332"); /* Guess it will be CPU32 */
- }
- }
- else if (TOUPPER (processor[3]) == 'F') /* 68F333 */
- strcpy (family, "68332"); /* CPU32 */
- else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */
- && ((TOUPPER (processor[2]) == 'E')
- || (TOUPPER (processor[2]) == 'H')
- || (TOUPPER (processor[2]) == 'L')))
- {
- strcpy (family, "68");
- strncat (family, processor + 4, 7);
- family[9] = '\0';
- }
- else /* "Regular" processors. */
+ for (i = 0; i < number_of_maus; i++)
{
- strncpy (family, processor, 9);
- family[9] = '\0';
+ location_ptr[current_map->pc++] = this_byte (&(ieee->h));
+ next_byte (&(ieee->h));
}
}
- else if ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */
- || (strncmp (processor, "CPU32", 5) == 0))
- strcpy (family, "68332");
- else
+ break;
+
+ case ieee_load_with_relocation_enum:
{
- strncpy (family, processor, 9);
- family[9] = '\0';
- }
+ bfd_boolean loop = TRUE;
- arch = bfd_scan_arch (family);
- if (arch == 0)
- goto got_wrong_format;
- abfd->arch_info = arch;
- }
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ while (loop)
+ {
+ switch (this_byte (&(ieee->h)))
+ {
+ case ieee_variable_R_enum:
- if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
- goto fail;
+ case ieee_function_signed_open_b_enum:
+ case ieee_function_unsigned_open_b_enum:
+ case ieee_function_either_open_b_enum:
+ {
+ unsigned int extra = 4;
+ bfd_boolean pcrel = FALSE;
+ asection *section;
+ ieee_reloc_type *r;
- next_byte (&(ieee->h));
+ r = bfd_alloc (ieee->h.abfd, sizeof (* r));
+ if (!r)
+ return FALSE;
- if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
- goto fail;
+ *(current_map->reloc_tail_ptr) = r;
+ current_map->reloc_tail_ptr = &r->next;
+ r->next = (ieee_reloc_type *) NULL;
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
- if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
- goto fail;
+ r->relent.sym_ptr_ptr = 0;
+ if (! parse_expression (ieee,
+ &r->relent.addend,
+ &r->symbol,
+ &pcrel, &extra, §ion))
+ return FALSE;
- /* If there is a byte order info, take it. */
- if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
- || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
- next_byte (&(ieee->h));
-
- for (part = 0; part < N_W_VARIABLES; part++)
- {
- bfd_boolean ok;
-
- if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
- goto fail;
-
- if (this_byte_and_next (&(ieee->h)) != part)
- goto fail;
-
- ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
- if (! ok)
- goto fail;
- }
-
- if (ieee->w.r.external_part != 0)
- abfd->flags = HAS_SYMS;
-
- /* By now we know that this is a real IEEE file, we're going to read
- the whole thing into memory so that we can run up and down it
- quickly. We can work out how big the file is from the trailer
- record. */
-
- amt = ieee->w.r.me_record + 1;
- IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
- if (!IEEE_DATA (abfd)->h.first_byte)
- goto fail;
- if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- goto fail;
- /* FIXME: Check return value. I'm not sure whether it needs to read
- the entire buffer or not. */
- bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
- (bfd_size_type) ieee->w.r.me_record + 1, abfd);
-
- ieee_slurp_sections (abfd);
-
- if (! ieee_slurp_debug (abfd))
- goto fail;
-
- /* Parse section data to activate file and section flags implied by
- section contents. */
- if (! ieee_slurp_section_data (abfd))
- goto fail;
-
- return abfd->xvec;
-got_wrong_format:
- bfd_set_error (bfd_error_wrong_format);
-fail:
- bfd_release (abfd, ieee);
- abfd->tdata.ieee_data = save;
- return (const bfd_target *) NULL;
-}
-
-static void
-ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
- asymbol *symbol,
- symbol_info *ret)
-{
- bfd_symbol_info (symbol, ret);
- if (symbol->name[0] == ' ')
- ret->name = "* empty table entry ";
- if (!symbol->section)
- ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
-}
-
-static void
-ieee_print_symbol (bfd *abfd,
- void * afile,
- asymbol *symbol,
- bfd_print_symbol_type how)
-{
- FILE *file = (FILE *) afile;
-
- switch (how)
- {
- case bfd_print_symbol_name:
- fprintf (file, "%s", symbol->name);
- break;
- case bfd_print_symbol_more:
- BFD_FAIL ();
- break;
- case bfd_print_symbol_all:
- {
- const char *section_name =
- (symbol->section == (asection *) NULL
- ? "*abs"
- : symbol->section->name);
-
- if (symbol->name[0] == ' ')
- fprintf (file, "* empty table entry ");
- else
- {
- bfd_print_symbol_vandf (abfd, (void *) file, symbol);
-
- fprintf (file, " %-5s %04x %02x %s",
- section_name,
- (unsigned) ieee_symbol (symbol)->index,
- (unsigned) 0,
- symbol->name);
- }
- }
- break;
- }
-}
-
-static bfd_boolean
-do_one (ieee_data_type *ieee,
- ieee_per_section_type *current_map,
- unsigned char *location_ptr,
- asection *s,
- int iterations)
-{
- switch (this_byte (&(ieee->h)))
- {
- case ieee_load_constant_bytes_enum:
- {
- unsigned int number_of_maus;
- unsigned int i;
-
- next_byte (&(ieee->h));
- number_of_maus = must_parse_int (&(ieee->h));
-
- for (i = 0; i < number_of_maus; i++)
- {
- location_ptr[current_map->pc++] = this_byte (&(ieee->h));
- next_byte (&(ieee->h));
- }
- }
- break;
-
- case ieee_load_with_relocation_enum:
- {
- bfd_boolean loop = TRUE;
-
- next_byte (&(ieee->h));
- while (loop)
- {
- switch (this_byte (&(ieee->h)))
- {
- case ieee_variable_R_enum:
-
- case ieee_function_signed_open_b_enum:
- case ieee_function_unsigned_open_b_enum:
- case ieee_function_either_open_b_enum:
- {
- unsigned int extra = 4;
- bfd_boolean pcrel = FALSE;
- asection *section;
- ieee_reloc_type *r;
- bfd_size_type amt = sizeof (ieee_reloc_type);
-
- r = bfd_alloc (ieee->h.abfd, amt);
- if (!r)
- return FALSE;
-
- *(current_map->reloc_tail_ptr) = r;
- current_map->reloc_tail_ptr = &r->next;
- r->next = (ieee_reloc_type *) NULL;
- next_byte (&(ieee->h));
-/* abort();*/
- r->relent.sym_ptr_ptr = 0;
- parse_expression (ieee,
- &r->relent.addend,
- &r->symbol,
- &pcrel, &extra, §ion);
- r->relent.address = current_map->pc;
- s->flags |= SEC_RELOC;
- s->owner->flags |= HAS_RELOC;
- s->reloc_count++;
- if (r->relent.sym_ptr_ptr == NULL && section != NULL)
- r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
+ r->relent.address = current_map->pc;
+ s->flags |= SEC_RELOC;
+ s->owner->flags |= HAS_RELOC;
+ s->reloc_count++;
+ if (r->relent.sym_ptr_ptr == NULL && section != NULL)
+ r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
if (this_byte (&(ieee->h)) == (int) ieee_comma)
{
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
/* Fetch number of bytes to pad. */
extra = must_parse_int (&(ieee->h));
};
switch (this_byte (&(ieee->h)))
{
case ieee_function_signed_close_b_enum:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
break;
case ieee_function_unsigned_close_b_enum:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
break;
case ieee_function_either_close_b_enum:
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
break;
default:
break;
for (i = 0; i < this_size; i++)
{
location_ptr[current_map->pc++] = this_byte (&(ieee->h));
- next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
}
}
else
unsigned int section_number;
ieee_per_section_type *current_map = NULL;
asection *s;
-
+
/* Seek to the start of the data area. */
if (ieee->read_data)
return TRUE;
ieee->read_data = TRUE;
- ieee_seek (ieee, ieee->w.r.data_part);
+
+ if (! ieee_seek (ieee, ieee->w.r.data_part))
+ return FALSE;
/* Allocate enough space for all the section contents. */
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
ieee_per_section_type *per = ieee_per_section (s);
+ arelent **relpp;
if ((s->flags & SEC_DEBUGGING) != 0)
continue;
per->data = bfd_alloc (ieee->h.abfd, s->size);
if (!per->data)
return FALSE;
- per->reloc_tail_ptr =
- (ieee_reloc_type **) & (s->relocation);
+ relpp = &s->relocation;
+ per->reloc_tail_ptr = (ieee_reloc_type **) relpp;
}
while (TRUE)
default:
return TRUE;
- case ieee_set_current_section_enum:
- next_byte (&(ieee->h));
- section_number = must_parse_int (&(ieee->h));
- s = ieee->section_table[section_number];
- s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
- current_map = ieee_per_section (s);
- location_ptr = current_map->data - s->vma;
- /* The document I have says that Microtec's compilers reset
- this after a sec section, even though the standard says not
- to, SO... */
- current_map->pc = s->vma;
- break;
+ case ieee_set_current_section_enum:
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ section_number = must_parse_int (&(ieee->h));
+ s = ieee->section_table[section_number];
+ s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
+ current_map = ieee_per_section (s);
+ location_ptr = current_map->data - s->vma;
+ /* The document I have says that Microtec's compilers reset
+ this after a sec section, even though the standard says not
+ to, SO... */
+ current_map->pc = s->vma;
+ break;
+
+ case ieee_e2_first_byte_enum:
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ switch (this_byte (&(ieee->h)))
+ {
+ case ieee_set_current_pc_enum & 0xff:
+ {
+ bfd_vma value;
+ ieee_symbol_index_type symbol;
+ unsigned int extra;
+ bfd_boolean pcrel;
+
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ must_parse_int (&(ieee->h)); /* Throw away section #. */
+ if (! parse_expression (ieee, &value,
+ &symbol,
+ &pcrel, &extra,
+ 0))
+ return FALSE;
+
+ current_map->pc = value;
+ BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
+ }
+ break;
+
+ case ieee_value_starting_address_enum & 0xff:
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
+ {
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ }
+ abfd->start_address = must_parse_int (&(ieee->h));
+ /* We've got to the end of the data now - */
+ return TRUE;
+ default:
+ BFD_FAIL ();
+ return FALSE;
+ }
+ break;
+ case ieee_repeat_data_enum:
+ {
+ /* Repeat the following LD or LR n times - we do this by
+ remembering the stream pointer before running it and
+ resetting it and running it n times. We special case
+ the repetition of a repeat_data/load_constant. */
+ unsigned int iterations;
+ unsigned char *start;
+
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ iterations = must_parse_int (&(ieee->h));
+ start = ieee->h.input_p;
+ if (start[0] == (int) ieee_load_constant_bytes_enum
+ && start[1] == 1)
+ {
+ while (iterations != 0)
+ {
+ location_ptr[current_map->pc++] = start[2];
+ iterations--;
+ }
+ (void) next_byte (&(ieee->h));
+ (void) next_byte (&(ieee->h));
+ if (! next_byte (&(ieee->h)))
+ return FALSE;
+ }
+ else
+ {
+ while (iterations != 0)
+ {
+ ieee->h.input_p = start;
+ if (!do_one (ieee, current_map, location_ptr, s,
+ (int) iterations))
+ return FALSE;
+ iterations--;
+ }
+ }
+ }
+ break;
+ case ieee_load_constant_bytes_enum:
+ case ieee_load_with_relocation_enum:
+ if (!do_one (ieee, current_map, location_ptr, s, 1))
+ return FALSE;
+ }
+ }
+}
+
+static const bfd_target *
+ieee_object_p (bfd *abfd)
+{
+ char *processor;
+ unsigned int part;
+ ieee_data_type *ieee;
+ unsigned char buffer[300];
+ ieee_data_type *save = IEEE_DATA (abfd);
+ bfd_size_type amt;
+
+ abfd->tdata.ieee_data = 0;
+ ieee_mkobject (abfd);
+
+ ieee = IEEE_DATA (abfd);
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+ goto fail;
+ /* Read the first few bytes in to see if it makes sense. Ignore
+ bfd_bread return value; The file might be very small. */
+ if (bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd) <= 0)
+ goto got_wrong_format;
+
+ ieee->h.input_p = buffer;
+ ieee->h.total_amt = sizeof (buffer);
+ if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
+ goto got_wrong_format;
+
+ ieee->read_symbols = FALSE;
+ ieee->read_data = FALSE;
+ ieee->section_count = 0;
+ ieee->external_symbol_max_index = 0;
+ ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
+ ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
+ ieee->external_reference_max_index = 0;
+ ieee->h.abfd = abfd;
+ ieee->section_table = NULL;
+ ieee->section_table_size = 0;
+
+ processor = ieee->mb.processor = read_id (&(ieee->h));
+ if (strcmp (processor, "LIBRARY") == 0)
+ goto got_wrong_format;
+ ieee->mb.module_name = read_id (&(ieee->h));
+ if (abfd->filename == (const char *) NULL)
+ abfd->filename = xstrdup (ieee->mb.module_name);
+
+ /* Determine the architecture and machine type of the object file. */
+ {
+ const bfd_arch_info_type *arch;
+ char family[10];
+
+ /* IEEE does not specify the format of the processor identification
+ string, so the compiler is free to put in it whatever it wants.
+ We try here to recognize different processors belonging to the
+ m68k family. Code for other processors can be added here. */
+ if ((processor[0] == '6') && (processor[1] == '8'))
+ {
+ if (processor[2] == '3') /* 683xx integrated processors. */
+ {
+ switch (processor[3])
+ {
+ case '0': /* 68302, 68306, 68307 */
+ case '2': /* 68322, 68328 */
+ case '5': /* 68356 */
+ strcpy (family, "68000"); /* MC68000-based controllers. */
+ break;
+
+ case '3': /* 68330, 68331, 68332, 68333,
+ 68334, 68335, 68336, 68338 */
+ case '6': /* 68360 */
+ case '7': /* 68376 */
+ strcpy (family, "68332"); /* CPU32 and CPU32+ */
+ break;
+
+ case '4':
+ if (processor[4] == '9') /* 68349 */
+ strcpy (family, "68030"); /* CPU030 */
+ else /* 68340, 68341 */
+ strcpy (family, "68332"); /* CPU32 and CPU32+ */
+ break;
+
+ default: /* Does not exist yet. */
+ strcpy (family, "68332"); /* Guess it will be CPU32 */
+ }
+ }
+ else if (TOUPPER (processor[3]) == 'F') /* 68F333 */
+ strcpy (family, "68332"); /* CPU32 */
+ else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */
+ && ((TOUPPER (processor[2]) == 'E')
+ || (TOUPPER (processor[2]) == 'H')
+ || (TOUPPER (processor[2]) == 'L')))
+ {
+ strcpy (family, "68");
+ strncat (family, processor + 4, 7);
+ family[9] = '\0';
+ }
+ else /* "Regular" processors. */
+ {
+ strncpy (family, processor, 9);
+ family[9] = '\0';
+ }
+ }
+ else if ((CONST_STRNEQ (processor, "cpu32")) /* CPU32 and CPU32+ */
+ || (CONST_STRNEQ (processor, "CPU32")))
+ strcpy (family, "68332");
+ else
+ {
+ strncpy (family, processor, 9);
+ family[9] = '\0';
+ }
+
+ arch = bfd_scan_arch (family);
+ if (arch == 0)
+ goto got_wrong_format;
+ abfd->arch_info = arch;
+ }
+
+ if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
+ goto fail;
+
+ if (! next_byte (&(ieee->h)))
+ goto fail;
+
+ if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
+ goto fail;
+
+ if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
+ goto fail;
+
+ /* If there is a byte order info, take it. */
+ if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
+ || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
+ {
+ if (! next_byte (&(ieee->h)))
+ goto fail;
+ }
+
+ for (part = 0; part < N_W_VARIABLES; part++)
+ {
+ bfd_boolean ok;
+
+ if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
+ goto fail;
+
+ if (this_byte_and_next (&(ieee->h)) != part)
+ goto fail;
+
+ ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
+ if (! ok)
+ goto fail;
+ }
+
+ if (ieee->w.r.external_part != 0)
+ abfd->flags = HAS_SYMS;
+
+ /* By now we know that this is a real IEEE file, we're going to read
+ the whole thing into memory so that we can run up and down it
+ quickly. We can work out how big the file is from the trailer
+ record. */
+
+ amt = ieee->w.r.me_record + 1;
+ IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
+ if (!IEEE_DATA (abfd)->h.first_byte)
+ goto fail;
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+ goto fail;
+
+ /* FIXME: Check return value. I'm not sure whether it needs to read
+ the entire buffer or not. */
+ amt = bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
+ (bfd_size_type) ieee->w.r.me_record + 1, abfd);
+ if (amt <= 0)
+ goto fail;
+
+ IEEE_DATA (abfd)->h.total_amt = amt;
+ if (ieee_slurp_sections (abfd))
+ goto fail;
+
+ if (! ieee_slurp_debug (abfd))
+ goto fail;
+
+ /* Parse section data to activate file and section flags implied by
+ section contents. */
+ if (! ieee_slurp_section_data (abfd))
+ goto fail;
+
+ return abfd->xvec;
+got_wrong_format:
+ bfd_set_error (bfd_error_wrong_format);
+fail:
+ bfd_release (abfd, ieee);
+ abfd->tdata.ieee_data = save;
+ return (const bfd_target *) NULL;
+}
+
+static void
+ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+ asymbol *symbol,
+ symbol_info *ret)
+{
+ bfd_symbol_info (symbol, ret);
+ if (symbol->name[0] == ' ')
+ ret->name = "* empty table entry ";
+ if (!symbol->section)
+ ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
+}
- case ieee_e2_first_byte_enum:
- next_byte (&(ieee->h));
- switch (this_byte (&(ieee->h)))
- {
- case ieee_set_current_pc_enum & 0xff:
- {
- bfd_vma value;
- ieee_symbol_index_type symbol;
- unsigned int extra;
- bfd_boolean pcrel;
+static void
+ieee_print_symbol (bfd *abfd,
+ void * afile,
+ asymbol *symbol,
+ bfd_print_symbol_type how)
+{
+ FILE *file = (FILE *) afile;
- next_byte (&(ieee->h));
- must_parse_int (&(ieee->h)); /* Throw away section #. */
- parse_expression (ieee, &value,
- &symbol,
- &pcrel, &extra,
- 0);
- current_map->pc = value;
- BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
- }
- break;
+ switch (how)
+ {
+ case bfd_print_symbol_name:
+ fprintf (file, "%s", symbol->name);
+ break;
+ case bfd_print_symbol_more:
+ BFD_FAIL ();
+ break;
+ case bfd_print_symbol_all:
+ {
+ const char *section_name =
+ (symbol->section == (asection *) NULL
+ ? "*abs"
+ : symbol->section->name);
- case ieee_value_starting_address_enum & 0xff:
- next_byte (&(ieee->h));
- if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
- next_byte (&(ieee->h));
- abfd->start_address = must_parse_int (&(ieee->h));
- /* We've got to the end of the data now - */
- return TRUE;
- default:
- BFD_FAIL ();
- return FALSE;
- }
- break;
- case ieee_repeat_data_enum:
+ if (symbol->name[0] == ' ')
+ fprintf (file, "* empty table entry ");
+ else
{
- /* Repeat the following LD or LR n times - we do this by
- remembering the stream pointer before running it and
- resetting it and running it n times. We special case
- the repetition of a repeat_data/load_constant. */
- unsigned int iterations;
- unsigned char *start;
+ bfd_print_symbol_vandf (abfd, (void *) file, symbol);
- next_byte (&(ieee->h));
- iterations = must_parse_int (&(ieee->h));
- start = ieee->h.input_p;
- if (start[0] == (int) ieee_load_constant_bytes_enum
- && start[1] == 1)
- {
- while (iterations != 0)
- {
- location_ptr[current_map->pc++] = start[2];
- iterations--;
- }
- next_byte (&(ieee->h));
- next_byte (&(ieee->h));
- next_byte (&(ieee->h));
- }
- else
- {
- while (iterations != 0)
- {
- ieee->h.input_p = start;
- if (!do_one (ieee, current_map, location_ptr, s,
- (int) iterations))
- return FALSE;
- iterations--;
- }
- }
+ fprintf (file, " %-5s %04x %02x %s",
+ section_name,
+ (unsigned) ieee_symbol (symbol)->index,
+ (unsigned) 0,
+ symbol->name);
}
- break;
- case ieee_load_constant_bytes_enum:
- case ieee_load_with_relocation_enum:
- if (!do_one (ieee, current_map, location_ptr, s, 1))
- return FALSE;
- }
+ }
+ break;
}
}
static bfd_boolean
ieee_new_section_hook (bfd *abfd, asection *newsect)
{
- newsect->used_by_bfd = bfd_alloc (abfd, (bfd_size_type) sizeof (ieee_per_section_type));
if (!newsect->used_by_bfd)
- return FALSE;
+ {
+ newsect->used_by_bfd = bfd_alloc (abfd, sizeof (ieee_per_section_type));
+ if (!newsect->used_by_bfd)
+ return FALSE;
+ }
ieee_per_section (newsect)->data = NULL;
ieee_per_section (newsect)->section = newsect;
- return TRUE;
+ return _bfd_generic_new_section_hook (abfd, newsect);
}
static long
return TRUE;
}
-
-static unsigned char *output_ptr_start;
-static unsigned char *output_ptr;
-static unsigned char *output_ptr_end;
-static unsigned char *input_ptr_start;
-static unsigned char *input_ptr;
-static unsigned char *input_ptr_end;
-static bfd *input_bfd;
-static bfd *output_bfd;
-static int output_buffer;
-
-static bfd_boolean
-ieee_mkobject (bfd *abfd)
-{
- bfd_size_type amt;
-
- output_ptr_start = NULL;
- output_ptr = NULL;
- output_ptr_end = NULL;
- input_ptr_start = NULL;
- input_ptr = NULL;
- input_ptr_end = NULL;
- input_bfd = NULL;
- output_bfd = NULL;
- output_buffer = 0;
- amt = sizeof (ieee_data_type);
- abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
- return abfd->tdata.ieee_data != NULL;
-}
-
static void
fill (void)
{
{
case 4:
OUT (value >> 24);
+ /* Fall through. */
case 3:
OUT (value >> 16);
+ /* Fall through. */
case 2:
OUT (value >> 8);
+ /* Fall through. */
case 1:
OUT (value);
}
}
static void
-copy_id ()
+copy_id (void)
{
int length = THIS ();
char ch;
#define VAR(x) ((x | 0x80))
static void
-copy_expression ()
+copy_expression (void)
{
int stack[10];
int *tos = stack;
will overwrite later. */
static void
-fill_int (buf)
- struct output_buffer_struct *buf;
+fill_int (struct output_buffer_struct *buf)
{
if (buf->buffer == output_buffer)
{
}
static void
-drop_int (buf)
- struct output_buffer_struct *buf;
+drop_int (struct output_buffer_struct *buf)
{
int type = THIS ();
int ch;
case 0x84:
ch = THIS ();
NEXT ();
+ /* Fall through. */
case 0x83:
ch = THIS ();
NEXT ();
+ /* Fall through. */
case 0x82:
ch = THIS ();
NEXT ();
+ /* Fall through. */
case 0x81:
ch = THIS ();
NEXT ();
+ /* Fall through. */
case 0x80:
break;
}
}
+ (void) ch;
OUT (0x84);
buf->ptrp = output_ptr;
buf->buffer = output_buffer;
}
static void
-copy_int ()
+copy_int (void)
{
int type = THIS ();
int ch;
ch = THIS ();
NEXT ();
OUT (ch);
+ /* Fall through. */
case 0x83:
ch = THIS ();
NEXT ();
OUT (ch);
+ /* Fall through. */
case 0x82:
ch = THIS ();
NEXT ();
OUT (ch);
+ /* Fall through. */
case 0x81:
ch = THIS ();
NEXT ();
OUT (ch);
+ /* Fall through. */
case 0x80:
break;
}
}
}
-#define ID copy_id()
-#define INT copy_int()
-#define EXP copy_expression()
-#define INTn(q) copy_int()
-#define EXPn(q) copy_expression()
+#define ID copy_id ()
+#define INT copy_int ()
+#define EXP copy_expression ()
+#define INTn(q) copy_int ()
+#define EXPn(q) copy_expression ()
+
+static void
+copy_till_end (void)
+{
+ int ch = THIS ();
+
+ while (1)
+ {
+ while (ch <= 0x80)
+ {
+ OUT (ch);
+ NEXT ();
+ ch = THIS ();
+ }
+ switch (ch)
+ {
+ case 0x84:
+ OUT (THIS ());
+ NEXT ();
+ /* Fall through. */
+ case 0x83:
+ OUT (THIS ());
+ NEXT ();
+ /* Fall through. */
+ case 0x82:
+ OUT (THIS ());
+ NEXT ();
+ /* Fall through. */
+ case 0x81:
+ OUT (THIS ());
+ NEXT ();
+ OUT (THIS ());
+ NEXT ();
+
+ ch = THIS ();
+ break;
+ default:
+ return;
+ }
+ }
+
+}
static void
-f1_record ()
+f1_record (void)
{
int ch;
}
static void
-f0_record ()
+f0_record (void)
{
/* Attribute record. */
NEXT ();
}
static void
-copy_till_end ()
-{
- int ch = THIS ();
-
- while (1)
- {
- while (ch <= 0x80)
- {
- OUT (ch);
- NEXT ();
- ch = THIS ();
- }
- switch (ch)
- {
- case 0x84:
- OUT (THIS ());
- NEXT ();
- case 0x83:
- OUT (THIS ());
- NEXT ();
- case 0x82:
- OUT (THIS ());
- NEXT ();
- case 0x81:
- OUT (THIS ());
- NEXT ();
- OUT (THIS ());
- NEXT ();
-
- ch = THIS ();
- break;
- default:
- return;
- }
- }
-
-}
-
-static void
-f2_record ()
+f2_record (void)
{
NEXT ();
OUT (0xf2);
copy_till_end ();
}
-
static void
-f8_record ()
+f8_record (void)
{
int ch;
NEXT ();
}
static void
-e2_record ()
+e2_record (void)
{
OUT (0xe2);
NEXT ();
}
static void
-block ()
+block (void)
{
int ch;
}
}
-
/* Moves all the debug information from the source bfd to the output
bfd, and relocates any expressions it finds. */
static void
-relocate_debug (output, input)
- bfd *output ATTRIBUTE_UNUSED;
- bfd *input;
+relocate_debug (bfd *output ATTRIBUTE_UNUSED,
+ bfd *input)
{
#define IBS 400
#define OBS 400
one place, relocating it and emitting it as we go. */
static bfd_boolean
-ieee_write_debug_part (abfd)
- bfd *abfd;
+ieee_write_debug_part (bfd *abfd)
{
ieee_data_type *ieee = IEEE_DATA (abfd);
bfd_chain_type *chain = ieee->chain_root;
/* Write the data in an ieee way. */
static bfd_boolean
-ieee_write_data_part (abfd)
- bfd *abfd;
+ieee_write_data_part (bfd *abfd)
{
asection *s;
return TRUE;
}
-
static bfd_boolean
-init_for_output (abfd)
- bfd *abfd;
+init_for_output (bfd *abfd)
{
asection *s;
not a byte image, but a record stream. */
static bfd_boolean
-ieee_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- sec_ptr section;
- const void * location;
- file_ptr offset;
- bfd_size_type count;
+ieee_set_section_contents (bfd *abfd,
+ sec_ptr section,
+ const void * location,
+ file_ptr offset,
+ bfd_size_type count)
{
if ((section->flags & SEC_DEBUGGING) != 0)
{
symbol values into indexes from the right base. */
static bfd_boolean
-ieee_write_external_part (abfd)
- bfd *abfd;
+ieee_write_external_part (bfd *abfd)
{
asymbol **q;
ieee_data_type *ieee = IEEE_DATA (abfd);
};
static bfd_boolean
-ieee_write_me_part (abfd)
- bfd *abfd;
+ieee_write_me_part (bfd *abfd)
{
ieee_data_type *ieee = IEEE_DATA (abfd);
ieee->w.r.trailer_part = bfd_tell (abfd);
/* Write out the IEEE processor ID. */
static bfd_boolean
-ieee_write_processor (abfd)
- bfd *abfd;
+ieee_write_processor (bfd *abfd)
{
const bfd_arch_info_type *arch;
return FALSE;
break;
- case bfd_arch_a29k:
- if (! ieee_write_id (abfd, "29000"))
- return FALSE;
- break;
-
case bfd_arch_h8300:
if (! ieee_write_id (abfd, "H8/300"))
return FALSE;
case bfd_mach_m68040: id = "68040"; break;
case bfd_mach_m68060: id = "68060"; break;
case bfd_mach_cpu32: id = "cpu32"; break;
- case bfd_mach_mcf5200:id = "5200"; break;
- case bfd_mach_mcf5206e:id = "5206e"; break;
- case bfd_mach_mcf5307:id = "5307"; break;
- case bfd_mach_mcf5407:id = "5407"; break;
- case bfd_mach_mcf528x:id = "5282"; break;
+ case bfd_mach_mcf_isa_a_nodiv: id = "isa-a:nodiv"; break;
+ case bfd_mach_mcf_isa_a: id = "isa-a"; break;
+ case bfd_mach_mcf_isa_a_mac: id = "isa-a:mac"; break;
+ case bfd_mach_mcf_isa_a_emac: id = "isa-a:emac"; break;
+ case bfd_mach_mcf_isa_aplus: id = "isa-aplus"; break;
+ case bfd_mach_mcf_isa_aplus_mac: id = "isa-aplus:mac"; break;
+ case bfd_mach_mcf_isa_aplus_emac: id = "isa-aplus:mac"; break;
+ case bfd_mach_mcf_isa_b_nousp: id = "isa-b:nousp"; break;
+ case bfd_mach_mcf_isa_b_nousp_mac: id = "isa-b:nousp:mac"; break;
+ case bfd_mach_mcf_isa_b_nousp_emac: id = "isa-b:nousp:emac"; break;
+ case bfd_mach_mcf_isa_b: id = "isa-b"; break;
+ case bfd_mach_mcf_isa_b_mac: id = "isa-b:mac"; break;
+ case bfd_mach_mcf_isa_b_emac: id = "isa-b:emac"; break;
+ case bfd_mach_mcf_isa_b_float: id = "isa-b:float"; break;
+ case bfd_mach_mcf_isa_b_float_mac: id = "isa-b:float:mac"; break;
+ case bfd_mach_mcf_isa_b_float_emac: id = "isa-b:float:emac"; break;
+ case bfd_mach_mcf_isa_c: id = "isa-c"; break;
+ case bfd_mach_mcf_isa_c_mac: id = "isa-c:mac"; break;
+ case bfd_mach_mcf_isa_c_emac: id = "isa-c:emac"; break;
+ case bfd_mach_mcf_isa_c_nodiv: id = "isa-c:nodiv"; break;
+ case bfd_mach_mcf_isa_c_nodiv_mac: id = "isa-c:nodiv:mac"; break;
+ case bfd_mach_mcf_isa_c_nodiv_emac: id = "isa-c:nodiv:emac"; break;
}
if (! ieee_write_id (abfd, id))
}
static bfd_boolean
-ieee_write_object_contents (abfd)
- bfd *abfd;
+ieee_write_object_contents (bfd *abfd)
{
ieee_data_type *ieee = IEEE_DATA (abfd);
unsigned int i;
hold them all plus all the cached symbol entries. */
static asymbol *
-ieee_make_empty_symbol (abfd)
- bfd *abfd;
+ieee_make_empty_symbol (bfd *abfd)
{
bfd_size_type amt = sizeof (ieee_symbol_type);
- ieee_symbol_type *new = bfd_zalloc (abfd, amt);
+ ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
- if (!new)
+ if (!new_symbol)
return NULL;
- new->symbol.the_bfd = abfd;
- return &new->symbol;
+ new_symbol->symbol.the_bfd = abfd;
+ return &new_symbol->symbol;
}
static bfd *
-ieee_openr_next_archived_file (arch, prev)
- bfd *arch;
- bfd *prev;
+ieee_openr_next_archived_file (bfd *arch, bfd *prev)
{
ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
else
{
bfd_set_error (bfd_error_no_more_archived_files);
- return (bfd *) NULL;
+ return NULL;
}
}
}
-static bfd_boolean
-ieee_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
- functionname_ptr, line_ptr)
- bfd *abfd ATTRIBUTE_UNUSED;
- asection *section ATTRIBUTE_UNUSED;
- asymbol **symbols ATTRIBUTE_UNUSED;
- bfd_vma offset ATTRIBUTE_UNUSED;
- const char **filename_ptr ATTRIBUTE_UNUSED;
- const char **functionname_ptr ATTRIBUTE_UNUSED;
- unsigned int *line_ptr ATTRIBUTE_UNUSED;
-{
- return FALSE;
-}
+#define ieee_find_nearest_line _bfd_nosymbols_find_nearest_line
+#define ieee_find_line _bfd_nosymbols_find_line
+#define ieee_find_inliner_info _bfd_nosymbols_find_inliner_info
static int
-ieee_generic_stat_arch_elt (abfd, buf)
- bfd *abfd;
- struct stat *buf;
+ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
{
ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
ieee_data_type *ieee;
}
static int
-ieee_sizeof_headers (abfd, x)
- bfd *abfd ATTRIBUTE_UNUSED;
- bfd_boolean x ATTRIBUTE_UNUSED;
+ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
return 0;
}
#define ieee_slurp_extended_name_table bfd_true
#define ieee_construct_extended_name_table \
((bfd_boolean (*) \
- PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
+ (bfd *, char **, bfd_size_type *, const char **)) \
bfd_true)
#define ieee_truncate_arname bfd_dont_truncate_arname
#define ieee_write_armap \
((bfd_boolean (*) \
- PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
+ (bfd *, unsigned int, struct orl *, unsigned int, int)) \
bfd_true)
#define ieee_read_ar_hdr bfd_nullvoidptr
+#define ieee_write_ar_hdr ((bfd_boolean (*) (bfd *, bfd *)) bfd_false)
#define ieee_update_armap_timestamp bfd_true
#define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
+#define ieee_get_symbol_version_string \
+ _bfd_nosymbols_get_symbol_version_string
#define ieee_bfd_is_target_special_symbol \
((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
#define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
#define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
+#define ieee_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
#define ieee_set_arch_mach _bfd_generic_set_arch_mach
bfd_generic_get_relocated_section_contents
#define ieee_bfd_relax_section bfd_generic_relax_section
#define ieee_bfd_gc_sections bfd_generic_gc_sections
+#define ieee_bfd_lookup_section_flags bfd_generic_lookup_section_flags
#define ieee_bfd_merge_sections bfd_generic_merge_sections
#define ieee_bfd_is_group_section bfd_generic_is_group_section
#define ieee_bfd_discard_group bfd_generic_discard_group
#define ieee_section_already_linked \
_bfd_generic_section_already_linked
+#define ieee_bfd_define_common_symbol bfd_generic_define_common_symbol
#define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
-#define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
#define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
#define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
+#define ieee_bfd_copy_link_hash_symbol_type \
+ _bfd_generic_copy_link_hash_symbol_type
#define ieee_bfd_final_link _bfd_generic_final_link
#define ieee_bfd_link_split_section _bfd_generic_link_split_section
+#define ieee_bfd_link_check_relocs _bfd_generic_link_check_relocs
const bfd_target ieee_vec =
{
- "ieee", /* name */
+ "ieee", /* Name. */
bfd_target_ieee_flavour,
- BFD_ENDIAN_UNKNOWN, /* target byte order */
- BFD_ENDIAN_UNKNOWN, /* target headers byte order */
- (HAS_RELOC | EXEC_P | /* object flags */
+ BFD_ENDIAN_UNKNOWN, /* Target byte order. */
+ BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
+ (HAS_RELOC | EXEC_P | /* Object flags. */
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
(SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
- | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
- '_', /* leading underscore */
- ' ', /* ar_pad_char */
- 16, /* ar_max_namelen */
+ | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
+ '_', /* Leading underscore. */
+ ' ', /* AR_pad_char. */
+ 16, /* AR_max_namelen. */
+ 0, /* match priority. */
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
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_getb32, bfd_getb_signed_32, bfd_putb32,
- bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
+ bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
{_bfd_dummy_target,
- ieee_object_p, /* bfd_check_format */
+ ieee_object_p, /* bfd_check_format. */
ieee_archive_p,
_bfd_dummy_target,
},
/* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
- _bfd_generic_link_hash_table_free,
ieee_bfd_link_add_symbols, ieee_bfd_final_link,
ieee_bfd_link_split_section, ieee_bfd_gc_sections,
ieee_bfd_merge_sections. */
NULL,
- (void *) 0
+ NULL
};
projects / deliverable / binutils-gdb.git / blobdiff