X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fcoff-alpha.c;h=d36921bbfe6784523bbbd533ccfdbfa93fe9d701;hb=b61121178ec07f9da1242e439fe1a23a314ad30e;hp=4f3ab57ef6cf005e5da3e2ee3a3c04fb84f7abfc;hpb=3cac74d016404e4c8d425af463062b1e2534ec53;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/coff-alpha.c b/bfd/coff-alpha.c index 4f3ab57ef6..d36921bbfe 100644 --- a/bfd/coff-alpha.c +++ b/bfd/coff-alpha.c @@ -1,27 +1,27 @@ /* BFD back-end for ALPHA Extended-Coff files. - Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 - Free Software Foundation, Inc. + Copyright (C) 1993-2019 Free Software Foundation, Inc. Modified from coff-mips.c by Steve Chamberlain and Ian Lance Taylor . -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + 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., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "bfdlink.h" #include "libbfd.h" #include "coff/internal.h" @@ -35,36 +35,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Prototypes for static functions. */ -static const bfd_target *alpha_ecoff_object_p PARAMS ((bfd *)); -static boolean alpha_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr)); -static PTR alpha_ecoff_mkobject_hook PARAMS ((bfd *, PTR filehdr, PTR aouthdr)); -static void alpha_ecoff_swap_reloc_in PARAMS ((bfd *, PTR, - struct internal_reloc *)); -static void alpha_ecoff_swap_reloc_out PARAMS ((bfd *, - const struct internal_reloc *, - PTR)); -static void alpha_adjust_reloc_in PARAMS ((bfd *, - const struct internal_reloc *, - arelent *)); -static void alpha_adjust_reloc_out PARAMS ((bfd *, const arelent *, - struct internal_reloc *)); -static reloc_howto_type *alpha_bfd_reloc_type_lookup - PARAMS ((bfd *, bfd_reloc_code_real_type)); -static bfd_byte *alpha_ecoff_get_relocated_section_contents - PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *, - bfd_byte *data, boolean relocateable, asymbol **symbols)); -static bfd_vma alpha_convert_external_reloc - PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *, - struct ecoff_link_hash_entry *)); -static boolean alpha_relocate_section PARAMS ((bfd *, struct bfd_link_info *, - bfd *, asection *, - bfd_byte *, PTR)); -static boolean alpha_adjust_headers - PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *)); -static PTR alpha_ecoff_read_ar_hdr PARAMS ((bfd *)); -static bfd *alpha_ecoff_get_elt_at_filepos PARAMS ((bfd *, file_ptr)); -static bfd *alpha_ecoff_openr_next_archived_file PARAMS ((bfd *, bfd *)); -static bfd *alpha_ecoff_get_elt_at_index PARAMS ((bfd *, symindex)); + /* ECOFF has COFF sections, but the debugging information is stored in a completely different format. ECOFF targets use some of the @@ -123,18 +94,13 @@ static bfd *alpha_ecoff_get_elt_at_index PARAMS ((bfd *, symindex)); /* How to process the various reloc types. */ static bfd_reloc_status_type -reloc_nil PARAMS ((bfd *, arelent *, asymbol *, PTR, - asection *, bfd *, char **)); - -static bfd_reloc_status_type -reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc ATTRIBUTE_UNUSED; - asymbol *sym ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *sec ATTRIBUTE_UNUSED; - bfd *output_bfd ATTRIBUTE_UNUSED; - char **error_message ATTRIBUTE_UNUSED; +reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc ATTRIBUTE_UNUSED, + asymbol *sym ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *sec ATTRIBUTE_UNUSED, + bfd *output_bfd ATTRIBUTE_UNUSED, + char **error_message ATTRIBUTE_UNUSED) { return bfd_reloc_ok; } @@ -152,45 +118,45 @@ static reloc_howto_type alpha_howto_table[] = 0, /* rightshift */ 0, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ - true, /* pc_relative */ + TRUE, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont, /* complain_on_overflow */ reloc_nil, /* special_function */ "IGNORE", /* name */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - true), /* pcrel_offset */ + TRUE), /* 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 */ + TRUE, /* partial_inplace */ MINUS_ONE, /* src_mask */ MINUS_ONE, /* dst_mask */ - false), /* pcrel_offset */ + 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 @@ -199,15 +165,15 @@ static reloc_howto_type 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 @@ -216,15 +182,15 @@ static reloc_howto_type 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 @@ -239,15 +205,15 @@ static reloc_howto_type 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 */ reloc_nil, /* 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 @@ -264,15 +230,15 @@ static reloc_howto_type 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 */ reloc_nil, /* 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 @@ -281,90 +247,90 @@ static reloc_howto_type 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 */ - true, /* partial_inplace */ + TRUE, /* partial_inplace */ 0x1fffff, /* 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 */ - true, /* pc_relative */ + TRUE, /* 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 */ + TRUE, /* partial_inplace */ MINUS_ONE, /* src_mask */ MINUS_ONE, /* dst_mask */ - false), /* pcrel_offset */ + 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. */ @@ -372,15 +338,15 @@ static reloc_howto_type 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 */ MINUS_ONE, /* dst_mask */ - false), /* pcrel_offset */ + FALSE), /* pcrel_offset */ /* Subtract the reloc address from the value on the top of the relocation stack. */ @@ -388,15 +354,15 @@ static reloc_howto_type 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. */ @@ -404,37 +370,36 @@ static reloc_howto_type 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 */ }; /* Recognize an Alpha ECOFF file. */ static const bfd_target * -alpha_ecoff_object_p (abfd) - bfd *abfd; +alpha_ecoff_object_p (bfd *abfd) { static const bfd_target *ret; @@ -459,9 +424,9 @@ alpha_ecoff_object_p (abfd) bfd_size_type size; size = sec->line_filepos * 8; - BFD_ASSERT (size == bfd_section_size (abfd, sec) - || size + 8 == bfd_section_size (abfd, sec)); - if (! bfd_set_section_size (abfd, sec, size)) + BFD_ASSERT (size == sec->size + || size + 8 == sec->size); + if (!bfd_set_section_size (sec, size)) return NULL; } } @@ -471,29 +436,31 @@ alpha_ecoff_object_p (abfd) /* See whether the magic number matches. */ -static boolean -alpha_ecoff_bad_format_hook (abfd, filehdr) - bfd *abfd ATTRIBUTE_UNUSED; - PTR filehdr; +static bfd_boolean +alpha_ecoff_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, + void * filehdr) { struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; - if (ALPHA_ECOFF_BADMAG (*internal_f)) - return false; + if (! ALPHA_ECOFF_BADMAG (*internal_f)) + return TRUE; + + if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f)) + _bfd_error_handler + (_("%pB: cannot handle compressed Alpha binaries; " + "use compiler flags, or objZ, to generate uncompressed binaries"), + abfd); - return true; + return FALSE; } /* This is a hook called by coff_real_object_p to create any backend specific information. */ -static PTR -alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr) - bfd *abfd; - PTR filehdr; - PTR aouthdr; +static void * +alpha_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr) { - PTR ecoff; + void * ecoff; ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr); @@ -523,10 +490,9 @@ alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr) /* Swap a reloc in. */ static void -alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern) - bfd *abfd; - PTR ext_ptr; - struct internal_reloc *intern; +alpha_ecoff_swap_reloc_in (bfd *abfd, + void * ext_ptr, + struct internal_reloc *intern) { const RELOC *ext = (RELOC *) ext_ptr; @@ -571,10 +537,9 @@ alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern) /* Swap a reloc out. */ static void -alpha_ecoff_swap_reloc_out (abfd, intern, dst) - bfd *abfd; - const struct internal_reloc *intern; - PTR dst; +alpha_ecoff_swap_reloc_out (bfd *abfd, + const struct internal_reloc *intern, + void * dst) { RELOC *ext = (RELOC *) dst; long symndx; @@ -600,8 +565,11 @@ alpha_ecoff_swap_reloc_out (abfd, intern, dst) size = intern->r_size; } + /* XXX FIXME: The maximum symndx value used to be 14 but this + fails with object files produced by DEC's C++ compiler. + Where does the value 14 (or 15) come from anyway ? */ BFD_ASSERT (intern->r_extern - || (intern->r_symndx >= 0 && intern->r_symndx <= 14)); + || (intern->r_symndx >= 0 && intern->r_symndx <= 15)); H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr); H_PUT_32 (abfd, symndx, ext->r_symndx); @@ -623,13 +591,20 @@ alpha_ecoff_swap_reloc_out (abfd, intern, dst) this backend routine. It must fill in the howto field. */ static void -alpha_adjust_reloc_in (abfd, intern, rptr) - bfd *abfd; - const struct internal_reloc *intern; - arelent *rptr; +alpha_adjust_reloc_in (bfd *abfd, + const struct internal_reloc *intern, + arelent *rptr) { if (intern->r_type > ALPHA_R_GPVALUE) - abort (); + { + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + abfd, intern->r_type); + bfd_set_error (bfd_error_bad_value); + rptr->addend = 0; + rptr->howto = NULL; + return; + } switch (intern->r_type) { @@ -638,8 +613,8 @@ alpha_adjust_reloc_in (abfd, intern, rptr) case ALPHA_R_SREL32: case ALPHA_R_SREL64: /* This relocs appear to be fully resolved when they are against - internal symbols. Against external symbols, BRADDR at least - appears to be resolved against the next instruction. */ + internal symbols. Against external symbols, BRADDR at least + appears to be resolved against the next instruction. */ if (! intern->r_extern) rptr->addend = 0; else @@ -665,7 +640,7 @@ alpha_adjust_reloc_in (abfd, intern, rptr) case ALPHA_R_OP_STORE: /* The STORE reloc needs the size and offset fields. We store them in the addend. */ - BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256); + BFD_ASSERT (intern->r_offset <= 256); rptr->addend = (intern->r_offset << 8) + intern->r_size; break; @@ -707,10 +682,9 @@ alpha_adjust_reloc_in (abfd, intern, rptr) not need to undo. */ static void -alpha_adjust_reloc_out (abfd, rel, intern) - bfd *abfd ATTRIBUTE_UNUSED; - const arelent *rel; - struct internal_reloc *intern; +alpha_adjust_reloc_out (bfd *abfd ATTRIBUTE_UNUSED, + const arelent *rel, + struct internal_reloc *intern) { switch (intern->r_type) { @@ -749,23 +723,22 @@ alpha_adjust_reloc_out (abfd, rel, intern) assembler is going to handle this. */ static bfd_byte * -alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, - data, relocateable, symbols) - bfd *abfd; - struct bfd_link_info *link_info; - struct bfd_link_order *link_order; - bfd_byte *data; - boolean relocateable; - asymbol **symbols; +alpha_ecoff_get_relocated_section_contents (bfd *abfd, + struct bfd_link_info *link_info, + struct bfd_link_order *link_order, + bfd_byte *data, + bfd_boolean relocatable, + asymbol **symbols) { bfd *input_bfd = link_order->u.indirect.section->owner; asection *input_section = link_order->u.indirect.section; long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); arelent **reloc_vector = NULL; long reloc_count; - bfd *output_bfd = relocateable ? abfd : (bfd *) NULL; + bfd *output_bfd = relocatable ? abfd : (bfd *) NULL; bfd_vma gp; - boolean gp_undefined; + bfd_size_type sz; + bfd_boolean gp_undefined; bfd_vma stack[RELOC_STACKSIZE]; int tos = 0; @@ -775,14 +748,10 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, if (reloc_vector == NULL && reloc_size != 0) goto error_return; - if (! bfd_get_section_contents (input_bfd, input_section, data, - (file_ptr) 0, input_section->_raw_size)) + sz = input_section->rawsize ? input_section->rawsize : input_section->size; + if (! bfd_get_section_contents (input_bfd, input_section, data, 0, sz)) goto error_return; - /* The section size is not going to change. */ - input_section->_cooked_size = input_section->_raw_size; - input_section->reloc_done = true; - reloc_count = bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector, symbols); if (reloc_count < 0) @@ -791,11 +760,11 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, goto successful_return; /* Get the GP value for the output BFD. */ - gp_undefined = false; + gp_undefined = FALSE; gp = _bfd_get_gp_value (abfd); if (gp == 0) { - if (relocateable != false) + if (relocatable) { asection *sec; bfd_vma lo; @@ -819,11 +788,11 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, { struct bfd_link_hash_entry *h; - h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false, - true); + h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE, + TRUE); if (h == (struct bfd_link_hash_entry *) NULL || h->type != bfd_link_hash_defined) - gp_undefined = true; + gp_undefined = TRUE; else { gp = (h->u.def.value @@ -855,7 +824,7 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, case ALPHA_R_SREL16: case ALPHA_R_SREL32: case ALPHA_R_SREL64: - if (relocateable + if (relocatable && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0) { rel->address += input_section->output_offset; @@ -988,7 +957,7 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, asymbol *symbol; bfd_vma relocation; - if (relocateable) + if (relocatable) { rel->address += input_section->output_offset; break; @@ -1021,7 +990,7 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, bfd_vma val; int offset, size; - if (relocateable) + if (relocatable) { rel->address += input_section->output_offset; break; @@ -1048,7 +1017,7 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, asymbol *symbol; bfd_vma relocation; - if (relocateable) + if (relocatable) { rel->address += input_section->output_offset; break; @@ -1081,7 +1050,7 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, asymbol *symbol; bfd_vma relocation; - if (relocateable) + if (relocatable) { rel->address += input_section->output_offset; break; @@ -1111,14 +1080,14 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, case ALPHA_R_GPVALUE: /* I really don't know if this does the right thing. */ gp = rel->addend; - gp_undefined = false; + gp_undefined = FALSE; break; default: abort (); } - if (relocateable) + if (relocatable) { asection *os = input_section->output_section; @@ -1132,23 +1101,19 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, switch (r) { case bfd_reloc_undefined: - if (! ((*link_info->callbacks->undefined_symbol) - (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr), - input_bfd, input_section, rel->address, true))) - goto error_return; + (*link_info->callbacks->undefined_symbol) + (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr), + input_bfd, input_section, rel->address, TRUE); break; case bfd_reloc_dangerous: - if (! ((*link_info->callbacks->reloc_dangerous) - (link_info, err, input_bfd, input_section, - rel->address))) - goto error_return; + (*link_info->callbacks->reloc_dangerous) + (link_info, err, input_bfd, input_section, rel->address); break; case bfd_reloc_overflow: - if (! ((*link_info->callbacks->reloc_overflow) - (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr), - rel->howto->name, rel->addend, input_bfd, - input_section, rel->address))) - goto error_return; + (*link_info->callbacks->reloc_overflow) + (link_info, NULL, bfd_asymbol_name (*rel->sym_ptr_ptr), + rel->howto->name, rel->addend, input_bfd, + input_section, rel->address); break; case bfd_reloc_outofrange: default: @@ -1175,9 +1140,8 @@ alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, /* Get the howto structure for a generic reloc type. */ static reloc_howto_type * -alpha_bfd_reloc_type_lookup (abfd, code) - bfd *abfd ATTRIBUTE_UNUSED; - bfd_reloc_code_real_type code; +alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, + bfd_reloc_code_real_type code) { int alpha_type; @@ -1220,46 +1184,44 @@ alpha_bfd_reloc_type_lookup (abfd, code) case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break; -#if 0 - case ???: - alpha_type = ALPHA_R_OP_PUSH; - break; - case ???: - alpha_type = ALPHA_R_OP_STORE; - break; - case ???: - alpha_type = ALPHA_R_OP_PSUB; - break; - case ???: - alpha_type = ALPHA_R_OP_PRSHIFT; - break; - case ???: - alpha_type = ALPHA_R_GPVALUE; - break; -#endif default: return (reloc_howto_type *) NULL; } return &alpha_howto_table[alpha_type]; } + +static reloc_howto_type * +alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, + const char *r_name) +{ + unsigned int i; + + for (i = 0; + i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]); + i++) + if (alpha_howto_table[i].name != NULL + && strcasecmp (alpha_howto_table[i].name, r_name) == 0) + return &alpha_howto_table[i]; + + return NULL; +} /* A helper routine for alpha_relocate_section which converts an - external reloc when generating relocateable output. Returns the + external reloc when generating relocatable output. Returns the relocation amount. */ static bfd_vma -alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h) - bfd *output_bfd ATTRIBUTE_UNUSED; - struct bfd_link_info *info; - bfd *input_bfd; - struct external_reloc *ext_rel; - struct ecoff_link_hash_entry *h; +alpha_convert_external_reloc (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info, + bfd *input_bfd, + struct external_reloc *ext_rel, + struct ecoff_link_hash_entry *h) { unsigned long r_symndx; bfd_vma relocation; - BFD_ASSERT (info->relocateable); + BFD_ASSERT (bfd_link_relocatable (info)); if (h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak) @@ -1275,7 +1237,7 @@ alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h) /* Compute a new r_symndx value. */ hsec = h->root.u.def.section; - name = bfd_get_section_name (output_bfd, hsec->output_section); + name = bfd_section_name (hsec->output_section); r_symndx = (unsigned long) -1; switch (name[1]) @@ -1365,20 +1327,18 @@ alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h) quite similar to get_relocated_section_contents. Perhaps they could be combined somehow. */ -static boolean -alpha_relocate_section (output_bfd, info, input_bfd, input_section, - contents, external_relocs) - bfd *output_bfd; - struct bfd_link_info *info; - bfd *input_bfd; - asection *input_section; - bfd_byte *contents; - PTR external_relocs; +static bfd_boolean +alpha_relocate_section (bfd *output_bfd, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + void * external_relocs) { asection **symndx_to_section, *lita_sec; struct ecoff_link_hash_entry **sym_hashes; bfd_vma gp; - boolean gp_undefined; + bfd_boolean gp_undefined; bfd_vma stack[RELOC_STACKSIZE]; int tos = 0; struct external_reloc *ext_rel; @@ -1394,7 +1354,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, amt = NUM_RELOC_SECTIONS * sizeof (asection *); symndx_to_section = (asection **) bfd_alloc (input_bfd, amt); if (!symndx_to_section) - return false; + return FALSE; symndx_to_section[RELOC_SECTION_NONE] = NULL; symndx_to_section[RELOC_SECTION_TEXT] = @@ -1440,7 +1400,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, lita_sec = symndx_to_section[RELOC_SECTION_LITA]; gp = _bfd_get_gp_value (output_bfd); - if (! info->relocateable && lita_sec != NULL) + if (! bfd_link_relocatable (info) && lita_sec != NULL) { struct ecoff_section_tdata *lita_sec_data; @@ -1452,7 +1412,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, amt = sizeof (struct ecoff_section_tdata); lita_sec_data = ((struct ecoff_section_tdata *) bfd_zalloc (input_bfd, amt)); - ecoff_section_data (input_bfd, lita_sec) = lita_sec_data; + lita_sec->used_by_bfd = lita_sec_data; } if (lita_sec_data->gp != 0) @@ -1467,9 +1427,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, bfd_size_type lita_size; lita_vma = lita_sec->output_offset + lita_sec->output_section->vma; - lita_size = lita_sec->_cooked_size; - if (lita_size == 0) - lita_size = lita_sec->_raw_size; + lita_size = lita_sec->size; if (gp == 0 || lita_vma < gp - 0x8000 @@ -1485,7 +1443,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, _("using multiple gp values"), (char *) NULL, output_bfd, (asection *) NULL, (bfd_vma) 0); - ecoff_data (output_bfd)->issued_multiple_gp_warning = true; + ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE; } if (lita_vma < gp - 0x8000) gp = lita_vma + lita_size - 0x8000; @@ -1515,9 +1473,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, int r_extern; int r_offset; int r_size; - boolean relocatep; - boolean adjust_addrp; - boolean gp_usedp; + bfd_boolean relocatep; + bfd_boolean adjust_addrp; + bfd_boolean gp_usedp; bfd_vma addend; r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr); @@ -1532,15 +1490,31 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE) >> RELOC_BITS3_SIZE_SH_LITTLE); - relocatep = false; - adjust_addrp = true; - gp_usedp = false; + relocatep = FALSE; + adjust_addrp = TRUE; + gp_usedp = FALSE; addend = 0; switch (r_type) { + case ALPHA_R_GPRELHIGH: + _bfd_error_handler (_("%pB: %s unsupported"), + input_bfd, "ALPHA_R_GPRELHIGH"); + bfd_set_error (bfd_error_bad_value); + continue; + + case ALPHA_R_GPRELLOW: + _bfd_error_handler (_("%pB: %s unsupported"), + input_bfd, "ALPHA_R_GPRELLOW"); + bfd_set_error (bfd_error_bad_value); + continue; + default: - abort (); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + input_bfd, (int) r_type); + bfd_set_error (bfd_error_bad_value); + continue; case ALPHA_R_IGNORE: /* This reloc appears after a GPDISP reloc. On earlier @@ -1549,16 +1523,16 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, not otherwise used for anything. For some reason, the address of the relocation does not appear to include the section VMA, unlike the other relocation types. */ - if (info->relocateable) + if (bfd_link_relocatable (info)) H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr, ext_rel->r_vaddr); - adjust_addrp = false; + adjust_addrp = FALSE; break; case ALPHA_R_REFLONG: case ALPHA_R_REFQUAD: case ALPHA_R_HINT: - relocatep = true; + relocatep = TRUE; break; case ALPHA_R_BRADDR: @@ -1567,7 +1541,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, case ALPHA_R_SREL64: if (r_extern) addend += - (r_vaddr + 4); - relocatep = true; + relocatep = TRUE; break; case ALPHA_R_GPREL32: @@ -1575,9 +1549,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, bit offset from the current GP value. We must adjust it by the different between the original GP value and the current GP value. */ - relocatep = true; + relocatep = TRUE; addend = ecoff_data (input_bfd)->gp - gp; - gp_usedp = true; + gp_usedp = TRUE; break; case ALPHA_R_LITERAL: @@ -1608,9 +1582,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, || ((insn >> 26) & 0x3f) == 0x28); } - relocatep = true; + relocatep = TRUE; addend = ecoff_data (input_bfd)->gp - gp; - gp_usedp = true; + gp_usedp = TRUE; break; case ALPHA_R_LITUSE: @@ -1674,7 +1648,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, bfd_put_32 (input_bfd, (bfd_vma) insn2, contents + r_vaddr - input_section->vma + r_symndx); - gp_usedp = true; + gp_usedp = TRUE; } break; @@ -1702,7 +1676,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, if (h == (struct ecoff_link_hash_entry *) NULL) abort (); - if (! info->relocateable) + if (! bfd_link_relocatable (info)) { if (h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak) @@ -1715,10 +1689,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, do not have a meaningful number for the location within the section that is being relocated. */ - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.string, input_bfd, - input_section, (bfd_vma) 0, true))) - return false; + (*info->callbacks->undefined_symbol) + (info, h->root.root.string, input_bfd, + input_section, (bfd_vma) 0, TRUE); addend = 0; } } @@ -1731,10 +1704,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, /* This symbol is not being written out. Pass the address as 0, as with undefined_symbol, above. */ - if (! ((*info->callbacks->unattached_reloc) - (info, h->root.root.string, input_bfd, - input_section, (bfd_vma) 0))) - return false; + (*info->callbacks->unattached_reloc) + (info, h->root.root.string, + input_bfd, input_section, (bfd_vma) 0); } addend = alpha_convert_external_reloc (output_bfd, info, @@ -1745,7 +1717,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, addend += r_vaddr; - if (info->relocateable) + if (bfd_link_relocatable (info)) { /* Adjust r_vaddr by the addend. */ H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr); @@ -1774,14 +1746,14 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, } } - adjust_addrp = false; + adjust_addrp = FALSE; break; case ALPHA_R_OP_STORE: /* Store a value from the reloc stack into a bitfield. If - we are generating relocateable output, all we do is + we are generating relocatable output, all we do is adjust the address of the reloc. */ - if (! info->relocateable) + if (! bfd_link_relocatable (info)) { bfd_vma mask; bfd_vma val; @@ -1811,7 +1783,7 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, case ALPHA_R_GPVALUE: /* I really don't know if this does the right thing. */ gp = ecoff_data (input_bfd)->gp + r_symndx; - gp_undefined = false; + gp_undefined = FALSE; break; } @@ -1847,9 +1819,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, abort (); } - if (info->relocateable) + if (bfd_link_relocatable (info)) { - /* We are generating relocateable output, and must + /* We are generating relocatable output, and must convert the existing reloc. */ if (r_extern) { @@ -1858,10 +1830,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, && h->indx == -1) { /* This symbol is not being written out. */ - if (! ((*info->callbacks->unattached_reloc) - (info, h->root.root.string, input_bfd, - input_section, r_vaddr - input_section->vma))) - return false; + (*info->callbacks->unattached_reloc) + (info, h->root.root.string, input_bfd, + input_section, r_vaddr - input_section->vma); } relocation = alpha_convert_external_reloc (output_bfd, @@ -1915,11 +1886,9 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, } else { - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.string, input_bfd, - input_section, - r_vaddr - input_section->vma, true))) - return false; + (*info->callbacks->undefined_symbol) + (info, h->root.root.string, input_bfd, input_section, + r_vaddr - input_section->vma, TRUE); relocation = 0; } } @@ -1959,20 +1928,18 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, if (r_extern) name = sym_hashes[r_symndx]->root.root.string; else - name = bfd_section_name (input_bfd, - symndx_to_section[r_symndx]); - if (! ((*info->callbacks->reloc_overflow) - (info, name, alpha_howto_table[r_type].name, - (bfd_vma) 0, input_bfd, input_section, - r_vaddr - input_section->vma))) - return false; + name = bfd_section_name (symndx_to_section[r_symndx]); + (*info->callbacks->reloc_overflow) + (info, NULL, name, alpha_howto_table[r_type].name, + (bfd_vma) 0, input_bfd, input_section, + r_vaddr - input_section->vma); } break; } } } - if (info->relocateable && adjust_addrp) + if (bfd_link_relocatable (info) && adjust_addrp) { /* Change the address of the relocation. */ H_PUT_64 (input_bfd, @@ -1985,37 +1952,35 @@ alpha_relocate_section (output_bfd, info, input_bfd, input_section, if (gp_usedp && gp_undefined) { - if (! ((*info->callbacks->reloc_dangerous) - (info, _("GP relative relocation used when GP not defined"), - input_bfd, input_section, r_vaddr - input_section->vma))) - return false; + (*info->callbacks->reloc_dangerous) + (info, _("GP relative relocation used when GP not defined"), + input_bfd, input_section, r_vaddr - input_section->vma); /* Only give the error once per link. */ gp = 4; _bfd_set_gp_value (output_bfd, gp); - gp_undefined = false; + gp_undefined = FALSE; } } if (tos != 0) abort (); - return true; + return TRUE; } /* Do final adjustments to the filehdr and the aouthdr. This routine sets the dynamic bits in the file header. */ -static boolean -alpha_adjust_headers (abfd, fhdr, ahdr) - bfd *abfd; - struct internal_filehdr *fhdr; - struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED; +static bfd_boolean +alpha_adjust_headers (bfd *abfd, + struct internal_filehdr *fhdr, + struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED) { if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P)) fhdr->f_flags |= F_ALPHA_CALL_SHARED; else if ((abfd->flags & DYNAMIC) != 0) fhdr->f_flags |= F_ALPHA_SHARABLE; - return true; + return TRUE; } /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital @@ -2030,6 +1995,7 @@ alpha_adjust_headers (abfd, fhdr, ahdr) _bfd_ecoff_construct_extended_name_table #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname #define alpha_ecoff_write_armap _bfd_ecoff_write_armap +#define alpha_ecoff_write_ar_hdr _bfd_generic_write_ar_hdr #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp @@ -2040,9 +2006,8 @@ alpha_adjust_headers (abfd, fhdr, ahdr) /* Read an archive header. This is like the standard routine, but it also accepts ARFZMAG. */ -static PTR -alpha_ecoff_read_ar_hdr (abfd) - bfd *abfd; +static void * +alpha_ecoff_read_ar_hdr (bfd *abfd) { struct areltdata *ret; struct ar_hdr *h; @@ -2057,7 +2022,7 @@ alpha_ecoff_read_ar_hdr (abfd) bfd_byte ab[8]; /* This is a compressed file. We must set the size correctly. - The size is the eight bytes after the dummy file header. */ + The size is the eight bytes after the dummy file header. */ if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0) @@ -2066,16 +2031,14 @@ alpha_ecoff_read_ar_hdr (abfd) ret->parsed_size = H_GET_64 (abfd, ab); } - return (PTR) ret; + return ret; } /* Get an archive element at a specified file position. This is where we uncompress the archive element if necessary. */ static bfd * -alpha_ecoff_get_elt_at_filepos (archive, filepos) - bfd *archive; - file_ptr filepos; +alpha_ecoff_get_elt_at_filepos (bfd *archive, file_ptr filepos) { bfd *nbfd = NULL; struct areltdata *tdata; @@ -2085,6 +2048,7 @@ alpha_ecoff_get_elt_at_filepos (archive, filepos) bfd_byte *buf, *p; struct bfd_in_memory *bim; + buf = NULL; nbfd = _bfd_get_elt_at_filepos (archive, filepos); if (nbfd == NULL) goto error_return; @@ -2116,16 +2080,14 @@ alpha_ecoff_get_elt_at_filepos (archive, filepos) goto error_return; size = H_GET_64 (nbfd, ab); - if (size == 0) - buf = NULL; - else + if (size != 0) { bfd_size_type left; bfd_byte dict[4096]; unsigned int h; bfd_byte b; - buf = (bfd_byte *) bfd_alloc (nbfd, size); + buf = (bfd_byte *) bfd_malloc (size); if (buf == NULL) goto error_return; p = buf; @@ -2179,22 +2141,26 @@ alpha_ecoff_get_elt_at_filepos (archive, filepos) /* Now the uncompressed file contents are in buf. */ bim = ((struct bfd_in_memory *) - bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory))); + bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory))); if (bim == NULL) goto error_return; bim->size = size; bim->buffer = buf; - nbfd->mtime_set = true; + nbfd->mtime_set = TRUE; nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10); nbfd->flags |= BFD_IN_MEMORY; - nbfd->iostream = (PTR) bim; + nbfd->iostream = bim; + nbfd->iovec = &_bfd_memory_iovec; + nbfd->origin = 0; BFD_ASSERT (! nbfd->cacheable); return nbfd; error_return: + if (buf != NULL) + free (buf); if (nbfd != NULL) bfd_close (nbfd); return NULL; @@ -2203,11 +2169,9 @@ alpha_ecoff_get_elt_at_filepos (archive, filepos) /* Open the next archived file. */ static bfd * -alpha_ecoff_openr_next_archived_file (archive, last_file) - bfd *archive; - bfd *last_file; +alpha_ecoff_openr_next_archived_file (bfd *archive, bfd *last_file) { - file_ptr filestart; + ufile_ptr filestart; if (last_file == NULL) filestart = bfd_ardata (archive)->first_file_filepos; @@ -2218,7 +2182,7 @@ alpha_ecoff_openr_next_archived_file (archive, last_file) bfd_size_type size; /* We can't use arelt_size here, because that uses parsed_size, - which is the uncompressed size. We need the compressed size. */ + which is the uncompressed size. We need the compressed size. */ t = (struct areltdata *) last_file->arelt_data; h = (struct ar_hdr *) t->arch_header; size = strtol (h->ar_size, (char **) NULL, 10); @@ -2226,8 +2190,14 @@ alpha_ecoff_openr_next_archived_file (archive, last_file) /* Pad to an even boundary... Note that last_file->origin can be odd in the case of BSD-4.4-style element with a long odd size. */ - filestart = last_file->origin + size; + filestart = last_file->proxy_origin + size; filestart += filestart % 2; + if (filestart < last_file->proxy_origin) + { + /* Prevent looping. See PR19256. */ + bfd_set_error (bfd_error_malformed_archive); + return NULL; + } } return alpha_ecoff_get_elt_at_filepos (archive, filestart); @@ -2236,15 +2206,74 @@ alpha_ecoff_openr_next_archived_file (archive, last_file) /* Open the archive file given an index into the armap. */ static bfd * -alpha_ecoff_get_elt_at_index (abfd, index) - bfd *abfd; - symindex index; +alpha_ecoff_get_elt_at_index (bfd *abfd, symindex sym_index) { carsym *entry; - entry = bfd_ardata (abfd)->symdefs + index; + entry = bfd_ardata (abfd)->symdefs + sym_index; return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset); } + +static void +alpha_ecoff_swap_coff_aux_in (bfd *abfd ATTRIBUTE_UNUSED, + void *ext1 ATTRIBUTE_UNUSED, + int type ATTRIBUTE_UNUSED, + int in_class ATTRIBUTE_UNUSED, + int indx ATTRIBUTE_UNUSED, + int numaux ATTRIBUTE_UNUSED, + void *in1 ATTRIBUTE_UNUSED) +{ +} + +static void +alpha_ecoff_swap_coff_sym_in (bfd *abfd ATTRIBUTE_UNUSED, + void *ext1 ATTRIBUTE_UNUSED, + void *in1 ATTRIBUTE_UNUSED) +{ +} + +static void +alpha_ecoff_swap_coff_lineno_in (bfd *abfd ATTRIBUTE_UNUSED, + void *ext1 ATTRIBUTE_UNUSED, + void *in1 ATTRIBUTE_UNUSED) +{ +} + +static unsigned int +alpha_ecoff_swap_coff_aux_out (bfd *abfd ATTRIBUTE_UNUSED, + void *inp ATTRIBUTE_UNUSED, + int type ATTRIBUTE_UNUSED, + int in_class ATTRIBUTE_UNUSED, + int indx ATTRIBUTE_UNUSED, + int numaux ATTRIBUTE_UNUSED, + void *extp ATTRIBUTE_UNUSED) +{ + return 0; +} + +static unsigned int +alpha_ecoff_swap_coff_sym_out (bfd *abfd ATTRIBUTE_UNUSED, + void *inp ATTRIBUTE_UNUSED, + void *extp ATTRIBUTE_UNUSED) +{ + return 0; +} + +static unsigned int +alpha_ecoff_swap_coff_lineno_out (bfd *abfd ATTRIBUTE_UNUSED, + void *inp ATTRIBUTE_UNUSED, + void *extp ATTRIBUTE_UNUSED) +{ + return 0; +} + +static unsigned int +alpha_ecoff_swap_coff_reloc_out (bfd *abfd ATTRIBUTE_UNUSED, + void *inp ATTRIBUTE_UNUSED, + void *extp ATTRIBUTE_UNUSED) +{ + return 0; +} /* This is the ECOFF backend structure. The backend field of the target vector points to this. */ @@ -2253,23 +2282,21 @@ static const struct ecoff_backend_data alpha_ecoff_backend_data = { /* COFF backend structure. */ { - (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */ - (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */ - (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */ - (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/ - (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */ - (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */ - (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */ + alpha_ecoff_swap_coff_aux_in, alpha_ecoff_swap_coff_sym_in, + alpha_ecoff_swap_coff_lineno_in, alpha_ecoff_swap_coff_aux_out, + alpha_ecoff_swap_coff_sym_out, alpha_ecoff_swap_coff_lineno_out, + alpha_ecoff_swap_coff_reloc_out, alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out, alpha_ecoff_swap_scnhdr_out, - FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, true, false, 4, false, 2, + FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, + ECOFF_NO_LONG_SECTION_NAMES, 4, FALSE, 2, 32768, alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in, alpha_ecoff_swap_scnhdr_in, NULL, alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook, alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags, _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, - NULL, NULL, NULL + NULL, NULL, NULL, NULL }, /* Supported architecture. */ bfd_arch_alpha, @@ -2278,10 +2305,10 @@ static const struct ecoff_backend_data alpha_ecoff_backend_data = /* The page boundary used to align sections in a demand-paged executable file. E.g., 0x1000. */ 0x2000, - /* True if the .rdata section is part of the text segment, as on the - Alpha. False if .rdata is part of the data segment, as on the + /* TRUE if the .rdata section is part of the text segment, as on the + Alpha. FALSE if .rdata is part of the data segment, as on the MIPS. */ - true, + TRUE, /* Bitsize of constructor entries. */ 64, /* Reloc to use for constructor entries. */ @@ -2343,6 +2370,8 @@ static const struct ecoff_backend_data alpha_ecoff_backend_data = /* Looking up a reloc type is Alpha specific. */ #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup +#define _bfd_ecoff_bfd_reloc_name_lookup \ + alpha_bfd_reloc_name_lookup /* So is getting relocated section contents. */ #define _bfd_ecoff_bfd_get_relocated_section_contents \ @@ -2352,27 +2381,42 @@ static const struct ecoff_backend_data alpha_ecoff_backend_data = #define _bfd_ecoff_get_section_contents_in_window \ _bfd_generic_get_section_contents_in_window +/* Input section flag lookup is generic. */ +#define _bfd_ecoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags + /* Relaxing sections is generic. */ #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections +#define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section +#define _bfd_ecoff_bfd_group_name bfd_generic_group_name #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group +#define _bfd_ecoff_section_already_linked \ + _bfd_coff_section_already_linked +#define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol +#define _bfd_ecoff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol +#define _bfd_ecoff_bfd_define_start_stop bfd_generic_define_start_stop +#define _bfd_ecoff_bfd_link_check_relocs _bfd_generic_link_check_relocs -const bfd_target ecoffalpha_little_vec = +/* Installing internal relocations in a section is also generic. */ +#define _bfd_ecoff_set_reloc _bfd_generic_set_reloc + +const bfd_target alpha_ecoff_le_vec = { "ecoff-littlealpha", /* name */ bfd_target_ecoff_flavour, BFD_ENDIAN_LITTLE, /* data byte order is little */ BFD_ENDIAN_LITTLE, /* header byte order is little */ - (HAS_RELOC | EXEC_P | /* object flags */ - HAS_LINENO | HAS_DEBUG | - HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (HAS_RELOC | EXEC_P /* object flags */ + | HAS_LINENO | HAS_DEBUG + | HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), 0, /* leading underscore */ ' ', /* ar_pad_char */ 15, /* ar_max_namelen */ + 0, /* match priority. */ bfd_getl64, bfd_getl_signed_64, bfd_putl64, bfd_getl32, bfd_getl_signed_32, bfd_putl32, bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ @@ -2380,24 +2424,36 @@ const bfd_target ecoffalpha_little_vec = bfd_getl32, bfd_getl_signed_32, bfd_putl32, bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ - {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */ - _bfd_ecoff_archive_p, _bfd_dummy_target}, - {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */ - _bfd_generic_mkarchive, bfd_false}, - {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */ - _bfd_write_archive_contents, bfd_false}, - - BFD_JUMP_TABLE_GENERIC (_bfd_ecoff), - BFD_JUMP_TABLE_COPY (_bfd_ecoff), - BFD_JUMP_TABLE_CORE (_bfd_nocore), - BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff), - BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff), - BFD_JUMP_TABLE_RELOCS (_bfd_ecoff), - BFD_JUMP_TABLE_WRITE (_bfd_ecoff), - BFD_JUMP_TABLE_LINK (_bfd_ecoff), - BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + { /* bfd_check_format */ + _bfd_dummy_target, + alpha_ecoff_object_p, + bfd_generic_archive_p, + _bfd_dummy_target + }, + { /* bfd_set_format */ + _bfd_bool_bfd_false_error, + _bfd_ecoff_mkobject, + _bfd_generic_mkarchive, + _bfd_bool_bfd_false_error + }, + { /* bfd_write_contents */ + _bfd_bool_bfd_false_error, + _bfd_ecoff_write_object_contents, + _bfd_write_archive_contents, + _bfd_bool_bfd_false_error + }, + + BFD_JUMP_TABLE_GENERIC (_bfd_ecoff), + BFD_JUMP_TABLE_COPY (_bfd_ecoff), + BFD_JUMP_TABLE_CORE (_bfd_nocore), + BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff), + BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff), + BFD_JUMP_TABLE_RELOCS (_bfd_ecoff), + BFD_JUMP_TABLE_WRITE (_bfd_ecoff), + BFD_JUMP_TABLE_LINK (_bfd_ecoff), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), NULL, - (PTR) &alpha_ecoff_backend_data + &alpha_ecoff_backend_data };