/* Support for 32-bit Alpha NLM (NetWare Loadable Module)
- Copyright (C) 1993 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 2000, 2001, 2002 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* This file describes the 32 bit Alpha NLM format. You might think
that an Alpha chip would use a 64 bit format, but, for some reason,
bfd *abfd;
{
struct nlm32_alpha_external_prefix_header s;
- bfd_size_type size;
+ file_ptr size;
- if (bfd_read ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
+ if (bfd_bread ((PTR) &s, (bfd_size_type) sizeof s, abfd) != sizeof s)
return false;
- if (bfd_h_get_32 (abfd, s.magic) != NLM32_ALPHA_MAGIC)
+ if (H_GET_32 (abfd, s.magic) != NLM32_ALPHA_MAGIC)
return false;
/* FIXME: Should we check the format number? */
/* Skip to the end of the header. */
- size = bfd_h_get_32 (abfd, s.size);
+ size = H_GET_32 (abfd, s.size);
if (bfd_seek (abfd, size, SEEK_SET) != 0)
return false;
struct nlm32_alpha_external_prefix_header s;
memset (&s, 0, sizeof s);
- bfd_h_put_32 (abfd, (bfd_vma) NLM32_ALPHA_MAGIC, s.magic);
- 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)
+ H_PUT_32 (abfd, NLM32_ALPHA_MAGIC, s.magic);
+ H_PUT_32 (abfd, 2, s.format);
+ H_PUT_32 (abfd, sizeof s, s.size);
+ if (bfd_bwrite ((PTR) &s, (bfd_size_type) sizeof s, abfd) != sizeof s)
return false;
return true;
}
asection *code_sec, *data_sec;
/* Read the reloc from the file. */
- if (bfd_read (&ext, sizeof ext, 1, abfd) != sizeof ext)
+ if (bfd_bread (&ext, (bfd_size_type) sizeof ext, abfd) != sizeof ext)
return false;
/* Swap in the reloc information. */
- r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext.r_vaddr);
- r_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext.r_symndx);
+ r_vaddr = H_GET_64 (abfd, ext.r_vaddr);
+ r_symndx = H_GET_32 (abfd, ext.r_symndx);
- BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
+ BFD_ASSERT (bfd_little_endian (abfd));
r_type = ((ext.r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
>> RELOC_BITS0_TYPE_SH_LITTLE);
|| r_type == ALPHA_R_GPDISP
|| r_type == ALPHA_R_IGNORE)
{
- rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
rel->addend = 0;
}
else if (r_symndx == ALPHA_RELOC_SECTION_TEXT)
else
{
BFD_ASSERT (0);
- rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
rel->addend = 0;
}
}
addend, but they do use a special code. Put this code in the
addend field. */
rel->addend = r_symndx;
- rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
break;
case ALPHA_R_OP_STORE:
some reason the address of this reloc type is not adjusted by
the section vma. We record the gp value for this object file
here, for convenience when doing the GPDISP relocation. */
- rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
rel->address = r_vaddr;
rel->addend = gp_value;
break;
}
else
BFD_ASSERT (0);
- rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
break;
default:
static boolean
nlm_alpha_mangle_relocs (abfd, sec, data, offset, count)
- bfd *abfd;
- asection *sec;
- PTR data;
- bfd_vma offset;
- bfd_size_type count;
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec ATTRIBUTE_UNUSED;
+ PTR data ATTRIBUTE_UNUSED;
+ bfd_vma offset ATTRIBUTE_UNUSED;
+ bfd_size_type count ATTRIBUTE_UNUSED;
{
return true;
}
bfd_size_type rcount; /* number of relocs */
bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
unsigned char symlength; /* length of symbol name */
+ char *name;
+ bfd_size_type amt;
- if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
+ if (bfd_bread ((PTR) &symlength, (bfd_size_type) sizeof (symlength), abfd)
!= sizeof (symlength))
return false;
sym -> symbol.the_bfd = abfd;
- sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
- if (!sym -> symbol.name)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
- != symlength)
+ name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
+ if (name == NULL)
+ return false;
+ if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
return false;
+ name[symlength] = '\0';
+ sym -> symbol.name = name;
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))
+ sym -> symbol.section = bfd_und_section_ptr;
+ if (bfd_bread ((PTR) temp, (bfd_size_type) sizeof (temp), abfd)
+ != sizeof (temp))
return false;
- rcount = bfd_h_get_32 (abfd, temp);
- nlm_relocs = ((struct nlm_relent *)
- bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
+ rcount = H_GET_32 (abfd, temp);
+ amt = rcount * sizeof (struct nlm_relent);
+ nlm_relocs = (struct nlm_relent *) bfd_alloc (abfd, amt);
if (!nlm_relocs)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
sym -> relocs = nlm_relocs;
sym -> rcnt = 0;
while (sym -> rcnt < rcount)
{
asection *section;
-
- if (nlm_alpha_read_reloc (abfd, sym, §ion,
- &nlm_relocs -> reloc)
- == false)
+
+ if (! nlm_alpha_read_reloc (abfd, sym, §ion, &nlm_relocs -> reloc))
return false;
nlm_relocs -> section = section;
nlm_relocs++;
r_vaddr += bfd_section_size (abfd,
bfd_get_section_by_name (abfd,
NLM_CODE_NAME));
- if (bfd_get_section (sym) == &bfd_und_section)
+ if (bfd_is_und_section (bfd_get_section (sym)))
{
r_extern = 1;
r_symndx = 0;
}
/* Swap out the relocation fields. */
- bfd_h_put_64 (abfd, r_vaddr, (bfd_byte *) ext.r_vaddr);
- bfd_h_put_32 (abfd, r_symndx, (bfd_byte *) ext.r_symndx);
+ H_PUT_64 (abfd, r_vaddr, ext.r_vaddr);
+ H_PUT_32 (abfd, r_symndx, ext.r_symndx);
- BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
+ BFD_ASSERT (bfd_little_endian (abfd));
ext.r_bits[0] = ((r_type << RELOC_BITS0_TYPE_SH_LITTLE)
& RELOC_BITS0_TYPE_LITTLE);
& RELOC_BITS3_SIZE_LITTLE);
/* Write out the relocation. */
- if (bfd_write (&ext, sizeof ext, 1, abfd) != sizeof ext)
+ if (bfd_bwrite (&ext, (bfd_size_type) sizeof ext, abfd) != sizeof ext)
return false;
return true;
static bfd_vma
nlm_alpha_get_public_offset (abfd, sym)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
asymbol *sym;
{
return bfd_asymbol_value (sym);
asymbol *sym;
struct reloc_and_sec *relocs;
{
- int i;
+ bfd_size_type i;
bfd_byte len;
unsigned char temp[NLM_TARGET_LONG_SIZE];
arelent r;
len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
+ if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
+ != sizeof (bfd_byte))
+ || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
return false;
bfd_put_32 (abfd, count + 2, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
return false;
/* The first two relocs for each external symbol are the .lita
address and the GP value. */
- r.sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
+ r.sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
r.howto = &nlm32_alpha_nw_howto;
r.address = nlm_alpha_backend_data (abfd)->lita_address;
r.addend = nlm_alpha_backend_data (abfd)->lita_size + 1;
- if (nlm_alpha_write_import (abfd, (asection *) NULL, &r) == false)
+ if (! nlm_alpha_write_import (abfd, (asection *) NULL, &r))
return false;
r.address = nlm_alpha_backend_data (abfd)->gp;
r.addend = 0;
- if (nlm_alpha_write_import (abfd, (asection *) NULL, &r) == false)
+ if (! nlm_alpha_write_import (abfd, (asection *) NULL, &r))
return false;
for (i = 0; i < count; i++)
{
- if (nlm_alpha_write_import (abfd, relocs[i].sec,
- relocs[i].rel) == false)
+ if (! nlm_alpha_write_import (abfd, relocs[i].sec, relocs[i].rel))
return false;
}