/* BFD back-end for ieee-695 objects.
- Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
+ Copyright (C) 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
Written by Steve Chamberlain of Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
#include "libbfd.h"
#include "ieee.h"
#include "libieee.h"
-#include "obstack.h"
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
+
+static boolean ieee_write_byte PARAMS ((bfd *, bfd_byte));
+static boolean ieee_write_2bytes PARAMS ((bfd *, int));
+static boolean ieee_write_int PARAMS ((bfd *, bfd_vma));
+static boolean ieee_write_id PARAMS ((bfd *, const char *));
+static boolean ieee_write_expression
+ PARAMS ((bfd *, bfd_vma, asymbol *, boolean, unsigned int));
+static void ieee_write_int5 PARAMS ((bfd_byte *, bfd_vma));
+static boolean ieee_write_int5_out PARAMS ((bfd *, bfd_vma));
+static boolean ieee_write_section_part PARAMS ((bfd *));
+static boolean do_with_relocs PARAMS ((bfd *, asection *));
+static boolean do_as_repeat PARAMS ((bfd *, asection *));
+static boolean do_without_relocs PARAMS ((bfd *, asection *));
+static boolean ieee_write_external_part PARAMS ((bfd *));
+static boolean ieee_write_data_part PARAMS ((bfd *));
+static boolean ieee_write_debug_part PARAMS ((bfd *));
+static boolean ieee_write_me_part PARAMS ((bfd *));
+
+static boolean ieee_slurp_debug PARAMS ((bfd *));
/* Functions for writing to ieee files in the strange way that the
standard requires. */
-static void
+static boolean
ieee_write_byte (abfd, byte)
bfd *abfd;
bfd_byte byte;
{
- if (bfd_write ((PTR) & byte, 1, 1, abfd) != 1)
- abort ();
-}
-
-static void
-ieee_write_twobyte (abfd, twobyte)
- bfd *abfd;
- int twobyte;
-{
- bfd_byte b[2];
- b[1] = twobyte & 0xff;
- b[0] = twobyte >> 8;
- if (bfd_write ((PTR) & b[0], 1, 2, abfd) != 2)
- abort ();
+ if (bfd_write ((PTR) &byte, 1, 1, abfd) != 1)
+ return false;
+ return true;
}
-static void
+static boolean
ieee_write_2bytes (abfd, bytes)
bfd *abfd;
int bytes;
{
bfd_byte buffer[2];
+
buffer[0] = bytes >> 8;
buffer[1] = bytes & 0xff;
-
if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2)
- abort ();
+ return false;
+ return true;
}
-static void
+static boolean
ieee_write_int (abfd, value)
bfd *abfd;
bfd_vma value;
{
- if (((unsigned) value) <= 127)
+ if (value <= 127)
{
- ieee_write_byte (abfd, (bfd_byte) value);
+ if (! ieee_write_byte (abfd, (bfd_byte) value))
+ return false;
}
else
{
unsigned int length;
+
/* How many significant bytes ? */
/* FIXME FOR LONGER INTS */
if (value & 0xff000000)
- {
- length = 4;
- }
+ length = 4;
else if (value & 0x00ff0000)
- {
- length = 3;
- }
+ length = 3;
else if (value & 0x0000ff00)
- {
- length = 2;
- }
+ length = 2;
else
length = 1;
- ieee_write_byte (abfd,
- (bfd_byte) ((int) ieee_number_repeat_start_enum + length));
+ if (! ieee_write_byte (abfd,
+ (bfd_byte) ((int) ieee_number_repeat_start_enum
+ + length)))
+ return false;
switch (length)
{
case 4:
- ieee_write_byte (abfd, (bfd_byte) (value >> 24));
+ if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
+ return false;
+ /* Fall through. */
case 3:
- ieee_write_byte (abfd, (bfd_byte) (value >> 16));
+ if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
+ return false;
+ /* Fall through. */
case 2:
- ieee_write_byte (abfd, (bfd_byte) (value >> 8));
+ if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
+ return false;
+ /* Fall through. */
case 1:
- ieee_write_byte (abfd, (bfd_byte) (value));
+ if (! ieee_write_byte (abfd, (bfd_byte) (value)))
+ return false;
}
}
+
+ return true;
}
-static void
+static boolean
ieee_write_id (abfd, id)
bfd *abfd;
- CONST char *id;
+ const char *id;
{
size_t length = strlen (id);
+
if (length <= 127)
{
- ieee_write_byte (abfd, (bfd_byte) length);
+ if (! ieee_write_byte (abfd, (bfd_byte) length))
+ return false;
}
else if (length < 255)
{
- ieee_write_byte (abfd, ieee_extension_length_1_enum);
- ieee_write_byte (abfd, (bfd_byte) length);
+ if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
+ || ! ieee_write_byte (abfd, (bfd_byte) length))
+ return false;
}
else if (length < 65535)
{
- ieee_write_byte (abfd, ieee_extension_length_2_enum);
- ieee_write_byte (abfd, (bfd_byte) (length >> 8));
- ieee_write_byte (abfd, (bfd_byte) (length & 0xff));
+ if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
+ || ! ieee_write_2bytes (abfd, (int) length))
+ return false;
}
else
{
- BFD_FAIL ();
+ (*_bfd_error_handler)
+ ("%s: string too long (%d chars, max 65535)",
+ bfd_get_filename (abfd), length);
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
}
+
if (bfd_write ((PTR) id, 1, length, abfd) != length)
- abort ();
+ return false;
+ return true;
}
\f
-
/***************************************************************************
Functions for reading from ieee files in the strange way that the
standard requires:
/* Buy memory and read string */
string = bfd_alloc (ieee->abfd, length + 1);
if (!string)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
bfd_get_string (ieee, string, length);
string[length] = 0;
return string;
}
-static void
+static boolean
ieee_write_expression (abfd, value, symbol, pcrel, index)
bfd *abfd;
bfd_vma value;
if (value != 0)
{
- ieee_write_int (abfd, value);
+ if (! ieee_write_int (abfd, value))
+ return false;
term_count++;
}
|| bfd_is_und_section (symbol->section))
{
/* Def of a common symbol */
- ieee_write_byte (abfd, ieee_variable_X_enum);
- ieee_write_int (abfd, symbol->value);
+ if (! ieee_write_byte (abfd, ieee_variable_X_enum)
+ || ! ieee_write_int (abfd, symbol->value))
+ return false;
term_count++;
}
else if (! bfd_is_abs_section (symbol->section))
{
/* Ref to defined symbol - */
- ieee_write_byte (abfd, ieee_variable_R_enum);
- ieee_write_byte (abfd,
- (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE));
+ if (! ieee_write_byte (abfd, ieee_variable_R_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (symbol->section->index
+ + IEEE_SECTION_NUMBER_BASE)))
+ return false;
term_count++;
if (symbol->flags & BSF_GLOBAL)
{
- ieee_write_byte (abfd, ieee_variable_I_enum);
- ieee_write_int (abfd, symbol->value);
+ if (! ieee_write_byte (abfd, ieee_variable_I_enum)
+ || ! ieee_write_int (abfd, symbol->value))
+ return false;
term_count++;
}
else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
{
- /* This is a reference to a defined local symbol,
- We can easily do a local as a section+offset */
- ieee_write_byte (abfd, ieee_variable_R_enum); /* or L */
- ieee_write_byte (abfd,
- (bfd_byte) (symbol->section->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_int (abfd, symbol->value);
+ /* This is a reference to a defined local symbol. We can
+ easily do a local as a section+offset. */
+ if (! ieee_write_int (abfd, symbol->value))
+ return false;
term_count++;
}
else
{
- BFD_FAIL ();
+ (*_bfd_error_handler)
+ ("%s: unrecognized symbol `%s' flags 0x%x",
+ bfd_get_filename (abfd), bfd_asymbol_name (symbol),
+ symbol->flags);
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
}
}
if (pcrel)
{
/* subtract the pc from here by asking for PC of this section*/
- ieee_write_byte (abfd, ieee_variable_P_enum);
- ieee_write_byte (abfd, (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_byte (abfd, ieee_function_minus_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_P_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_byte (abfd, ieee_function_minus_enum))
+ return false;
}
- if (term_count == 1)
- {
- ieee_write_byte (abfd, 0);
- }
- else
+ while (term_count > 1)
{
- while (term_count > 1)
- {
- ieee_write_byte (abfd, ieee_function_plus_enum);
- term_count--;
- }
+ if (! ieee_write_byte (abfd, ieee_function_plus_enum))
+ return false;
+ term_count--;
}
+
+ return true;
}
\f
-
/*****************************************************************************/
/*
buffer[4] = (value >> 0) & 0xff;
}
-static void
+static boolean
ieee_write_int5_out (abfd, value)
bfd *abfd;
bfd_vma value;
{
bfd_byte b[5];
+
ieee_write_int5 (b, value);
if (bfd_write ((PTR) b, 1, 5, abfd) != 5)
- abort ();
+ return false;
+ return true;
}
static boolean
} ieee_value_type;
-static
-reloc_howto_type abs32_howto
-= HOWTO (1, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false);
-static
-reloc_howto_type abs16_howto
-= HOWTO (1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false);
-
-static
-reloc_howto_type abs8_howto
-= HOWTO (1, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "abs8", true, 0x000000ff, 0x000000ff, false);
-
-static
-reloc_howto_type rel32_howto
-= HOWTO (1, 0, 2, 32, true, 0, complain_overflow_signed, 0, "rel32", true, 0xffffffff,
- 0xffffffff, false);
-
-static
-reloc_howto_type rel16_howto
-= HOWTO (1, 0, 1, 16, true, 0, complain_overflow_signed, 0, "rel16", true, 0x0000ffff, 0x0000ffff, false);
-
-static
-reloc_howto_type rel8_howto
-= HOWTO (1, 0, 0, 8, true, 0, complain_overflow_signed, 0, "rel8", true, 0x000000ff, 0x000000ff, false);
-
-
-static ieee_symbol_index_type NOSYMBOL =
-{0, 0};
-
+static reloc_howto_type abs32_howto =
+ HOWTO (1,
+ 0,
+ 2,
+ 32,
+ false,
+ 0,
+ complain_overflow_bitfield,
+ 0,
+ "abs32",
+ true,
+ 0xffffffff,
+ 0xffffffff,
+ false);
+
+static reloc_howto_type abs16_howto =
+ HOWTO (1,
+ 0,
+ 1,
+ 16,
+ false,
+ 0,
+ complain_overflow_bitfield,
+ 0,
+ "abs16",
+ true,
+ 0x0000ffff,
+ 0x0000ffff,
+ false);
+
+static reloc_howto_type abs8_howto =
+ HOWTO (1,
+ 0,
+ 0,
+ 8,
+ false,
+ 0,
+ complain_overflow_bitfield,
+ 0,
+ "abs8",
+ true,
+ 0x000000ff,
+ 0x000000ff,
+ false);
+
+static reloc_howto_type rel32_howto =
+ HOWTO (1,
+ 0,
+ 2,
+ 32,
+ true,
+ 0,
+ complain_overflow_signed,
+ 0,
+ "rel32",
+ true,
+ 0xffffffff,
+ 0xffffffff,
+ false);
+
+static reloc_howto_type rel16_howto =
+ HOWTO (1,
+ 0,
+ 1,
+ 16,
+ true,
+ 0,
+ complain_overflow_signed,
+ 0,
+ "rel16",
+ true,
+ 0x0000ffff,
+ 0x0000ffff,
+ false);
+
+static reloc_howto_type rel8_howto =
+ HOWTO (1,
+ 0,
+ 0,
+ 8,
+ true,
+ 0,
+ complain_overflow_signed,
+ 0,
+ "rel8",
+ true,
+ 0x000000ff,
+ 0x000000ff,
+ false);
+
+static ieee_symbol_index_type NOSYMBOL = {0, 0};
static void
parse_expression (ieee, value, symbol, pcrel, extra, section)
ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd,
sizeof (ieee_symbol_type));
if (!new_symbol)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
new_symbol->index = new_index;
last_index = new_index;
asection *section;
if (!tmp)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
sprintf (tmp, " fsec%4d", index);
section = bfd_make_section (abfd, tmp);
ieee->section_table[index] = section;
case ieee_region_base_address_enum:
section = ieee->section_table[must_parse_int (&(ieee->h))];
section->vma = must_parse_int (&(ieee->h));
+ section->lma = section->vma;
break;
case ieee_mau_size_enum:
must_parse_int (&(ieee->h));
case ieee_section_base_address_enum:
section = ieee->section_table[must_parse_int (&(ieee->h))];
section->vma = must_parse_int (&(ieee->h));
+ section->lma = section->vma;
break;
case ieee_section_offset_enum:
(void) must_parse_int (&(ieee->h));
}
}
}
-\f
+/* Make a section for the debugging information, if any. We don't try
+ to interpret the debugging information; we just point the section
+ at the area in the file so that program which understand can dig it
+ out. */
+
+static boolean
+ieee_slurp_debug (abfd)
+ bfd *abfd;
+{
+ ieee_data_type *ieee = IEEE_DATA (abfd);
+ asection *sec;
+
+ if (ieee->w.r.debug_information_part == 0)
+ return true;
+
+ sec = bfd_make_section (abfd, ".debug");
+ if (sec == NULL)
+ return false;
+ sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS;
+ sec->filepos = ieee->w.r.debug_information_part;
+ sec->_raw_size = ieee->w.r.data_part - ieee->w.r.debug_information_part;
+
+ return true;
+}
+\f
/***********************************************************************
* archive stuff
*/
{
char *library;
boolean loop;
-
unsigned int i;
unsigned char buffer[512];
- struct obstack ob;
file_ptr buffer_offset = 0;
ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
ieee_ar_data_type *ieee;
abfd->tdata.ieee_ar_data = (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
if (!abfd->tdata.ieee_ar_data)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
ieee = IEEE_AR_DATA (abfd);
/* FIXME: Check return value. I'm not sure whether it needs to read
}
/* Throw away the filename */
read_id (&(ieee->h));
- /* This must be an IEEE archive, so we'll buy some space to do
- things */
-
- if (!obstack_begin (&ob, 128))
- {
- bfd_set_error (bfd_error_no_memory);
- return (const bfd_target *) NULL;
- }
ieee->element_count = 0;
ieee->element_index = 0;
t.abfd = (bfd *) NULL;
ieee->element_count++;
- obstack_grow (&ob, (PTR) & t, sizeof (t));
+ bfd_alloc_grow (abfd, (PTR) &t, sizeof t);
/* Make sure that we don't go over the end of the buffer */
loop = false;
}
- ieee->elements = (ieee_ar_obstack_type *) obstack_finish (&ob);
+ ieee->elements = (ieee_ar_obstack_type *) bfd_alloc_finish (abfd);
if (!ieee->elements)
- {
- bfd_set_error (bfd_error_no_memory);
- return (const bfd_target *) NULL;
- }
+ return (const bfd_target *) NULL;
/* Now scan the area again, and replace BB offsets with file */
/* offsets */
/* Determine the architecture and machine type of the object file.
*/
{
- bfd_arch_info_type *arch = bfd_scan_arch (processor);
+ const bfd_arch_info_type *arch = bfd_scan_arch (processor);
if (arch == 0)
goto got_wrong_format;
abfd->arch_info = arch;
IEEE_DATA (abfd)->h.first_byte = (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record
+ 50);
if (!IEEE_DATA (abfd)->h.first_byte)
- {
- bfd_set_error (bfd_error_no_memory);
- goto fail;
- }
+ 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
bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1, ieee->w.r.me_record + 50, abfd);
ieee_slurp_sections (abfd);
+
+ if (! ieee_slurp_debug (abfd))
+ goto fail;
+
return abfd->xvec;
got_wrong_format:
bfd_set_error (bfd_error_wrong_format);
break;
case bfd_print_symbol_all:
{
- CONST char *section_name = symbol->section == (asection *) NULL ?
- (CONST char *) "*abs" : symbol->section->name;
+ const char *section_name =
+ (symbol->section == (asection *) NULL
+ ? "*abs"
+ : symbol->section->name);
if (symbol->name[0] == ' ')
{
fprintf (file, "* empty table entry ");
fprintf (file, " %-5s %04x %02x %s",
section_name,
(unsigned) ieee_symbol (symbol)->index,
- (unsigned) 0, /*
- aout_symbol(symbol)->desc & 0xffff,
- aout_symbol(symbol)->other & 0xff,*/
+ (unsigned) 0,
symbol->name);
}
}
(ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
sizeof (ieee_reloc_type));
if (!r)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
*(current_map->reloc_tail_ptr) = r;
current_map->reloc_tail_ptr = &r->next;
}
/* Build a relocation entry for this type */
/* If pc rel then stick -ve pc into instruction
- and take out of reloc ..
+ and take out of reloc ..
- I've changed this. It's all too
- complicated. I keep 0 in the
- instruction now.
- */
+ I've changed this. It's all too complicated. I
+ keep 0 in the instruction now. */
switch (extra)
{
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
+ if ((s->flags & SEC_DEBUGGING) != 0)
+ continue;
per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size);
if (!per->data)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
/*SUPPRESS 68*/
per->reloc_tail_ptr =
(ieee_reloc_type **) & (s->relocation);
newsect->used_by_bfd = (PTR)
bfd_alloc (abfd, sizeof (ieee_per_section_type));
if (!newsect->used_by_bfd)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
ieee_per_section (newsect)->data = (bfd_byte *) NULL;
ieee_per_section (newsect)->section = newsect;
return true;
bfd *abfd;
sec_ptr asect;
{
+ if ((asect->flags & SEC_DEBUGGING) != 0)
+ return 0;
if (! ieee_slurp_section_data (abfd))
return -1;
return (asect->reloc_count + 1) * sizeof (arelent *);
bfd_size_type count;
{
ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
+ if ((section->flags & SEC_DEBUGGING) != 0)
+ return _bfd_generic_get_section_contents (abfd, section, location,
+ offset, count);
ieee_slurp_section_data (abfd);
(void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count);
return true;
ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
ieee_data_type *ieee = IEEE_DATA (abfd);
+ if ((section->flags & SEC_DEBUGGING) != 0)
+ return 0;
+
while (src != (ieee_reloc_type *) NULL)
{
/* Work out which symbol to attach it this reloc to */
return a->address - b->address;
}
-/*
-Write the section headers
-*/
+/* Write the section headers. */
-static void
+static boolean
ieee_write_section_part (abfd)
bfd *abfd;
{
ieee->w.r.section_part = bfd_tell (abfd);
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
- if (! bfd_is_abs_section (s))
+ if (! bfd_is_abs_section (s)
+ && (s->flags & SEC_DEBUGGING) == 0)
{
- ieee_write_byte (abfd, ieee_section_type_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
+ if (! ieee_write_byte (abfd, ieee_section_type_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index
+ + IEEE_SECTION_NUMBER_BASE)))
+ return false;
if (abfd->flags & EXEC_P)
{
/* This image is executable, so output absolute sections */
- ieee_write_byte (abfd, ieee_variable_A_enum);
- ieee_write_byte (abfd, ieee_variable_S_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_A_enum)
+ || ! ieee_write_byte (abfd, ieee_variable_S_enum))
+ return false;
}
else
{
- ieee_write_byte (abfd, ieee_variable_C_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_C_enum))
+ return false;
}
switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
{
case SEC_CODE | SEC_LOAD:
case SEC_CODE:
- ieee_write_byte (abfd, ieee_variable_P_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_P_enum))
+ return false;
break;
case SEC_DATA:
default:
- ieee_write_byte (abfd, ieee_variable_D_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_D_enum))
+ return false;
break;
case SEC_ROM:
case SEC_ROM | SEC_DATA:
case SEC_ROM | SEC_LOAD:
case SEC_ROM | SEC_DATA | SEC_LOAD:
-
- ieee_write_byte (abfd, ieee_variable_R_enum);
+ if (! ieee_write_byte (abfd, ieee_variable_R_enum))
+ return false;
}
- ieee_write_id (abfd, s->name);
+ if (! ieee_write_id (abfd, s->name))
+ return false;
#if 0
ieee_write_int (abfd, 0); /* Parent */
ieee_write_int (abfd, 0); /* Brother */
ieee_write_int (abfd, 0); /* Context */
#endif
/* Alignment */
- ieee_write_byte (abfd, ieee_section_alignment_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_int (abfd, 1 << s->alignment_power);
+ if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index
+ + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_int (abfd, 1 << s->alignment_power))
+ return false;
/* Size */
- ieee_write_2bytes (abfd, ieee_section_size_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_int (abfd, s->_raw_size);
+ if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index
+ + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_int (abfd, s->_raw_size))
+ return false;
if (abfd->flags & EXEC_P)
{
/* Relocateable sections don't have asl records */
/* Vma */
- ieee_write_2bytes (abfd, ieee_section_base_address_enum);
- ieee_write_byte (abfd,
- (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_int (abfd, s->vma);
+ if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
+ || ! ieee_write_byte (abfd,
+ ((bfd_byte)
+ (s->index
+ + IEEE_SECTION_NUMBER_BASE)))
+ || ! ieee_write_int (abfd, s->vma))
+ return false;
}
}
-
}
+
+ return true;
}
asection *s;
{
unsigned int relocs_to_go = s->reloc_count;
-
bfd_byte *stream = ieee_per_section (s)->data;
arelent **p = s->orelocation;
-
bfd_size_type current_byte_index = 0;
qsort (s->orelocation,
comp);
/* Output the section preheader */
- ieee_write_byte (abfd, ieee_set_current_section_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
-
- ieee_write_twobyte (abfd, ieee_set_current_pc_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_expression (abfd, 0, s->symbol, 0, 0);
+ if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_expression (abfd, 0, s->symbol, 0, 0))
+ return false;
if (relocs_to_go == 0)
{
- /* If there arn't any relocations then output the load constant byte
- opcode rather than the load with relocation opcode */
+ /* If there aren't any relocations then output the load constant
+ byte opcode rather than the load with relocation opcode */
while (current_byte_index < s->_raw_size)
{
if (run != 0)
{
- ieee_write_byte (abfd, ieee_load_constant_bytes_enum);
+ if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
+ return false;
/* Output a stream of bytes */
- ieee_write_int (abfd, run);
+ if (! ieee_write_int (abfd, run))
+ return false;
if (bfd_write ((PTR) (stream + current_byte_index),
1,
run,
}
else
{
- ieee_write_byte (abfd, ieee_load_with_relocation_enum);
-
+ if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
+ return false;
/* Output the data stream as the longest sequence of bytes
- possible, allowing for the a reasonable packet size and
- relocation stuffs */
+ possible, allowing for the a reasonable packet size and
+ relocation stuffs. */
if ((PTR) stream == (PTR) NULL)
{
/* Outputting a section without data, fill it up */
stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
if (!stream)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
memset ((PTR) stream, 0, (size_t) s->_raw_size);
}
while (current_byte_index < s->_raw_size)
if (run != 0)
{
/* Output a stream of bytes */
- ieee_write_int (abfd, run);
+ if (! ieee_write_int (abfd, run))
+ return false;
if (bfd_write ((PTR) (stream + current_byte_index),
1,
run,
/* Output any relocations here */
if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
{
- while (relocs_to_go && (*p) && (*p)->address == current_byte_index)
+ while (relocs_to_go
+ && (*p) && (*p)->address == current_byte_index)
{
-
arelent *r = *p;
bfd_vma ov;
ov = 0;
BFD_FAIL ();
}
- ieee_write_byte (abfd, ieee_function_either_open_b_enum);
-/* abort();*/
+ if (! ieee_write_byte (abfd,
+ ieee_function_either_open_b_enum))
+ return false;
+
+/* abort();*/
if (r->sym_ptr_ptr != (asymbol **) NULL)
{
- ieee_write_expression (abfd, r->addend + ov,
- *(r->sym_ptr_ptr),
- r->howto->pc_relative, s->index);
+ if (! ieee_write_expression (abfd, r->addend + ov,
+ *(r->sym_ptr_ptr),
+ r->howto->pc_relative,
+ s->index))
+ return false;
}
else
{
- ieee_write_expression (abfd, r->addend + ov,
- (asymbol *) NULL,
- r->howto->pc_relative, s->index);
+ if (! ieee_write_expression (abfd, r->addend + ov,
+ (asymbol *) NULL,
+ r->howto->pc_relative,
+ s->index))
+ return false;
}
if (1 || r->howto->size != 2)
{
- ieee_write_byte (abfd, ieee_comma);
- ieee_write_int (abfd, 1 << r->howto->size);
+ if (! ieee_write_byte (abfd, ieee_comma)
+ || ! ieee_write_int (abfd, 1 << r->howto->size))
+ return false;
}
- ieee_write_byte (abfd,
- ieee_function_either_close_b_enum);
+ if (! ieee_write_byte (abfd,
+ ieee_function_either_close_b_enum))
+ return false;
relocs_to_go--;
p++;
}
}
}
+
return true;
}
-/* If there are no relocations in the output section then we can
-be clever about how we write. We block items up into a max of 127
-bytes */
+/* If there are no relocations in the output section then we can be
+ clever about how we write. We block items up into a max of 127
+ bytes. */
-static void
+static boolean
do_as_repeat (abfd, s)
bfd *abfd;
asection *s;
{
if (s->_raw_size)
{
- ieee_write_byte (abfd, ieee_set_current_section_enum);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8);
- ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff);
- ieee_write_byte (abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
- ieee_write_int (abfd, s->vma);
-
- ieee_write_byte (abfd, ieee_repeat_data_enum);
- ieee_write_int (abfd, s->_raw_size);
- ieee_write_byte (abfd, ieee_load_constant_bytes_enum);
- ieee_write_byte (abfd, 1);
- ieee_write_byte (abfd, 0);
+ if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index
+ + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
+ || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
+ || ! ieee_write_byte (abfd,
+ (bfd_byte) (s->index
+ + IEEE_SECTION_NUMBER_BASE))
+ || ! ieee_write_int (abfd, s->vma)
+ || ! ieee_write_byte (abfd, ieee_repeat_data_enum)
+ || ! ieee_write_int (abfd, s->_raw_size)
+ || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
+ || ! ieee_write_byte (abfd, 1)
+ || ! ieee_write_byte (abfd, 0))
+ return false;
}
+
+ return true;
}
-static void
+static boolean
do_without_relocs (abfd, s)
bfd *abfd;
asection *s;
if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
{
- do_as_repeat (abfd, s);
+ if (! do_as_repeat (abfd, s))
+ return false;
}
else
{
{
if (stream[i] != 0)
{
- do_with_relocs (abfd, s);
- return;
+ if (! do_with_relocs (abfd, s))
+ return false;
+ return true;
}
}
- do_as_repeat (abfd, s);
+ if (! do_as_repeat (abfd, s))
+ return false;
}
+ return true;
}
the debug info in each, and copy it out, relocating it as we go.
*/
-static void
+static boolean
ieee_write_debug_part (abfd)
bfd *abfd;
{
if (chain == (bfd_chain_type *) NULL)
{
-#if 0
- /* There is no debug info, so we'll fake some up */
- CONST static char fake[] =
- {
- 0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3,
- '1', '.', '1', 0x82, 1991 >> 8, 1991 & 0xff, 9, 20, 11, 07, 50};
- ieee->w.r.debug_information_part = 0;
+ asection *s;
+ for (s = abfd->sections; s != NULL; s = s->next)
+ if ((s->flags & SEC_DEBUGGING) != 0)
+ break;
+ if (s == NULL)
+ {
+ ieee->w.r.debug_information_part = 0;
+ return true;
+ }
- here;
-
-
- /* bfd_write(fake, 1, sizeof(fake), abfd);*/
- /* Now write a header for each section */
- {
- int i = 0;
- asection *s = abfd->sections;
- while (s)
- {
- if (s != abfd->abs_section)
- {
-
- ieee_write_byte (abfd, 0xf8);
- ieee_write_byte (abfd, 0x0b);
- ieee_write_byte (abfd, 0);
- ieee_write_byte (abfd, 0);
- ieee_write_byte (abfd, 1);
- ieee_write_byte (abfd, i + IEEE_SECTION_NUMBER_BASE);
- ieee_write_expression (abfd, 0, s->symbol, 0, 0, 0);
- ieee_write_byte (abfd, 0);
- ieee_write_byte (abfd, 0xf9);
- ieee_write_expression (abfd, s->size,
- bfd_abs_section_ptr->symbol, 0, 0, 0);
- i++;
- }
-
- s = s->next;
-
- }
- /* Close the scope */
- ieee_write_byte (abfd, 0xf9);
- }
-#endif
+ ieee->w.r.debug_information_part = here;
+ if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size)
+ return false;
}
else
{
if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
SEEK_SET)
!= 0)
- abort ();
+ return false;
relocate_debug (abfd, entry);
}
{
ieee->w.r.debug_information_part = 0;
}
+
+ flush ();
}
- flush ();
+ return true;
}
-/* write the data in an ieee way */
-static void
+/* Write the data in an ieee way. */
+
+static boolean
ieee_write_data_part (abfd)
bfd *abfd;
{
ieee->w.r.data_part = bfd_tell (abfd);
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
+ if ((s->flags & SEC_DEBUGGING) != 0)
+ continue;
/* Sort the reloc records so we can insert them in the correct
places */
if (s->reloc_count != 0)
{
- do_with_relocs (abfd, s);
+ if (! do_with_relocs (abfd, s))
+ return false;
}
else
{
- do_without_relocs (abfd, s);
+ if (! do_without_relocs (abfd, s))
+ return false;
}
}
+
+ return true;
}
asection *s;
for (s = abfd->sections; s != (asection *) NULL; s = s->next)
{
+ if ((s->flags & SEC_DEBUGGING) != 0)
+ continue;
if (s->_raw_size != 0)
{
ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
if (!ieee_per_section (s)->data)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
}
}
return true;
file_ptr offset;
bfd_size_type count;
{
+ if ((section->flags & SEC_DEBUGGING) != 0)
+ {
+ if (section->contents == NULL)
+ {
+ section->contents = bfd_alloc (abfd, section->_raw_size);
+ if (section->contents == NULL)
+ return false;
+ }
+ /* bfd_set_section_contents has already checked that everything
+ is within range. */
+ memcpy (section->contents + offset, location, count);
+ return true;
+ }
+
if (ieee_per_section (section)->data == (bfd_byte *) NULL)
{
if (!init_for_output (abfd))
return true;
}
-/*
-write the external symbols of a file, IEEE considers two sorts of
-external symbols, public, and referenced. It uses to internal forms
-to index them as well. When we write them out we turn their symbol
-values into indexes from the right base.
-*/
-static void
+/* Write the external symbols of a file. IEEE considers two sorts of
+ external symbols, public, and referenced. It uses to internal
+ forms to index them as well. When we write them out we turn their
+ symbol values into indexes from the right base. */
+
+static boolean
ieee_write_external_part (abfd)
bfd *abfd;
{
if (bfd_is_und_section (p->section))
{
/* This must be a symbol reference .. */
- ieee_write_byte (abfd, ieee_external_reference_enum);
- ieee_write_int (abfd, reference_index);
- ieee_write_id (abfd, p->name);
+ if (! ieee_write_byte (abfd, ieee_external_reference_enum)
+ || ! ieee_write_int (abfd, reference_index)
+ || ! ieee_write_id (abfd, p->name))
+ return false;
p->value = reference_index;
reference_index++;
}
else if (bfd_is_com_section (p->section))
{
/* This is a weak reference */
- ieee_write_byte (abfd, ieee_external_reference_enum);
- ieee_write_int (abfd, reference_index);
- ieee_write_id (abfd, p->name);
- ieee_write_byte (abfd, ieee_weak_external_reference_enum);
- ieee_write_int (abfd, reference_index);
- ieee_write_int (abfd, p->value);
- ieee_write_int (abfd, BFD_FORT_COMM_DEFAULT_VALUE);
+ if (! ieee_write_byte (abfd, ieee_external_reference_enum)
+ || ! ieee_write_int (abfd, reference_index)
+ || ! ieee_write_id (abfd, p->name)
+ || ! ieee_write_byte (abfd,
+ ieee_weak_external_reference_enum)
+ || ! ieee_write_int (abfd, reference_index)
+ || ! ieee_write_int (abfd, p->value)
+ || ! ieee_write_int (abfd, BFD_FORT_COMM_DEFAULT_VALUE))
+ return false;
p->value = reference_index;
reference_index++;
}
{
/* This must be a symbol definition */
-
- ieee_write_byte (abfd, ieee_external_symbol_enum);
- ieee_write_int (abfd, public_index);
- ieee_write_id (abfd, p->name);
-
- ieee_write_twobyte (abfd, ieee_attribute_record_enum);
- ieee_write_int (abfd, public_index);
- ieee_write_byte (abfd, 15); /* instruction address */
- ieee_write_byte (abfd, 19); /* static symbol */
- ieee_write_byte (abfd, 1); /* one of them */
-
+ if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
+ || ! ieee_write_int (abfd, public_index)
+ || ! ieee_write_id (abfd, p->name)
+ || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
+ || ! ieee_write_int (abfd, public_index)
+ || ! ieee_write_byte (abfd, 15) /* instruction address */
+ || ! ieee_write_byte (abfd, 19) /* static symbol */
+ || ! ieee_write_byte (abfd, 1)) /* one of them */
+ return false;
/* Write out the value */
- ieee_write_2bytes (abfd, ieee_value_record_enum);
- ieee_write_int (abfd, public_index);
+ if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
+ || ! ieee_write_int (abfd, public_index))
+ return false;
if (! bfd_is_abs_section (p->section))
{
if (abfd->flags & EXEC_P)
{
/* If fully linked, then output all symbols
- relocated */
- ieee_write_int (abfd,
- p->value + p->section->output_offset + p->section->output_section->vma);
-
+ relocated */
+ if (! (ieee_write_int
+ (abfd,
+ (p->value
+ + p->section->output_offset
+ + p->section->output_section->vma))))
+ return false;
}
else
{
- ieee_write_expression (abfd,
- p->value + p->section->output_offset,
- p->section->output_section->symbol
- ,false, 0);
+ if (! (ieee_write_expression
+ (abfd,
+ p->value + p->section->output_offset,
+ p->section->output_section->symbol,
+ false, 0)))
+ return false;
}
}
else
{
- ieee_write_expression (abfd,
- p->value,
- bfd_abs_section_ptr->symbol,
- false, 0);
+ if (! ieee_write_expression (abfd,
+ p->value,
+ bfd_abs_section_ptr->symbol,
+ false, 0))
+ return false;
}
p->value = public_index;
public_index++;
if (hadone)
ieee->w.r.external_part = here;
+ return true;
}
/* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
};
-static
-void
+static boolean
ieee_write_me_part (abfd)
bfd *abfd;
{
if (abfd->start_address)
{
ieee->w.r.me_record = bfd_tell (abfd);
- ieee_write_2bytes (abfd, ieee_value_starting_address_enum);
- ieee_write_byte (abfd, ieee_function_either_open_b_enum);
- ieee_write_int (abfd, abfd->start_address);
- ieee_write_byte (abfd, ieee_function_either_close_b_enum);
+ if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
+ || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
+ || ! ieee_write_int (abfd, abfd->start_address)
+ || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
+ return false;
}
else
{
ieee->w.r.me_record = bfd_tell (abfd);
}
- ieee_write_byte (abfd, ieee_module_end_enum);
-
+ if (! ieee_write_byte (abfd, ieee_module_end_enum))
+ return false;
+ return true;
}
boolean
ieee_data_type *ieee = IEEE_DATA (abfd);
unsigned int i;
file_ptr old;
+
/* Fast forward over the header area */
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
return false;
- ieee_write_byte (abfd, ieee_module_beginning_enum);
-
- ieee_write_id (abfd, bfd_printable_name (abfd));
- ieee_write_id (abfd, abfd->filename);
+ if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
+ || ! ieee_write_id (abfd, bfd_printable_name (abfd))
+ || ! ieee_write_id (abfd, abfd->filename))
+ return false;
/* Fast forward over the variable bits */
- ieee_write_byte (abfd, ieee_address_descriptor_enum);
+ if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
+ return false;
/* Bits per MAU */
- ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd)));
+ if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
+ return false;
/* MAU's per address */
- ieee_write_byte (abfd,
- (bfd_byte) (bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd)));
+ if (! ieee_write_byte (abfd,
+ (bfd_byte) (bfd_arch_bits_per_address (abfd)
+ / bfd_arch_bits_per_byte (abfd))))
+ return false;
old = bfd_tell (abfd);
if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten))
return false;
if (abfd->flags & EXEC_P)
- ieee_write_byte (abfd, 0x1);/* Absolute */
+ {
+ if (! ieee_write_byte (abfd, 0x1)) /* Absolute */
+ return false;
+ }
else
- ieee_write_byte (abfd, 0x2);/* Relocateable */
+ {
+ if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */
+ return false;
+ }
ieee->w.r.environmental_record = bfd_tell (abfd);
if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi))
return false;
output_bfd = abfd;
- flush ();
- ieee_write_section_part (abfd);
- /*
- First write the symbols, this changes their values into table
- indeces so we cant use it after this point
- */
- ieee_write_external_part (abfd);
- /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
+ flush ();
+ if (! ieee_write_section_part (abfd))
+ return false;
+ /* First write the symbols. This changes their values into table
+ indeces so we cant use it after this point. */
+ if (! ieee_write_external_part (abfd))
+ return false;
/* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
+ /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
- /*
- Write any debugs we have been told about
- */
- ieee_write_debug_part (abfd);
-
- /*
- Can only write the data once the symbols have been written since
- the data contains relocation information which points to the
- symbols
- */
- ieee_write_data_part (abfd);
+ /* Write any debugs we have been told about. */
+ if (! ieee_write_debug_part (abfd))
+ return false;
- /*
- At the end we put the end !
- */
- ieee_write_me_part (abfd);
+ /* Can only write the data once the symbols have been written, since
+ the data contains relocation information which points to the
+ symbols. */
+ if (! ieee_write_data_part (abfd))
+ return false;
+ /* At the end we put the end! */
+ if (! ieee_write_me_part (abfd))
+ return false;
/* Generate the header */
if (bfd_seek (abfd, old, SEEK_SET) != 0)
for (i = 0; i < N_W_VARIABLES; i++)
{
- ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum);
- ieee_write_byte (abfd, (bfd_byte) i);
- ieee_write_int5_out (abfd, ieee->w.offset[i]);
+ if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
+ || ! ieee_write_byte (abfd, (bfd_byte) i)
+ || ! ieee_write_int5_out (abfd, ieee->w.offset[i]))
+ return false;
}
+
return true;
}
\f
-
-
/* Native-level interface to symbols. */
/* We read the symbols into a buffer, which is discarded when this
-function exits. We read the strings into a buffer large enough to
-hold them all plus all the cached symbol entries. */
+ function exits. We read the strings into a buffer large enough to
+ hold them all plus all the cached symbol entries. */
asymbol *
ieee_make_empty_symbol (abfd)
bfd *abfd;
{
-
ieee_symbol_type *new =
- (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
+ (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
if (!new)
- {
- bfd_set_error (bfd_error_no_error);
- return NULL;
- }
+ return NULL;
new->symbol.the_bfd = abfd;
return &new->symbol;
}
{
bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
if (!n)
- {
- bfd_set_error (bfd_error_no_memory);
- abort (); /* FIXME */
- }
+ abort (); /* FIXME */
n->this = section->owner;
n->next = (bfd_chain_type *) NULL;
((boolean (*) \
PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
bfd_true)
+#define ieee_read_ar_hdr bfd_nullvoidptr
#define ieee_update_armap_timestamp bfd_true
#define ieee_bfd_is_local_label bfd_generic_is_local_label
#define ieee_set_arch_mach _bfd_generic_set_arch_mach
+#define ieee_get_section_contents_in_window \
+ _bfd_generic_get_section_contents_in_window
#define ieee_bfd_get_relocated_section_contents \
bfd_generic_get_relocated_section_contents
#define ieee_bfd_relax_section bfd_generic_relax_section
{
"ieee", /* name */
bfd_target_ieee_flavour,
- true, /* target byte order */
- true, /* target headers byte order */
+ 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),
projects / deliverable / binutils-gdb.git / blobdiff