| /* BFD semi-generic back-end for a.out binaries. |
| Copyright (C) 1990-2021 Free Software Foundation, Inc. |
| Written by Cygnus Support. |
| |
| 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 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. |
| |
| 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. */ |
| |
| /* |
| SECTION |
| a.out backends |
| |
| DESCRIPTION |
| |
| BFD supports a number of different flavours of a.out format, |
| though the major differences are only the sizes of the |
| structures on disk, and the shape of the relocation |
| information. |
| |
| The support is split into a basic support file @file{aoutx.h} |
| and other files which derive functions from the base. One |
| derivation file is @file{aoutf1.h} (for a.out flavour 1), and |
| adds to the basic a.out functions support for sun3, sun4, and |
| 386 a.out files, to create a target jump vector for a specific |
| target. |
| |
| This information is further split out into more specific files |
| for each machine, including @file{sunos.c} for sun3 and sun4, |
| and @file{demo64.c} for a demonstration of a 64 bit a.out format. |
| |
| The base file @file{aoutx.h} defines general mechanisms for |
| reading and writing records to and from disk and various |
| other methods which BFD requires. It is included by |
| @file{aout32.c} and @file{aout64.c} to form the names |
| <<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc. |
| |
| As an example, this is what goes on to make the back end for a |
| sun4, from @file{aout32.c}: |
| |
| | #define ARCH_SIZE 32 |
| | #include "aoutx.h" |
| |
| Which exports names: |
| |
| | ... |
| | aout_32_canonicalize_reloc |
| | aout_32_find_nearest_line |
| | aout_32_get_lineno |
| | aout_32_get_reloc_upper_bound |
| | ... |
| |
| from @file{sunos.c}: |
| |
| | #define TARGET_NAME "a.out-sunos-big" |
| | #define VECNAME sparc_aout_sunos_be_vec |
| | #include "aoutf1.h" |
| |
| requires all the names from @file{aout32.c}, and produces the jump vector |
| |
| | sparc_aout_sunos_be_vec |
| |
| The file @file{host-aout.c} is a special case. It is for a large set |
| of hosts that use ``more or less standard'' a.out files, and |
| for which cross-debugging is not interesting. It uses the |
| standard 32-bit a.out support routines, but determines the |
| file offsets and addresses of the text, data, and BSS |
| sections, the machine architecture and machine type, and the |
| entry point address, in a host-dependent manner. Once these |
| values have been determined, generic code is used to handle |
| the object file. |
| |
| When porting it to run on a new system, you must supply: |
| |
| | HOST_PAGE_SIZE |
| | HOST_SEGMENT_SIZE |
| | HOST_MACHINE_ARCH (optional) |
| | HOST_MACHINE_MACHINE (optional) |
| | HOST_TEXT_START_ADDR |
| | HOST_STACK_END_ADDR |
| |
| in the file @file{../include/sys/h-@var{XXX}.h} (for your host). These |
| values, plus the structures and macros defined in @file{a.out.h} on |
| your host system, will produce a BFD target that will access |
| ordinary a.out files on your host. To configure a new machine |
| to use @file{host-aout.c}, specify: |
| |
| | TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec |
| | TDEPFILES= host-aout.o trad-core.o |
| |
| in the @file{config/@var{XXX}.mt} file, and modify @file{configure.ac} |
| to use the |
| @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your |
| configuration is selected. */ |
| |
| /* Some assumptions: |
| * Any BFD with D_PAGED set is ZMAGIC, and vice versa. |
| Doesn't matter what the setting of WP_TEXT is on output, but it'll |
| get set on input. |
| * Any BFD with D_PAGED clear and WP_TEXT set is NMAGIC. |
| * Any BFD with both flags clear is OMAGIC. |
| (Just want to make these explicit, so the conditions tested in this |
| file make sense if you're more familiar with a.out than with BFD.) */ |
| |
| #define KEEPIT udata.i |
| |
| #include "sysdep.h" |
| #include <limits.h> |
| #include "bfd.h" |
| #include "safe-ctype.h" |
| #include "bfdlink.h" |
| |
| #include "libaout.h" |
| #include "libbfd.h" |
| #include "aout/aout64.h" |
| #include "aout/stab_gnu.h" |
| #include "aout/ar.h" |
| |
| #ifdef BMAGIC |
| #define N_IS_BMAGIC(x) (N_MAGIC (x) == BMAGIC) |
| #else |
| #define N_IS_BMAGIC(x) (0) |
| #endif |
| |
| #ifdef QMAGIC |
| #define N_SET_QMAGIC(x) N_SET_MAGIC (x, QMAGIC) |
| #else |
| #define N_SET_QMAGIC(x) do { /**/ } while (0) |
| #endif |
| |
| /* |
| SUBSECTION |
| Relocations |
| |
| DESCRIPTION |
| The file @file{aoutx.h} provides for both the @emph{standard} |
| and @emph{extended} forms of a.out relocation records. |
| |
| The standard records contain only an address, a symbol index, |
| and a type field. The extended records also have a full |
| integer for an addend. */ |
| |
| #ifndef CTOR_TABLE_RELOC_HOWTO |
| #define CTOR_TABLE_RELOC_IDX 2 |
| #define CTOR_TABLE_RELOC_HOWTO(BFD) \ |
| ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE \ |
| ? howto_table_ext : howto_table_std) \ |
| + CTOR_TABLE_RELOC_IDX) |
| #endif |
| |
| #ifndef MY_swap_std_reloc_in |
| #define MY_swap_std_reloc_in NAME (aout, swap_std_reloc_in) |
| #endif |
| |
| #ifndef MY_swap_ext_reloc_in |
| #define MY_swap_ext_reloc_in NAME (aout, swap_ext_reloc_in) |
| #endif |
| |
| #ifndef MY_swap_std_reloc_out |
| #define MY_swap_std_reloc_out NAME (aout, swap_std_reloc_out) |
| #endif |
| |
| #ifndef MY_swap_ext_reloc_out |
| #define MY_swap_ext_reloc_out NAME (aout, swap_ext_reloc_out) |
| #endif |
| |
| #ifndef MY_final_link_relocate |
| #define MY_final_link_relocate _bfd_final_link_relocate |
| #endif |
| |
| #ifndef MY_relocate_contents |
| #define MY_relocate_contents _bfd_relocate_contents |
| #endif |
| |
| #define howto_table_ext NAME (aout, ext_howto_table) |
| #define howto_table_std NAME (aout, std_howto_table) |
| |
| reloc_howto_type howto_table_ext[] = |
| { |
| /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */ |
| HOWTO (RELOC_8, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "8", false, 0, 0x000000ff, false), |
| HOWTO (RELOC_16, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "16", false, 0, 0x0000ffff, false), |
| HOWTO (RELOC_32, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "32", false, 0, 0xffffffff, false), |
| HOWTO (RELOC_DISP8, 0, 0, 8, true, 0, complain_overflow_signed, 0, "DISP8", false, 0, 0x000000ff, false), |
| HOWTO (RELOC_DISP16, 0, 1, 16, true, 0, complain_overflow_signed, 0, "DISP16", false, 0, 0x0000ffff, false), |
| HOWTO (RELOC_DISP32, 0, 2, 32, true, 0, complain_overflow_signed, 0, "DISP32", false, 0, 0xffffffff, false), |
| HOWTO (RELOC_WDISP30, 2, 2, 30, true, 0, complain_overflow_signed, 0, "WDISP30", false, 0, 0x3fffffff, false), |
| HOWTO (RELOC_WDISP22, 2, 2, 22, true, 0, complain_overflow_signed, 0, "WDISP22", false, 0, 0x003fffff, false), |
| HOWTO (RELOC_HI22, 10, 2, 22, false, 0, complain_overflow_bitfield, 0, "HI22", false, 0, 0x003fffff, false), |
| HOWTO (RELOC_22, 0, 2, 22, false, 0, complain_overflow_bitfield, 0, "22", false, 0, 0x003fffff, false), |
| HOWTO (RELOC_13, 0, 2, 13, false, 0, complain_overflow_bitfield, 0, "13", false, 0, 0x00001fff, false), |
| HOWTO (RELOC_LO10, 0, 2, 10, false, 0, complain_overflow_dont, 0, "LO10", false, 0, 0x000003ff, false), |
| HOWTO (RELOC_SFA_BASE,0, 2, 32, false, 0, complain_overflow_bitfield, 0, "SFA_BASE", false, 0, 0xffffffff, false), |
| HOWTO (RELOC_SFA_OFF13,0, 2, 32, false, 0, complain_overflow_bitfield, 0, "SFA_OFF13", false, 0, 0xffffffff, false), |
| HOWTO (RELOC_BASE10, 0, 2, 10, false, 0, complain_overflow_dont, 0, "BASE10", false, 0, 0x000003ff, false), |
| HOWTO (RELOC_BASE13, 0, 2, 13, false, 0, complain_overflow_signed, 0, "BASE13", false, 0, 0x00001fff, false), |
| HOWTO (RELOC_BASE22, 10, 2, 22, false, 0, complain_overflow_bitfield, 0, "BASE22", false, 0, 0x003fffff, false), |
| HOWTO (RELOC_PC10, 0, 2, 10, true, 0, complain_overflow_dont, 0, "PC10", false, 0, 0x000003ff, true), |
| HOWTO (RELOC_PC22, 10, 2, 22, true, 0, complain_overflow_signed, 0, "PC22", false, 0, 0x003fffff, true), |
| HOWTO (RELOC_JMP_TBL, 2, 2, 30, true, 0, complain_overflow_signed, 0, "JMP_TBL", false, 0, 0x3fffffff, false), |
| HOWTO (RELOC_SEGOFF16,0, 2, 0, false, 0, complain_overflow_bitfield, 0, "SEGOFF16", false, 0, 0x00000000, false), |
| HOWTO (RELOC_GLOB_DAT,0, 2, 0, false, 0, complain_overflow_bitfield, 0, "GLOB_DAT", false, 0, 0x00000000, false), |
| HOWTO (RELOC_JMP_SLOT,0, 2, 0, false, 0, complain_overflow_bitfield, 0, "JMP_SLOT", false, 0, 0x00000000, false), |
| HOWTO (RELOC_RELATIVE,0, 2, 0, false, 0, complain_overflow_bitfield, 0, "RELATIVE", false, 0, 0x00000000, false), |
| HOWTO (0, 0, 3, 0, false, 0, complain_overflow_dont, 0, "R_SPARC_NONE",false, 0, 0x00000000, true), |
| HOWTO (0, 0, 3, 0, false, 0, complain_overflow_dont, 0, "R_SPARC_NONE",false, 0, 0x00000000, true), |
| #define RELOC_SPARC_REV32 RELOC_WDISP19 |
| HOWTO (RELOC_SPARC_REV32, 0, 2, 32, false, 0, complain_overflow_dont, 0,"R_SPARC_REV32",false, 0, 0xffffffff, false), |
| }; |
| |
| /* Convert standard reloc records to "arelent" format (incl byte swap). */ |
| |
| reloc_howto_type howto_table_std[] = |
| { |
| /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */ |
| HOWTO ( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false), |
| HOWTO ( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false), |
| HOWTO ( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false), |
| HOWTO ( 3, 0, 4, 64, false, 0, complain_overflow_bitfield,0,"64", true, 0xdeaddead,0xdeaddead, false), |
| HOWTO ( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, false), |
| HOWTO ( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false), |
| HOWTO ( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, false), |
| HOWTO ( 7, 0, 4, 64, true, 0, complain_overflow_signed, 0,"DISP64", true, 0xfeedface,0xfeedface, false), |
| HOWTO ( 8, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"GOT_REL", false, 0,0x00000000, false), |
| HOWTO ( 9, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"BASE16", false,0xffffffff,0xffffffff, false), |
| HOWTO (10, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"BASE32", false,0xffffffff,0xffffffff, false), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| HOWTO (16, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"JMP_TABLE", false, 0,0x00000000, false), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| HOWTO (32, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"RELATIVE", false, 0,0x00000000, false), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| EMPTY_HOWTO (-1), |
| HOWTO (40, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"BASEREL", false, 0,0x00000000, false), |
| }; |
| |
| #define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0])) |
| |
| reloc_howto_type * |
| NAME (aout, reloc_type_lookup) (bfd *abfd, bfd_reloc_code_real_type code) |
| { |
| #define EXT(i, j) case i: return & howto_table_ext [j] |
| #define STD(i, j) case i: return & howto_table_std [j] |
| int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE; |
| |
| if (code == BFD_RELOC_CTOR) |
| switch (bfd_arch_bits_per_address (abfd)) |
| { |
| case 32: |
| code = BFD_RELOC_32; |
| break; |
| case 64: |
| code = BFD_RELOC_64; |
| break; |
| } |
| |
| if (ext) |
| switch (code) |
| { |
| EXT (BFD_RELOC_8, 0); |
| EXT (BFD_RELOC_16, 1); |
| EXT (BFD_RELOC_32, 2); |
| EXT (BFD_RELOC_HI22, 8); |
| EXT (BFD_RELOC_LO10, 11); |
| EXT (BFD_RELOC_32_PCREL_S2, 6); |
| EXT (BFD_RELOC_SPARC_WDISP22, 7); |
| EXT (BFD_RELOC_SPARC13, 10); |
| EXT (BFD_RELOC_SPARC_GOT10, 14); |
| EXT (BFD_RELOC_SPARC_BASE13, 15); |
| EXT (BFD_RELOC_SPARC_GOT13, 15); |
| EXT (BFD_RELOC_SPARC_GOT22, 16); |
| EXT (BFD_RELOC_SPARC_PC10, 17); |
| EXT (BFD_RELOC_SPARC_PC22, 18); |
| EXT (BFD_RELOC_SPARC_WPLT30, 19); |
| EXT (BFD_RELOC_SPARC_REV32, 26); |
| default: |
| return NULL; |
| } |
| else |
| /* std relocs. */ |
| switch (code) |
| { |
| STD (BFD_RELOC_8, 0); |
| STD (BFD_RELOC_16, 1); |
| STD (BFD_RELOC_32, 2); |
| STD (BFD_RELOC_8_PCREL, 4); |
| STD (BFD_RELOC_16_PCREL, 5); |
| STD (BFD_RELOC_32_PCREL, 6); |
| STD (BFD_RELOC_16_BASEREL, 9); |
| STD (BFD_RELOC_32_BASEREL, 10); |
| default: |
| return NULL; |
| } |
| } |
| |
| reloc_howto_type * |
| NAME (aout, reloc_name_lookup) (bfd *abfd, const char *r_name) |
| { |
| unsigned int i, size; |
| reloc_howto_type *howto_table; |
| |
| if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE) |
| { |
| howto_table = howto_table_ext; |
| size = sizeof (howto_table_ext) / sizeof (howto_table_ext[0]); |
| } |
| else |
| { |
| howto_table = howto_table_std; |
| size = sizeof (howto_table_std) / sizeof (howto_table_std[0]); |
| } |
| |
| for (i = 0; i < size; i++) |
| if (howto_table[i].name != NULL |
| && strcasecmp (howto_table[i].name, r_name) == 0) |
| return &howto_table[i]; |
| |
| return NULL; |
| } |
| |
| /* |
| SUBSECTION |
| Internal entry points |
| |
| DESCRIPTION |
| @file{aoutx.h} exports several routines for accessing the |
| contents of an a.out file, which are gathered and exported in |
| turn by various format specific files (eg sunos.c). |
| */ |
| |
| /* |
| FUNCTION |
| aout_@var{size}_swap_exec_header_in |
| |
| SYNOPSIS |
| void aout_@var{size}_swap_exec_header_in, |
| (bfd *abfd, |
| struct external_exec *bytes, |
| struct internal_exec *execp); |
| |
| DESCRIPTION |
| Swap the information in an executable header @var{raw_bytes} taken |
| from a raw byte stream memory image into the internal exec header |
| structure @var{execp}. |
| */ |
| |
| #ifndef NAME_swap_exec_header_in |
| void |
| NAME (aout, swap_exec_header_in) (bfd *abfd, |
| struct external_exec *bytes, |
| struct internal_exec *execp) |
| { |
| /* The internal_exec structure has some fields that are unused in this |
| configuration (IE for i960), so ensure that all such uninitialized |
| fields are zero'd out. There are places where two of these structs |
| are memcmp'd, and thus the contents do matter. */ |
| memset ((void *) execp, 0, sizeof (struct internal_exec)); |
| /* Now fill in fields in the execp, from the bytes in the raw data. */ |
| execp->a_info = 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); |
| } |
| #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in) |
| #endif |
| |
| /* |
| FUNCTION |
| aout_@var{size}_swap_exec_header_out |
| |
| SYNOPSIS |
| void aout_@var{size}_swap_exec_header_out |
| (bfd *abfd, |
| struct internal_exec *execp, |
| struct external_exec *raw_bytes); |
| |
| DESCRIPTION |
| Swap the information in an internal exec header structure |
| @var{execp} into the buffer @var{raw_bytes} ready for writing to disk. |
| */ |
| void |
| NAME (aout, swap_exec_header_out) (bfd *abfd, |
| struct internal_exec *execp, |
| struct external_exec *bytes) |
| { |
| /* Now fill in fields in the raw data, from the fields in the exec struct. */ |
| H_PUT_32 (abfd, execp->a_info , bytes->e_info); |
| PUT_WORD (abfd, execp->a_text , bytes->e_text); |
| PUT_WORD (abfd, execp->a_data , bytes->e_data); |
| PUT_WORD (abfd, execp->a_bss , bytes->e_bss); |
| PUT_WORD (abfd, execp->a_syms , bytes->e_syms); |
| PUT_WORD (abfd, execp->a_entry , bytes->e_entry); |
| PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize); |
| PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize); |
| } |
| |
| /* Make all the section for an a.out file. */ |
| |
| bool |
| NAME (aout, make_sections) (bfd *abfd) |
| { |
| if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL) |
| return false; |
| if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL) |
| return false; |
| if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL) |
| return false; |
| return true; |
| } |
| |
| /* |
| FUNCTION |
| aout_@var{size}_some_aout_object_p |
| |
| SYNOPSIS |
| const bfd_target *aout_@var{size}_some_aout_object_p |
| (bfd *abfd, |
| struct internal_exec *execp, |
| const bfd_target *(*callback_to_real_object_p) (bfd *)); |
| |
| DESCRIPTION |
| Some a.out variant thinks that the file open in @var{abfd} |
| checking is an a.out file. Do some more checking, and set up |
| for access if it really is. Call back to the calling |
| environment's "finish up" function just before returning, to |
| handle any last-minute setup. |
| */ |
| |
| bfd_cleanup |
| NAME (aout, some_aout_object_p) (bfd *abfd, |
| struct internal_exec *execp, |
| bfd_cleanup (*callback_to_real_object_p) (bfd *)) |
| { |
| struct aout_data_struct *rawptr, *oldrawptr; |
| bfd_cleanup result; |
| size_t amt = sizeof (* rawptr); |
| |
| rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt); |
| if (rawptr == NULL) |
| return NULL; |
| |
| oldrawptr = abfd->tdata.aout_data; |
| abfd->tdata.aout_data = rawptr; |
| |
| /* Copy the contents of the old tdata struct. */ |
| if (oldrawptr != NULL) |
| *abfd->tdata.aout_data = *oldrawptr; |
| |
| abfd->tdata.aout_data->a.hdr = &rawptr->e; |
| /* Copy in the internal_exec struct. */ |
| *(abfd->tdata.aout_data->a.hdr) = *execp; |
| execp = abfd->tdata.aout_data->a.hdr; |
| |
| /* Set the file flags. */ |
| abfd->flags = BFD_NO_FLAGS; |
| if (execp->a_drsize || execp->a_trsize) |
| abfd->flags |= HAS_RELOC; |
| /* Setting of EXEC_P has been deferred to the bottom of this function. */ |
| if (execp->a_syms) |
| abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS; |
| if (N_DYNAMIC (execp)) |
| abfd->flags |= DYNAMIC; |
| |
| if (N_MAGIC (execp) == ZMAGIC) |
| { |
| abfd->flags |= D_PAGED | WP_TEXT; |
| adata (abfd).magic = z_magic; |
| } |
| else if (N_IS_QMAGIC (execp)) |
| { |
| abfd->flags |= D_PAGED | WP_TEXT; |
| adata (abfd).magic = z_magic; |
| adata (abfd).subformat = q_magic_format; |
| } |
| else if (N_MAGIC (execp) == NMAGIC) |
| { |
| abfd->flags |= WP_TEXT; |
| adata (abfd).magic = n_magic; |
| } |
| else if (N_MAGIC (execp) == OMAGIC || N_IS_BMAGIC (execp)) |
| adata (abfd).magic = o_magic; |
| else |
| /* Should have been checked with N_BADMAG before this routine |
| was called. */ |
| abort (); |
| |
| abfd->start_address = execp->a_entry; |
| |
| obj_aout_symbols (abfd) = NULL; |
| abfd->symcount = execp->a_syms / sizeof (struct external_nlist); |
| |
| /* The default relocation entry size is that of traditional V7 Unix. */ |
| obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; |
| |
| /* The default symbol entry size is that of traditional Unix. */ |
| obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE; |
| |
| #ifdef USE_MMAP |
| bfd_init_window (&obj_aout_sym_window (abfd)); |
| bfd_init_window (&obj_aout_string_window (abfd)); |
| #endif |
| obj_aout_external_syms (abfd) = NULL; |
| obj_aout_external_strings (abfd) = NULL; |
| obj_aout_sym_hashes (abfd) = NULL; |
| |
| if (! NAME (aout, make_sections) (abfd)) |
| goto error_ret; |
| |
| obj_datasec (abfd)->size = execp->a_data; |
| obj_bsssec (abfd)->size = execp->a_bss; |
| |
| obj_textsec (abfd)->flags = |
| (execp->a_trsize != 0 |
| ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC) |
| : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)); |
| obj_datasec (abfd)->flags = |
| (execp->a_drsize != 0 |
| ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC) |
| : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS)); |
| obj_bsssec (abfd)->flags = SEC_ALLOC; |
| |
| #ifdef THIS_IS_ONLY_DOCUMENTATION |
| /* The common code can't fill in these things because they depend |
| on either the start address of the text segment, the rounding |
| up of virtual addresses between segments, or the starting file |
| position of the text segment -- all of which varies among different |
| versions of a.out. */ |
| |
| /* Call back to the format-dependent code to fill in the rest of the |
| fields and do any further cleanup. Things that should be filled |
| in by the callback: */ |
| |
| struct exec *execp = exec_hdr (abfd); |
| |
| obj_textsec (abfd)->size = N_TXTSIZE (execp); |
| /* Data and bss are already filled in since they're so standard. */ |
| |
| /* 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); |
| |
| /* 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); |
| |
| /* The file offsets of the string table and symbol table. */ |
| obj_str_filepos (abfd) = N_STROFF (execp); |
| obj_sym_filepos (abfd) = N_SYMOFF (execp); |
| |
| /* Determine the architecture and machine type of the object file. */ |
| switch (N_MACHTYPE (exec_hdr (abfd))) |
| { |
| default: |
| abfd->obj_arch = bfd_arch_obscure; |
| break; |
| } |
| |
| adata (abfd)->page_size = TARGET_PAGE_SIZE; |
| adata (abfd)->segment_size = SEGMENT_SIZE; |
| adata (abfd)->exec_bytes_size = EXEC_BYTES_SIZE; |
| |
| return _bfd_no_cleanup |
| |
| /* The architecture is encoded in various ways in various a.out variants, |
| or is not encoded at all in some of them. The relocation size depends |
| on the architecture and the a.out variant. Finally, the return value |
| is the bfd_target vector in use. If an error occurs, return zero and |
| set bfd_error to the appropriate error code. |
| |
| Formats such as b.out, which have additional fields in the a.out |
| header, should cope with them in this callback as well. */ |
| #endif /* DOCUMENTATION */ |
| |
| result = (*callback_to_real_object_p) (abfd); |
| |
| /* Now that the segment addresses have been worked out, take a better |
| guess at whether the file is executable. If the entry point |
| is within the text segment, assume it is. (This makes files |
| executable even if their entry point address is 0, as long as |
| their text starts at zero.). |
| |
| This test had to be changed to deal with systems where the text segment |
| runs at a different location than the default. The problem is that the |
| entry address can appear to be outside the text segment, thus causing an |
| erroneous conclusion that the file isn't executable. |
| |
| To fix this, we now accept any non-zero entry point as an indication of |
| executability. This will work most of the time, since only the linker |
| sets the entry point, and that is likely to be non-zero for most systems. */ |
| |
| if (execp->a_entry != 0 |
| || (execp->a_entry >= obj_textsec (abfd)->vma |
| && execp->a_entry < (obj_textsec (abfd)->vma |
| + obj_textsec (abfd)->size) |
| && execp->a_trsize == 0 |
| && execp->a_drsize == 0)) |
| abfd->flags |= EXEC_P; |
| #ifdef STAT_FOR_EXEC |
| else |
| { |
| struct stat stat_buf; |
| |
| /* The original heuristic doesn't work in some important cases. |
| The a.out file has no information about the text start |
| address. For files (like kernels) linked to non-standard |
| addresses (ld -Ttext nnn) the entry point may not be between |
| the default text start (obj_textsec(abfd)->vma) and |
| (obj_textsec(abfd)->vma) + text size. This is not just a mach |
| issue. Many kernels are loaded at non standard addresses. */ |
| if (abfd->iostream != NULL |
| && (abfd->flags & BFD_IN_MEMORY) == 0 |
| && (fstat (fileno ((FILE *) (abfd->iostream)), &stat_buf) == 0) |
| && ((stat_buf.st_mode & 0111) != 0)) |
| abfd->flags |= EXEC_P; |
| } |
| #endif /* STAT_FOR_EXEC */ |
| |
| if (result) |
| return result; |
| |
| error_ret: |
| bfd_release (abfd, rawptr); |
| abfd->tdata.aout_data = oldrawptr; |
| return NULL; |
| } |
| |
| /* |
| FUNCTION |
| aout_@var{size}_mkobject |
| |
| SYNOPSIS |
| bool aout_@var{size}_mkobject, (bfd *abfd); |
| |
| DESCRIPTION |
| Initialize BFD @var{abfd} for use with a.out files. |
| */ |
| |
| bool |
| NAME (aout, mkobject) (bfd *abfd) |
| { |
| struct aout_data_struct *rawptr; |
| size_t amt = sizeof (* rawptr); |
| |
| bfd_set_error (bfd_error_system_call); |
| |
| rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt); |
| if (rawptr == NULL) |
| return false; |
| |
| abfd->tdata.aout_data = rawptr; |
| exec_hdr (abfd) = &(rawptr->e); |
| |
| obj_textsec (abfd) = NULL; |
| obj_datasec (abfd) = NULL; |
| obj_bsssec (abfd) = NULL; |
| |
| return true; |
| } |
| |
| /* |
| FUNCTION |
| aout_@var{size}_machine_type |
| |
| SYNOPSIS |
| enum machine_type aout_@var{size}_machine_type |
| (enum bfd_architecture arch, |
| unsigned long machine, |
| bool *unknown); |
| |
| DESCRIPTION |
| Keep track of machine architecture and machine type for |
| a.out's. Return the <<machine_type>> for a particular |
| architecture and machine, or <<M_UNKNOWN>> if that exact architecture |
| and machine can't be represented in a.out format. |
| |
| If the architecture is understood, machine type 0 (default) |
| is always understood. |
| */ |
| |
| enum machine_type |
| NAME (aout, machine_type) (enum bfd_architecture arch, |
| unsigned long machine, |
| bool *unknown) |
| { |
| enum machine_type arch_flags; |
| |
| arch_flags = M_UNKNOWN; |
| *unknown = true; |
| |
| switch (arch) |
| { |
| case bfd_arch_sparc: |
| if (machine == 0 |
| || machine == bfd_mach_sparc |
| || machine == bfd_mach_sparc_sparclite |
| || machine == bfd_mach_sparc_sparclite_le |
| || machine == bfd_mach_sparc_v8plus |
| || machine == bfd_mach_sparc_v8plusa |
| || machine == bfd_mach_sparc_v8plusb |
| || machine == bfd_mach_sparc_v8plusc |
| || machine == bfd_mach_sparc_v8plusd |
| || machine == bfd_mach_sparc_v8pluse |
| || machine == bfd_mach_sparc_v8plusv |
| || machine == bfd_mach_sparc_v8plusm |
| || machine == bfd_mach_sparc_v8plusm8 |
| || machine == bfd_mach_sparc_v9 |
| || machine == bfd_mach_sparc_v9a |
| || machine == bfd_mach_sparc_v9b |
| || machine == bfd_mach_sparc_v9c |
| || machine == bfd_mach_sparc_v9d |
| || machine == bfd_mach_sparc_v9e |
| || machine == bfd_mach_sparc_v9v |
| || machine == bfd_mach_sparc_v9m |
| || machine == bfd_mach_sparc_v9m8) |
| arch_flags = M_SPARC; |
| else if (machine == bfd_mach_sparc_sparclet) |
| arch_flags = M_SPARCLET; |
| break; |
| |
| case bfd_arch_i386: |
| if (machine == 0 |
| || machine == bfd_mach_i386_i386 |
| || machine == bfd_mach_i386_i386_intel_syntax) |
| arch_flags = M_386; |
| break; |
| |
| case bfd_arch_arm: |
| if (machine == 0) |
| arch_flags = M_ARM; |
| break; |
| |
| case bfd_arch_mips: |
| switch (machine) |
| { |
| case 0: |
| case bfd_mach_mips3000: |
| case bfd_mach_mips3900: |
| arch_flags = M_MIPS1; |
| break; |
| case bfd_mach_mips6000: |
| arch_flags = M_MIPS2; |
| break; |
| case bfd_mach_mips4000: |
| case bfd_mach_mips4010: |
| case bfd_mach_mips4100: |
| case bfd_mach_mips4300: |
| case bfd_mach_mips4400: |
| case bfd_mach_mips4600: |
| case bfd_mach_mips4650: |
| case bfd_mach_mips8000: |
| case bfd_mach_mips9000: |
| case bfd_mach_mips10000: |
| case bfd_mach_mips12000: |
| case bfd_mach_mips14000: |
| case bfd_mach_mips16000: |
| case bfd_mach_mips16: |
| case bfd_mach_mipsisa32: |
| case bfd_mach_mipsisa32r2: |
| case bfd_mach_mipsisa32r3: |
| case bfd_mach_mipsisa32r5: |
| case bfd_mach_mipsisa32r6: |
| case bfd_mach_mips5: |
| case bfd_mach_mipsisa64: |
| case bfd_mach_mipsisa64r2: |
| case bfd_mach_mipsisa64r3: |
| case bfd_mach_mipsisa64r5: |
| case bfd_mach_mipsisa64r6: |
| case bfd_mach_mips_sb1: |
| case bfd_mach_mips_xlr: |
| /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */ |
| arch_flags = M_MIPS2; |
| break; |
| default: |
| arch_flags = M_UNKNOWN; |
| break; |
| } |
| break; |
| |
| case bfd_arch_ns32k: |
| switch (machine) |
| { |
| case 0: arch_flags = M_NS32532; break; |
| case 32032: arch_flags = M_NS32032; break; |
| case 32532: arch_flags = M_NS32532; break; |
| default: arch_flags = M_UNKNOWN; break; |
| } |
| break; |
| |
| case bfd_arch_vax: |
| *unknown = false; |
| break; |
| |
| case bfd_arch_cris: |
| if (machine == 0 || machine == 255) |
| arch_flags = M_CRIS; |
| break; |
| |
| default: |
| arch_flags = M_UNKNOWN; |
| } |
| |
| if (arch_flags != M_UNKNOWN) |
| *unknown = false; |
| |
| return arch_flags; |
| } |
| |
| /* |
| FUNCTION |
| aout_@var{size}_set_arch_mach |
| |
| SYNOPSIS |
| bool aout_@var{size}_set_arch_mach, |
| (bfd *, |
| enum bfd_architecture arch, |
| unsigned long machine); |
| |
| DESCRIPTION |
| Set the architecture and the machine of the BFD @var{abfd} to the |
| values @var{arch} and @var{machine}. Verify that @var{abfd}'s format |
| can support the architecture required. |
| */ |
| |
| bool |
| NAME (aout, set_arch_mach) (bfd *abfd, |
| enum bfd_architecture arch, |
| unsigned long machine) |
| { |
| if (! bfd_default_set_arch_mach (abfd, arch, machine)) |
| return false; |
| |
| if (arch != bfd_arch_unknown) |
| { |
| bool unknown; |
| |
| NAME (aout, machine_type) (arch, machine, &unknown); |
| if (unknown) |
| return false; |
| } |
| |
| /* Determine the size of a relocation entry. */ |
| switch (arch) |
| { |
| case bfd_arch_sparc: |
| case bfd_arch_mips: |
| obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; |
| break; |
| default: |
| obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; |
| break; |
| } |
| |
| return (*aout_backend_info (abfd)->set_sizes) (abfd); |
| } |
| |
| static void |
| adjust_o_magic (bfd *abfd, struct internal_exec *execp) |
| { |
| file_ptr pos = adata (abfd).exec_bytes_size; |
| bfd_vma vma = 0; |
| int pad = 0; |
| asection *text = obj_textsec (abfd); |
| asection *data = obj_datasec (abfd); |
| asection *bss = obj_bsssec (abfd); |
| |
| /* Text. */ |
| text->filepos = pos; |
| if (!text->user_set_vma) |
| text->vma = vma; |
| else |
| vma = text->vma; |
| |
| pos += execp->a_text; |
| vma += execp->a_text; |
| |
| /* Data. */ |
| if (!data->user_set_vma) |
| { |
| pos += pad; |
| vma += pad; |
| data->vma = vma; |
| } |
| else |
| vma = data->vma; |
| execp->a_text += pad; |
| |
| data->filepos = pos; |
| pos += data->size; |
| vma += data->size; |
| |
| /* BSS. */ |
| if (!bss->user_set_vma) |
| { |
| pos += pad; |
| vma += pad; |
| bss->vma = vma; |
| } |
| else |
| { |
| /* The VMA of the .bss section is set by the VMA of the |
| .data section plus the size of the .data section. We may |
| need to add padding bytes to make this true. */ |
| pad = bss->vma - vma; |
| if (pad < 0) |
| pad = 0; |
| pos += pad; |
| } |
| execp->a_data = data->size + pad; |
| bss->filepos = pos; |
| execp->a_bss = bss->size; |
| |
| N_SET_MAGIC (execp, OMAGIC); |
| } |
| |
| static void |
| adjust_z_magic (bfd *abfd, struct internal_exec *execp) |
| { |
| bfd_size_type data_pad, text_pad; |
| file_ptr text_end; |
| const struct aout_backend_data *abdp; |
| /* TRUE if text includes exec header. */ |
| bool ztih; |
| asection *text = obj_textsec (abfd); |
| asection *data = obj_datasec (abfd); |
| asection *bss = obj_bsssec (abfd); |
| |
| abdp = aout_backend_info (abfd); |
| |
| /* Text. */ |
| ztih = (abdp != NULL |
| && (abdp->text_includes_header |
| || obj_aout_subformat (abfd) == q_magic_format)); |
| text->filepos = (ztih |
| ? adata (abfd).exec_bytes_size |
| : adata (abfd).zmagic_disk_block_size); |
| if (!text->user_set_vma) |
| { |
| /* ?? Do we really need to check for relocs here? */ |
| text->vma = ((abfd->flags & HAS_RELOC) |
| ? 0 |
| : (ztih |
| ? abdp->default_text_vma + adata (abfd).exec_bytes_size |
| : abdp->default_text_vma)); |
| text_pad = 0; |
| } |
| else |
| { |
| /* The .text section is being loaded at an unusual address. We |
| may need to pad it such that the .data section starts at a page |
| boundary. */ |
| if (ztih) |
| text_pad = ((text->filepos - text->vma) |
| & (adata (abfd).page_size - 1)); |
| else |
| text_pad = (-text->vma |
| & (adata (abfd).page_size - 1)); |
| } |
| |
| /* Find start of data. */ |
| if (ztih) |
| { |
| text_end = text->filepos + execp->a_text; |
| text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end; |
| } |
| else |
| { |
| /* Note that if page_size == zmagic_disk_block_size, then |
| filepos == page_size, and this case is the same as the ztih |
| case. */ |
| text_end = execp->a_text; |
| text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end; |
| text_end += text->filepos; |
| } |
| execp->a_text += text_pad; |
| |
| /* Data. */ |
| if (!data->user_set_vma) |
| { |
| bfd_vma vma; |
| vma = text->vma + execp->a_text; |
| data->vma = BFD_ALIGN (vma, adata (abfd).segment_size); |
| } |
| if (abdp && abdp->zmagic_mapped_contiguous) |
| { |
| text_pad = data->vma - (text->vma + execp->a_text); |
| /* Only pad the text section if the data |
| section is going to be placed after it. */ |
| if (text_pad > 0) |
| execp->a_text += text_pad; |
| } |
| data->filepos = text->filepos + execp->a_text; |
| |
| /* Fix up exec header while we're at it. */ |
| if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted))) |
| execp->a_text += adata (abfd).exec_bytes_size; |
| if (obj_aout_subformat (abfd) == q_magic_format) |
| N_SET_QMAGIC (execp); |
| else |
| N_SET_MAGIC (execp, ZMAGIC); |
| |
| /* Spec says data section should be rounded up to page boundary. */ |
| execp->a_data = align_power (data->size, bss->alignment_power); |
| execp->a_data = BFD_ALIGN (execp->a_data, adata (abfd).page_size); |
| data_pad = execp->a_data - data->size; |
| |
| /* BSS. */ |
| if (!bss->user_set_vma) |
| bss->vma = data->vma + execp->a_data; |
| /* If the BSS immediately follows the data section and extra space |
| in the page is left after the data section, fudge data |
| in the header so that the bss section looks smaller by that |
| amount. We'll start the bss section there, and lie to the OS. |
| (Note that a linker script, as well as the above assignment, |
| could have explicitly set the BSS vma to immediately follow |
| the data section.) */ |
| if (align_power (bss->vma, bss->alignment_power) == data->vma + execp->a_data) |
| execp->a_bss = data_pad > bss->size ? 0 : bss->size - data_pad; |
| else |
| execp->a_bss = bss->size; |
| } |
| |
| static void |
| adjust_n_magic (bfd *abfd, struct internal_exec *execp) |
| { |
| file_ptr pos = adata (abfd).exec_bytes_size; |
| bfd_vma vma = 0; |
| int pad; |
| asection *text = obj_textsec (abfd); |
| asection *data = obj_datasec (abfd); |
| asection *bss = obj_bsssec (abfd); |
| |
| /* Text. */ |
| text->filepos = pos; |
| if (!text->user_set_vma) |
| text->vma = vma; |
| else |
| vma = text->vma; |
| pos += execp->a_text; |
| vma += execp->a_text; |
| |
| /* Data. */ |
| data->filepos = pos; |
| if (!data->user_set_vma) |
| data->vma = BFD_ALIGN (vma, adata (abfd).segment_size); |
| vma = data->vma; |
| |
| /* Since BSS follows data immediately, see if it needs alignment. */ |
| vma += data->size; |
| pad = align_power (vma, bss->alignment_power) - vma; |
| execp->a_data = data->size + pad; |
| pos += execp->a_data; |
| |
| /* BSS. */ |
| if (!bss->user_set_vma) |
| bss->vma = vma; |
| else |
| vma = bss->vma; |
| |
| /* Fix up exec header. */ |
| execp->a_bss = bss->size; |
| N_SET_MAGIC (execp, NMAGIC); |
| } |
| |
| bool |
| NAME (aout, adjust_sizes_and_vmas) (bfd *abfd) |
| { |
| struct internal_exec *execp = exec_hdr (abfd); |
| |
| if (! NAME (aout, make_sections) (abfd)) |
| return false; |
| |
| if (adata (abfd).magic != undecided_magic) |
| return true; |
| |
| execp->a_text = align_power (obj_textsec (abfd)->size, |
| obj_textsec (abfd)->alignment_power); |
| |
| /* Rule (heuristic) for when to pad to a new page. Note that there |
| are (at least) two ways demand-paged (ZMAGIC) files have been |
| handled. Most Berkeley-based systems start the text segment at |
| (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text |
| segment right after the exec header; the latter is counted in the |
| text segment size, and is paged in by the kernel with the rest of |
| the text. */ |
| |
| /* This perhaps isn't the right way to do this, but made it simpler for me |
| to understand enough to implement it. Better would probably be to go |
| right from BFD flags to alignment/positioning characteristics. But the |
| old code was sloppy enough about handling the flags, and had enough |
| other magic, that it was a little hard for me to understand. I think |
| I understand it better now, but I haven't time to do the cleanup this |
| minute. */ |
| |
| if (abfd->flags & D_PAGED) |
| /* Whether or not WP_TEXT is set -- let D_PAGED override. */ |
| adata (abfd).magic = z_magic; |
| else if (abfd->flags & WP_TEXT) |
| adata (abfd).magic = n_magic; |
| else |
| adata (abfd).magic = o_magic; |
| |
| #ifdef BFD_AOUT_DEBUG /* requires gcc2 */ |
| #if __GNUC__ >= 2 |
| fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n", |
| ({ char *str; |
| switch (adata (abfd).magic) |
| { |
| case n_magic: str = "NMAGIC"; break; |
| case o_magic: str = "OMAGIC"; break; |
| case z_magic: str = "ZMAGIC"; break; |
| default: abort (); |
| } |
| str; |
| }), |
| obj_textsec (abfd)->vma, obj_textsec (abfd)->size, |
| obj_textsec (abfd)->alignment_power, |
| obj_datasec (abfd)->vma, obj_datasec (abfd)->size, |
| obj_datasec (abfd)->alignment_power, |
| obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size, |
| obj_bsssec (abfd)->alignment_power); |
| #endif |
| #endif |
| |
| switch (adata (abfd).magic) |
| { |
| case o_magic: |
| adjust_o_magic (abfd, execp); |
| break; |
| case z_magic: |
| adjust_z_magic (abfd, execp); |
| break; |
| case n_magic: |
| adjust_n_magic (abfd, execp); |
| break; |
| default: |
| abort (); |
| } |
| |
| #ifdef BFD_AOUT_DEBUG |
| fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n", |
| obj_textsec (abfd)->vma, execp->a_text, |
| obj_textsec (abfd)->filepos, |
| obj_datasec (abfd)->vma, execp->a_data, |
| obj_datasec (abfd)->filepos, |
| obj_bsssec (abfd)->vma, execp->a_bss); |
| #endif |
| |
| return true; |
| } |
| |
| /* |
| FUNCTION |
| aout_@var{size}_new_section_hook |
| |
| SYNOPSIS |
| bool aout_@var{size}_new_section_hook, |
| (bfd *abfd, |
| asection *newsect); |
| |
| DESCRIPTION |
| Called by the BFD in response to a @code{bfd_make_section} |
| request. |
| */ |
| bool |
| NAME (aout, new_section_hook) (bfd *abfd, asection *newsect) |
| { |
| /* Align to double at least. */ |
| newsect->alignment_power = bfd_get_arch_info (abfd)->section_align_power; |
| |
| if (bfd_get_format (abfd) == bfd_object) |
| { |
| if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text")) |
| { |
| obj_textsec (abfd)= newsect; |
| newsect->target_index = N_TEXT; |
| } |
| else if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data")) |
| { |
| obj_datasec (abfd) = newsect; |
| newsect->target_index = N_DATA; |
| } |
| else if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss")) |
| { |
| obj_bsssec (abfd) = newsect; |
| newsect->target_index = N_BSS; |
| } |
| } |
| |
| /* We allow more than three sections internally. */ |
| return _bfd_generic_new_section_hook (abfd, newsect); |
| } |
| |
| bool |
| NAME (aout, set_section_contents) (bfd *abfd, |
| sec_ptr section, |
| const void * location, |
| file_ptr offset, |
| bfd_size_type count) |
| { |
| if (! abfd->output_has_begun) |
| { |
| if (! NAME (aout, adjust_sizes_and_vmas) (abfd)) |
| return false; |
| } |
| |
| if (section == obj_bsssec (abfd)) |
| { |
| bfd_set_error (bfd_error_no_contents); |
| return false; |
| } |
| |
| if (section != obj_textsec (abfd) |
| && section != obj_datasec (abfd)) |
| { |
| if (aout_section_merge_with_text_p (abfd, section)) |
| section->filepos = obj_textsec (abfd)->filepos + |
| (section->vma - obj_textsec (abfd)->vma); |
| else |
| { |
| _bfd_error_handler |
| /* xgettext:c-format */ |
| (_("%pB: can not represent section `%pA' in a.out object file format"), |
| abfd, section); |
| bfd_set_error (bfd_error_nonrepresentable_section); |
| return false; |
| } |
| } |
| |
| if (count != 0) |
| { |
| if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 |
| || bfd_bwrite (location, count, abfd) != count) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* Read the external symbols from an a.out file. */ |
| |
| static bool |
| aout_get_external_symbols (bfd *abfd) |
| { |
| if (obj_aout_external_syms (abfd) == NULL) |
| { |
| bfd_size_type count; |
| struct external_nlist *syms; |
| bfd_size_type amt = exec_hdr (abfd)->a_syms; |
| |
| count = amt / EXTERNAL_NLIST_SIZE; |
| if (count == 0) |
| return true; /* Nothing to do. */ |
| |
| #ifdef USE_MMAP |
| if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd), amt, |
| &obj_aout_sym_window (abfd), true)) |
| return false; |
| syms = (struct external_nlist *) obj_aout_sym_window (abfd).data; |
| #else |
| /* We allocate using malloc to make the values easy to free |
| later on. If we put them on the objalloc it might not be |
| possible to free them. */ |
| if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) |
| return false; |
| syms = (struct external_nlist *) _bfd_malloc_and_read (abfd, amt, amt); |
| if (syms == NULL) |
| return false; |
| #endif |
| |
| obj_aout_external_syms (abfd) = syms; |
| obj_aout_external_sym_count (abfd) = count; |
| } |
| |
| if (obj_aout_external_strings (abfd) == NULL |
| && exec_hdr (abfd)->a_syms != 0) |
| { |
| unsigned char string_chars[BYTES_IN_WORD]; |
| bfd_size_type stringsize; |
| char *strings; |
| bfd_size_type amt = BYTES_IN_WORD; |
| |
| /* Get the size of the strings. */ |
| if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0 |
| || bfd_bread ((void *) string_chars, amt, abfd) != amt) |
| return false; |
| stringsize = GET_WORD (abfd, string_chars); |
| if (stringsize == 0) |
| stringsize = 1; |
| else if (stringsize < BYTES_IN_WORD |
| || (size_t) stringsize != stringsize) |
| { |
| bfd_set_error (bfd_error_bad_value); |
| return false; |
| } |
| |
| #ifdef USE_MMAP |
| if (stringsize >= BYTES_IN_WORD) |
| { |
| if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize + 1, |
| &obj_aout_string_window (abfd), true)) |
| return false; |
| strings = (char *) obj_aout_string_window (abfd).data; |
| } |
| else |
| #endif |
| { |
| strings = (char *) bfd_malloc (stringsize + 1); |
| if (strings == NULL) |
| return false; |
| |
| if (stringsize >= BYTES_IN_WORD) |
| { |
| /* Keep the string count in the buffer for convenience |
| when indexing with e_strx. */ |
| amt = stringsize - BYTES_IN_WORD; |
| if (bfd_bread (strings + BYTES_IN_WORD, amt, abfd) != amt) |
| { |
| free (strings); |
| return false; |
| } |
| } |
| } |
| /* Ensure that a zero index yields an empty string. */ |
| memset (strings, 0, BYTES_IN_WORD); |
| |
| /* Ensure that the string buffer is NUL terminated. */ |
| strings[stringsize] = 0; |
| |
| obj_aout_external_strings (abfd) = strings; |
| obj_aout_external_string_size (abfd) = stringsize; |
| } |
| |
| return true; |
| } |
| |
| /* Translate an a.out symbol into a BFD symbol. The desc, other, type |
| and symbol->value fields of CACHE_PTR will be set from the a.out |
| nlist structure. This function is responsible for setting |
| symbol->flags and symbol->section, and adjusting symbol->value. */ |
| |
| static bool |
| translate_from_native_sym_flags (bfd *abfd, aout_symbol_type *cache_ptr) |
| { |
| flagword visible; |
| |
| if ((cache_ptr->type & N_STAB) != 0 |
| || cache_ptr->type == N_FN) |
| { |
| asection *sec; |
| |
| /* This is a debugging symbol. */ |
| cache_ptr->symbol.flags = BSF_DEBUGGING; |
| |
| /* Work out the symbol section. */ |
| switch (cache_ptr->type & N_TYPE) |
| { |
| case N_TEXT: |
| case N_FN: |
| sec = obj_textsec (abfd); |
| break; |
| case N_DATA: |
| sec = obj_datasec (abfd); |
| break; |
| case N_BSS: |
| sec = obj_bsssec (abfd); |
| break; |
| default: |
| case N_ABS: |
| sec = bfd_abs_section_ptr; |
| break; |
| } |
| |
| cache_ptr->symbol.section = sec; |
| cache_ptr->symbol.value -= sec->vma; |
| |
| return true; |
| } |
| |
| /* Get the default visibility. This does not apply to all types, so |
| we just hold it in a local variable to use if wanted. */ |
| if ((cache_ptr->type & N_EXT) == 0) |
| visible = BSF_LOCAL; |
| else |
| visible = BSF_GLOBAL; |
| |
| switch (cache_ptr->type) |
| { |
| default: |
| case N_ABS: case N_ABS | N_EXT: |
| cache_ptr->symbol.section = bfd_abs_section_ptr; |
| cache_ptr->symbol.flags = visible; |
| break; |
| |
| case N_UNDF | N_EXT: |
| if (cache_ptr->symbol.value != 0) |
| { |
| /* This is a common symbol. */ |
| cache_ptr->symbol.flags = BSF_GLOBAL; |
| cache_ptr->symbol.section = bfd_com_section_ptr; |
| } |
| else |
| { |
| cache_ptr->symbol.flags = 0; |
| cache_ptr->symbol.section = bfd_und_section_ptr; |
| } |
| break; |
| |
| case N_TEXT: case N_TEXT | N_EXT: |
| cache_ptr->symbol.section = obj_textsec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = visible; |
| break; |
| |
| /* N_SETV symbols used to represent set vectors placed in the |
| data section. They are no longer generated. Theoretically, |
| it was possible to extract the entries and combine them with |
| new ones, although I don't know if that was ever actually |
| done. Unless that feature is restored, treat them as data |
| symbols. */ |
| case N_SETV: case N_SETV | N_EXT: |
| case N_DATA: case N_DATA | N_EXT: |
| cache_ptr->symbol.section = obj_datasec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = visible; |
| break; |
| |
| case N_BSS: case N_BSS | N_EXT: |
| cache_ptr->symbol.section = obj_bsssec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = visible; |
| break; |
| |
| case N_SETA: case N_SETA | N_EXT: |
| case N_SETT: case N_SETT | N_EXT: |
| case N_SETD: case N_SETD | N_EXT: |
| case N_SETB: case N_SETB | N_EXT: |
| { |
| /* This code is no longer needed. It used to be used to make |
| the linker handle set symbols, but they are now handled in |
| the add_symbols routine instead. */ |
| switch (cache_ptr->type & N_TYPE) |
| { |
| case N_SETA: |
| cache_ptr->symbol.section = bfd_abs_section_ptr; |
| break; |
| case N_SETT: |
| cache_ptr->symbol.section = obj_textsec (abfd); |
| break; |
| case N_SETD: |
| cache_ptr->symbol.section = obj_datasec (abfd); |
| break; |
| case N_SETB: |
| cache_ptr->symbol.section = obj_bsssec (abfd); |
| break; |
| } |
| |
| cache_ptr->symbol.flags |= BSF_CONSTRUCTOR; |
| } |
| break; |
| |
| case N_WARNING: |
| /* This symbol is the text of a warning message. The next |
| symbol is the symbol to associate the warning with. If a |
| reference is made to that symbol, a warning is issued. */ |
| cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_WARNING; |
| cache_ptr->symbol.section = bfd_abs_section_ptr; |
| break; |
| |
| case N_INDR: case N_INDR | N_EXT: |
| /* An indirect symbol. This consists of two symbols in a row. |
| The first symbol is the name of the indirection. The second |
| symbol is the name of the target. A reference to the first |
| symbol becomes a reference to the second. */ |
| cache_ptr->symbol.flags = BSF_DEBUGGING | BSF_INDIRECT | visible; |
| cache_ptr->symbol.section = bfd_ind_section_ptr; |
| break; |
| |
| case N_WEAKU: |
| cache_ptr->symbol.section = bfd_und_section_ptr; |
| cache_ptr->symbol.flags = BSF_WEAK; |
| break; |
| |
| case N_WEAKA: |
| cache_ptr->symbol.section = bfd_abs_section_ptr; |
| cache_ptr->symbol.flags = BSF_WEAK; |
| break; |
| |
| case N_WEAKT: |
| cache_ptr->symbol.section = obj_textsec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = BSF_WEAK; |
| break; |
| |
| case N_WEAKD: |
| cache_ptr->symbol.section = obj_datasec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = BSF_WEAK; |
| break; |
| |
| case N_WEAKB: |
| cache_ptr->symbol.section = obj_bsssec (abfd); |
| cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; |
| cache_ptr->symbol.flags = BSF_WEAK; |
| break; |
| } |
| |
| return true; |
| } |
| |
| /* Set the fields of SYM_POINTER according to CACHE_PTR. */ |
| |
| static bool |
| translate_to_native_sym_flags (bfd *abfd, |
| asymbol *cache_ptr, |
| struct external_nlist *sym_pointer) |
| { |
| bfd_vma value = cache_ptr->value; |
| asection *sec; |
| bfd_vma off; |
| |
| /* Mask out any existing type bits in case copying from one section |
| to another. */ |
| sym_pointer->e_type[0] &= ~N_TYPE; |
| |
| sec = bfd_asymbol_section (cache_ptr); |
| off = 0; |
| |
| if (sec == NULL) |
| { |
| /* This case occurs, e.g., for the *DEBUG* section of a COFF |
| file. */ |
| _bfd_error_handler |
| /* xgettext:c-format */ |
| (_("%pB: can not represent section for symbol `%s' in a.out " |
| "object file format"), |
| abfd, |
| cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*")); |
| bfd_set_error (bfd_error_nonrepresentable_section); |
| return false; |
| } |
| |
| if (sec->output_section != NULL) |
| { |
| off = sec->output_offset; |
| sec = sec->output_section; |
| } |
| |
| if (bfd_is_abs_section (sec)) |
| sym_pointer->e_type[0] |= N_ABS; |
| else if (sec == obj_textsec (abfd)) |
| sym_pointer->e_type[0] |= N_TEXT; |
| else if (sec == obj_datasec (abfd)) |
| sym_pointer->e_type[0] |= N_DATA; |
| else if (sec == obj_bsssec (abfd)) |
| sym_pointer->e_type[0] |= N_BSS; |
| else if (bfd_is_und_section (sec)) |
| sym_pointer->e_type[0] = N_UNDF | N_EXT; |
| else if (bfd_is_ind_section (sec)) |
| sym_pointer->e_type[0] = N_INDR; |
| else if (bfd_is_com_section (sec)) |
| sym_pointer->e_type[0] = N_UNDF | N_EXT; |
| else |
| { |
| if (aout_section_merge_with_text_p (abfd, sec)) |
| sym_pointer->e_type[0] |= N_TEXT; |
| else |
| { |
| _bfd_error_handler |
| /* xgettext:c-format */ |
| (_("%pB: can not represent section `%pA' in a.out object file format"), |
| abfd, sec); |
| bfd_set_error (bfd_error_nonrepresentable_section); |
| return false; |
| } |
| } |
| |
| /* Turn the symbol from section relative to absolute again. */ |
| value += sec->vma + off; |
| |
| if ((cache_ptr->flags & BSF_WARNING) != 0) |
| sym_pointer->e_type[0] = N_WARNING; |
| |
| if ((cache_ptr->flags & BSF_DEBUGGING) != 0) |
| sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type; |
| else if ((cache_ptr->flags & BSF_GLOBAL) != 0) |
| sym_pointer->e_type[0] |= N_EXT; |
| else if ((cache_ptr->flags & BSF_LOCAL) != 0) |
| sym_pointer->e_type[0] &= ~N_EXT; |
| |
| if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0) |
| { |
| int type = ((aout_symbol_type *) cache_ptr)->type; |
| |
| switch (type) |
| { |
| case N_ABS: type = N_SETA; break; |
| case N_TEXT: type = N_SETT; break; |
| case N_DATA: type = N_SETD; break; |
| case N_BSS: type = N_SETB; break; |
| } |
| sym_pointer->e_type[0] = type; |
| } |
| |
| if ((cache_ptr->flags & BSF_WEAK) != 0) |
| { |
| int type; |
| |
| switch (sym_pointer->e_type[0] & N_TYPE) |
| { |
| default: |
| case N_ABS: type = N_WEAKA; break; |
| case N_TEXT: type = N_WEAKT; break; |
| case N_DATA: type = N_WEAKD; break; |
| case N_BSS: type = N_WEAKB; break; |
| case N_UNDF: type = N_WEAKU; break; |
| } |
| sym_pointer->e_type[0] = type; |
| } |
| |
| PUT_WORD (abfd, value, sym_pointer->e_value); |
| |
| return true; |
| } |
| |
| /* Native-level interface to symbols. */ |
| |
| asymbol * |
| NAME (aout, make_empty_symbol) (bfd *abfd) |
| { |
| size_t amt = sizeof (aout_symbol_type); |
| |
| aout_symbol_type *new_symbol = (aout_symbol_type *) bfd_zalloc (abfd, amt); |
| if (!new_symbol) |
| return NULL; |
| new_symbol->symbol.the_bfd = abfd; |
| |
| return &new_symbol->symbol; |
| } |
| |
| /* Translate a set of external symbols into internal symbols. */ |
| |
| bool |
| NAME (aout, translate_symbol_table) (bfd *abfd, |
| aout_symbol_type *in, |
| struct external_nlist *ext, |
| bfd_size_type count, |
| char *str, |
| bfd_size_type strsize, |
| bool dynamic) |
| { |
| struct external_nlist *ext_end; |
| |
| ext_end = ext + count; |
| for (; ext < ext_end; ext++, in++) |
| { |
| bfd_vma x; |
| |
| x = GET_WORD (abfd, ext->e_strx); |
| in->symbol.the_bfd = abfd; |
| |
| /* For the normal symbols, the zero index points at the number |
| of bytes in the string table but is to be interpreted as the |
| null string. For the dynamic symbols, the number of bytes in |
| the string table is stored in the __DYNAMIC structure and the |
| zero index points at an actual string. */ |
| if (x == 0 && ! dynamic) |
| in->symbol.name = ""; |
| else if (x < strsize) |
| in->symbol.name = str + x; |
| else |
| { |
| _bfd_error_handler |
| (_("%pB: invalid string offset %" PRIu64 " >= %" PRIu64), |
| abfd, (uint64_t) x, (uint64_t) strsize); |
| bfd_set_error (bfd_error_bad_value); |
| return false; |
| } |
| |
| in->symbol.value = GET_SWORD (abfd, ext->e_value); |
| in->desc = H_GET_16 (abfd, ext->e_desc); |
| in->other = H_GET_8 (abfd, ext->e_other); |
| in->type = H_GET_8 (abfd, ext->e_type); |
| in->symbol.udata.p = NULL; |
| |
| if (! translate_from_native_sym_flags (abfd, in)) |
| return false; |
| |
| if (dynamic) |
| in->symbol.flags |= BSF_DYNAMIC; |
| } |
| |
| return true; |
| } |
| |
| /* We read the symbols into a buffer, which is discarded when this |
| function exits. We read the strings into a buffer large enough to |
| hold them all plus all the cached symbol entries. */ |
| |
| bool |
| NAME (aout, slurp_symbol_table) (bfd *abfd) |
| { |
| struct external_nlist *old_external_syms; |
| aout_symbol_type *cached; |
| bfd_size_type cached_size; |
| |
| /* If there's no work to be done, don't do any. */ |
| if (obj_aout_symbols (abfd) != NULL) |
| return true; |
| |
| old_external_syms = obj_aout_external_syms (abfd); |
| |
| if (! aout_get_external_symbols (abfd)) |
| return false; |
| |
| cached_size = obj_aout_external_sym_count (abfd); |
| if (cached_size == 0) |
| return true; /* Nothing to do. */ |
| |
| cached_size *= sizeof (aout_symbol_type); |
| cached = (aout_symbol_type *) bfd_zmalloc (cached_size); |
| if (cached == NULL) |
| return false; |
| |
| /* Convert from external symbol information to internal. */ |
| if (! (NAME (aout, translate_symbol_table) |
| (abfd, cached, |
| obj_aout_external_syms (abfd), |
| obj_aout_external_sym_count (abfd), |
| obj_aout_external_strings (abfd), |
| obj_aout_external_string_size (abfd), |
| false))) |
| { |
| free (cached); |
| return false; |
| } |
| |
| abfd->symcount = obj_aout_external_sym_count (abfd); |
| |
| obj_aout_symbols (abfd) = cached; |
| |
| /* It is very likely that anybody who calls this function will not |
| want the external symbol information, so if it was allocated |
| because of our call to aout_get_external_symbols, we free it up |
| right away to save space. */ |
| if (old_external_syms == NULL |
| && obj_aout_external_syms (abfd) != NULL) |
| { |
| #ifdef USE_MMAP |
| bfd_free_window (&obj_aout_sym_window (abfd)); |
| #else |
| free (obj_aout_external_syms (abfd)); |
| #endif |
| obj_aout_external_syms (abfd) = NULL; |
| } |
| |
| return true; |
| } |
| |
| /* We use a hash table when writing out symbols so that we only write |
| out a particular string once. This helps particularly when the |
| linker writes out stabs debugging entries, because each different |
| contributing object file tends to have many duplicate stabs |
| strings. |
| |
| This hash table code breaks dbx on SunOS 4.1.3, so we don't do it |
| if BFD_TRADITIONAL_FORMAT is set. */ |
| |
| /* Get the index of a string in a strtab, adding it if it is not |
| already present. */ |
| |
| static inline bfd_size_type |
| add_to_stringtab (bfd *abfd, |
| struct bfd_strtab_hash *tab, |
| const char *str, |
| bool copy) |
| { |
| bool hash; |
| bfd_size_type str_index; |
| |
| /* An index of 0 always means the empty string. */ |
| if (str == 0 || *str == '\0') |
| return 0; |
| |
| /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx |
| doesn't understand a hashed string table. */ |
| hash = true; |
| if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0) |
| hash = false; |
| |
| str_index = _bfd_stringtab_add (tab, str, hash, copy); |
| |
| if (str_index != (bfd_size_type) -1) |
| /* Add BYTES_IN_WORD to the return value to account for the |
| space taken up by the string table size. */ |
| str_index += BYTES_IN_WORD; |
| |
| return str_index; |
| } |
| |
| /* Write out a strtab. ABFD is already at the right location in the |
| file. */ |
| |
| static bool |
| emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab) |
| { |
| bfd_byte buffer[BYTES_IN_WORD]; |
| size_t amt = BYTES_IN_WORD; |
| |
| /* The string table starts with the size. */ |
| PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer); |
| if (bfd_bwrite ((void *) buffer, amt, abfd) != amt) |
| return false; |
| |
| return _bfd_stringtab_emit (abfd, tab); |
| } |
| |
| bool |
| NAME (aout, write_syms) (bfd *abfd) |
| { |
| unsigned int count ; |
| asymbol **generic = bfd_get_outsymbols (abfd); |
| struct bfd_strtab_hash *strtab; |
| |
| strtab = _bfd_stringtab_init (); |
| if (strtab == NULL) |
| return false; |
| |
| for (count = 0; count < bfd_get_symcount (abfd); count++) |
| { |
| asymbol *g = generic[count]; |
| bfd_size_type indx; |
| struct external_nlist nsp; |
| size_t amt; |
| |
| indx = add_to_stringtab (abfd, strtab, g->name, false); |
| if (indx == (bfd_size_type) -1) |
| goto error_return; |
| PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx); |
| |
| if (bfd_asymbol_flavour (g) == abfd->xvec->flavour) |
| { |
| H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc); |
| H_PUT_8 (abfd, aout_symbol (g)->other, nsp.e_other); |
| H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type); |
| } |
| else |
| { |
| H_PUT_16 (abfd, 0, nsp.e_desc); |
| H_PUT_8 (abfd, 0, nsp.e_other); |
| H_PUT_8 (abfd, 0, nsp.e_type); |
| } |
| |
| if (! translate_to_native_sym_flags (abfd, g, &nsp)) |
| goto error_return; |
| |
| amt = EXTERNAL_NLIST_SIZE; |
| if (bfd_bwrite ((void *) &nsp, amt, abfd) != amt) |
| goto error_return; |
| |
| /* NB: `KEEPIT' currently overlays `udata.p', so set this only |
| here, at the end. */ |
| g->KEEPIT = count; |
| } |
| |
| if (! emit_stringtab (abfd, strtab)) |
| goto error_return; |
| |
| _bfd_stringtab_free (strtab); |
| |
| return true; |
| |
| error_return: |
| _bfd_stringtab_free (strtab); |
| return false; |
| } |
| |
| long |
| NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location) |
| { |
| unsigned int counter = 0; |
| aout_symbol_type *symbase; |
| |
| if (!NAME (aout, slurp_symbol_table) (abfd)) |
| return -1; |
| |
| for (symbase = obj_aout_symbols (abfd); |
| counter++ < bfd_get_symcount (abfd); |
| ) |
| *(location++) = (asymbol *) (symbase++); |
| *location++ =0; |
| return bfd_get_symcount (abfd); |
| } |
| |
| /* Standard reloc stuff. */ |
| /* Output standard relocation information to a file in target byte order. */ |
| |
| extern void NAME (aout, swap_std_reloc_out) |
| (bfd *, arelent *, struct reloc_std_external *); |
| |
| void |
| NAME (aout, swap_std_reloc_out) (bfd *abfd, |
| arelent *g, |
| struct reloc_std_external *natptr) |
| { |
| int r_index; |
| asymbol *sym = *(g->sym_ptr_ptr); |
| int r_extern; |
| unsigned int r_length; |
| int r_pcrel; |
| int r_baserel, r_jmptable, r_relative; |
| asection *output_section = sym->section->output_section; |
| |
| PUT_WORD (abfd, g->address, natptr->r_address); |
| |
| BFD_ASSERT (g->howto != NULL); |
| |
| switch (bfd_get_reloc_size (g->howto)) |
| { |
| default: |
| _bfd_error_handler (_("%pB: unsupported AOUT relocation size: %d"), |
| abfd, bfd_get_reloc_size (g->howto)); |
| bfd_set_error (bfd_error_bad_value); |
| return; |
| case 1: |
| case 2: |
| case 4: |
| r_length = g->howto->size; /* Size as a power of two. */ |
| break; |
| case 8: |
| r_length = 3; |
| break; |
| } |
| |
| r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */ |
| /* XXX This relies on relocs coming from a.out files. */ |
| r_baserel = (g->howto->type & 8) != 0; |
| r_jmptable = (g->howto->type & 16) != 0; |
| r_relative = (g->howto->type & 32) != 0; |
| |
| /* Name was clobbered by aout_write_syms to be symbol index. */ |
| |
| /* 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) |
| || bfd_is_abs_section (output_section) |
| || bfd_is_und_section (output_section) |
| /* PR gas/3041 a.out relocs against weak symbols |
| must be treated as if they were against externs. */ |
| || (sym->flags & BSF_WEAK)) |
| { |
| if (bfd_abs_section_ptr->symbol == sym) |
| { |
| /* Whoops, looked like an abs symbol, but is |
| really an offset from the abs section. */ |
| r_index = N_ABS; |
| r_extern = 0; |
| } |
| else |
| { |
| /* Fill in symbol. */ |
| r_extern = 1; |
| r_index = (*(g->sym_ptr_ptr))->KEEPIT; |
| } |
| } |
| else |
| { |
| /* Just an ordinary section. */ |
| r_extern = 0; |
| r_index = output_section->target_index; |
| } |
| |
| /* Now the fun stuff. */ |
| if (bfd_header_big_endian (abfd)) |
| { |
| 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)); |
| } |
| } |
| |
| /* Extended stuff. */ |
| /* Output extended relocation information to a file in target byte order. */ |
| |
| extern void NAME (aout, swap_ext_reloc_out) |
| (bfd *, arelent *, struct reloc_ext_external *); |
| |
| void |
| NAME (aout, swap_ext_reloc_out) (bfd *abfd, |
| arelent *g, |
| struct reloc_ext_external *natptr) |
| { |
| int r_index; |
| int r_extern; |
| unsigned int r_type; |
| bfd_vma r_addend; |
| 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; |
| if ((sym->flags & BSF_SECTION_SYM) != 0) |
| r_addend += (*(g->sym_ptr_ptr))->section->output_section->vma; |
| |
| /* 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_abs_section (bfd_asymbol_section (sym))) |
| { |
| r_extern = 0; |
| r_index = N_ABS; |
| } |
| else if ((sym->flags & BSF_SECTION_SYM) == 0) |
| { |
| if (bfd_is_und_section (bfd_asymbol_section (sym)) |
| || (sym->flags & BSF_GLOBAL) != 0) |
| r_extern = 1; |
| else |
| r_extern = 0; |
| r_index = (*(g->sym_ptr_ptr))->KEEPIT; |
| } |
| else |
| { |
| /* Just an ordinary section. */ |
| r_extern = 0; |
| r_index = output_section->target_index; |
| } |
| |
| /* Now the fun stuff. */ |
| if (bfd_header_big_endian (abfd)) |
| { |
| 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. |
| |
| 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 |
| to give the true offset from the section. */ |
| |
| #define MOVE_ADDRESS(ad) \ |
| if (r_extern) \ |
| { \ |
| /* Undefined symbol. */ \ |
| if (r_index < bfd_get_symcount (abfd)) \ |
| cache_ptr->sym_ptr_ptr = symbols + r_index; \ |
| cache_ptr->addend = ad; \ |
| } \ |
| else \ |
| { \ |
| /* Defined, section relative. Replace symbol with pointer to \ |
| symbol which points to section. */ \ |
| switch (r_index) \ |
| { \ |
| case N_TEXT: \ |
| case N_TEXT | N_EXT: \ |
| cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \ |
| cache_ptr->addend = ad - su->textsec->vma; \ |
| break; \ |
| case N_DATA: \ |
| case N_DATA | N_EXT: \ |
| cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \ |
| cache_ptr->addend = ad - su->datasec->vma; \ |
| break; \ |
| case N_BSS: \ |
| case N_BSS | N_EXT: \ |
| cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \ |
| cache_ptr->addend = ad - su->bsssec->vma; \ |
| break; \ |
| default: \ |
| case N_ABS: \ |
| case N_ABS | N_EXT: \ |
| cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \ |
| cache_ptr->addend = ad; \ |
| break; \ |
| } \ |
| } |
| |
| void |
| NAME (aout, swap_ext_reloc_in) (bfd *abfd, |
| struct reloc_ext_external *bytes, |
| arelent *cache_ptr, |
| asymbol **symbols, |
| bfd_size_type symcount) |
| { |
| unsigned int r_index; |
| int r_extern; |
| unsigned int r_type; |
| struct aoutdata *su = &(abfd->tdata.aout_data->a); |
| |
| cache_ptr->address = (GET_SWORD (abfd, bytes->r_address)); |
| |
| /* Now the fun stuff. */ |
| if (bfd_header_big_endian (abfd)) |
| { |
| r_index = (((unsigned int) bytes->r_index[0] << 16) |
| | ((unsigned int) 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 = (((unsigned int) bytes->r_index[2] << 16) |
| | ((unsigned int) 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); |
| } |
| |
| if (r_type < TABLE_SIZE (howto_table_ext)) |
| cache_ptr->howto = howto_table_ext + r_type; |
| else |
| cache_ptr->howto = NULL; |
| |
| /* Base relative relocs are always against the symbol table, |
| regardless of the setting of r_extern. r_extern just reflects |
| whether the symbol the reloc is against is local or global. */ |
| if (r_type == (unsigned int) RELOC_BASE10 |
| || r_type == (unsigned int) RELOC_BASE13 |
| || r_type == (unsigned int) RELOC_BASE22) |
| r_extern = 1; |
| |
| if (r_extern && r_index > symcount) |
| { |
| /* We could arrange to return an error, but it might be useful |
| to see the file even if it is bad. */ |
| r_extern = 0; |
| r_index = N_ABS; |
| } |
| |
| MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend)); |
| } |
| |
| void |
| NAME (aout, swap_std_reloc_in) (bfd *abfd, |
| struct reloc_std_external *bytes, |
| arelent *cache_ptr, |
| asymbol **symbols, |
| bfd_size_type symcount) |
| { |
| unsigned 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); |
| unsigned int howto_idx; |
| |
| cache_ptr->address = H_GET_32 (abfd, bytes->r_address); |
| |
| /* Now the fun stuff. */ |
| if (bfd_header_big_endian (abfd)) |
| { |
| r_index = (((unsigned int) bytes->r_index[0] << 16) |
| | ((unsigned int) bytes->r_index[1] << 8) |
| | bytes->r_index[2]); |
| r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG)); |
| r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG)); |
| r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG)); |
| r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG)); |
| r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG)); |
| r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG) |
| >> RELOC_STD_BITS_LENGTH_SH_BIG); |
| } |
| else |
| { |
| r_index = (((unsigned int) bytes->r_index[2] << 16) |
| | ((unsigned int) bytes->r_index[1] << 8) |
| | bytes->r_index[0]); |
| r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE)); |
| r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE)); |
| r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE)); |
| r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE)); |
| r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE)); |
| r_length = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE) |
| >> RELOC_STD_BITS_LENGTH_SH_LITTLE); |
| } |
| |
| howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel |
| + 16 * r_jmptable + 32 * r_relative); |
| if (howto_idx < TABLE_SIZE (howto_table_std)) |
| { |
| cache_ptr->howto = howto_table_std + howto_idx; |
| if (cache_ptr->howto->type == (unsigned int) -1) |
| cache_ptr->howto = NULL; |
| } |
| else |
| cache_ptr->howto = NULL; |
| |
| /* Base relative relocs are always against the symbol table, |
| regardless of the setting of r_extern. r_extern just reflects |
| whether the symbol the reloc is against is local or global. */ |
| if (r_baserel) |
| r_extern = 1; |
| |
| if (r_extern && r_index >= symcount) |
| { |
| /* We could arrange to return an error, but it might be useful |
| to see the file even if it is bad. FIXME: Of course this |
| means that objdump -r *doesn't* see the actual reloc, and |
| objcopy silently writes a different reloc. */ |
| r_extern = 0; |
| r_index = N_ABS; |
| } |
| |
| MOVE_ADDRESS (0); |
| } |
| |
| /* Read and swap the relocs for a section. */ |
| |
| bool |
| NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols) |
| { |
| bfd_size_type count; |
| bfd_size_type reloc_size; |
| void * relocs; |
| arelent *reloc_cache; |
| size_t each_size; |
| unsigned int counter = 0; |
| arelent *cache_ptr; |
| bfd_size_type amt; |
| |
| if (asect->relocation) |
| return true; |
| |
| if (asect->flags & SEC_CONSTRUCTOR) |
| return true; |
| |
| if (asect == obj_datasec (abfd)) |
| reloc_size = exec_hdr (abfd)->a_drsize; |
| else if (asect == obj_textsec (abfd)) |
| reloc_size = exec_hdr (abfd)->a_trsize; |
| else if (asect == obj_bsssec (abfd)) |
| reloc_size = 0; |
| else |
| { |
| bfd_set_error (bfd_error_invalid_operation); |
| return false; |
| } |
| |
| each_size = obj_reloc_entry_size (abfd); |
| count = reloc_size / each_size; |
| if (count == 0) |
| return true; /* Nothing to be done. */ |
| |
| if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0) |
| return false; |
| relocs = _bfd_malloc_and_read (abfd, reloc_size, reloc_size); |
| if (relocs == NULL) |
| return false; |
| |
| amt = count * sizeof (arelent); |
| reloc_cache = (arelent *) bfd_zmalloc (amt); |
| if (reloc_cache == NULL) |
| { |
| free (relocs); |
| return false; |
| } |
| |
| cache_ptr = reloc_cache; |
| if (each_size == RELOC_EXT_SIZE) |
| { |
| struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs; |
| |
| for (; counter < count; counter++, rptr++, cache_ptr++) |
| MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols, |
| (bfd_size_type) bfd_get_symcount (abfd)); |
| } |
| else |
| { |
| struct reloc_std_external *rptr = (struct reloc_std_external *) relocs; |
| |
| for (; counter < count; counter++, rptr++, cache_ptr++) |
| MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols, |
| (bfd_size_type) bfd_get_symcount (abfd)); |
| } |
| |
| free (relocs); |
| |
| asect->relocation = reloc_cache; |
| asect->reloc_count = cache_ptr - reloc_cache; |
| |
| return true; |
| } |
| |
| /* Write out a relocation section into an object file. */ |
| |
| bool |
| NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section) |
| { |
| arelent **generic; |
| unsigned char *native, *natptr; |
| size_t each_size; |
| |
| unsigned int count = section->reloc_count; |
| bfd_size_type natsize; |
| |
| if (count == 0 || section->orelocation == NULL) |
| return true; |
| |
| each_size = obj_reloc_entry_size (abfd); |
| natsize = (bfd_size_type) each_size * count; |
| native = (unsigned char *) bfd_zalloc (abfd, natsize); |
| if (!native) |
| return false; |
| |
| generic = section->orelocation; |
| |
| if (each_size == RELOC_EXT_SIZE) |
| { |
| for (natptr = native; |
| count != 0; |
| --count, natptr += each_size, ++generic) |
| { |
| /* PR 20921: If the howto field has not been initialised then skip |
| this reloc. |
| PR 20929: Similarly for the symbol field. */ |
| if ((*generic)->howto == NULL |
| || (*generic)->sym_ptr_ptr == NULL) |
| { |
| bfd_set_error (bfd_error_invalid_operation); |
| _bfd_error_handler (_("%pB: attempt to write out " |
| "unknown reloc type"), abfd); |
| return false; |
| } |
| MY_swap_ext_reloc_out (abfd, *generic, |
| (struct reloc_ext_external *) natptr); |
| } |
| } |
| else |
| { |
| for (natptr = native; |
| count != 0; |
| --count, natptr += each_size, ++generic) |
| { |
| if ((*generic)->howto == NULL |
| || (*generic)->sym_ptr_ptr == NULL) |
| { |
| bfd_set_error (bfd_error_invalid_operation); |
| _bfd_error_handler (_("%pB: attempt to write out " |
| "unknown reloc type"), abfd); |
| return false; |
| } |
| MY_swap_std_reloc_out (abfd, *generic, |
| (struct reloc_std_external *) natptr); |
| } |
| } |
| |
| if (bfd_bwrite ((void *) native, 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. */ |
| |
| long |
| NAME (aout, canonicalize_reloc) (bfd *abfd, |
| sec_ptr section, |
| arelent **relptr, |
| asymbol **symbols) |
| { |
| arelent *tblptr = section->relocation; |
| unsigned int count; |
| |
| if (section == obj_bsssec (abfd)) |
| { |
| *relptr = NULL; |
| return 0; |
| } |
| |
| if (!(tblptr || NAME (aout, slurp_reloc_table) (abfd, section, symbols))) |
| return -1; |
| |
| 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; |
| |
| for (count = 0; count++ < section->reloc_count; ) |
| { |
| *relptr++ = tblptr++; |
| } |
| } |
| *relptr = 0; |
| |
| return section->reloc_count; |
| } |
| |
| long |
| NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect) |
| { |
| bfd_size_type count; |
| |
| if (bfd_get_format (abfd) != bfd_object) |
| { |
| bfd_set_error (bfd_error_invalid_operation); |
| return -1; |
| } |
| |
| if (asect->flags & SEC_CONSTRUCTOR) |
| count = asect->reloc_count; |
| else if (asect == obj_datasec (abfd)) |
| count = exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd); |
| else if (asect == obj_textsec (abfd)) |
| count = exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd); |
| else if (asect == obj_bsssec (abfd)) |
| count = 0; |
| else |
| { |
| bfd_set_error (bfd_error_invalid_operation); |
| return -1; |
| } |
| |
| if (count >= LONG_MAX / sizeof (arelent *)) |
| { |
| bfd_set_error (bfd_error_file_too_big); |
| return -1; |
| } |
| return (count + 1) * sizeof (arelent *); |
| } |
| |
| long |
| NAME (aout, get_symtab_upper_bound) (bfd *abfd) |
| { |
| if (!NAME (aout, slurp_symbol_table) (abfd)) |
| return -1; |
| |
| return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *)); |
| } |
| |
| alent * |
| NAME (aout, get_lineno) (bfd *ignore_abfd ATTRIBUTE_UNUSED, |
| asymbol *ignore_symbol ATTRIBUTE_UNUSED) |
| { |
| return NULL; |
| } |
| |
| void |
| NAME (aout, get_symbol_info) (bfd *ignore_abfd ATTRIBUTE_UNUSED, |
| asymbol *symbol, |
| symbol_info *ret) |
| { |
| bfd_symbol_info (symbol, ret); |
| |
| if (ret->type == '?') |
| { |
| int type_code = aout_symbol (symbol)->type & 0xff; |
| const char *stab_name = bfd_get_stab_name (type_code); |
| static char buf[10]; |
| |
| if (stab_name == NULL) |
| { |
| sprintf (buf, "(%d)", type_code); |
| stab_name = buf; |
| } |
| ret->type = '-'; |
| ret->stab_type = type_code; |
| ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff); |
| ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff); |
| ret->stab_name = stab_name; |
| } |
| } |
| |
| void |
| NAME (aout, print_symbol) (bfd *abfd, |
| void * afile, |
| asymbol *symbol, |
| bfd_print_symbol_type how) |
| { |
| FILE *file = (FILE *)afile; |
| |
| switch (how) |
| { |
| case bfd_print_symbol_name: |
| if (symbol->name) |
| fprintf (file,"%s", symbol->name); |
| break; |
| case bfd_print_symbol_more: |
| fprintf (file,"%4x %2x %2x", |
| (unsigned) (aout_symbol (symbol)->desc & 0xffff), |
| (unsigned) (aout_symbol (symbol)->other & 0xff), |
| (unsigned) (aout_symbol (symbol)->type)); |
| break; |
| case bfd_print_symbol_all: |
| { |
| const char *section_name = symbol->section->name; |
| |
| bfd_print_symbol_vandf (abfd, (void *)file, symbol); |
| |
| fprintf (file," %-5s %04x %02x %02x", |
| section_name, |
| (unsigned) (aout_symbol (symbol)->desc & 0xffff), |
| (unsigned) (aout_symbol (symbol)->other & 0xff), |
| (unsigned) (aout_symbol (symbol)->type & 0xff)); |
| if (symbol->name) |
| fprintf (file," %s", symbol->name); |
| } |
| break; |
| } |
| } |
| |
| /* If we don't have to allocate more than 1MB to hold the generic |
| symbols, we use the generic minisymbol methord: it's faster, since |
| it only translates the symbols once, not multiple times. */ |
| #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol)) |
| |
| /* Read minisymbols. For minisymbols, we use the unmodified a.out |
| symbols. The minisymbol_to_symbol function translates these into |
| BFD asymbol structures. */ |
| |
| long |
| NAME (aout, read_minisymbols) (bfd *abfd, |
| bool dynamic, |
| void * *minisymsp, |
| unsigned int *sizep) |
| { |
| if (dynamic) |
| /* We could handle the dynamic symbols here as well, but it's |
| easier to hand them off. */ |
| return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); |
| |
| if (! aout_get_external_symbols (abfd)) |
| return -1; |
| |
| if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD) |
| return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); |
| |
| *minisymsp = (void *) obj_aout_external_syms (abfd); |
| |
| /* By passing the external symbols back from this routine, we are |
| giving up control over the memory block. Clear |
| obj_aout_external_syms, so that we do not try to free it |
| ourselves. */ |
| obj_aout_external_syms (abfd) = NULL; |
| |
| *sizep = EXTERNAL_NLIST_SIZE; |
| return obj_aout_external_sym_count (abfd); |
| } |
| |
| /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an |
| unmodified a.out symbol. The SYM argument is a structure returned |
| by bfd_make_empty_symbol, which we fill in here. */ |
| |
| asymbol * |
| NAME (aout, minisymbol_to_symbol) (bfd *abfd, |
| bool dynamic, |
| const void * minisym, |
| asymbol *sym) |
| { |
| if (dynamic |
| || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD) |
| return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym); |
| |
| memset (sym, 0, sizeof (aout_symbol_type)); |
| |
| /* We call translate_symbol_table to translate a single symbol. */ |
| if (! (NAME (aout, translate_symbol_table) |
| (abfd, |
| (aout_symbol_type *) sym, |
| (struct external_nlist *) minisym, |
| (bfd_size_type) 1, |
| obj_aout_external_strings (abfd), |
| obj_aout_external_string_size (abfd), |
| false))) |
| return NULL; |
| |
| return sym; |
| } |
| |
| /* Provided a BFD, a section and an offset into the section, calculate |
| and return the name of the source file and the line nearest to the |
| wanted location. */ |
| |
| bool |
| NAME (aout, find_nearest_line) (bfd *abfd, |
| asymbol **symbols, |
| asection *section, |
| bfd_vma offset, |
| const char **filename_ptr, |
| const char **functionname_ptr, |
| unsigned int *line_ptr, |
| unsigned int *disriminator_ptr) |
| { |
| /* Run down the file looking for the filename, function and linenumber. */ |
| asymbol **p; |
| const char *directory_name = NULL; |
| const char *main_file_name = NULL; |
| const char *current_file_name = NULL; |
| const char *line_file_name = NULL; /* Value of current_file_name at line number. */ |
| const char *line_directory_name = NULL; /* Value of directory_name at line number. */ |
| bfd_vma low_line_vma = 0; |
| bfd_vma low_func_vma = 0; |
| asymbol *func = 0; |
| bfd_size_type filelen, funclen; |
| char *buf; |
| |
| *filename_ptr = bfd_get_filename (abfd); |
| *functionname_ptr = NULL; |
| *line_ptr = 0; |
| if (disriminator_ptr) |
| *disriminator_ptr = 0; |
| |
| if (symbols != NULL) |
| { |
| for (p = symbols; *p; p++) |
| { |
| aout_symbol_type *q = (aout_symbol_type *) (*p); |
| next: |
| switch (q->type) |
| { |
| case N_TEXT: |
| /* If this looks like a file name symbol, and it comes after |
| the line number we have found so far, but before the |
| offset, then we have probably not found the right line |
| number. */ |
| if (q->symbol.value <= offset |
| && ((q->symbol.value > low_line_vma |
| && (line_file_name != NULL |
| || *line_ptr != 0)) |
| || (q->symbol.value > low_func_vma |
| && func != NULL))) |
| { |
| const char *symname; |
| |
| symname = q->symbol.name; |
| |
| if (symname != NULL |
| && strlen (symname) > 2 |
| && strcmp (symname + strlen (symname) - 2, ".o") == 0) |
| { |
| if (q->symbol.value > low_line_vma) |
| { |
| *line_ptr = 0; |
| line_file_name = NULL; |
| } |
| if (q->symbol.value > low_func_vma) |
| func = NULL; |
| } |
| } |
| break; |
| |
| case N_SO: |
| /* If this symbol is less than the offset, but greater than |
| the line number we have found so far, then we have not |
| found the right line number. */ |
| if (q->symbol.value <= offset) |
| { |
| if (q->symbol.value > low_line_vma) |
| { |
| *line_ptr = 0; |
| line_file_name = NULL; |
| } |
| if (q->symbol.value > low_func_vma) |
| func = NULL; |
| } |
| |
| main_file_name = current_file_name = q->symbol.name; |
| /* Look ahead to next symbol to check if that too is an N_SO. */ |
| p++; |
| if (*p == NULL) |
| goto done; |
| q = (aout_symbol_type *) (*p); |
| if (q->type != (int)N_SO) |
| goto next; |
| |
| /* Found a second N_SO First is directory; second is filename. */ |
| directory_name = current_file_name; |
| main_file_name = current_file_name = q->symbol.name; |
| if (obj_textsec (abfd) != section) |
| goto done; |
| break; |
| case N_SOL: |
| current_file_name = q->symbol.name; |
| break; |
| |
| case N_SLINE: |
| |
| case N_DSLINE: |
| case N_BSLINE: |
| /* We'll keep this if it resolves nearer than the one we have |
| already. */ |
| if (q->symbol.value >= low_line_vma |
| && q->symbol.value <= offset) |
| { |
| *line_ptr = q->desc; |
| low_line_vma = q->symbol.value; |
| line_file_name = current_file_name; |
| line_directory_name = directory_name; |
| } |
| break; |
| case N_FUN: |
| { |
| /* We'll keep this if it is nearer than the one we have already. */ |
| if (q->symbol.value >= low_func_vma |
| && q->symbol.value <= offset) |
| { |
| low_func_vma = q->symbol.value; |
| func = (asymbol *)q; |
| } |
| else if (q->symbol.value > offset) |
| goto done; |
| } |
| break; |
| } |
| } |
| } |
| |
| done: |
| if (*line_ptr != 0) |
| { |
| main_file_name = line_file_name; |
| directory_name = line_directory_name; |
| } |
| |
| if (main_file_name == NULL |
| || IS_ABSOLUTE_PATH (main_file_name) |
| || directory_name == NULL) |
| filelen = 0; |
| else |
| filelen = strlen (directory_name) + strlen (main_file_name); |
| |
| if (func == NULL) |
| funclen = 0; |
| else |
| funclen = strlen (bfd_asymbol_name (func)); |
| |
| free (adata (abfd).line_buf); |
| |
| if (filelen + funclen == 0) |
| adata (abfd).line_buf = buf = NULL; |
| else |
| { |
| buf = (char *) bfd_malloc (filelen + funclen + 3); |
| adata (abfd).line_buf = buf; |
| if (buf == NULL) |
| return false; |
| } |
| |
| if (main_file_name != NULL) |
| { |
| if (IS_ABSOLUTE_PATH (main_file_name) || directory_name == NULL) |
| *filename_ptr = main_file_name; |
| else |
| { |
| if (buf == NULL) |
| /* PR binutils/20891: In a corrupt input file both |
| main_file_name and directory_name can be empty... */ |
| * filename_ptr = NULL; |
| else |
| { |
| snprintf (buf, filelen + 1, "%s%s", directory_name, |
| main_file_name); |
| *filename_ptr = buf; |
| buf += filelen + 1; |
| } |
| } |
| } |
| |
| if (func) |
| { |
| const char *function = func->name; |
| char *colon; |
| |
| if (buf == NULL) |
| { |
| /* PR binutils/20892: In a corrupt input file func can be empty. */ |
| * functionname_ptr = NULL; |
| return true; |
| } |
| /* The caller expects a symbol name. We actually have a |
| function name, without the leading underscore. Put the |
| underscore back in, so that the caller gets a symbol name. */ |
| if (bfd_get_symbol_leading_char (abfd) == '\0') |
| strcpy (buf, function); |
| else |
| { |
| buf[0] = bfd_get_symbol_leading_char (abfd); |
| strcpy (buf + 1, function); |
| } |
| /* Have to remove : stuff. */ |
| colon = strchr (buf, ':'); |
| if (colon != NULL) |
| *colon = '\0'; |
| *functionname_ptr = buf; |
| } |
| |
| return true; |
| } |
| |
| int |
| NAME (aout, sizeof_headers) (bfd *abfd, |
| struct bfd_link_info *info ATTRIBUTE_UNUSED) |
| { |
| return adata (abfd).exec_bytes_size; |
| } |
| |
| /* Free all information we have cached for this BFD. We can always |
| read it again later if we need it. */ |
| |
| bool |
| NAME (aout, bfd_free_cached_info) (bfd *abfd) |
| { |
| asection *o; |
| |
| if (bfd_get_format (abfd) != bfd_object |
| || abfd->tdata.aout_data == NULL) |
| return true; |
| |
| #define BFCI_FREE(x) do { free (x); x = NULL; } while (0) |
| BFCI_FREE (obj_aout_symbols (abfd)); |
| #ifdef USE_MMAP |
| obj_aout_external_syms (abfd) = 0; |
| bfd_free_window (&obj_aout_sym_window (abfd)); |
| bfd_free_window (&obj_aout_string_window (abfd)); |
| obj_aout_external_strings (abfd) = 0; |
| #else |
| BFCI_FREE (obj_aout_external_syms (abfd)); |
| BFCI_FREE (obj_aout_external_strings (abfd)); |
| #endif |
| for (o = abfd->sections; o != NULL; o = o->next) |
| BFCI_FREE (o->relocation); |
| #undef BFCI_FREE |
| |
| return true; |
| } |
| |
| /* a.out link code. */ |
| |
| /* Routine to create an entry in an a.out link hash table. */ |
| |
| struct bfd_hash_entry * |
| NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry, |
| struct bfd_hash_table *table, |
| const char *string) |
| { |
| struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry; |
| |
| /* Allocate the structure if it has not already been allocated by a |
| subclass. */ |
| if (ret == NULL) |
| ret = (struct aout_link_hash_entry *) bfd_hash_allocate (table, |
| sizeof (* ret)); |
| if (ret == NULL) |
| return NULL; |
| |
| /* Call the allocation method of the superclass. */ |
| ret = ((struct aout_link_hash_entry *) |
| _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, |
| table, string)); |
| if (ret) |
| { |
| /* Set local fields. */ |
| ret->written = false; |
| ret->indx = -1; |
| } |
| |
| return (struct bfd_hash_entry *) ret; |
| } |
| |
| /* Initialize an a.out link hash table. */ |
| |
| bool |
| NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table, |
| bfd *abfd, |
| struct bfd_hash_entry *(*newfunc) |
| (struct bfd_hash_entry *, struct bfd_hash_table *, |
| const char *), |
| unsigned int entsize) |
| { |
| return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize); |
| } |
| |
| /* Create an a.out link hash table. */ |
| |
| struct bfd_link_hash_table * |
| NAME (aout, link_hash_table_create) (bfd *abfd) |
| { |
| struct aout_link_hash_table *ret; |
| size_t amt = sizeof (* ret); |
| |
| ret = (struct aout_link_hash_table *) bfd_malloc (amt); |
| if (ret == NULL) |
| return NULL; |
| |
| if (!NAME (aout, link_hash_table_init) (ret, abfd, |
| NAME (aout, link_hash_newfunc), |
| sizeof (struct aout_link_hash_entry))) |
| { |
| free (ret); |
| return NULL; |
| } |
| return &ret->root; |
| } |
| |
| /* Add all symbols from an object file to the hash table. */ |
| |
| static bool |
| aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info) |
| { |
| bool (*add_one_symbol) |
| (struct bfd_link_info *, bfd *, const char *, flagword, asection *, |
| bfd_vma, const char *, bool, bool, struct bfd_link_hash_entry **); |
| struct external_nlist *syms; |
| bfd_size_type sym_count; |
| char *strings; |
|