X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fnlm32-alpha.c;h=3bf597b17870fd3619fc6447c9e3bde27194d308;hb=bd695bcc90bf296d67a85cd49c6fe1879715e04e;hp=b18eb658675f1af4df0ef06b67be79f951d6d51c;hpb=f888e93ccafdf88bcacc813eab9144d781ac47fc;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/nlm32-alpha.c b/bfd/nlm32-alpha.c index b18eb65867..3bf597b178 100644 --- a/bfd/nlm32-alpha.c +++ b/bfd/nlm32-alpha.c @@ -1,5 +1,6 @@ /* Support for 32-bit Alpha NLM (NetWare Loadable Module) - Copyright (C) 1993 Free Software Foundation, Inc. + Copyright 1993, 1994, 2000, 2001, 2002, 2003, 2004 + Free Software Foundation, Inc. Written by Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -16,7 +17,7 @@ GNU General Public License for more details. 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, @@ -33,69 +34,71 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "libnlm.h" -static boolean nlm_alpha_backend_object_p +static bfd_boolean nlm_alpha_backend_object_p PARAMS ((bfd *)); -static boolean nlm_alpha_write_prefix +static bfd_boolean nlm_alpha_write_prefix PARAMS ((bfd *)); -static boolean nlm_alpha_read_reloc +static bfd_boolean nlm_alpha_read_reloc PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *)); -static boolean nlm_alpha_mangle_relocs - PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type)); -static boolean nlm_alpha_read_import +static bfd_boolean nlm_alpha_mangle_relocs + PARAMS ((bfd *, asection *, const PTR, bfd_vma, bfd_size_type)); +static bfd_boolean nlm_alpha_read_import PARAMS ((bfd *, nlmNAME(symbol_type) *)); -static boolean nlm_alpha_write_import +static bfd_boolean nlm_alpha_write_import PARAMS ((bfd *, asection *, arelent *)); -static boolean nlm_alpha_set_public_section +static bfd_boolean nlm_alpha_set_public_section PARAMS ((bfd *, nlmNAME(symbol_type) *)); static bfd_vma nlm_alpha_get_public_offset PARAMS ((bfd *, asymbol *)); -static boolean nlm_alpha_write_external +static bfd_boolean nlm_alpha_write_external PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *)); /* Alpha NLM's have a prefix header before the standard NLM. This function reads it in, verifies the version, and seeks the bfd to the location before the regular NLM header. */ -static boolean +static bfd_boolean nlm_alpha_backend_object_p (abfd) 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) - return false; + 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) - return false; + 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; + return FALSE; - return true; + return TRUE; } /* Write out the prefix. */ -static boolean +static bfd_boolean nlm_alpha_write_prefix (abfd) bfd *abfd; { 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) - return false; - return true; + 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; } +#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1) + /* How to process the various reloc types. */ static reloc_howto_type nlm32_alpha_howto_table[] = @@ -107,45 +110,45 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "IGNORE", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* A 32 bit reference to a symbol. */ HOWTO (ALPHA_R_REFLONG, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ 0, /* special_function */ "REFLONG", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* A 64 bit reference to a symbol. */ HOWTO (ALPHA_R_REFQUAD, /* type */ 0, /* rightshift */ 4, /* size (0 = byte, 1 = short, 2 = long) */ 64, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ 0, /* special_function */ "REFQUAD", /* name */ - true, /* partial_inplace */ - 0xffffffffffffffff, /* src_mask */ - 0xffffffffffffffff, /* dst_mask */ - false), /* pcrel_offset */ + TRUE, /* partial_inplace */ + ONES (64), /* src_mask */ + ONES (64), /* dst_mask */ + FALSE), /* pcrel_offset */ /* A 32 bit GP relative offset. This is just like REFLONG except that when the value is used the value of the gp register will be @@ -154,15 +157,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ 0, /* special_function */ "GPREL32", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Used for an instruction that refers to memory off the GP register. The offset is 16 bits of the 32 bit instruction. This @@ -171,15 +174,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ 0, /* special_function */ "LITERAL", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffff, /* src_mask */ 0xffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* This reloc only appears immediately following a LITERAL reloc. It identifies a use of the literal. It seems that the linker can @@ -194,15 +197,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "LITUSE", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Load the gp register. This is always used for a ldah instruction which loads the upper 16 bits of the gp register. The next reloc @@ -219,15 +222,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 16, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "GPDISP", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffff, /* src_mask */ 0xffff, /* dst_mask */ - true), /* pcrel_offset */ + TRUE), /* pcrel_offset */ /* A 21 bit branch. The native assembler generates these for branches within the text segment, and also fills in the PC @@ -237,90 +240,90 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 2, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 21, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ 0, /* special_function */ "BRADDR", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0x1fffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* A hint for a jump to a register. */ HOWTO (ALPHA_R_HINT, /* type */ 2, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 14, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "HINT", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0x3fff, /* src_mask */ 0x3fff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* 16 bit PC relative offset. */ HOWTO (ALPHA_R_SREL16, /* type */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ 0, /* special_function */ "SREL16", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffff, /* src_mask */ 0xffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* 32 bit PC relative offset. */ HOWTO (ALPHA_R_SREL32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ 0, /* special_function */ "SREL32", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* A 64 bit PC relative offset. */ HOWTO (ALPHA_R_SREL64, /* type */ 0, /* rightshift */ 4, /* size (0 = byte, 1 = short, 2 = long) */ 64, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ 0, /* special_function */ "SREL64", /* name */ - true, /* partial_inplace */ - 0xffffffffffffffff, /* src_mask */ - 0xffffffffffffffff, /* dst_mask */ - false), /* pcrel_offset */ + TRUE, /* partial_inplace */ + ONES (64), /* src_mask */ + ONES (64), /* dst_mask */ + FALSE), /* pcrel_offset */ /* Push a value on the reloc evaluation stack. */ HOWTO (ALPHA_R_OP_PUSH, /* type */ 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "OP_PUSH", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Store the value from the stack at the given address. Store it in a bitfield of size r_size starting at bit position r_offset. */ @@ -328,15 +331,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 4, /* size (0 = byte, 1 = short, 2 = long) */ 64, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "OP_STORE", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ - 0xffffffffffffffff, /* dst_mask */ - false), /* pcrel_offset */ + ONES (64), /* dst_mask */ + FALSE), /* pcrel_offset */ /* Subtract the reloc address from the value on the top of the relocation stack. */ @@ -344,15 +347,15 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "OP_PSUB", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Shift the value on the top of the relocation stack right by the given value. */ @@ -360,30 +363,30 @@ static reloc_howto_type nlm32_alpha_howto_table[] = 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "OP_PRSHIFT", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Adjust the GP value for a new range in the object file. */ HOWTO (ALPHA_R_GPVALUE, /* type */ 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "GPVALUE", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false) /* pcrel_offset */ + FALSE) /* pcrel_offset */ }; static reloc_howto_type nlm32_alpha_nw_howto = @@ -391,21 +394,21 @@ static reloc_howto_type nlm32_alpha_nw_howto = 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - false, /* pc_relative */ + FALSE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ 0, /* special_function */ "NW_RELOC", /* name */ - false, /* partial_inplace */ + FALSE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - false); /* pcrel_offset */ + FALSE); /* pcrel_offset */ /* Read an Alpha NLM reloc. This routine keeps some static data which it uses when handling local relocs. This only works correctly because all the local relocs are read at once. */ -static boolean +static bfd_boolean nlm_alpha_read_reloc (abfd, sym, secp, rel) bfd *abfd; nlmNAME(symbol_type) *sym; @@ -421,14 +424,14 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) asection *code_sec, *data_sec; /* Read the reloc from the file. */ - if (bfd_read (&ext, sizeof ext, 1, abfd) != sizeof ext) - return false; + 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); @@ -461,7 +464,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) || 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) @@ -478,7 +481,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) 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; } } @@ -487,7 +490,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) or .data section. R_NW_RELOC relocs don't really have a section, so we put them in .text. */ if (r_type == ALPHA_R_NW_RELOC - || r_vaddr < bfd_section_size (abfd, code_sec)) + || r_vaddr < code_sec->size) { *secp = code_sec; rel->address = r_vaddr; @@ -495,7 +498,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) else { *secp = data_sec; - rel->address = r_vaddr - bfd_section_size (abfd, code_sec); + rel->address = r_vaddr - code_sec->size; } /* We must adjust the addend based on the type. */ @@ -531,7 +534,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) 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: @@ -562,7 +565,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) 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; @@ -584,7 +587,7 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) } 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: @@ -596,25 +599,25 @@ nlm_alpha_read_reloc (abfd, sym, secp, rel) else rel->howto = &nlm32_alpha_howto_table[r_type]; - return true; + return TRUE; } /* Mangle Alpha NLM relocs for output. */ -static boolean +static bfd_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; + const PTR data ATTRIBUTE_UNUSED; + bfd_vma offset ATTRIBUTE_UNUSED; + bfd_size_type count ATTRIBUTE_UNUSED; { - return true; + return TRUE; } /* Read an ALPHA NLM import record */ -static boolean +static bfd_boolean nlm_alpha_read_import (abfd, sym) bfd *abfd; nlmNAME(symbol_type) *sym; @@ -623,54 +626,50 @@ nlm_alpha_read_import (abfd, sym) 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; + 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) - return false; + 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)) - return false; - rcount = bfd_h_get_32 (abfd, temp); - nlm_relocs = ((struct nlm_relent *) - bfd_alloc (abfd, rcount * sizeof (struct nlm_relent))); + sym -> symbol.section = bfd_und_section_ptr; + if (bfd_bread ((PTR) temp, (bfd_size_type) sizeof (temp), abfd) + != sizeof (temp)) + return FALSE; + 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) - return false; + + if (! nlm_alpha_read_reloc (abfd, sym, §ion, &nlm_relocs -> reloc)) + return FALSE; nlm_relocs -> section = section; nlm_relocs++; sym -> rcnt++; } - return true; + return TRUE; } /* Write an Alpha NLM reloc. */ -static boolean +static bfd_boolean nlm_alpha_write_import (abfd, sec, rel) bfd *abfd; asection *sec; @@ -690,10 +689,8 @@ nlm_alpha_write_import (abfd, sec, rel) { r_vaddr = bfd_get_section_vma (abfd, sec) + rel->address; if ((sec->flags & SEC_CODE) == 0) - r_vaddr += bfd_section_size (abfd, - bfd_get_section_by_name (abfd, - NLM_CODE_NAME)); - if (bfd_get_section (sym) == &bfd_und_section) + r_vaddr += bfd_get_section_by_name (abfd, NLM_CODE_NAME) -> size; + if (bfd_is_und_section (bfd_get_section (sym))) { r_extern = 1; r_symndx = 0; @@ -754,10 +751,10 @@ nlm_alpha_write_import (abfd, sec, rel) } /* 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); @@ -769,10 +766,10 @@ nlm_alpha_write_import (abfd, sec, rel) & RELOC_BITS3_SIZE_LITTLE); /* Write out the relocation. */ - if (bfd_write (&ext, sizeof ext, 1, abfd) != sizeof ext) - return false; + if (bfd_bwrite (&ext, (bfd_size_type) sizeof ext, abfd) != sizeof ext) + return FALSE; - return true; + return TRUE; } /* Alpha NetWare does not use the high bit to determine whether a @@ -783,7 +780,7 @@ nlm_alpha_write_import (abfd, sec, rel) /* Set the section for a public symbol. */ -static boolean +static bfd_boolean nlm_alpha_set_public_section (abfd, sym) bfd *abfd; nlmNAME(symbol_type) *sym; @@ -792,7 +789,7 @@ nlm_alpha_set_public_section (abfd, sym) code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME); data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME); - if (sym->symbol.value < bfd_section_size (abfd, code_sec)) + if (sym->symbol.value < code_sec->size) { sym->symbol.section = code_sec; sym->symbol.flags |= BSF_FUNCTION; @@ -800,18 +797,18 @@ nlm_alpha_set_public_section (abfd, sym) else { sym->symbol.section = data_sec; - sym->symbol.value -= bfd_section_size (abfd, code_sec); + sym->symbol.value -= code_sec->size; /* The data segment had better be aligned. */ - BFD_ASSERT ((bfd_section_size (abfd, code_sec) & 0xf) == 0); + BFD_ASSERT ((code_sec->size & 0xf) == 0); } - return true; + return TRUE; } /* Get the offset to write out for a public symbol. */ static bfd_vma nlm_alpha_get_public_offset (abfd, sym) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; asymbol *sym; { return bfd_asymbol_value (sym); @@ -819,50 +816,50 @@ nlm_alpha_get_public_offset (abfd, sym) /* Write an Alpha NLM external symbol. */ -static boolean +static bfd_boolean nlm_alpha_write_external (abfd, count, sym, relocs) bfd *abfd; bfd_size_type count; 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) - return false; + 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)) - return false; + 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) - return 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) - return 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) - return false; + if (! nlm_alpha_write_import (abfd, relocs[i].sec, relocs[i].rel)) + return FALSE; } - return true; + return TRUE; } #include "nlmswap.h" @@ -874,7 +871,7 @@ static const struct nlm_backend_data nlm32_alpha_backend = sizeof (struct nlm32_alpha_external_prefix_header), bfd_arch_alpha, 0, - true, /* no uninitialized data permitted by Alpha NetWare. */ + TRUE, /* no uninitialized data permitted by Alpha NetWare. */ nlm_alpha_backend_object_p, nlm_alpha_write_prefix, nlm_alpha_read_reloc,