read. (bfd_error_system_call or bfd_error_file_truncated).
* som.c: Do not blindly set bfd_error_system_call after a
failing bfd_read, bfd_write, or bfd_seek. In a few places
(like som_object_p) override the error status set by bfd_read.
* aix386-core.c, aout-encap,c archive.c, bout.c: Likewise.
* coff-rs6000.c, coffgen.c ecoff.c, elf.c: Likewise.
* elf32-hppa.c, elfcode.h, hp300hpux.c, i386lynx.c: Likewise.
* nlm32-alpha.c, nlm32-i386.c, nlm32-sparc.c: Likewise.
* som.c: Check return values from several bfd_{seek,read,write}
calls that we just assumed were not failing.
+Sat Mar 26 10:25:43 1994 Jeffrey A. Law (law@snake.cs.utah.edu)
+
+ * libbfd.c (bfd_read): Set bfd_error as appropriate for a short
+ read. (bfd_error_system_call or bfd_error_file_truncated).
+
+ * som.c: Do not blindly set bfd_error_system_call after a
+ failing bfd_read, bfd_write, or bfd_seek. In a few places
+ (like som_object_p) override the error status set by bfd_read.
+
+ * aix386-core.c, aout-encap,c archive.c, bout.c: Likewise.
+ * coff-rs6000.c, coffgen.c ecoff.c, elf.c: Likewise.
+ * elf32-hppa.c, elfcode.h, hp300hpux.c, i386lynx.c: Likewise.
+ * nlm32-alpha.c, nlm32-i386.c, nlm32-sparc.c: Likewise.
+
+ * som.c: Check return values from several bfd_{seek,read,write}
+ calls that we just assumed were not failing.
+
Fri Mar 25 11:44:06 1994 Jim Kingdon (kingdon@lioth.cygnus.com)
* hosts/sysv4.h (HAVE_PROCFS): Add comments about ptx4.
struct corehdr internal_core;
} *mergem;
- bfd_set_error (bfd_error_system_call);
-
if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) != sizeof (longbuf))
- return 0;
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
+ return 0;
+ }
if (strncmp(longbuf,COR_MAGIC,4)) return 0;
if ((bfd_read ((PTR) core, 1, core_size, abfd)) != core_size)
{
- bfd_set_error (bfd_error_system_call);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
bfd_release (abfd, (char *)mergem);
return 0;
}
((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
#define aix386_bfd_final_link \
((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
+#define aix386_bfd_copy_private_section_data \
+ ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_false)
+#define aix386_bfd_copy_private_bfd_data \
+ ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_false)
+#define aix386_bfd_is_local_label \
+ ((boolean (*) PARAMS ((bfd *, asection *))) bfd_false)
/* If somebody calls any byte-swapping routines, shoot them. */
void
struct external_exec exec_bytes;
struct internal_exec exec;
- bfd_set_error (bfd_error_system_call);
-
if (bfd_read ((PTR)magicbuf, 1, sizeof (magicbuf), abfd) !=
sizeof (magicbuf))
- return 0;
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
+ return 0;
+ }
coff_magic = bfd_h_get_16 (abfd, magicbuf);
if (coff_magic != COFF_MAGIC)
if (bfd_ardata (abfd) == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
{
if (!bfd_has_map (abfd))
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return BFD_NO_MORE_SYMBOLS;
}
nbfd = _bfd_new_bfd_contained_in (obfd);
if (nbfd == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
return nbfd;
if (new_cache == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
index = strtol (name + 1, NULL, 10);
if (errno != 0)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
if (bfd_read ((PTR) hdrp, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
{
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return NULL;
}
if (strncmp (hdr.ar_fmag, ARFMAG, 2))
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
parsed_size = strtol (hdr.ar_size, NULL, 10);
if (errno != 0)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
filename = get_extended_arelt_filename (abfd, hdr.ar_name);
if (filename == NULL)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
}
allocptr = bfd_zalloc (abfd, allocsize);
if (allocptr == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
filename = (allocptr
+ sizeof (struct ar_hdr));
if (bfd_read (filename, 1, namelen, abfd) != namelen)
{
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return NULL;
}
filename[namelen] = '\0';
allocptr = bfd_zalloc (abfd, allocsize);
if (allocptr == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
}
return n_nfd;
if (0 > bfd_seek (archive, filepos, SEEK_SET))
- {
- bfd_error = system_call_error;
- return NULL;
- }
+ return NULL;
if ((new_areldata = _bfd_snarf_ar_hdr (archive)) == NULL)
return NULL;
if ((bfd_get_format (archive) != bfd_archive) ||
(archive->direction == write_direction))
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return NULL;
}
if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG)
{
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
return NULL;
}
if (bfd_ardata (abfd) == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
if (raw_armap == (bfd_byte *) NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
byebye:
bfd_release (abfd, (PTR) raw_armap);
return false;
parsed_size - BSD_SYMDEF_COUNT_SIZE)
{
/* Probably we're using the wrong byte ordering. */
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
goto byebye;
}
* sizeof (carsym)));
if (!ardata->symdefs)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) int_buf, 1, 4, abfd) != 4)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return false;
}
/* It seems that all numeric information in a coff archive is always
ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1);
if (ardata->symdefs == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
carsyms = ardata->symdefs;
raw_armap = (int *) bfd_alloc (abfd, ptrsize);
if (raw_armap == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
goto release_symdefs;
}
if (bfd_read ((PTR) raw_armap, 1, ptrsize, abfd) != ptrsize
|| bfd_read ((PTR) stringbase, 1, stringsize, abfd) != stringsize)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
goto release_raw_armap;
}
raw_armap = (bfd_byte *) bfd_zalloc (abfd, mapdata->parsed_size);
if (raw_armap == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
byebye:
bfd_release (abfd, (PTR) mapdata);
return false;
if (bfd_read ((PTR) raw_armap, 1, mapdata->parsed_size, abfd) !=
mapdata->parsed_size)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
byebyebye:
bfd_release (abfd, (PTR) raw_armap);
goto byebye;
> mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
{
/* Probably we're using the wrong byte ordering. */
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
goto byebyebye;
}
* BSD_SYMDEF_SIZE));
if (!ardata->symdefs)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
bfd_zalloc (abfd, namedata->parsed_size);
if (bfd_ardata (abfd)->extended_names == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
byebye:
bfd_release (abfd, (PTR) namedata);
return false;
if (bfd_read ((PTR) bfd_ardata (abfd)->extended_names, 1,
namedata->parsed_size, abfd) != namedata->parsed_size)
{
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
bfd_release (abfd, (PTR) (bfd_ardata (abfd)->extended_names));
bfd_ardata (abfd)->extended_names = NULL;
goto byebye;
if (!normal)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
thislen = strlen (normal);
*tabloc = bfd_zalloc (abfd, total_namelen);
if (*tabloc == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (!normal)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
thislen = strlen (normal);
struct ar_hdr *hdr = arch_hdr (current);
strcpy (strptr, normal);
strptr[thislen] = '\012';
- hdr->ar_name[0] = ' ';
+ hdr->ar_name[0] = ar_padchar (current);
/* We know there will always be enough room (one of the few
cases where you may safely use sprintf). */
sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc));
if (stat (filename, &status) != 0)
{
- bfd_error = system_call_error;
+ bfd_set_error (bfd_error_system_call);
return NULL;
}
sizeof (struct areltdata));
if (ared == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
/* ar headers are space padded, not null padded! */
- memset (hdr, ' ', sizeof (struct ar_hdr));
+ memset ((PTR) hdr, ' ', sizeof (struct ar_hdr));
strncpy (hdr->ar_fmag, ARFMAG, 2);
if (abfd->arelt_data == NULL)
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return -1;
}
{
if (bfd_write_p (current))
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
}
if (!current->arelt_data)
struct ar_hdr hdr;
memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
- sprintf (&(hdr.ar_name[0]), "ARFILENAMES/");
+ if (ar_padchar (arch) == '/')
+ sprintf (&(hdr.ar_name[0]), "//");
+ else
+ sprintf (&(hdr.ar_name[0]), "ARFILENAMES/");
sprintf (&(hdr.ar_size[0]), "%-10d", (int) elength);
hdr.ar_fmag[0] = '`';
hdr.ar_fmag[1] = '\012';
/* write ar header */
if (bfd_write ((char *) hdr, 1, sizeof (*hdr), arch) != sizeof (*hdr))
- {
- syserr:
- bfd_error = system_call_error;
- return false;
- }
+ return false;
if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
- goto syserr;
+ return false;
while (remaining)
{
unsigned int amt = DEFAULT_BUFFERSIZE;
errno = 0;
if (bfd_read (buffer, amt, 1, current) != amt)
{
- if (errno)
- goto syserr;
- /* Looks like a truncated archive. */
- bfd_error = malformed_archive;
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_malformed_archive);
return false;
}
if (bfd_write (buffer, amt, 1, arch) != amt)
- goto syserr;
+ return false;
remaining -= amt;
}
if ((arelt_size (current) % 2) == 1)
map = (struct orl *) malloc (orl_max * sizeof (struct orl));
if (map == NULL)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (first_name == NULL)
{
free (map);
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
{
free (map);
bfd_release (arch, first_name);
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
}
free (syms);
free (map);
bfd_release (arch, first_name);
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
#include "sysdep.h"
#include "libbfd.h"
#include "bfdlink.h"
+#include "genlink.h"
#include "bout.h"
#include "aout/stab_gnu.h"
#include "libaout.h" /* BFD a.out internal data structures */
+static int aligncode PARAMS ((bfd *abfd, asection *input_section,
+ arelent *r, unsigned int shrink));
+static void perform_slip PARAMS ((bfd *abfd, unsigned int slip,
+ asection *input_section, bfd_vma value));
static boolean b_out_squirt_out_relocs PARAMS ((bfd *abfd, asection *section));
static bfd_target *b_out_callback PARAMS ((bfd *));
static bfd_reloc_status_type calljx_callback
unsigned int srcidx, unsigned int dstidx, asection *));
static bfd_vma get_value PARAMS ((arelent *, struct bfd_link_info *,
asection *));
-static int abs32code PARAMS ((asection *, asymbol **, arelent *,
+static int abs32code PARAMS ((bfd *, asection *, arelent *,
unsigned int, struct bfd_link_info *));
static boolean b_out_relax_section PARAMS ((bfd *, asection *,
struct bfd_link_info *,
- asymbol **symbols));
+ boolean *));
static bfd_byte *b_out_get_relocated_section_contents
PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
bfd_byte *, boolean, asymbol **));
stream memory image, into the internal exec_header structure. */
void
-DEFUN(bout_swap_exec_header_in,(abfd, raw_bytes, execp),
- bfd *abfd AND
- struct external_exec *raw_bytes AND
- struct internal_exec *execp)
+bout_swap_exec_header_in (abfd, raw_bytes, execp)
+ bfd *abfd;
+ struct external_exec *raw_bytes;
+ struct internal_exec *execp;
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
struct internal_exec *execp,
struct external_exec *raw_bytes));
void
-DEFUN(bout_swap_exec_header_out,(abfd, execp, raw_bytes),
- bfd *abfd AND
- struct internal_exec *execp AND
- struct external_exec *raw_bytes)
+bout_swap_exec_header_out (abfd, execp, raw_bytes)
+ bfd *abfd;
+ struct internal_exec *execp;
+ struct external_exec *raw_bytes;
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
count = reloc_size / sizeof (struct relocation_info);
relocs = (struct relocation_info *) malloc (reloc_size);
- if (!relocs) {
+ if (!relocs && reloc_size != 0) {
bfd_set_error (bfd_error_no_memory);
return false;
}
}
if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) {
- bfd_set_error (bfd_error_system_call);
free (reloc_cache);
free (relocs);
return false;
if (count == 0) return true;
generic = section->orelocation;
native = ((struct relocation_info *) malloc (natsize));
- if (!native) {
+ if (!native && natsize != 0) {
bfd_set_error (bfd_error_no_memory);
return false;
}
}
static int
-DEFUN(b_out_sizeof_headers,(ignore_abfd, ignore),
- bfd *ignore_abfd AND
- boolean ignore)
+b_out_sizeof_headers (ignore_abfd, ignore)
+ bfd *ignore_abfd;
+ boolean ignore;
{
return sizeof(struct internal_exec);
}
}
static void
-DEFUN(perform_slip,(s, slip, input_section, value),
- asymbol **s AND
- unsigned int slip AND
- asection *input_section AND
- bfd_vma value)
+perform_slip (abfd, slip, input_section, value)
+ bfd *abfd;
+ unsigned int slip;
+ asection *input_section;
+ bfd_vma value;
{
+ asymbol **s;
+
+ s = _bfd_generic_link_get_symbols (abfd);
+ BFD_ASSERT (s != (asymbol **) NULL);
/* Find all symbols past this point, and make them know
what's happened */
if (p->value > value)
{
p->value -=slip;
+ if (p->udata != NULL)
+ {
+ struct generic_link_hash_entry *h;
+
+ h = (struct generic_link_hash_entry *) p->udata;
+ BFD_ASSERT (h->root.type == bfd_link_hash_defined);
+ h->root.u.def.value -= slip;
+ BFD_ASSERT (h->root.u.def.value == p->value);
+ }
}
}
s++;
If it can, then it changes the amode */
static int
-abs32code (input_section, symbols, r, shrink, link_info)
+abs32code (abfd, input_section, r, shrink, link_info)
+ bfd *abfd;
asection *input_section;
- asymbol **symbols;
arelent *r;
unsigned int shrink;
struct bfd_link_info *link_info;
/* This will be four bytes smaller in the long run */
shrink += 4 ;
- perform_slip(symbols, 4, input_section, r->address-shrink +4);
+ perform_slip (abfd, 4, input_section, r->address-shrink + 4);
}
return shrink;
}
static int
-DEFUN(aligncode,(input_section, symbols, r, shrink),
- asection *input_section AND
- asymbol **symbols AND
- arelent *r AND
- unsigned int shrink)
+aligncode (abfd, input_section, r, shrink)
+ bfd *abfd;
+ asection *input_section;
+ arelent *r;
+ unsigned int shrink;
{
bfd_vma dot = output_addr (input_section) + r->address;
bfd_vma gap;
r->addend = old_end - dot + r->address;
/* This will be N bytes smaller in the long run, adjust all the symbols */
- perform_slip(symbols, shrink_delta, input_section, r->address - shrink );
+ perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
shrink += shrink_delta;
}
return shrink;
}
static boolean
-b_out_relax_section (abfd, i, link_info, symbols)
+b_out_relax_section (abfd, i, link_info, again)
bfd *abfd;
asection *i;
struct bfd_link_info *link_info;
- asymbol **symbols;
+ boolean *again;
{
-
/* Get enough memory to hold the stuff */
bfd *input_bfd = i->owner;
asection *input_section = i;
int shrink = 0 ;
- boolean new = false;
arelent **reloc_vector = NULL;
-
bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
input_section);
+ /* We only run this relaxation once. It might work to run it
+ multiple times, but it hasn't been tested. */
+ *again = false;
+
if (reloc_size)
{
reloc_vector = (arelent **) malloc (reloc_size);
- if (reloc_vector == NULL)
+ if (reloc_vector == NULL && reloc_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
/* Get the relocs and think about them */
if (bfd_canonicalize_reloc(input_bfd, input_section, reloc_vector,
- symbols))
+ _bfd_generic_link_get_symbols (input_bfd)))
{
arelent **parent;
for (parent = reloc_vector; *parent; parent++)
{
case ALIGNER:
/* An alignment reloc */
- shrink = aligncode(input_section, symbols, r,shrink);
- new=true;
+ shrink = aligncode (abfd, input_section, r, shrink);
break;
case ABS32CODE:
/* A 32bit reloc in an addressing mode */
- shrink = abs32code (input_section, symbols, r, shrink, link_info);
- new=true;
+ shrink = abs32code (input_bfd, input_section, r, shrink,
+ link_info);
break;
case ABS32CODE_SHRUNK:
shrink+=4;
if (reloc_vector != NULL)
free (reloc_vector);
- return new;
+ return true;
error_return:
if (reloc_vector != NULL)
free (reloc_vector);
symbols);
reloc_vector = (arelent **) malloc (reloc_size);
- if (reloc_vector == NULL)
+ if (reloc_vector == NULL && reloc_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
rs6000coff_mkarchive (abfd)
bfd *abfd;
{
- bfd_error = invalid_operation; /* write not supported */
+ bfd_set_error (bfd_error_invalid_operation); /* write not supported */
return false;
}
size = sizeof (h.hdr);
if (bfd_read(&h.hdr, 1, size, abfd) != size) {
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return NULL;
}
size = atoi(h.hdr.ar_namlen); /* ar_name[] length */
size += size & 1;
if (bfd_read(&h.hdr._ar_name.ar_name[2], 1, size, abfd) != size) {
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return NULL;
}
if (strncmp(h.hdr._ar_name.ar_fmag + size, AIAFMAG, 2)) {
- bfd_error = malformed_archive;
+ bfd_set_error (bfd_error_malformed_archive);
return NULL;
}
* if the filename is NULL, we're (probably) at the end.
*/
if (size == 0) {
- bfd_error = no_more_archived_files;
+ bfd_set_error (bfd_error_no_more_archived_files);
return NULL;
}
allocptr = bfd_zalloc(abfd, sizeof (*ared) + size);
if (allocptr == NULL) {
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return NULL;
}
n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
if (n_nfd) return n_nfd;
- if (0 != bfd_seek (archive, filepos, SEEK_SET)) {
- bfd_error = system_call_error;
+ if (0 != bfd_seek (archive, filepos, SEEK_SET))
return NULL;
- }
if ((new_areldata = rs6000coff_snarf_ar_hdr (archive)) == NULL) return NULL;
register struct artdata *art;
if (bfd_read (&hdr, sizeof (hdr), 1, abfd) != sizeof (hdr)) {
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
if (strncmp(hdr.fl_magic, AIAMAG, SAIAMAG)) {
- bfd_error = wrong_format;
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
abfd->tdata.aout_ar_data =
(void *) bfd_zalloc(abfd, sizeof (*art) + sizeof (hdr));
if ((art = bfd_ardata (abfd)) == NULL) {
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return 0;
}
char *aloser;
if (abfd->arelt_data == NULL) {
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return -1;
}
unsigned int orl_count;
int stridx;
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
}
#endif /* HOST_AIX */
/* Take a section header read from a coff file (in HOST byte order),
and make a BFD "section" out of it. This is used by ECOFF. */
static boolean
-DEFUN(make_a_section_from_file,(abfd, hdr, target_index),
- bfd *abfd AND
- struct internal_scnhdr *hdr AND
- unsigned int target_index)
+make_a_section_from_file (abfd, hdr, target_index)
+ bfd *abfd;
+ struct internal_scnhdr *hdr;
+ unsigned int target_index;
{
asection *return_section;
char *name;
static
bfd_target *
-DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a),
- bfd *abfd AND
- unsigned nscns AND
- struct internal_filehdr *internal_f AND
- struct internal_aouthdr *internal_a)
+coff_real_object_p (abfd, nscns, internal_f, internal_a)
+ bfd *abfd;
+ unsigned nscns;
+ struct internal_filehdr *internal_f;
+ struct internal_aouthdr *internal_a;
{
PTR tdata;
size_t readsize; /* length of file_info */
not a COFF file. This is also used by ECOFF. */
bfd_target *
-DEFUN(coff_object_p,(abfd),
- bfd *abfd)
+coff_object_p (abfd)
+ bfd *abfd;
{
unsigned int filhsz;
unsigned int aoutsz;
struct internal_filehdr internal_f;
struct internal_aouthdr internal_a;
- bfd_set_error (bfd_error_system_call);
-
/* figure out how much to read */
filhsz = bfd_coff_filhsz (abfd);
aoutsz = bfd_coff_aoutsz (abfd);
if (filehdr == NULL)
return 0;
if (bfd_read(filehdr, 1, filhsz, abfd) != filhsz)
- return 0;
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
+ return 0;
+ }
bfd_coff_swap_filehdr_in(abfd, filehdr, &internal_f);
bfd_release (abfd, filehdr);
/* Get the BFD section from a COFF symbol section number. */
struct sec *
-DEFUN(coff_section_from_bfd_index,(abfd, index),
- bfd *abfd AND
- int index)
+coff_section_from_bfd_index (abfd, index)
+ bfd *abfd;
+ int index;
{
struct sec *answer = abfd->sections;
/* Canonicalize a COFF symbol table. */
unsigned int
-DEFUN(coff_get_symtab, (abfd, alocation),
- bfd *abfd AND
- asymbol **alocation)
+coff_get_symtab (abfd, alocation)
+ bfd *abfd;
+ asymbol **alocation;
{
unsigned int counter = 0;
coff_symbol_type *symbase;
/* Set lineno_count for the output sections of a COFF file. */
int
-DEFUN(coff_count_linenumbers,(abfd),
- bfd *abfd)
+coff_count_linenumbers (abfd)
+ bfd *abfd;
{
unsigned int limit = bfd_get_symcount(abfd);
unsigned int i;
/*ARGSUSED*/
coff_symbol_type *
-DEFUN(coff_symbol_from,(ignore_abfd, symbol),
- bfd *ignore_abfd AND
- asymbol *symbol)
+coff_symbol_from (ignore_abfd, symbol)
+ bfd *ignore_abfd;
+ asymbol *symbol;
{
if (bfd_asymbol_flavour(symbol) != bfd_target_coff_flavour)
return (coff_symbol_type *)NULL;
}
static void
-DEFUN(fixup_symbol_value,(coff_symbol_ptr, syment),
-coff_symbol_type *coff_symbol_ptr AND
-struct internal_syment *syment)
+fixup_symbol_value (coff_symbol_ptr, syment)
+ coff_symbol_type *coff_symbol_ptr;
+ struct internal_syment *syment;
{
/* Normalize the symbol flags */
*/
boolean
-DEFUN(coff_renumber_symbols,(bfd_ptr),
- bfd *bfd_ptr)
+coff_renumber_symbols (bfd_ptr)
+ bfd *bfd_ptr;
{
unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
static asection *debug_string_section;
static void
-DEFUN(coff_fix_symbol_name,(abfd, symbol, native),
- bfd *abfd AND
- asymbol *symbol AND
- combined_entry_type *native)
+coff_fix_symbol_name (abfd, symbol, native)
+ bfd *abfd;
+ asymbol *symbol;
+ combined_entry_type *native;
{
unsigned int name_length;
union internal_auxent *auxent;
#define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
static unsigned int
-DEFUN(coff_write_symbol,(abfd, symbol, native, written),
-bfd *abfd AND
-asymbol *symbol AND
-combined_entry_type *native AND
-unsigned int written)
+coff_write_symbol (abfd, symbol, native, written)
+ bfd *abfd;
+ asymbol *symbol;
+ combined_entry_type *native;
+ unsigned int written;
{
unsigned int numaux = native->u.syment.n_numaux;
int type = native->u.syment.n_type;
static unsigned int
-DEFUN(coff_write_alien_symbol,(abfd, symbol, written),
- bfd *abfd AND
- asymbol *symbol AND
- unsigned int written)
+coff_write_alien_symbol (abfd, symbol, written)
+ bfd *abfd;
+ asymbol *symbol;
+ unsigned int written;
{
/*
This symbol has been created by the loader, or come from a non
}
static unsigned int
-DEFUN(coff_write_native_symbol,(abfd, symbol, written),
-bfd *abfd AND
-coff_symbol_type *symbol AND
-unsigned int written)
+coff_write_native_symbol (abfd, symbol, written)
+ bfd *abfd;
+ coff_symbol_type *symbol;
+ unsigned int written;
{
/*
Does this symbol have an ascociated line number - if so then
}
void
-DEFUN(coff_write_symbols,(abfd),
- bfd *abfd)
+coff_write_symbols (abfd)
+ bfd *abfd;
{
unsigned int i;
unsigned int limit = bfd_get_symcount(abfd);
}
boolean
-DEFUN(coff_write_linenumbers,(abfd),
- bfd *abfd)
+coff_write_linenumbers (abfd)
+ bfd *abfd;
{
asection *s;
bfd_size_type linesz;
if (!buff)
{
bfd_set_error (bfd_error_no_memory);
- return;
+ return false;
}
for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
if (s->lineno_count) {
/*ARGSUSED*/
alent *
-DEFUN(coff_get_lineno,(ignore_abfd, symbol),
- bfd *ignore_abfd AND
- asymbol *symbol)
+coff_get_lineno (ignore_abfd, symbol)
+ bfd *ignore_abfd;
+ asymbol *symbol;
{
return coffsymbol(symbol)->lineno;
}
pointers to syments. */
static void
-DEFUN(coff_pointerize_aux,(abfd, table_base, type, class, auxent),
-bfd *abfd AND
-combined_entry_type *table_base AND
-int type AND
-int class AND
-combined_entry_type *auxent)
+coff_pointerize_aux (abfd, table_base, type, class, auxent)
+ bfd *abfd;
+ combined_entry_type *table_base;
+ int type;
+ int class;
+ combined_entry_type *auxent;
{
/* Don't bother if this is a file or a section */
if (class == C_STAT && type == T_NULL) return;
}
static char *
-DEFUN(build_string_table,(abfd),
-bfd *abfd)
+build_string_table (abfd)
+ bfd *abfd;
{
char string_table_size_buffer[4];
unsigned int string_table_size;
symbols === the symbol table size. */
if (bfd_read((char *) string_table_size_buffer,
sizeof(string_table_size_buffer),
- 1, abfd) != sizeof(string_table_size)) {
- bfd_set_error (bfd_error_system_call);
+ 1, abfd) != sizeof(string_table_size))
return (NULL);
- } /* on error */
string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
bfd_set_error (bfd_error_no_memory);
return (NULL);
} /* on mallocation error */
- if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
- bfd_set_error (bfd_error_system_call);
+ if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size)
return (NULL);
- }
return string_table;
}
we didn't want to go to the trouble until someone needed it. */
static char *
-DEFUN(build_debug_section,(abfd),
- bfd *abfd)
+build_debug_section (abfd)
+ bfd *abfd;
{
char *debug_section;
long position;
bfd_seek (abfd, sect->filepos, SEEK_SET);
if (bfd_read (debug_section,
bfd_get_section_size_before_reloc (sect), 1, abfd)
- != bfd_get_section_size_before_reloc(sect)) {
- bfd_set_error (bfd_error_system_call);
+ != bfd_get_section_size_before_reloc(sect))
return NULL;
- }
bfd_seek (abfd, position, SEEK_SET);
return debug_section;
}
\0-terminated, but will not exceed 'maxlen' characters. The copy *will*
be \0-terminated. */
static char *
-DEFUN(copy_name,(abfd, name, maxlen),
- bfd *abfd AND
- char *name AND
- int maxlen)
+copy_name (abfd, name, maxlen)
+ bfd *abfd;
+ char *name;
+ int maxlen;
{
int len;
char *newname;
terminated string. */
combined_entry_type *
-DEFUN(coff_get_normalized_symtab,(abfd),
-bfd *abfd)
+coff_get_normalized_symtab (abfd)
+ bfd *abfd;
{
combined_entry_type *internal;
combined_entry_type *internal_ptr;
}
if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
- || bfd_read(raw, raw_size, 1, abfd) != raw_size) {
- bfd_set_error (bfd_error_system_call);
+ || bfd_read(raw, raw_size, 1, abfd) != raw_size)
return (NULL);
- }
/* mark the end of the symbols */
raw_end = (char *) raw + bfd_get_symcount(abfd) * symesz;
/*
} /* coff_get_normalized_symtab() */
unsigned int
-DEFUN (coff_get_reloc_upper_bound, (abfd, asect),
- bfd *abfd AND
- sec_ptr asect)
+coff_get_reloc_upper_bound (abfd, asect)
+ bfd *abfd;
+ sec_ptr asect;
{
if (bfd_get_format(abfd) != bfd_object) {
bfd_set_error (bfd_error_invalid_operation);
}
asymbol *
-DEFUN (coff_make_empty_symbol, (abfd),
- bfd *abfd)
+coff_make_empty_symbol (abfd)
+ bfd *abfd;
{
coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
if (new == NULL) {
/*ARGSUSED*/
boolean
-DEFUN(coff_find_nearest_line,(abfd,
- section,
- ignore_symbols,
- offset,
- filename_ptr,
- functionname_ptr,
- line_ptr),
- bfd *abfd AND
- asection *section AND
- asymbol **ignore_symbols AND
- bfd_vma offset AND
- CONST char **filename_ptr AND
- CONST char **functionname_ptr AND
- unsigned int *line_ptr)
+coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
+ functionname_ptr, line_ptr)
+ bfd *abfd;
+ asection *section;
+ asymbol **ignore_symbols;
+ bfd_vma offset;
+ CONST char **filename_ptr;
+ CONST char **functionname_ptr;
+ unsigned int *line_ptr;
{
static bfd *cache_abfd;
static asection *cache_section;
}
int
-DEFUN(coff_sizeof_headers,(abfd, reloc),
- bfd *abfd AND
- boolean reloc)
+coff_sizeof_headers (abfd, reloc)
+ bfd *abfd;
+ boolean reloc;
{
size_t size;
if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) == -1
|| (bfd_read (raw, external_hdr_size, 1, abfd)
!= external_hdr_size))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header;
(*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr);
SEEK_SET) != 0
|| bfd_read (raw, raw_size, 1, abfd) != raw_size)
{
- bfd_set_error (bfd_error_system_call);
bfd_release (abfd, raw);
return false;
}
return false;
if (bfd_read (external_relocs, 1, external_relocs_size, abfd)
!= external_relocs_size)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++)
{
struct internal_aouthdr internal_a;
int i;
- bfd_set_error (bfd_error_system_call);
-
/* Determine where the sections and relocs will go in the output
file. */
reloc_size = ecoff_compute_reloc_file_positions (abfd);
static boolean elf32_hppa_backend_section_from_bfd_section
PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *, int *));
+static boolean som_bfd_is_local_label PARAMS ((bfd *, asymbol *));
+
/* ELF/PA relocation howto entries. */
static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
return NULL;
}
+/* Return true if SYM represents a local label symbol. */
+
+static boolean
+hppa_elf_is_local_label (abfd, sym)
+ bfd *abfd;
+ asymbol *sym;
+{
+ return (sym->name[0] == 'L' && sym->name[1] == '$');
+}
/* Update the symbol extention chain to include the symbol pointed to
by SYMBOLP if SYMBOLP is a function symbol. Used internally and by GAS. */
/* Make space to hold the relocations for the stub section. */
reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
reloc_vector = (arelent **) malloc (reloc_size);
- if (reloc_vector == NULL)
+ if (reloc_vector == NULL && reloc_size != 0)
{
/* FIXME: should be returning an error so the caller can
clean up */
/* Read in the symextn section. */
if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ return false;
if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->size, abfd)
!= symextn_hdr->size)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ return false;
/* Parse entries in the symbol extension section, updating the symtab
entries as we go */
#define bfd_generic_get_section_contents hppa_elf_get_section_contents
#define bfd_elf32_set_section_contents hppa_elf_set_section_contents
+#define bfd_elf32_bfd_is_local_label hppa_elf_is_local_label
#define elf_backend_section_processing elf32_hppa_backend_section_processing
/* Read in the ELF header in external format. */
if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
- goto got_system_call;
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ goto got_wrong_format_error;
+ else
+ goto got_no_match;
+ }
/* Now check to see if we have a valid ELF file, and one that BFD can
make use of. The magic number must match, the address size ('class')
if (!i_shdrp || !elf_elfsections (abfd))
goto got_no_memory_error;
if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) == -1)
- goto got_system_call;
+ goto got_no_match;
for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
{
if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
- goto got_system_call;
+ goto got_no_match;
elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
/* If we are going to use goto's to avoid duplicating error setting
and return(NULL) code, then this at least makes it more maintainable. */
-got_system_call:
- bfd_set_error (bfd_error_system_call);
- goto got_no_match;
got_wrong_format_error:
bfd_set_error (bfd_error_wrong_format);
goto got_no_match;
struct seg_info *seg = NULL;
done = (char *) malloc (i_ehdrp->e_shnum);
- if (done == NULL)
+ if (done == NULL && i_ehdrp->e_shnum != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
build the caller's pointer vector. */
if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
symcount = hdr->sh_size / sizeof (Elf_External_Sym);
long i;
if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
symbase = ((elf_symbol_type *)
bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
/* Temporarily allocate room for the raw ELF symbols. */
x_symp = ((Elf_External_Sym *)
malloc (symcount * sizeof (Elf_External_Sym)));
- if (x_symp == NULL)
+ if (x_symp == NULL && symcount != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
!= symcount * sizeof (Elf_External_Sym))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Skip first symbol, which is a null dummy. */
for (i = 1; i < symcount; i++)
{
if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
{
- bfd_set_error (bfd_error_system_call);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return NULL;
}
return NULL;
}
if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return NULL;
- }
+ return NULL;
for (phindex = 0; phindex < i_ehdrp->e_phnum; phindex++)
{
if (bfd_read ((PTR) & x_phdr, sizeof (x_phdr), 1, abfd)
!= sizeof (x_phdr))
- {
- bfd_set_error (bfd_error_system_call);
- return NULL;
- }
+ return NULL;
elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
}
/* Set parameters about this a.out file that are machine-dependent.
This routine is called from some_aout_object_p just before it returns. */
static bfd_target *
-DEFUN(MY(callback),(abfd),
- bfd *abfd)
+MY (callback) (abfd)
+ bfd *abfd;
{
struct internal_exec *execp = exec_hdr (abfd);
/* Calculate the file positions of the parts of a newly read aout header */
- obj_textsec (abfd)->_raw_size = N_TXTSIZE(*execp);
+ obj_textsec (abfd)->_raw_size = N_TXTSIZE (*execp);
/* The virtual memory addresses of the sections */
- obj_textsec (abfd)->vma = N_TXTADDR(*execp);
- obj_datasec (abfd)->vma = N_DATADDR(*execp);
- obj_bsssec (abfd)->vma = N_BSSADDR(*execp);
+ obj_textsec (abfd)->vma = N_TXTADDR (*execp);
+ obj_datasec (abfd)->vma = N_DATADDR (*execp);
+ obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
/* The file offsets of the sections */
obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
obj_datasec (abfd)->filepos = N_DATOFF (*execp);
/* The file offsets of the relocation info */
- obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
- obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
+ obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
+ obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
obj_sym_filepos (abfd) = N_SYMOFF (*execp);
/* Determine the architecture and machine type of the object file. */
#ifdef SET_ARCH_MACH
- SET_ARCH_MACH(abfd, *execp);
+ SET_ARCH_MACH (abfd, *execp);
#else
- bfd_default_set_arch_mach(abfd, DEFAULT_ARCH, 0);
+ bfd_default_set_arch_mach (abfd, DEFAULT_ARCH, 0);
#endif
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- {
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ {
/* The file offsets of the relocation info */
- obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF(*execp);
- obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF(*execp);
+ obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF (*execp);
+ obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
- obj_sym_filepos (abfd) = N_GNU_SYMOFF(*execp);
+ obj_sym_filepos (abfd) = N_GNU_SYMOFF (*execp);
obj_str_filepos (abfd) = (obj_sym_filepos (abfd) + execp->a_syms);
abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
bfd_get_symcount (abfd) = execp->a_syms / 12;
obj_symbol_entry_size (abfd) = 12;
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
- }
+ }
return abfd->xvec;
}
-extern boolean aout_32_write_syms PARAMS ((bfd *abfd));
+extern boolean aout_32_write_syms PARAMS ((bfd * abfd));
static boolean
-DEFUN(MY(write_object_contents),(abfd),
- bfd *abfd)
+MY (write_object_contents) (abfd)
+ bfd *abfd;
{
- struct external_exec exec_bytes;
- struct internal_exec *execp = exec_hdr (abfd);
- bfd_size_type text_size; /* dummy vars */
- file_ptr text_end;
+ struct external_exec exec_bytes;
+ struct internal_exec *execp = exec_hdr (abfd);
+ bfd_size_type text_size; /* dummy vars */
+ file_ptr text_end;
- memset (&exec_bytes, 0, sizeof (exec_bytes));
+ memset (&exec_bytes, 0, sizeof (exec_bytes));
#if CHOOSE_RELOC_SIZE
- CHOOSE_RELOC_SIZE(abfd);
+ CHOOSE_RELOC_SIZE (abfd);
#else
- obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
+ obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
#endif
- if (adata(abfd).magic == undecided_magic)
- NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
- execp->a_syms = 0;
+ if (adata (abfd).magic == undecided_magic)
+ NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
+ execp->a_syms = 0;
- execp->a_entry = bfd_get_start_address (abfd);
+ execp->a_entry = bfd_get_start_address (abfd);
- execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
- obj_reloc_entry_size (abfd));
- execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
- obj_reloc_entry_size (abfd));
+ execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
+ obj_reloc_entry_size (abfd));
+ execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
+ obj_reloc_entry_size (abfd));
- N_SET_MACHTYPE(*execp, 0xc);
- N_SET_FLAGS (*execp, 0x2);
+ N_SET_MACHTYPE (*execp, 0xc);
+ N_SET_FLAGS (*execp, 0x2);
- NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
+ NAME (aout, swap_exec_header_out) (abfd, execp, &exec_bytes);
- /* update fields not covered by default swap_exec_header_out */
+ /* update fields not covered by default swap_exec_header_out */
- /* this is really the sym table size but we store it in drelocs */
- bfd_h_put_32 (abfd, bfd_get_symcount (abfd) * 12, exec_bytes.e_drelocs);
+ /* this is really the sym table size but we store it in drelocs */
+ bfd_h_put_32 (abfd, bfd_get_symcount (abfd) * 12, exec_bytes.e_drelocs);
- bfd_seek (abfd, 0L, false);
- bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
+ bfd_seek (abfd, 0L, false);
+ bfd_write ((PTR) & exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
- /* Write out the symbols, and then the relocs. We must write out
+ /* Write out the symbols, and then the relocs. We must write out
the symbols first so that we know the symbol indices. */
- if (bfd_get_symcount (abfd) != 0)
- {
- /* Skip the relocs to where we want to put the symbols. */
- if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
- SEEK_SET) != 0)
- return false;
- }
+ if (bfd_get_symcount (abfd) != 0)
+ {
+ /* Skip the relocs to where we want to put the symbols. */
+ if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
+ SEEK_SET) != 0)
+ return false;
+ }
- if (! MY(write_syms) (abfd))
- return false;
+ if (!MY (write_syms) (abfd))
+ return false;
- if (bfd_get_symcount (abfd) != 0)
- {
- bfd_seek (abfd, (long)(N_TRELOFF(*execp)), false);
+ if (bfd_get_symcount (abfd) != 0)
+ {
+ bfd_seek (abfd, (long) (N_TRELOFF (*execp)), false);
- if (!NAME(aout,squirt_out_relocs) (abfd, obj_textsec (abfd))) return false;
- bfd_seek (abfd, (long)(N_DRELOFF(*execp)), false);
+ if (!NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd)))
+ return false;
+ bfd_seek (abfd, (long) (N_DRELOFF (*execp)), false);
- if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false;
+ if (!NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
+ return false;
}
- return true;
-}
+ return true;
+}
/* convert the hp symbol type to be the same as aout64.h usage so we */
/* can piggyback routines in aoutx.h. */
static void
-DEFUN(convert_sym_type,(sym_pointer, cache_ptr, abfd),
- struct external_nlist *sym_pointer AND
- aout_symbol_type *cache_ptr AND
- bfd *abfd)
+convert_sym_type (sym_pointer, cache_ptr, abfd)
+ struct external_nlist *sym_pointer;
+ aout_symbol_type *cache_ptr;
+ bfd *abfd;
{
- int name_type;
- int new_type;
+ int name_type;
+ int new_type;
- name_type = (cache_ptr->type);
- new_type = 0;
+ name_type = (cache_ptr->type);
+ new_type = 0;
- if ((name_type & HP_SYMTYPE_ALIGN) != 0)
+ if ((name_type & HP_SYMTYPE_ALIGN) != 0)
{
- /* iou_error ("aligned symbol encountered: %s", name);*/
- name_type = 0;
+ /* iou_error ("aligned symbol encountered: %s", name);*/
+ name_type = 0;
}
- if (name_type == HP_SYMTYPE_FILENAME)
- new_type = N_FN;
- else
- {
- switch (name_type & HP_SYMTYPE_TYPE)
- {
- case HP_SYMTYPE_UNDEFINED:
- new_type = N_UNDF;
- break;
-
- case HP_SYMTYPE_ABSOLUTE:
- new_type = N_ABS;
- break;
-
- case HP_SYMTYPE_TEXT:
- new_type = N_TEXT;
- break;
-
- case HP_SYMTYPE_DATA:
- new_type = N_DATA;
- break;
-
- case HP_SYMTYPE_BSS:
- new_type = N_BSS;
- break;
-
- case HP_SYMTYPE_COMMON:
- new_type = N_COMM;
- break;
-
- default:
- fprintf (stderr, "unknown symbol type encountered: %x", name_type);
- }
- if (name_type & HP_SYMTYPE_EXTERNAL)
- new_type |= N_EXT;
-
- if (name_type & HP_SECONDARY_SYMBOL)
- new_type = (new_type & ~N_TYPE) | N_INDR;
- }
- cache_ptr->type = new_type;
+ if (name_type == HP_SYMTYPE_FILENAME)
+ new_type = N_FN;
+ else
+ {
+ switch (name_type & HP_SYMTYPE_TYPE)
+ {
+ case HP_SYMTYPE_UNDEFINED:
+ new_type = N_UNDF;
+ break;
+
+ case HP_SYMTYPE_ABSOLUTE:
+ new_type = N_ABS;
+ break;
+
+ case HP_SYMTYPE_TEXT:
+ new_type = N_TEXT;
+ break;
+
+ case HP_SYMTYPE_DATA:
+ new_type = N_DATA;
+ break;
+
+ case HP_SYMTYPE_BSS:
+ new_type = N_BSS;
+ break;
+
+ case HP_SYMTYPE_COMMON:
+ new_type = N_COMM;
+ break;
+
+ default:
+ fprintf (stderr, "unknown symbol type encountered: %x", name_type);
+ }
+ if (name_type & HP_SYMTYPE_EXTERNAL)
+ new_type |= N_EXT;
+
+ if (name_type & HP_SECONDARY_SYMBOL)
+ new_type = (new_type & ~N_TYPE) | N_INDR;
+ }
+ cache_ptr->type = new_type;
}
*/
void
-DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
- bfd *abfd AND
- struct external_exec *raw_bytes AND
- struct internal_exec *execp)
+ NAME (aout, swap_exec_header_in) (abfd, raw_bytes, execp)
+ bfd *abfd;
+ struct external_exec *raw_bytes;
+ struct internal_exec *execp;
{
- struct external_exec *bytes = (struct external_exec *)raw_bytes;
+ struct external_exec *bytes = (struct external_exec *) raw_bytes;
/* The internal_exec structure has some fields that are unused in this
configuration (IE for i960), so ensure that all such uninitialized
are memcmp'd, and thus the contents do matter. */
memset (execp, 0, sizeof (struct internal_exec));
/* Now fill in fields in the execp, from the bytes in the raw data. */
- execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
- execp->a_text = GET_WORD (abfd, bytes->e_text);
- execp->a_data = GET_WORD (abfd, bytes->e_data);
- execp->a_bss = GET_WORD (abfd, bytes->e_bss);
- execp->a_syms = GET_WORD (abfd, bytes->e_syms);
- execp->a_entry = GET_WORD (abfd, bytes->e_entry);
+ execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
+ execp->a_text = GET_WORD (abfd, bytes->e_text);
+ execp->a_data = GET_WORD (abfd, bytes->e_data);
+ execp->a_bss = GET_WORD (abfd, bytes->e_bss);
+ execp->a_syms = GET_WORD (abfd, bytes->e_syms);
+ execp->a_entry = GET_WORD (abfd, bytes->e_entry);
execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
/* to be set. */
/***************************************************************/
do
- {
+ {
long syms;
- struct aout_data_struct *rawptr;
- if (bfd_h_get_32 (abfd, bytes->e_passize) != 0) break;
- if (bfd_h_get_32 (abfd, bytes->e_syms) != 0) break;
- if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0) break;
+ struct aout_data_struct *rawptr;
+ if (bfd_h_get_32 (abfd, bytes->e_passize) != 0)
+ break;
+ if (bfd_h_get_32 (abfd, bytes->e_syms) != 0)
+ break;
+ if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0)
+ break;
syms = bfd_h_get_32 (abfd, bytes->e_drelocs);
- if (syms == 0) break;
+ if (syms == 0)
+ break;
/* OK, we've passed the test as best as we can determine */
execp->a_syms = syms;
/* allocate storage for where we will store this result */
- rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
+ rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
- if (rawptr == NULL) {
- bfd_error = no_memory;
- return;
- }
+ if (rawptr == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return;
+ }
abfd->tdata.aout_data = rawptr;
- obj_aout_subformat(abfd) = gnu_encap_format;
- } while (0);
+ obj_aout_subformat (abfd) = gnu_encap_format;
+ }
+ while (0);
}
*/
boolean
-DEFUN(MY(slurp_symbol_table),(abfd),
- bfd *abfd)
+MY (slurp_symbol_table) (abfd)
+ bfd *abfd;
{
bfd_size_type symbol_bytes;
struct external_nlist *syms;
unsigned num_secondary = 0;
/* If there's no work to be done, don't do any */
- if (obj_aout_symbols (abfd) != (aout_symbol_type *)NULL) return true;
- symbol_bytes = exec_hdr(abfd)->a_syms;
- if (symbol_bytes == 0) {
- bfd_error = no_symbols;
- return false;
- }
+ if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
+ return true;
+ symbol_bytes = exec_hdr (abfd)->a_syms;
+ if (symbol_bytes == 0)
+ {
+ bfd_set_error (bfd_error_no_symbols);
+ return false;
+ }
- strings = (char *) bfd_alloc(abfd,
- symbol_bytes + SYM_EXTRA_BYTES);
+ strings = (char *) bfd_alloc (abfd,
+ symbol_bytes + SYM_EXTRA_BYTES);
if (!strings)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
syms = (struct external_nlist *) (strings + SYM_EXTRA_BYTES);
bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
- if (bfd_read ((PTR)syms, symbol_bytes, 1, abfd) != symbol_bytes)
- {
+ if (bfd_read ((PTR) syms, symbol_bytes, 1, abfd) != symbol_bytes)
+ {
bfd_release (abfd, syms);
return false;
- }
+ }
- sym_end = (struct external_nlist *) (((char *)syms) + symbol_bytes);
+ sym_end = (struct external_nlist *) (((char *) syms) + symbol_bytes);
/* first, march thru the table and figure out how many symbols there are */
for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++, num_syms++)
- {
- if (bfd_get_8(abfd, sym_pointer->e_type) & HP_SECONDARY_SYMBOL)
- num_secondary++;
+ {
+ if (bfd_get_8 (abfd, sym_pointer->e_type) & HP_SECONDARY_SYMBOL)
+ num_secondary++;
/* skip over the embedded symbol. */
- sym_pointer = (struct external_nlist *) (((char *)sym_pointer) +
- sym_pointer->e_length[0]);
- }
+ sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
+ sym_pointer->e_length[0]);
+ }
/* now that we know the symbol count, update the bfd header */
- bfd_get_symcount (abfd) = num_syms+num_secondary;
+ bfd_get_symcount (abfd) = num_syms + num_secondary;
cached = (aout_symbol_type *)
- bfd_zalloc(abfd, (bfd_size_type)(bfd_get_symcount (abfd) *
- sizeof(aout_symbol_type)));
+ bfd_zalloc (abfd, (bfd_size_type) (bfd_get_symcount (abfd) *
+ sizeof (aout_symbol_type)));
if (!cached)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
num_secondary = 0;
/* OK, now walk the new symtable, cacheing symbol properties */
- {
- aout_symbol_type *cache_ptr = cached;
- aout_symbol_type cache_save;
- /* Run through table and copy values */
- for (sym_pointer = syms, cache_ptr = cached;
- sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+ {
+ aout_symbol_type *cache_ptr = cached;
+ aout_symbol_type cache_save;
+ /* Run through table and copy values */
+ for (sym_pointer = syms, cache_ptr = cached;
+ sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+ {
+ unsigned int length;
+ cache_ptr->symbol.the_bfd = abfd;
+ cache_ptr->symbol.value = GET_SWORD (abfd, sym_pointer->e_value);
+ cache_ptr->desc = bfd_get_16 (abfd, sym_pointer->e_almod);
+ cache_ptr->type = bfd_get_8 (abfd, sym_pointer->e_type);
+ cache_ptr->symbol.udata = 0;
+ length = bfd_get_8 (abfd, sym_pointer->e_length);
+ cache_ptr->other = length; /* other not used, save length here */
+
+ cache_save = *cache_ptr;
+ convert_sym_type (sym_pointer, cache_ptr, abfd);
+ if (!translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd))
+ return false;
+
+ /********************************************************/
+ /* for hpux, the 'lenght' value indicates the length of */
+ /* the symbol name which follows the nlist entry. */
+ /********************************************************/
+ if (length)
{
- unsigned int length;
- cache_ptr->symbol.the_bfd = abfd;
- cache_ptr->symbol.value = GET_SWORD(abfd, sym_pointer->e_value);
- cache_ptr->desc = bfd_get_16(abfd, sym_pointer->e_almod);
- cache_ptr->type = bfd_get_8(abfd, sym_pointer->e_type);
- cache_ptr->symbol.udata = 0;
- length = bfd_get_8(abfd, sym_pointer->e_length);
- cache_ptr->other = length; /* other not used, save length here */
-
- cache_save = *cache_ptr;
- convert_sym_type(sym_pointer, cache_ptr, abfd);
- if (!translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd))
+ /**************************************************************/
+ /* the hp string is not null terminated so we create a new one*/
+ /* by copying the string to overlap the just vacated nlist */
+ /* structure before it in memory. */
+ /**************************************************************/
+ cache_ptr->symbol.name = strings;
+ memcpy (strings, sym_pointer + 1, length);
+ strings[length] = '\0';
+ strings += length + 1;
+ }
+ else
+ cache_ptr->symbol.name = (char *) NULL;
+
+ /**********************************************************/
+ /* this is a bit of a kludge, but a secondary hp symbol */
+ /* gets translated into a gnu indirect symbol. When this */
+ /* happens, we need to create a "dummy" record to which */
+ /* we can point the indirect symbol to. */
+ /**********************************************************/
+ if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
+ {
+ aout_symbol_type *cache_ptr2 = cached + num_syms + num_secondary;
+
+ num_secondary++;
+
+ /* aoutx.h assumes the "next" value is the indirect sym */
+ /* since we don't want to disturb the order by inserting */
+ /* a new symbol, we tack on the created secondary syms */
+ /* at the end. */
+ cache_ptr->symbol.value = (bfd_vma) (cache_ptr2);
+ *cache_ptr2 = cache_save;
+ cache_ptr2->symbol.name = strings;
+ memcpy (strings, cache_ptr->symbol.name, length);
+ strcpy (strings + length, ":secondry"); /* 9 max chars + null */
+ strings += length + 10;
+ cache_ptr2->type &= ~HP_SECONDARY_SYMBOL; /* clear secondary */
+ convert_sym_type (sym_pointer, cache_ptr2, abfd);
+ if (!translate_from_native_sym_flags (sym_pointer, cache_ptr2,
+ abfd))
return false;
-
- /********************************************************/
- /* for hpux, the 'lenght' value indicates the length of */
- /* the symbol name which follows the nlist entry. */
- /********************************************************/
- if (length)
- {
- /**************************************************************/
- /* the hp string is not null terminated so we create a new one*/
- /* by copying the string to overlap the just vacated nlist */
- /* structure before it in memory. */
- /**************************************************************/
- cache_ptr->symbol.name = strings;
- memcpy(strings, sym_pointer+1, length);
- strings[length] = '\0';
- strings += length + 1;
- }
- else
- cache_ptr->symbol.name = (char *)NULL;
-
- /**********************************************************/
- /* this is a bit of a kludge, but a secondary hp symbol */
- /* gets translated into a gnu indirect symbol. When this */
- /* happens, we need to create a "dummy" record to which */
- /* we can point the indirect symbol to. */
- /**********************************************************/
- if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
- {
- aout_symbol_type *cache_ptr2 = cached + num_syms+num_secondary;
-
- num_secondary++;
-
- /* aoutx.h assumes the "next" value is the indirect sym */
- /* since we don't want to disturb the order by inserting */
- /* a new symbol, we tack on the created secondary syms */
- /* at the end. */
- cache_ptr->symbol.value = (bfd_vma)(cache_ptr2);
- *cache_ptr2 = cache_save;
- cache_ptr2->symbol.name = strings;
- memcpy(strings, cache_ptr->symbol.name, length);
- strcpy(strings+length,":secondry"); /* 9 max chars + null */
- strings += length+10;
- cache_ptr2->type &= ~HP_SECONDARY_SYMBOL; /* clear secondary */
- convert_sym_type(sym_pointer, cache_ptr2, abfd);
- if (!translate_from_native_sym_flags (sym_pointer, cache_ptr2,
- abfd))
- return false;
- }
-
- /* skip over the embedded symbol. */
- sym_pointer = (struct external_nlist *) (((char *)sym_pointer) +
- length);
}
- }
- obj_aout_symbols (abfd) = cached;
+ /* skip over the embedded symbol. */
+ sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
+ length);
+ }
+ }
+
+ obj_aout_symbols (abfd) = cached;
return true;
}
void
-DEFUN(MY(swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
- bfd *abfd AND
- struct hp300hpux_reloc *bytes AND
- arelent *cache_ptr AND
- asymbol **symbols)
+MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+ bfd *abfd;
+ struct hp300hpux_reloc *bytes;
+ arelent *cache_ptr;
+ asymbol **symbols;
{
int r_index;
int r_extern = 0;
unsigned int r_length;
int r_pcrel = 0;
- struct aoutdata *su = &(abfd->tdata.aout_data->a);
+ struct aoutdata *su = &(abfd->tdata.aout_data->a);
cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
- r_index = bfd_h_get_16(abfd, bytes->r_index);
+ r_index = bfd_h_get_16 (abfd, bytes->r_index);
switch (bytes->r_type[0])
- {
- case HP_RSEGMENT_TEXT:
+ {
+ case HP_RSEGMENT_TEXT:
r_index = N_TEXT;
break;
- case HP_RSEGMENT_DATA:
+ case HP_RSEGMENT_DATA:
r_index = N_DATA;
break;
- case HP_RSEGMENT_BSS:
+ case HP_RSEGMENT_BSS:
r_index = N_BSS;
break;
- case HP_RSEGMENT_EXTERNAL:
+ case HP_RSEGMENT_EXTERNAL:
r_extern = 1;
break;
- case HP_RSEGMENT_PCREL:
+ case HP_RSEGMENT_PCREL:
r_extern = 1;
r_pcrel = 1;
break;
- case HP_RSEGMENT_RDLT:
+ case HP_RSEGMENT_RDLT:
break;
- case HP_RSEGMENT_RPLT:
+ case HP_RSEGMENT_RPLT:
break;
- case HP_RSEGMENT_NOOP:
+ case HP_RSEGMENT_NOOP:
break;
- default:
+ default:
fprintf (stderr, "illegal relocation segment type: %x\n",
(bytes->r_type[0]));
- }
+ }
switch (bytes->r_length[0])
{
r_length = 2;
break;
default:
- fprintf (stderr, "illegal relocation length: %x\n",bytes->r_length[0] );
+ fprintf (stderr, "illegal relocation length: %x\n", bytes->r_length[0]);
r_length = 0;
}
- cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
+ cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
/* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */
/* This macro uses the r_index value computed above */
if (r_pcrel && r_extern)
- {
- /* The GNU linker assumes any offset from beginning of section */
- /* is already incorporated into the image while the HP linker */
- /* adds this in later. Add it in now... */
- MOVE_ADDRESS( - cache_ptr->address);
- }
+ {
+ /* The GNU linker assumes any offset from beginning of section */
+ /* is already incorporated into the image while the HP linker */
+ /* adds this in later. Add it in now... */
+ MOVE_ADDRESS (-cache_ptr->address);
+ }
else
- {
- MOVE_ADDRESS(0);
- }
+ {
+ MOVE_ADDRESS (0);
+ }
}
boolean
-DEFUN(MY(slurp_reloc_table),(abfd, asect, symbols),
- bfd *abfd AND
- sec_ptr asect AND
- asymbol **symbols)
+MY (slurp_reloc_table) (abfd, asect, symbols)
+ bfd *abfd;
+ sec_ptr asect;
+ asymbol **symbols;
{
unsigned int count;
bfd_size_type reloc_size;
unsigned int counter;
arelent *cache_ptr;
- if (asect->relocation) return true;
+ if (asect->relocation)
+ return true;
- if (asect->flags & SEC_CONSTRUCTOR) return true;
+ if (asect->flags & SEC_CONSTRUCTOR)
+ return true;
- if (asect == obj_datasec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_drsize;
- goto doit;
- }
+ if (asect == obj_datasec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_drsize;
+ goto doit;
+ }
- if (asect == obj_textsec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_trsize;
- goto doit;
- }
+ if (asect == obj_textsec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_trsize;
+ goto doit;
+ }
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
- doit:
+doit:
bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
each_size = obj_reloc_entry_size (abfd);
count = reloc_size / each_size;
- reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t)(count * sizeof
- (arelent)));
- if (!reloc_cache) {
-nomem:
- bfd_error = no_memory;
- return false;
- }
+ reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t) (count * sizeof
+ (arelent)));
+ if (!reloc_cache)
+ {
+ nomem:
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
relocs = (PTR) bfd_alloc (abfd, reloc_size);
- if (!relocs) {
- bfd_release (abfd, reloc_cache);
- goto nomem;
- }
+ if (!relocs)
+ {
+ bfd_release (abfd, reloc_cache);
+ goto nomem;
+ }
- if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size) {
- bfd_release (abfd, relocs);
- bfd_release (abfd, reloc_cache);
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+ {
+ bfd_release (abfd, relocs);
+ bfd_release (abfd, reloc_cache);
+ return false;
+ }
- rptr = (struct hp300hpux_reloc*) relocs;
- counter = 0;
- cache_ptr = reloc_cache;
+ rptr = (struct hp300hpux_reloc *) relocs;
+ counter = 0;
+ cache_ptr = reloc_cache;
- for (; counter < count; counter++, rptr++, cache_ptr++) {
- MY(swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
+ for (; counter < count; counter++, rptr++, cache_ptr++)
+ {
+ MY (swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
}
- bfd_release (abfd,relocs);
+ bfd_release (abfd, relocs);
asect->relocation = reloc_cache;
asect->reloc_count = count;
return true;
/* call aout_32 versions if the input file was generated by gcc */
/************************************************************************/
-unsigned int aout_32_get_symtab PARAMS((bfd *abfd, asymbol **location));
-unsigned int aout_32_get_symtab_upper_bound PARAMS ((bfd *abfd));
+unsigned int aout_32_get_symtab PARAMS ((bfd * abfd, asymbol ** location));
+unsigned int aout_32_get_symtab_upper_bound PARAMS ((bfd * abfd));
-unsigned int aout_32_canonicalize_reloc PARAMS((bfd *abfd, sec_ptr section,
- arelent **relptr,
- asymbol **symbols));
+unsigned int aout_32_canonicalize_reloc PARAMS ((bfd * abfd, sec_ptr section,
+ arelent ** relptr,
+ asymbol ** symbols));
unsigned int
-DEFUN(MY(get_symtab),(abfd, location),
- bfd *abfd AND
- asymbol **location)
+MY (get_symtab) (abfd, location)
+ bfd *abfd;
+ asymbol **location;
{
- unsigned int counter = 0;
- aout_symbol_type *symbase;
+ unsigned int counter = 0;
+ aout_symbol_type *symbase;
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- return aout_32_get_symtab(abfd,location);
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_get_symtab (abfd, location);
- if (!MY(slurp_symbol_table)(abfd)) return 0;
+ if (!MY (slurp_symbol_table) (abfd))
+ return 0;
- for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
- *(location++) = (asymbol *)( symbase++);
- *location++ =0;
- return bfd_get_symcount (abfd);
+ for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
+ *(location++) = (asymbol *) (symbase++);
+ *location++ = 0;
+ return bfd_get_symcount (abfd);
}
- unsigned int
-DEFUN(MY(get_symtab_upper_bound),(abfd),
- bfd *abfd)
+unsigned int
+MY (get_symtab_upper_bound) (abfd)
+ bfd *abfd;
{
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- return aout_32_get_symtab_upper_bound(abfd);
- if (!MY(slurp_symbol_table)(abfd)) return 0;
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_get_symtab_upper_bound (abfd);
+ if (!MY (slurp_symbol_table) (abfd))
+ return 0;
- return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
+ return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
}
unsigned int
-DEFUN(MY(canonicalize_reloc),(abfd, section, relptr, symbols),
- bfd *abfd AND
- sec_ptr section AND
- arelent **relptr AND
- asymbol **symbols)
+MY (canonicalize_reloc) (abfd, section, relptr, symbols)
+ bfd *abfd;
+ sec_ptr section;
+ arelent **relptr;
+ asymbol **symbols;
{
arelent *tblptr = section->relocation;
unsigned int count;
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- return aout_32_canonicalize_reloc(abfd,section,relptr,symbols);
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
- if (!(tblptr || MY(slurp_reloc_table)(abfd, section, symbols)))
+ if (!(tblptr || MY (slurp_reloc_table) (abfd, section, symbols)))
return 0;
- if (section->flags & SEC_CONSTRUCTOR) {
- arelent_chain *chain = section->constructor_chain;
- for (count = 0; count < section->reloc_count; count ++) {
- *relptr ++ = &chain->relent;
- chain = chain->next;
+ if (section->flags & SEC_CONSTRUCTOR)
+ {
+ arelent_chain *chain = section->constructor_chain;
+ for (count = 0; count < section->reloc_count; count++)
+ {
+ *relptr++ = &chain->relent;
+ chain = chain->next;
+ }
+ }
+ else
+ {
+ tblptr = section->relocation;
+ if (!tblptr)
+ return 0;
+
+ for (count = 0; count++ < section->reloc_count;)
+ {
+ *relptr++ = tblptr++;
+ }
}
- }
- else {
- tblptr = section->relocation;
- if (!tblptr) return 0;
-
- for (count = 0; count++ < section->reloc_count;)
- {
- *relptr++ = tblptr++;
- }
- }
*relptr = 0;
return section->reloc_count;
-/* BFD back-end for i386 a.out binaries under Lynx.
+/* BFD back-end for i386 a.out binaries under LynxOS.
Copyright (C) 1990, 1991, 1992 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
{ \
bfd_seek (abfd, (file_ptr)(N_SYMOFF(*execp)), SEEK_SET); \
\
- NAME(aout,write_syms)(abfd); \
+ if (! NAME(aout,write_syms)(abfd)) return false; \
\
bfd_seek (abfd, (file_ptr)(N_TRELOFF(*execp)), SEEK_SET); \
\
\
if (!NAME(lynx,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false; \
} \
- }
+ }
#endif
#include "libaout.h"
#ifdef HOST_LYNX
-char *lynx_core_file_failing_command();
-int lynx_core_file_failing_signal();
-boolean lynx_core_file_matches_executable_p();
-bfd_target *lynx_core_file_p();
+char *lynx_core_file_failing_command ();
+int lynx_core_file_failing_signal ();
+boolean lynx_core_file_matches_executable_p ();
+bfd_target *lynx_core_file_p ();
#define MY_core_file_failing_command lynx_core_file_failing_command
#define MY_core_file_failing_signal lynx_core_file_failing_signal
#define MY_core_file_p lynx_core_file_p
#endif /* HOST_LYNX */
-
\f
+
#define KEEPIT flags
extern reloc_howto_type aout_32_ext_howto_table[];
/* Output standard relocation information to a file in target byte order. */
void
-DEFUN(NAME(lynx,swap_std_reloc_out),(abfd, g, natptr),
- bfd *abfd AND
- arelent *g AND
- struct reloc_std_external *natptr)
+NAME (lynx, swap_std_reloc_out) (abfd, g, natptr)
+ bfd *abfd;
+ arelent *g;
+ struct reloc_std_external *natptr;
{
int r_index;
asymbol *sym = *(g->sym_ptr_ptr);
unsigned int r_addend;
asection *output_section = sym->section->output_section;
- PUT_WORD(abfd, g->address, natptr->r_address);
+ PUT_WORD (abfd, g->address, natptr->r_address);
- r_length = g->howto->size ; /* Size as a power of two */
- r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
+ r_length = g->howto->size; /* Size as a power of two */
+ r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
/* r_baserel, r_jmptable, r_relative??? FIXME-soon */
r_baserel = 0;
r_jmptable = 0;
r_relative = 0;
-
+
r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
-
+
/* name was clobbered by aout_write_syms to be symbol index */
- /* If this relocation is relative to a symbol then set the
+ /* If this relocation is relative to a symbol then set the
r_index to the symbols index, and the r_extern bit.
Absolute symbols can come in in two ways, either as an offset
from the abs section, or as a symbol which has an abs value.
check for that here
*/
-
+
if (bfd_is_com_section (output_section)
|| output_section == &bfd_abs_section
- || output_section == &bfd_und_section)
+ || output_section == &bfd_und_section)
{
if (bfd_abs_section.symbol == sym)
- {
- /* Whoops, looked like an abs symbol, but is really an offset
+ {
+ /* Whoops, looked like an abs symbol, but is really an offset
from the abs section */
- r_index = 0;
- r_extern = 0;
- }
- else
- {
- /* Fill in symbol */
- r_extern = 1;
- r_index = stoi((*(g->sym_ptr_ptr))->KEEPIT);
-
- }
+ r_index = 0;
+ r_extern = 0;
+ }
+ else
+ {
+ /* Fill in symbol */
+ r_extern = 1;
+ r_index = stoi ((*(g->sym_ptr_ptr))->KEEPIT);
+
+ }
}
- else
+ else
{
/* Just an ordinary section */
r_extern = 0;
- r_index = output_section->target_index;
+ r_index = output_section->target_index;
}
/* now the fun stuff */
- if (abfd->xvec->header_byteorder_big_p != false) {
+ if (abfd->xvec->header_byteorder_big_p != false)
+ {
natptr->r_index[0] = r_index >> 16;
natptr->r_index[1] = r_index >> 8;
natptr->r_index[2] = r_index;
natptr->r_type[0] =
- (r_extern? RELOC_STD_BITS_EXTERN_BIG: 0)
- | (r_pcrel? RELOC_STD_BITS_PCREL_BIG: 0)
- | (r_baserel? RELOC_STD_BITS_BASEREL_BIG: 0)
- | (r_jmptable? RELOC_STD_BITS_JMPTABLE_BIG: 0)
- | (r_relative? RELOC_STD_BITS_RELATIVE_BIG: 0)
- | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
- } else {
- natptr->r_index[2] = r_index >> 16;
- natptr->r_index[1] = r_index >> 8;
- natptr->r_index[0] = r_index;
- natptr->r_type[0] =
- (r_extern? RELOC_STD_BITS_EXTERN_LITTLE: 0)
- | (r_pcrel? RELOC_STD_BITS_PCREL_LITTLE: 0)
- | (r_baserel? RELOC_STD_BITS_BASEREL_LITTLE: 0)
- | (r_jmptable? RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
- | (r_relative? RELOC_STD_BITS_RELATIVE_LITTLE: 0)
- | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
- }
+ (r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
+ | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
+ | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
+ | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
+ | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
+ | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
+ }
+ else
+ {
+ natptr->r_index[2] = r_index >> 16;
+ natptr->r_index[1] = r_index >> 8;
+ natptr->r_index[0] = r_index;
+ natptr->r_type[0] =
+ (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
+ | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
+ | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
+ | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
+ | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
+ | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
+ }
}
/* Output extended relocation information to a file in target byte order. */
void
-DEFUN(NAME(lynx,swap_ext_reloc_out),(abfd, g, natptr),
- bfd *abfd AND
- arelent *g AND
- register struct reloc_ext_external *natptr)
+NAME (lynx, swap_ext_reloc_out) (abfd, g, natptr)
+ bfd *abfd;
+ arelent *g;
+ register struct reloc_ext_external *natptr;
{
int r_index;
int r_extern;
unsigned int r_type;
unsigned int r_addend;
- asymbol *sym = *(g->sym_ptr_ptr);
+ asymbol *sym = *(g->sym_ptr_ptr);
asection *output_section = sym->section->output_section;
-
+
PUT_WORD (abfd, g->address, natptr->r_address);
-
+
r_type = (unsigned int) g->howto->type;
-
+
r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
- /* If this relocation is relative to a symbol then set the
+ /* If this relocation is relative to a symbol then set the
r_index to the symbols index, and the r_extern bit.
Absolute symbols can come in in two ways, either as an offset
from the abs section, or as a symbol which has an abs value.
check for that here
*/
-
+
if (bfd_is_com_section (output_section)
|| output_section == &bfd_abs_section
|| output_section == &bfd_und_section)
- {
- if (bfd_abs_section.symbol == sym)
{
- /* Whoops, looked like an abs symbol, but is really an offset
+ if (bfd_abs_section.symbol == sym)
+ {
+ /* Whoops, looked like an abs symbol, but is really an offset
from the abs section */
- r_index = 0;
- r_extern = 0;
- }
- else
+ r_index = 0;
+ r_extern = 0;
+ }
+ else
+ {
+ r_extern = 1;
+ r_index = stoi ((*(g->sym_ptr_ptr))->KEEPIT);
+ }
+ }
+ else
{
- r_extern = 1;
- r_index = stoi((*(g->sym_ptr_ptr))->KEEPIT);
+ /* Just an ordinary section */
+ r_extern = 0;
+ r_index = output_section->target_index;
}
- }
- else
- {
- /* Just an ordinary section */
- r_extern = 0;
- r_index = output_section->target_index;
- }
-
-
+
+
/* now the fun stuff */
- if (abfd->xvec->header_byteorder_big_p != false) {
- natptr->r_index[0] = r_index >> 16;
- natptr->r_index[1] = r_index >> 8;
- natptr->r_index[2] = r_index;
- natptr->r_type[0] =
- (r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
- | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
- } else {
- natptr->r_index[2] = r_index >> 16;
- natptr->r_index[1] = r_index >> 8;
- natptr->r_index[0] = r_index;
- natptr->r_type[0] =
- (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
- | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
- }
+ if (abfd->xvec->header_byteorder_big_p != false)
+ {
+ natptr->r_index[0] = r_index >> 16;
+ natptr->r_index[1] = r_index >> 8;
+ natptr->r_index[2] = r_index;
+ natptr->r_type[0] =
+ (r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
+ | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
+ }
+ else
+ {
+ natptr->r_index[2] = r_index >> 16;
+ natptr->r_index[1] = r_index >> 8;
+ natptr->r_index[0] = r_index;
+ natptr->r_type[0] =
+ (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
+ | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
+ }
PUT_WORD (abfd, r_addend, natptr->r_addend);
}
/* BFD deals internally with all things based from the section they're
in. so, something in 10 bytes into a text section with a base of
- 50 would have a symbol (.text+10) and know .text vma was 50.
+ 50 would have a symbol (.text+10) and know .text vma was 50.
Aout keeps all it's symbols based from zero, so the symbol would
contain 60. This macro subs the base of each section from the value
} \
void
-DEFUN(NAME(lynx,swap_ext_reloc_in), (abfd, bytes, cache_ptr, symbols),
- bfd *abfd AND
- struct reloc_ext_external *bytes AND
- arelent *cache_ptr AND
- asymbol **symbols)
+NAME (lynx, swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols)
+ bfd *abfd;
+ struct reloc_ext_external *bytes;
+ arelent *cache_ptr;
+ asymbol **symbols;
{
int r_index;
int r_extern;
cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
- /* now the fun stuff */
- if (1 /* abfd->xvec->header_byteorder_big_p != false */) {
- r_index = (bytes->r_index[0] << 16)
- | (bytes->r_index[1] << 8)
- | bytes->r_index[2];
- r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
- r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
- >> RELOC_EXT_BITS_TYPE_SH_BIG;
- } else {
- r_index = (bytes->r_index[2] << 16)
- | (bytes->r_index[1] << 8)
- | bytes->r_index[0];
- r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
- r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
- >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
- }
-
- cache_ptr->howto = aout_32_ext_howto_table + r_type;
- MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
+ r_index = bytes->r_index[1];
+ r_extern = (0 != (bytes->r_index[0] & RELOC_EXT_BITS_EXTERN_BIG));
+ r_type = (bytes->r_index[0] & RELOC_EXT_BITS_TYPE_BIG)
+ >> RELOC_EXT_BITS_TYPE_SH_BIG;
+
+ cache_ptr->howto = aout_32_ext_howto_table + r_type;
+ MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
}
void
-DEFUN(NAME(lynx,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
- bfd *abfd AND
- struct reloc_std_external *bytes AND
- arelent *cache_ptr AND
- asymbol **symbols)
+NAME (lynx, swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+ bfd *abfd;
+ struct reloc_std_external *bytes;
+ arelent *cache_ptr;
+ asymbol **symbols;
{
- char tmp;
int r_index;
int r_extern;
unsigned int r_length;
int r_pcrel;
int r_baserel, r_jmptable, r_relative;
- struct aoutdata *su = &(abfd->tdata.aout_data->a);
+ struct aoutdata *su = &(abfd->tdata.aout_data->a);
cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
- r_index = (bytes->r_type[0] << 16)
- | (bytes->r_index[2] << 8)
- | bytes->r_index[1];
- r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
- r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
+ r_index = bytes->r_index[1];
+ r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
+ r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
r_baserel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_BASEREL_BIG));
- r_jmptable= (0 != (bytes->r_index[0] & RELOC_STD_BITS_JMPTABLE_BIG));
- r_relative= (0 != (bytes->r_index[0] & RELOC_STD_BITS_RELATIVE_BIG));
- r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
+ r_jmptable = (0 != (bytes->r_index[0] & RELOC_STD_BITS_JMPTABLE_BIG));
+ r_relative = (0 != (bytes->r_index[0] & RELOC_STD_BITS_RELATIVE_BIG));
+ r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
>> RELOC_STD_BITS_LENGTH_SH_BIG;
- cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
+ cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
/* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */
- MOVE_ADDRESS(0);
+ MOVE_ADDRESS (0);
}
/* Reloc hackery */
boolean
-DEFUN(NAME(lynx,slurp_reloc_table),(abfd, asect, symbols),
- bfd *abfd AND
- sec_ptr asect AND
- asymbol **symbols)
+NAME (lynx, slurp_reloc_table) (abfd, asect, symbols)
+ bfd *abfd;
+ sec_ptr asect;
+ asymbol **symbols;
{
unsigned int count;
bfd_size_type reloc_size;
arelent *reloc_cache;
size_t each_size;
- if (asect->relocation) return true;
+ if (asect->relocation)
+ return true;
- if (asect->flags & SEC_CONSTRUCTOR) return true;
+ if (asect->flags & SEC_CONSTRUCTOR)
+ return true;
- if (asect == obj_datasec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_drsize;
- goto doit;
- }
+ if (asect == obj_datasec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_drsize;
+ goto doit;
+ }
- if (asect == obj_textsec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_trsize;
- goto doit;
- }
+ if (asect == obj_textsec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_trsize;
+ goto doit;
+ }
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
- doit:
+doit:
bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
each_size = obj_reloc_entry_size (abfd);
count = reloc_size / each_size;
- reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t)(count * sizeof
- (arelent)));
- if (!reloc_cache) {
-nomem:
- bfd_error = no_memory;
- return false;
- }
+ reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t) (count * sizeof
+ (arelent)));
+ if (!reloc_cache)
+ {
+ nomem:
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
relocs = (PTR) bfd_alloc (abfd, reloc_size);
- if (!relocs) {
- bfd_release (abfd, reloc_cache);
- goto nomem;
- }
-
- if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size) {
- bfd_release (abfd, relocs);
- bfd_release (abfd, reloc_cache);
- bfd_error = system_call_error;
- return false;
- }
-
- if (each_size == RELOC_EXT_SIZE) {
- register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
- unsigned int counter = 0;
- arelent *cache_ptr = reloc_cache;
-
- for (; counter < count; counter++, rptr++, cache_ptr++) {
- NAME(lynx,swap_ext_reloc_in)(abfd, rptr, cache_ptr, symbols);
+ if (!relocs)
+ {
+ bfd_release (abfd, reloc_cache);
+ goto nomem;
}
- } else {
- register struct reloc_std_external *rptr = (struct reloc_std_external*) relocs;
- unsigned int counter = 0;
- arelent *cache_ptr = reloc_cache;
- for (; counter < count; counter++, rptr++, cache_ptr++) {
- NAME(lynx,swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
+ if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+ {
+ bfd_release (abfd, relocs);
+ bfd_release (abfd, reloc_cache);
+ return false;
+ }
+
+ if (each_size == RELOC_EXT_SIZE)
+ {
+ register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
+ unsigned int counter = 0;
+ arelent *cache_ptr = reloc_cache;
+
+ for (; counter < count; counter++, rptr++, cache_ptr++)
+ {
+ NAME (lynx, swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols);
+ }
}
+ else
+ {
+ register struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
+ unsigned int counter = 0;
+ arelent *cache_ptr = reloc_cache;
+
+ for (; counter < count; counter++, rptr++, cache_ptr++)
+ {
+ NAME (lynx, swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
+ }
- }
+ }
- bfd_release (abfd,relocs);
+ bfd_release (abfd, relocs);
asect->relocation = reloc_cache;
asect->reloc_count = count;
return true;
/* Write out a relocation section into an object file. */
boolean
-DEFUN(NAME(lynx,squirt_out_relocs),(abfd, section),
- bfd *abfd AND
- asection *section)
+NAME (lynx, squirt_out_relocs) (abfd, section)
+ bfd *abfd;
+ asection *section;
{
arelent **generic;
unsigned char *native, *natptr;
unsigned int count = section->reloc_count;
size_t natsize;
- if (count == 0) return true;
+ if (count == 0)
+ return true;
each_size = obj_reloc_entry_size (abfd);
natsize = each_size * count;
native = (unsigned char *) bfd_zalloc (abfd, natsize);
- if (!native) {
- bfd_error = no_memory;
- return false;
- }
+ if (!native)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
generic = section->orelocation;
- if (each_size == RELOC_EXT_SIZE)
+ if (each_size == RELOC_EXT_SIZE)
{
for (natptr = native;
count != 0;
--count, natptr += each_size, ++generic)
- NAME(lynx,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr);
+ NAME (lynx, swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *) natptr);
}
- else
+ else
{
for (natptr = native;
count != 0;
--count, natptr += each_size, ++generic)
- NAME(lynx,swap_std_reloc_out)(abfd, *generic, (struct reloc_std_external *)natptr);
+ NAME (lynx, swap_std_reloc_out) (abfd, *generic, (struct reloc_std_external *) natptr);
}
- if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
- bfd_release(abfd, native);
- return false;
- }
+ if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize)
+ {
+ bfd_release (abfd, native);
+ return false;
+ }
bfd_release (abfd, native);
return true;
/* This is stupid. This function should be a boolean predicate */
unsigned int
-DEFUN(NAME(lynx,canonicalize_reloc),(abfd, section, relptr, symbols),
- bfd *abfd AND
- sec_ptr section AND
- arelent **relptr AND
- asymbol **symbols)
+NAME (lynx, canonicalize_reloc) (abfd, section, relptr, symbols)
+ bfd *abfd;
+ sec_ptr section;
+ arelent **relptr;
+ asymbol **symbols;
{
arelent *tblptr = section->relocation;
unsigned int count;
- if (!(tblptr || NAME(lynx,slurp_reloc_table)(abfd, section, symbols)))
+ if (!(tblptr || NAME (lynx, slurp_reloc_table) (abfd, section, symbols)))
return 0;
- if (section->flags & SEC_CONSTRUCTOR) {
- arelent_chain *chain = section->constructor_chain;
- for (count = 0; count < section->reloc_count; count ++) {
- *relptr ++ = &chain->relent;
- chain = chain->next;
+ if (section->flags & SEC_CONSTRUCTOR)
+ {
+ arelent_chain *chain = section->constructor_chain;
+ for (count = 0; count < section->reloc_count; count++)
+ {
+ *relptr++ = &chain->relent;
+ chain = chain->next;
+ }
+ }
+ else
+ {
+ tblptr = section->relocation;
+ if (!tblptr)
+ return 0;
+
+ for (count = 0; count++ < section->reloc_count;)
+ {
+ *relptr++ = tblptr++;
+ }
}
- }
- else {
- tblptr = section->relocation;
- if (!tblptr) return 0;
-
- for (count = 0; count++ < section->reloc_count;)
- {
- *relptr++ = tblptr++;
- }
- }
*relptr = 0;
return section->reloc_count;
bfd_h_put_32 (abfd, (bfd_vma) 2, s.format);
bfd_h_put_32 (abfd, (bfd_vma) sizeof s, s.size);
if (bfd_write ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
return true;
}
\f
/* Read the reloc from the file. */
if (bfd_read (&ext, sizeof ext, 1, abfd) != sizeof ext)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
/* Swap in the reloc information. */
r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext.r_vaddr);
if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
!= sizeof (symlength))
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.the_bfd = abfd;
sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
if (!sym -> symbol.name)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
!= symlength)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.flags = 0;
sym -> symbol.value = 0;
sym -> symbol.section = &bfd_und_section;
if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return faflse;
rcount = bfd_h_get_32 (abfd, temp);
nlm_relocs = ((struct nlm_relent *)
bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
if (!nlm_relocs)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
sym -> relocs = nlm_relocs;
/* Write out the relocation. */
if (bfd_write (&ext, sizeof ext, 1, abfd) != sizeof ext)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
return true;
}
len = strlen (sym->name);
if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
|| bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
bfd_put_32 (abfd, count + 2, temp);
if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
/* The first two relocs for each external symbol are the .lita
address and the GP value. */
const char *name;
if (bfd_read (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
val = bfd_get_32 (abfd, temp);
|| rel->howto->src_mask != 0xffffffff
|| rel->howto->dst_mask != 0xffffffff)
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
}
/* NetWare only supports absolute internal relocs. */
if (rel->howto->pc_relative)
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
}
/* PC relative relocs on NetWare must be pcrel_offset. */
if (! rel->howto->pcrel_offset)
{
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
}
}
bfd_put_32 (abfd, val, temp);
if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
return true;
}
if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
!= sizeof (symlength))
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.the_bfd = abfd;
sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
if (!sym -> symbol.name)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
!= symlength)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.flags = 0;
sym -> symbol.value = 0;
sym -> symbol.section = &bfd_und_section;
if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
rcount = bfd_h_get_32 (abfd, temp);
nlm_relocs = ((struct nlm_relent *)
bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
if (!nlm_relocs)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
sym -> relocs = nlm_relocs;
len = strlen (sym->name);
if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
|| bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
bfd_put_32 (abfd, count, temp);
if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
for (i = 0; i < count; i++)
{
struct nlm32_sparc_reloc_ext tmp_reloc;
asection *code_sec, *data_sec;
- if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12) {
- bfd_error = system_call_error;
+ if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12)
return false;
- }
code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
* First, read in the number of relocation
* entries for this symbol
*/
- if (bfd_read ((PTR) temp, 4, 1, abfd)
- != 4)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ if (bfd_read ((PTR) temp, 4, 1, abfd) != 4)
+ return false;
rcount = bfd_get_32 (abfd, temp);
if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
!= sizeof (symlength))
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.the_bfd = abfd;
sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
if (!sym -> symbol.name)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
!= symlength)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ return false;
sym -> symbol.flags = 0;
sym -> symbol.value = 0;
sym -> symbol.section = &bfd_und_section;
bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
if (!nlm_relocs)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
sym -> relocs = nlm_relocs;
bfd_put_32 (abfd, count, temp);
if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
len = strlen (sym->name);
if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
|| bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
for (i = 0; i < count; i++)
{
if (bfd_write (temp, 4, 1, abfd) != 4
|| bfd_write (&len, 1, 1, abfd) != 1
|| bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
return true;
}
if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
{
- bfd_set_error (bfd_error_system_call);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
{
if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
{
- bfd_set_error (bfd_error_wrong_format);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
}
each subspace. Seek to the start of the relocation stream
for this subspace in preparation for writing out its fixup
stream. */
- if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) < 0)
+ return false;
/* Buffer space has already been allocated. Just perform some
initialization here. */
{
if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
+
p = tmp_space;
som_initialize_reloc_queue (reloc_queue);
}
/* Scribble out the relocations. */
if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
p = tmp_space;
total_reloc_size += subspace_reloc_size;
/* Seek to the start of the space strings in preparation for writing
them out. */
- if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Walk through all the spaces and subspaces (order is not important)
building up and writing string table entries for their names. */
{
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Reset to beginning of the buffer space. */
p = tmp_space;
}
/* Done with the space/subspace strings. Write out any information
contained in a partial block. */
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
*string_sizep = strings_size;
return true;
}
/* Seek to the start of the space strings in preparation for writing
them out. */
- if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
for (i = 0; i < num_syms; i++)
{
{
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Reset to beginning of the buffer space. */
p = tmp_space;
}
/* Scribble out any partial block. */
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
*string_sizep = strings_size;
return true;
{
unsigned int len;
- bfd_seek (abfd, current_offset, SEEK_SET);
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Write the aux_id structure and the string length. */
len = sizeof (struct aux_id) + sizeof (unsigned int);
obj_som_file_hdr (abfd)->aux_header_size += len;
current_offset += len;
if (bfd_write ((PTR) obj_som_version_hdr (abfd), len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Write the version string. */
len = obj_som_version_hdr (abfd)->header_id.length - sizeof (int);
current_offset += len;
if (bfd_write ((PTR) obj_som_version_hdr (abfd)->user_string,
len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
if (obj_som_copyright_hdr (abfd) != NULL)
{
unsigned int len;
- bfd_seek (abfd, current_offset, SEEK_SET);
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Write the aux_id structure and the string length. */
len = sizeof (struct aux_id) + sizeof (unsigned int);
obj_som_file_hdr (abfd)->aux_header_size += len;
current_offset += len;
if (bfd_write ((PTR) obj_som_copyright_hdr (abfd), len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Write the copyright string. */
len = obj_som_copyright_hdr (abfd)->header_id.length - sizeof (int);
current_offset += len;
if (bfd_write ((PTR) obj_som_copyright_hdr (abfd)->copyright,
len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Next comes the initialization pointers; we have no initialization
if (abfd->flags & EXEC_P)
current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
if (bfd_seek (abfd, current_offset - 1, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_write ((PTR) "", 1, 1, abfd) != 1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
obj_som_file_hdr (abfd)->unloadable_sp_size
= current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location;
exec_header.exec_bsize = 0;
exec_header.exec_dsize = tmp;
- bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location, SEEK_SET);
+ if (bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location,
+ SEEK_SET) < 0)
+ return false;
if (bfd_write ((PTR) &exec_header, AUX_HDR_SIZE, 1, abfd)
!= AUX_HDR_SIZE)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
return true;
}
/* Seek to the start of the subspace dictionary records. */
location = obj_som_file_hdr (abfd)->subspace_location;
- bfd_seek (abfd, location, SEEK_SET);
+ if (bfd_seek (abfd, location, SEEK_SET) < 0)
+ return false;
+
section = abfd->sections;
/* Now for each loadable space write out records for its subspaces. */
for (i = 0; i < num_spaces; i++)
if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
sizeof (struct subspace_dictionary_record), 1, abfd)
!= sizeof (struct subspace_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Goto the next section. */
section = section->next;
if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
sizeof (struct subspace_dictionary_record), 1, abfd)
!= sizeof (struct subspace_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Goto the next section. */
section = section->next;
Seek to the right location and start writing the space
dictionary records. */
location = obj_som_file_hdr (abfd)->space_location;
- bfd_seek (abfd, location, SEEK_SET);
+ if (bfd_seek (abfd, location, SEEK_SET) < 0)
+ return false;
section = abfd->sections;
for (i = 0; i < num_spaces; i++)
if (bfd_write ((PTR) som_section_data (section)->space_dict,
sizeof (struct space_dictionary_record), 1, abfd)
!= sizeof (struct space_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Goto the next section. */
section = section->next;
/* Only thing left to do is write out the file header. It is always
at location zero. Seek there and write it. */
- bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0)
+ return false;
if (bfd_write ((PTR) obj_som_file_hdr (abfd),
sizeof (struct header), 1, abfd)
!= sizeof (struct header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
return true;
}
/* Everything is ready, seek to the right location and
scribble out the symbol table. */
if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ return false;
if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (som_symtab != NULL)
free (som_symtab);
}
if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
!= obj_som_stringtab_size (abfd))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Save our results and return success. */
obj_som_stringtab (abfd) = stringtab;
goto error_return;
}
if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (buf, symbol_count * symsize, 1, abfd)
!= symbol_count * symsize)
- {
- bfd_set_error (bfd_error_no_symbols);
- goto error_return;
- }
+ goto error_return;
/* Iterate over all the symbols and internalize them. */
endbufp = buf + symbol_count;
obj_som_reloc_filepos (abfd) + section->rel_filepos,
SEEK_SET)
!= 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_read (external_relocs, 1, fixup_stream_size, abfd)
!= fixup_stream_size)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
+
/* Let callers know how many relocations found.
also save the relocation stream as we will
need it again. */
+ sizeof (unsigned int) + len + pad);
if (!obj_som_copyright_hdr (abfd))
{
- bfd_set_error (bfd_error_no_error);
+ bfd_set_error (bfd_error_no_memory);
return false;
}
obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
data. */
offset += som_section_data (section)->subspace_dict->file_loc_init_value;
if (bfd_seek (abfd, offset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_write ((PTR) location, 1, count, abfd) != count)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
return true;
}
which point to the hash chains. */
if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
!= lst_header->hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Walk each chain counting the number of symbols found on that particular
chain. */
/* Seek to the first symbol in this hash chain. */
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Read in this symbol and update the counter. */
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
(*count)++;
/* Now iterate through the rest of the symbols on this chain. */
/* Seek to the next symbol. */
if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
< 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Read the symbol in and update the counter. */
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
(*count)++;
}
}
which point to the hash chains. */
if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
!= lst_header->hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Seek to and read in the SOM dictionary. We will need this to fill
in the carsym's filepos field. */
if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read ((PTR) som_dict, lst_header->module_count,
sizeof (struct som_entry), abfd)
!= lst_header->module_count * sizeof (struct som_entry))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Walk each chain filling in the carsyms as we go along. */
for (i = 0; i < lst_header->hash_size; i++)
/* Seek to and read the first symbol on the chain. */
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Get the name of the symbol, first get the length which is stored
as a 32bit integer just before the symbol.
using the string table would not be safe. */
if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (&len, 1, 4, abfd) != 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Allocate space for the name and null terminate it too. */
set->name = bfd_zalloc (abfd, len + 1);
goto error_return;
}
if (bfd_read (set->name, 1, len, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
set->name[len] = 0;
/* Fill in the file offset. Note that the "location" field points
while (lst_symbol.next_entry)
{
/* Seek to the next symbol and read it in. */
- if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
- < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET) <0)
+ goto error_return;
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Seek to the name length & string and read them in. */
if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (&len, 1, 4, abfd) != 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Allocate space for the name and null terminate it too. */
set->name = bfd_zalloc (abfd, len + 1);
bfd_set_error (bfd_error_no_memory);
goto error_return;
}
+
if (bfd_read (set->name, 1, len, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
set->name[len] = 0;
/* Fill in the file offset. Note that the "location" field points
return false;
if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* For archives without .o files there is no symbol table. */
if (strncmp (nextname, "/ ", 16))
/* Read in and sanity check the archive header. */
if (bfd_read ((PTR) &ar_header, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (strncmp (ar_header.ar_fmag, ARFMAG, 2))
{
in just a minute. */
if (bfd_read ((PTR) & lst_header, 1, sizeof (struct lst_header), abfd)
!= sizeof (struct lst_header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Sanity check. */
if (lst_header.a_magic != LIBMAGIC)
/* Get back to the start of the library symbol table. */
if (bfd_seek (abfd, ardata->first_file_filepos - parsed_size
+ sizeof (struct lst_header), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Initializae the cache and allocate space for the library symbols. */
ardata->cache = 0;
/* Seek back to the "first" file in the archive. Note the "first"
file may be the extended name table. */
if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Notify the generic archive code that we have a symbol map. */
bfd_has_map (abfd) = true;
/* Now scribble out the hash table. */
if (bfd_write ((PTR) hash_table, lst.hash_size, 4, abfd)
!= lst.hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Then the SOM dictionary. */
if (bfd_write ((PTR) som_dict, lst.module_count,
sizeof (struct som_entry), abfd)
!= lst.module_count * sizeof (struct som_entry))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* The library symbols. */
if (bfd_write ((PTR) lst_syms, nsyms, sizeof (struct lst_symbol_record), abfd)
!= nsyms * sizeof (struct lst_symbol_record))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* And finally the strings. */
if (bfd_write ((PTR) strings, string_size, 1, abfd) != string_size)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (hash_table != NULL)
free (hash_table);
/* Scribble out the ar header. */
if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Now scribble out the lst header. */
if (bfd_write ((PTR) &lst, 1, sizeof (struct lst_header), abfd)
!= sizeof (struct lst_header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Build and write the armap. */
if (som_bfd_ar_write_symbol_stuff (abfd, nsyms, stringsize, lst) == false)
projects / binutils-gdb.git / commitdiff