/* BFD back-end for PDP-11 a.out binaries.
- Copyright (C) 2001-2019 Free Software Foundation, Inc.
+ Copyright (C) 2001-2020 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
/* BFD backend for PDP-11, running 2.11BSD in particular.
This file was hacked up by looking hard at the existing vaxnetbsd
- back end and the header files in 2.11BSD.
+ back end and the header files in 2.11BSD. The symbol table format
+ of 2.11BSD has been extended to accommodate .stab symbols. See
+ struct pdp11_external_nlist below for details.
TODO
* support for V7 file formats
#define ARCH_SIZE 16
#undef TARGET_IS_BIG_ENDIAN_P
-#define TARGET_PAGE_SIZE 256
+#define TARGET_PAGE_SIZE 8192
#define SEGMENT__SIZE TARGET_PAGE_SIZE
#define DEFAULT_ARCH bfd_arch_pdp11
#define N_SET_FLAGS(execp, flags) do { } while (0)
#define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \
&& N_MAGIC(x) != NMAGIC \
+ && N_MAGIC(x) != IMAGIC \
&& N_MAGIC(x) != ZMAGIC)
#include "sysdep.h"
#define A_MAGIC2 NMAGIC
#define NMAGIC 0410 /* Pure executable. */
#define ZMAGIC 0413 /* Demand-paged executable. */
-#define A_MAGIC3 0411 /* Separated I&D. */
+#define IMAGIC 0411 /* Separated I&D. */
+#define A_MAGIC3 IMAGIC
#define A_MAGIC4 0405 /* Overlay. */
#define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */
#define A_MAGIC6 0431 /* Auto-overlay (separate). */
#define A_FLAG_RELOC_STRIPPED 0x0001
+/* The following struct defines the format of an entry in the object file
+ symbol table. In the original 2.11BSD struct the index into the string
+ table is stored as a long, but the PDP11 C convention for storing a long in
+ memory placed the most significant word first even though the bytes within a
+ word are stored least significant first. So here the string table index is
+ considered to be just 16 bits and the first two bytes of the struct were
+ previously named e_unused. To extend the symbol table format to accommodate
+ .stab symbols, the e_unused bytes are renamed e_desc to store the desc field
+ of the .stab symbol. The GDP Project's STABS document says that the "other"
+ field is almost always unused and can be set to zero; the only nonzero cases
+ identified were for stabs in their own sections, which does not apply for
+ pdp11 a.out format, and for a special case of GNU Modula2 which is not
+ supported for the PDP11. */
#define external_nlist pdp11_external_nlist
struct pdp11_external_nlist
{
- bfd_byte e_unused[2]; /* Unused. */
+ bfd_byte e_desc[2]; /* The desc field for .stab symbols, else 0. */
bfd_byte e_strx[2]; /* Index into string table of name. */
bfd_byte e_type[1]; /* Type of symbol. */
bfd_byte e_ovly[1]; /* Overlay number. */
#include "aout/stab_gnu.h"
#include "aout/ar.h"
+/* The symbol type numbers for the 16-bit a.out format from 2.11BSD differ from
+ those defined in aout64.h so we must redefine them here. N_EXT changes from
+ 0x01 to 0x20 which creates a conflict with some .stab values, in particular
+ between undefined externals (N_UNDF+N_EXT) vs. global variables (N_GYSM) and
+ between external bss symbols (N_BSS+N_EXT) vs. function names (N_FUN). We
+ disambiguate those conflicts with a hack in is_stab() to look for the ':' in
+ the global variable or function name string. */
#undef N_TYPE
#undef N_UNDF
#undef N_ABS
#undef N_REG
#undef N_FN
#undef N_EXT
+#undef N_STAB
#define N_TYPE 0x1f /* Type mask. */
#define N_UNDF 0x00 /* Undefined. */
#define N_ABS 0x01 /* Absolute. */
#define N_REG 0x14 /* Register symbol. */
#define N_FN 0x1f /* File name. */
#define N_EXT 0x20 /* External flag. */
+/* Type numbers from .stab entries that could conflict:
+ N_GSYM 0x20 Global variable [conflict with external undef]
+ N_FNAME 0x22 Function name (for BSD Fortran) [ignored]
+ N_FUN 0x24 Function name [conflict with external BSS]
+ N_NOMAP 0x34 No DST map for sym. [ext. reg. doesn't exist]
+*/
#define RELOC_SIZE 2
struct external_nlist *output_syms;
};
+/* Copy of the link_info.separate_code boolean to select the output format with
+ separate instruction and data spaces selected by --imagic */
+static bfd_boolean separate_i_d = FALSE;
+
reloc_howto_type howto_table_pdp11[] =
{
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
HOWTO( 0, 0, 1, 16, FALSE, 0, complain_overflow_signed,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
HOWTO( 1, 0, 1, 16, TRUE, 0, complain_overflow_signed,0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO( 2, 0, 2, 32, FALSE, 0, complain_overflow_signed,0,"32", TRUE, 0x0000ffff,0x0000ffff, FALSE),
};
#define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
return &howto_table_pdp11[0];
case BFD_RELOC_16_PCREL:
return &howto_table_pdp11[1];
+ case BFD_RELOC_32:
+ return &howto_table_pdp11[2];
default:
return NULL;
}
return NULL;
}
+/* Disambiguate conflicts between normal symbol types and .stab symbol types
+ (undefined externals N_UNDF+N_EXT vs. global variables N_GYSM and external
+ bss symbols N_BSS+N_EXT vs. function names N_FUN) with a hack to look for
+ the ':' in the global variable or function name string. */
+
+static int
+is_stab (int type, const char *name)
+{
+ if (type == N_GSYM || type == N_FUN)
+ return (index(name, ':') != NULL);
+ return (type > N_FUN);
+}
+
static int
pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
{
environment's "finish up" function just before returning, to
handle any last-minute setup. */
-const bfd_target *
+bfd_cleanup
NAME (aout, some_aout_object_p) (bfd *abfd,
struct internal_exec *execp,
- const bfd_target *(*callback_to_real_object_p) (bfd *))
+ bfd_cleanup (*callback_to_real_object_p) (bfd *))
{
struct aout_data_struct *rawptr, *oldrawptr;
- const bfd_target *result;
- bfd_size_type amt = sizeof (struct aout_data_struct);
+ bfd_cleanup cleanup;
+ size_t amt = sizeof (struct aout_data_struct);
rawptr = bfd_zalloc (abfd, amt);
if (rawptr == NULL)
}
else if (N_MAGIC (execp) == OMAGIC)
adata (abfd).magic = o_magic;
+ else if (N_MAGIC (execp) == IMAGIC)
+ adata (abfd).magic = i_magic;
else
{
/* Should have been checked with N_BADMAG before this routine
adata(abfd)->segment_size = SEGMENT_SIZE;
adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
- return abfd->xvec;
+ 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
header, should cope with them in this callback as well. */
#endif /* DOCUMENTATION */
- result = (*callback_to_real_object_p)(abfd);
+ cleanup = (*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
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_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
}
#endif /* STAT_FOR_EXEC */
- if (!result)
+ if (!cleanup)
{
free (rawptr);
abfd->tdata.aout_data = oldrawptr;
}
- return result;
+ return cleanup;
}
/* Initialize ABFD for use with a.out files. */
NAME (aout, mkobject) (bfd *abfd)
{
struct aout_data_struct *rawptr;
- bfd_size_type amt = sizeof (struct aout_data_struct);
+ size_t amt = sizeof (struct aout_data_struct);
bfd_set_error (bfd_error_system_call);
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. */
- obj_textsec (abfd)->filepos = pos;
- if (! obj_textsec (abfd)->user_set_vma)
- obj_textsec (abfd)->vma = vma;
+ text->filepos = pos;
+ if (!text->user_set_vma)
+ text->vma = vma;
else
- vma = obj_textsec (abfd)->vma;
+ vma = text->vma;
- pos += obj_textsec (abfd)->size;
- vma += obj_textsec (abfd)->size;
+ pos += execp->a_text;
+ vma += execp->a_text;
/* Data. */
- if (!obj_datasec (abfd)->user_set_vma)
+ if (!data->user_set_vma)
{
- obj_textsec (abfd)->size += pad;
pos += pad;
vma += pad;
- obj_datasec (abfd)->vma = vma;
+ data->vma = vma;
}
else
- vma = obj_datasec (abfd)->vma;
- obj_datasec (abfd)->filepos = pos;
- pos += obj_datasec (abfd)->size;
- vma += obj_datasec (abfd)->size;
+ vma = data->vma;
+ execp->a_text += pad;
+
+ data->filepos = pos;
+ pos += data->size;
+ vma += data->size;
/* BSS. */
- if (! obj_bsssec (abfd)->user_set_vma)
+ if (!bss->user_set_vma)
{
- obj_datasec (abfd)->size += pad;
pos += pad;
vma += pad;
- obj_bsssec (abfd)->vma = vma;
+ bss->vma = vma;
}
- else
+ else if (data->size > 0 || bss->size > 0) /* PR25677: for objcopy --extract-symbol */
{
/* 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 = obj_bsssec (abfd)->vma - vma;
- if (pad > 0)
- {
- obj_datasec (abfd)->size += pad;
- pos += pad;
- }
+ pad = bss->vma - vma;
+ if (pad < 0)
+ pad = 0;
+ pos += pad;
}
- obj_bsssec (abfd)->filepos = pos;
+ execp->a_data = data->size + pad;
+ bss->filepos = pos;
+ execp->a_bss = bss->size;
- /* Fix up the exec header. */
- execp->a_text = obj_textsec (abfd)->size;
- execp->a_data = obj_datasec (abfd)->size;
- execp->a_bss = obj_bsssec (abfd)->size;
N_SET_MAGIC (execp, OMAGIC);
}
bfd_size_type data_pad, text_pad;
file_ptr text_end;
const struct aout_backend_data *abdp;
- int ztih; /* Nonzero if text includes exec header. */
+ /* TRUE if text includes exec header. */
+ bfd_boolean ztih;
+ asection *text = obj_textsec (abfd);
+ asection *data = obj_datasec (abfd);
+ asection *bss = obj_bsssec (abfd);
abdp = aout_backend_info (abfd);
ztih = (abdp != NULL
&& (abdp->text_includes_header
|| obj_aout_subformat (abfd) == q_magic_format));
- obj_textsec(abfd)->filepos = (ztih
- ? adata(abfd).exec_bytes_size
- : adata(abfd).zmagic_disk_block_size);
- if (! obj_textsec(abfd)->user_set_vma)
+ 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? */
- obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
- ? 0
- : (ztih
- ? (abdp->default_text_vma
- + adata (abfd).exec_bytes_size)
- : abdp->default_text_vma));
+ 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
may need to pad it such that the .data section starts at a page
boundary. */
if (ztih)
- text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
+ text_pad = ((text->filepos - text->vma)
& (adata (abfd).page_size - 1));
else
- text_pad = ((- obj_textsec (abfd)->vma)
+ text_pad = (-text->vma
& (adata (abfd).page_size - 1));
}
/* Find start of data. */
if (ztih)
{
- text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
+ 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 = obj_textsec (abfd)->size;
+ text_end = execp->a_text;
text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
- text_end += obj_textsec (abfd)->filepos;
+ text_end += text->filepos;
}
-
- obj_textsec (abfd)->size += text_pad;
- text_end += text_pad;
+ execp->a_text += text_pad;
/* Data. */
- if (!obj_datasec(abfd)->user_set_vma)
+ if (!data->user_set_vma)
{
bfd_vma vma;
- vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size;
- obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
+ vma = text->vma + execp->a_text;
+ data->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
}
if (abdp && abdp->zmagic_mapped_contiguous)
{
- text_pad = (obj_datasec(abfd)->vma
- - obj_textsec(abfd)->vma
- - obj_textsec(abfd)->size);
- obj_textsec(abfd)->size += text_pad;
+ 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;
}
- obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
- + obj_textsec (abfd)->size);
+ data->filepos = text->filepos + execp->a_text;
/* Fix up exec header while we're at it. */
- execp->a_text = obj_textsec(abfd)->size;
if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
- execp->a_text += adata(abfd).exec_bytes_size;
+ execp->a_text += adata (abfd).exec_bytes_size;
N_SET_MAGIC (execp, ZMAGIC);
/* Spec says data section should be rounded up to page boundary. */
- obj_datasec(abfd)->size
- = align_power (obj_datasec(abfd)->size,
- obj_bsssec(abfd)->alignment_power);
- execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size,
- adata(abfd).page_size);
- data_pad = execp->a_data - obj_datasec(abfd)->size;
+ 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 (!obj_bsssec(abfd)->user_set_vma)
- obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
- + obj_datasec(abfd)->size);
+ 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
(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 (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
- == obj_datasec(abfd)->vma + obj_datasec(abfd)->size)
- execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 :
- obj_bsssec(abfd)->size - data_pad;
+ 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 = obj_bsssec(abfd)->size;
+ execp->a_bss = bss->size;
}
static void
adjust_n_magic (bfd *abfd, struct internal_exec *execp)
{
- file_ptr pos = adata(abfd).exec_bytes_size;
+ 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. */
- obj_textsec(abfd)->filepos = pos;
- if (!obj_textsec(abfd)->user_set_vma)
- obj_textsec(abfd)->vma = vma;
+ text->filepos = pos;
+ if (!text->user_set_vma)
+ text->vma = vma;
else
- vma = obj_textsec(abfd)->vma;
- pos += obj_textsec(abfd)->size;
- vma += obj_textsec(abfd)->size;
+ vma = text->vma;
+ pos += execp->a_text;
+ vma += execp->a_text;
/* Data. */
- obj_datasec(abfd)->filepos = pos;
- if (!obj_datasec(abfd)->user_set_vma)
- obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
- vma = obj_datasec(abfd)->vma;
+ 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 += obj_datasec(abfd)->size;
- pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
- obj_datasec(abfd)->size += pad;
- pos += obj_datasec(abfd)->size;
+ vma += data->size;
+ pad = align_power (vma, bss->alignment_power) - vma;
+ execp->a_data = data->size + pad;
+ pos += execp->a_data;
/* BSS. */
- if (!obj_bsssec(abfd)->user_set_vma)
- obj_bsssec(abfd)->vma = vma;
+ if (!bss->user_set_vma)
+ bss->vma = vma;
else
- vma = obj_bsssec(abfd)->vma;
+ vma = bss->vma;
/* Fix up exec header. */
- execp->a_text = obj_textsec(abfd)->size;
- execp->a_data = obj_datasec(abfd)->size;
- execp->a_bss = obj_bsssec(abfd)->size;
+ execp->a_bss = bss->size;
N_SET_MAGIC (execp, NMAGIC);
}
+static void
+adjust_i_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;
+
+ /* Data. */
+ data->filepos = pos;
+ if (!data->user_set_vma)
+ data->vma = 0;
+ 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, IMAGIC);
+}
+
bfd_boolean
NAME (aout, adjust_sizes_and_vmas) (bfd *abfd)
{
if (! NAME (aout, make_sections) (abfd))
return FALSE;
- if (adata(abfd).magic != undecided_magic)
+ if (adata (abfd).magic != undecided_magic)
return TRUE;
- obj_textsec(abfd)->size =
- align_power(obj_textsec(abfd)->size,
- obj_textsec(abfd)->alignment_power);
+ 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
(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. */
+ 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
I understand it better now, but I haven't time to do the cleanup this
minute. */
- if (abfd->flags & WP_TEXT)
- adata(abfd).magic = n_magic;
+ if (separate_i_d)
+ adata (abfd).magic = i_magic;
+ else if (abfd->flags & WP_TEXT)
+ adata (abfd).magic = n_magic;
else
- adata(abfd).magic = o_magic;
+ 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 ();
- }
+ switch (adata (abfd).magic)
+ {
+ case n_magic: str = "NMAGIC"; break;
+ case o_magic: str = "OMAGIC"; break;
+ case i_magic: str = "IMAGIC"; 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);
+ 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)
+ switch (adata (abfd).magic)
{
case o_magic:
adjust_o_magic (abfd, execp);
case n_magic:
adjust_n_magic (abfd, execp);
break;
+ case i_magic:
+ adjust_i_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, obj_textsec(abfd)->size,
- obj_textsec(abfd)->filepos,
- obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
- obj_datasec(abfd)->filepos,
- obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size);
+ 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;
/* 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. */
- syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE);
- if (syms == NULL && count != 0)
+ if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
+ return FALSE;
+ syms = (struct external_nlist *)
+ _bfd_malloc_and_read (abfd, count * EXTERNAL_NLIST_SIZE,
+ count * EXTERNAL_NLIST_SIZE);
+ if (syms == NULL)
return FALSE;
-
- if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
- || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
- != exec_hdr (abfd)->a_syms))
- {
- free (syms);
- return FALSE;
- }
#endif
obj_aout_external_syms (abfd) = syms;
unsigned char string_chars[BYTES_IN_LONG];
bfd_size_type stringsize;
char *strings;
+ bfd_size_type amt = BYTES_IN_LONG;
/* Get the size of the strings. */
if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
- || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG,
- abfd) != BYTES_IN_LONG))
+ || bfd_bread ((void *) string_chars, amt, abfd) != amt)
return FALSE;
stringsize = H_GET_32 (abfd, string_chars);
+ if (stringsize == 0)
+ stringsize = 1;
+ else if (stringsize < BYTES_IN_LONG
+ || (size_t) stringsize != stringsize)
+ {
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
#ifdef USE_MMAP
- if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
- &obj_aout_string_window (abfd), TRUE))
- return FALSE;
- strings = (char *) obj_aout_string_window (abfd).data;
-#else
- strings = bfd_malloc (stringsize + 1);
- if (strings == NULL)
- return FALSE;
-
- /* Skip space for the string count in the buffer for convenience
- when using indexes. */
- if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4)
+ if (stringsize >= BYTES_IN_LONG)
{
- free (strings);
- return FALSE;
+ 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_LONG)
+ {
+ /* Keep the string count in the buffer for convenience
+ when indexing with e_strx. */
+ amt = stringsize - BYTES_IN_LONG;
+ if (bfd_bread (strings + BYTES_IN_LONG, amt, abfd) != amt)
+ {
+ free (strings);
+ return FALSE;
+ }
+ }
+ }
/* Ensure that a zero index yields an empty string. */
strings[0] = '\0';
- strings[stringsize - 1] = 0;
+ /* Ensure that the string buffer is NUL terminated. */
+ strings[stringsize] = 0;
obj_aout_external_strings (abfd) = strings;
obj_aout_external_string_size (abfd) = stringsize;
{
flagword visible;
- if (cache_ptr->type == N_FN)
+ if (is_stab (cache_ptr->type, cache_ptr->symbol.name))
{
asection *sec;
cache_ptr->symbol.flags = BSF_DEBUGGING;
/* Work out the symbol section. */
- switch (cache_ptr->type & N_TYPE)
+ switch (cache_ptr->type)
{
- case N_TEXT:
+ case N_SO:
+ case N_SOL:
+ case N_FUN:
+ case N_ENTRY:
+ case N_SLINE:
case N_FN:
sec = obj_textsec (abfd);
break;
- case N_DATA:
+ case N_STSYM:
+ case N_DSLINE:
sec = obj_datasec (abfd);
break;
- case N_BSS:
+ case N_LCSYM:
+ case N_BSLINE:
sec = obj_bsssec (abfd);
break;
default:
- case N_ABS:
sec = bfd_abs_section_ptr;
break;
}
bfd_vma value = cache_ptr->value;
asection *sec;
bfd_vma off;
+ const char *name = cache_ptr->name != NULL ? cache_ptr->name : "*unknown*";
/* Mask out any existing type bits in case copying from one section
to another. */
- sym_pointer->e_type[0] &= ~N_TYPE;
+ if (!is_stab (sym_pointer->e_type[0], name))
+ sym_pointer->e_type[0] &= ~N_TYPE;
sec = bfd_asymbol_section (cache_ptr);
off = 0;
_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*");
+ abfd, name);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
}
asymbol *
NAME (aout, make_empty_symbol) (bfd *abfd)
{
- bfd_size_type amt = sizeof (aout_symbol_type);
+ size_t amt = sizeof (aout_symbol_type);
aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
if (!new_symbol_type)
return &new_symbol_type->symbol;
}
-/* Translate a set of internal symbols into external symbols. */
+/* Translate a set of external symbols into internal symbols. */
bfd_boolean
NAME (aout, translate_symbol_table) (bfd *abfd,
for (; ext < ext_end; ext++, in++)
{
bfd_vma x;
+ int ovly;
x = GET_WORD (abfd, ext->e_strx);
in->symbol.the_bfd = abfd;
else if (x < strsize)
in->symbol.name = str + x;
else
- return FALSE;
+ {
+ _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;
+ }
+
+ ovly = H_GET_8 (abfd, ext->e_ovly);
+ if (ovly != 0)
+ {
+ _bfd_error_handler
+ (_("%pB: symbol indicates overlay (not supported)"), abfd);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
- in->symbol.value = GET_SWORD (abfd, ext->e_value);
- /* TODO: is 0 a safe value here? */
- in->desc = 0;
+ in->symbol.value = GET_WORD (abfd, ext->e_value);
+ /* e_desc is zero for normal symbols but for .stab symbols it
+ carries the desc field in our extended 2.11BSD format. */
+ in->desc = H_GET_16 (abfd, ext->e_desc);
in->other = 0;
in->type = H_GET_8 (abfd, ext->e_type);
in->symbol.udata.p = NULL;
/* Get the index of a string in a strtab, adding it if it is not
already present. */
-static INLINE bfd_size_type
+static inline bfd_size_type
add_to_stringtab (bfd *abfd,
struct bfd_strtab_hash *tab,
const char *str,
bfd_size_type indx;
struct external_nlist nsp;
- PUT_WORD (abfd, 0, nsp.e_unused);
-
indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
if (indx == (bfd_size_type) -1)
goto error_return;
PUT_WORD (abfd, indx, nsp.e_strx);
if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
- H_PUT_8 (abfd, aout_symbol(g)->type, nsp.e_type);
+ {
+ H_PUT_16 (abfd, aout_symbol (g)->desc, nsp.e_desc);
+ H_PUT_8 (abfd, 0, nsp.e_ovly);
+ H_PUT_8 (abfd, aout_symbol (g)->type, nsp.e_type);
+ }
else
- H_PUT_8 (abfd, 0, nsp.e_type);
+ {
+ H_PUT_16 (abfd, 0, nsp.e_desc);
+ H_PUT_8 (abfd, 0, nsp.e_ovly);
+ H_PUT_8 (abfd, 0, nsp.e_type);
+ }
if (! translate_to_native_sym_flags (abfd, g, &nsp))
goto error_return;
- H_PUT_8 (abfd, 0, nsp.e_ovly);
-
if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
!= EXTERNAL_NLIST_SIZE)
goto error_return;
return TRUE;
-error_return:
+ error_return:
_bfd_stringtab_free (strtab);
return FALSE;
}
local or global. */
r_extern = (reloc_entry & RTYPE) == REXT;
- if (r_extern && r_index > symcount)
+ 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. */
+ 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;
}
if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
return FALSE;
-
- each_size = obj_reloc_entry_size (abfd);
-
- relocs = bfd_malloc (reloc_size);
+ relocs = _bfd_malloc_and_read (abfd, reloc_size, reloc_size);
if (relocs == NULL && reloc_size != 0)
return FALSE;
- if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
- {
- free (relocs);
- return FALSE;
- }
-
+ each_size = obj_reloc_entry_size (abfd);
count = reloc_size / each_size;
/* Count the number of NON-ZERO relocs, this is the count we want. */
{
bfd_byte *r;
+ 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);
+ bfd_release (abfd, native);
+ return FALSE;
+ }
r = native + (*generic)->address;
pdp11_aout_swap_reloc_out (abfd, *generic, r);
count--;
size_t filelen, funclen;
char *buf;
- *filename_ptr = abfd->filename;
- *functionname_ptr = 0;
+ *filename_ptr = bfd_get_filename (abfd);
+ *functionname_ptr = NULL;
*line_ptr = 0;
if (discriminator_ptr)
*discriminator_ptr = 0;
const char * symname;
symname = q->symbol.name;
- if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
+
+ if (symname != NULL
+ && strlen (symname) > 2
+ && strcmp (symname + strlen (symname) - 2, ".o") == 0)
{
if (q->symbol.value > low_line_vma)
{
/* Look ahead to next symbol to check if that too is an N_SO. */
p++;
if (*p == NULL)
- break;
+ goto done;
q = (aout_symbol_type *)(*p);
if (q->type != (int) N_SO)
goto next;
else
funclen = strlen (bfd_asymbol_name (func));
- if (adata (abfd).line_buf != NULL)
- free (adata (abfd).line_buf);
+ free (adata (abfd).line_buf);
if (filelen + funclen == 0)
adata (abfd).line_buf = buf = NULL;
else
*filename_ptr = main_file_name;
else
{
- sprintf (buf, "%s%s", directory_name, main_file_name);
- *filename_ptr = buf;
- buf += filelen + 1;
+ 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;
+ }
}
}
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_format (abfd) != bfd_object)
return TRUE;
-#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
+#define BFCI_FREE(x) do { free (x); x = NULL; } while (0)
BFCI_FREE (obj_aout_symbols (abfd));
#ifdef USE_MMAP
NAME (aout, link_hash_table_create) (bfd *abfd)
{
struct aout_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct aout_link_hash_table);
+ size_t amt = sizeof (struct aout_link_hash_table);
ret = bfd_malloc (amt);
if (ret == NULL)
for (; p < pend; p++)
{
int type = H_GET_8 (abfd, p->e_type);
- const char *name;
+ const char *name = strings + GET_WORD (abfd, p->e_strx);
struct bfd_link_hash_entry *h;
/* Ignore symbols that are not externally visible. This is an
optimization only, as we check the type more thoroughly
below. */
if ((type & N_EXT) == 0
+ || is_stab(type, name)
|| type == N_FN)
continue;
- name = strings + GET_WORD (abfd, p->e_strx);
h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
/* We are only interested in symbols that are currently
type = H_GET_8 (abfd, p->e_type);
+ /* Ignore debugging symbols. */
+ if (is_stab(type, name))
+ continue;
+
+ /* PR 19629: Corrupt binaries can contain illegal string offsets. */
+ if (GET_WORD (abfd, p->e_strx) >= obj_aout_external_string_size (abfd))
+ return FALSE;
name = strings + GET_WORD (abfd, p->e_strx);
value = GET_WORD (abfd, p->e_value);
flags = BSF_GLOBAL;
switch (type)
{
default:
- /* Anything else should be a debugging symbol. */
- BFD_ASSERT ((type & N_STAB) != 0);
+ /* Shouldn't be any types not covered. */
+ BFD_ASSERT (0);
continue;
case N_UNDF:
break;
case N_TEXT | N_EXT:
section = obj_textsec (abfd);
- value -= bfd_get_section_vma (abfd, section);
+ value -= bfd_section_vma (section);
break;
case N_DATA | N_EXT:
/* Treat N_SETV symbols as N_DATA symbol; see comment in
translate_from_native_sym_flags. */
section = obj_datasec (abfd);
- value -= bfd_get_section_vma (abfd, section);
+ value -= bfd_section_vma (section);
break;
case N_BSS | N_EXT:
section = obj_bsssec (abfd);
- value -= bfd_get_section_vma (abfd, section);
+ value -= bfd_section_vma (section);
break;
}
return (struct bfd_hash_entry *) ret;
}
+/* Write out a symbol that was not associated with an a.out input
+ object. */
+
static bfd_boolean
aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
{
bfd_vma val;
struct external_nlist outsym;
bfd_size_type indx;
- bfd_size_type amt;
+ size_t amt;
if (h->root.type == bfd_link_hash_warning)
{
}
H_PUT_8 (output_bfd, type, outsym.e_type);
+ H_PUT_8 (output_bfd, 0, outsym.e_ovly);
indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
FALSE);
if (indx == (bfd_size_type) -1)
/* FIXME: No way to handle errors. */
abort ();
+ PUT_WORD (output_bfd, 0, outsym.e_desc);
PUT_WORD (output_bfd, indx, outsym.e_strx);
PUT_WORD (output_bfd, val, outsym.e_value);
(*flaginfo->info->callbacks->reloc_overflow)
(flaginfo->info, NULL,
(p->type == bfd_section_reloc_link_order
- ? bfd_section_name (flaginfo->output_bfd,
- pr->u.section)
+ ? bfd_section_name (pr->u.section)
: pr->u.name),
howto->name, pr->addend, NULL,
(asection *) NULL, (bfd_vma) 0);
r_extern = (r_type == REXT);
howto_idx = r_pcrel;
- BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
- howto = howto_table_pdp11 + howto_idx;
+ if (howto_idx < TABLE_SIZE (howto_table_pdp11))
+ howto = howto_table_pdp11 + howto_idx;
+ else
+ {
+ _bfd_error_handler (_("%pB: unsupported relocation type"),
+ input_bfd);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
}
if (relocatable)
asection *s;
s = aout_reloc_type_to_section (input_bfd, r_type);
- name = bfd_section_name (input_bfd, s);
+ name = bfd_section_name (s);
}
(*flaginfo->info->callbacks->reloc_overflow)
(flaginfo->info, (h ? &h->root : NULL), name, howto->name,
if (bfd_link_pic (info))
abfd->flags |= DYNAMIC;
+ separate_i_d = info->separate_code;
aout_info.info = info;
aout_info.output_bfd = abfd;
aout_info.contents = NULL;
}
}
- if (aout_info.contents != NULL)
- {
- free (aout_info.contents);
- aout_info.contents = NULL;
- }
- if (aout_info.relocs != NULL)
- {
- free (aout_info.relocs);
- aout_info.relocs = NULL;
- }
- if (aout_info.symbol_map != NULL)
- {
- free (aout_info.symbol_map);
- aout_info.symbol_map = NULL;
- }
- if (aout_info.output_syms != NULL)
- {
- free (aout_info.output_syms);
- aout_info.output_syms = NULL;
- }
+ free (aout_info.contents);
+ aout_info.contents = NULL;
+ free (aout_info.relocs);
+ aout_info.relocs = NULL;
+ free (aout_info.symbol_map);
+ aout_info.symbol_map = NULL;
+ free (aout_info.output_syms);
+ aout_info.output_syms = NULL;
if (includes_hash_initialized)
{
bfd_hash_table_free (&aout_info.includes.root);
else if (obj_textsec (abfd)->reloc_count == 0
&& obj_datasec (abfd)->reloc_count == 0)
{
- bfd_byte b;
-
- b = 0;
- if (bfd_seek (abfd,
- (file_ptr) (obj_datasec (abfd)->filepos
- + exec_hdr (abfd)->a_data
- - 1),
- SEEK_SET) != 0
- || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
- goto error_return;
+ /* The layout of a typical a.out file is header, text, data,
+ relocs, symbols, string table. When there are no relocs,
+ symbols or string table, the last thing in the file is data
+ and a_data may be rounded up. However we may have a smaller
+ sized .data section and thus not written final padding. The
+ same thing can happen with text if there is no data. Write
+ final padding here to extend the file. */
+ file_ptr pos = 0;
+
+ if (exec_hdr (abfd)->a_data > obj_datasec (abfd)->size)
+ pos = obj_datasec (abfd)->filepos + exec_hdr (abfd)->a_data;
+ else if (obj_datasec (abfd)->size == 0
+ && exec_hdr (abfd)->a_text > obj_textsec (abfd)->size)
+ pos = obj_textsec (abfd)->filepos + exec_hdr (abfd)->a_text;
+ if (pos != 0)
+ {
+ bfd_byte b = 0;
+
+ if (bfd_seek (abfd, pos - 1, SEEK_SET) != 0
+ || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
+ goto error_return;
+ }
}
return TRUE;
error_return:
- if (aout_info.contents != NULL)
- free (aout_info.contents);
- if (aout_info.relocs != NULL)
- free (aout_info.relocs);
- if (aout_info.symbol_map != NULL)
- free (aout_info.symbol_map);
- if (aout_info.output_syms != NULL)
- free (aout_info.output_syms);
+ free (aout_info.contents);
+ free (aout_info.relocs);
+ free (aout_info.symbol_map);
+ free (aout_info.output_syms);
if (includes_hash_initialized)
bfd_hash_table_free (&aout_info.includes.root);
return FALSE;
discarding such symbols. */
if (strip != strip_all
&& (strip != strip_some
- || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
+ || bfd_hash_lookup (flaginfo->info->keep_hash,
+ bfd_get_filename (input_bfd),
FALSE, FALSE) != NULL)
&& discard != discard_all)
{
H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
+ H_PUT_8 (output_bfd, 0, outsym->e_ovly);
+ H_PUT_16 (output_bfd, 0, outsym->e_desc);
strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
- input_bfd->filename, FALSE);
+ bfd_get_filename (input_bfd), FALSE);
if (strtab_index == (bfd_size_type) -1)
return FALSE;
PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
PUT_WORD (output_bfd,
- (bfd_get_section_vma (output_bfd,
- obj_textsec (input_bfd)->output_section)
+ (bfd_section_vma (obj_textsec (input_bfd)->output_section)
+ obj_textsec (input_bfd)->output_offset),
outsym->e_value);
++obj_aout_external_sym_count (output_bfd);
case strip_none:
break;
case strip_debugger:
- if ((type & N_STAB) != 0)
+ if (is_stab (type, name))
skip = TRUE;
break;
case strip_some:
}
/* Get the value of the symbol. */
- if ((type & N_TYPE) == N_TEXT
+ if (is_stab (type, name))
+ {
+ switch (type)
+ {
+ default:
+ symsec = bfd_abs_section_ptr;
+ break;
+ case N_SO:
+ case N_SOL:
+ case N_FUN:
+ case N_ENTRY:
+ case N_SLINE:
+ case N_FN:
+ symsec = obj_textsec (input_bfd);
+ break;
+ case N_STSYM:
+ case N_DSLINE:
+ symsec = obj_datasec (input_bfd);
+ break;
+ case N_LCSYM:
+ case N_BSLINE:
+ symsec = obj_bsssec (input_bfd);
+ break;
+ }
+ val = GET_WORD (input_bfd, sym->e_value);
+ }
+ else if ((type & N_TYPE) == N_TEXT
|| type == N_WEAKT)
symsec = obj_textsec (input_bfd);
else if ((type & N_TYPE) == N_DATA
val = GET_WORD (input_bfd, sym->e_value);
symsec = NULL;
}
- else if ((type & N_STAB) != 0)
- {
- val = GET_WORD (input_bfd, sym->e_value);
- symsec = NULL;
- }
else
{
/* If we get here with an indirect symbol, it means that
BFD_ASSERT (bfd_is_abs_section (output_section)
|| output_section->owner == output_bfd);
val = (hresolve->root.u.def.value
- + bfd_get_section_vma (output_bfd, output_section)
+ + bfd_section_vma (output_section)
+ input_section->output_offset);
/* Get the correct type based on the section. If
case discard_sec_merge:
break;
case discard_l:
- if ((type & N_STAB) == 0
+ if (!is_stab (type, name)
&& bfd_is_local_label_name (input_bfd, name))
skip = TRUE;
break;
/* Copy this symbol into the list of symbols we are going to
write out. */
H_PUT_8 (output_bfd, type, outsym->e_type);
+ H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_ovly), outsym->e_ovly);
+ H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
copy = FALSE;
if (! flaginfo->info->keep_memory)
{