static enum gdb_osabi
m68kbsd_aout_osabi_sniffer (bfd *abfd)
{
if (strcmp (bfd_get_target (abfd), "a.out-m68k-netbsd") == 0
|| strcmp (bfd_get_target (abfd), "a.out-m68k4k-netbsd") == 0)
return GDB_OSABI_NETBSD_AOUT;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
i386bsd_aout_osabi_sniffer (bfd *abfd)
{
if (strcmp (bfd_get_target (abfd), "a.out-i386-netbsd") == 0)
return GDB_OSABI_NETBSD_AOUT;
if (strcmp (bfd_get_target (abfd), "a.out-i386-freebsd") == 0)
return GDB_OSABI_FREEBSD_AOUT;
return GDB_OSABI_UNKNOWN;
}
bfd_boolean
ar_emul_default_create (bfd **abfd_out, char *archive_file_name,
char *file_name)
{
char *target = NULL;
/* Try to figure out the target to use for the archive from the
first object on the list. */
if (file_name != NULL)
{
bfd *obj;
obj = bfd_openr (file_name, NULL);
if (obj != NULL)
{
if (bfd_check_format (obj, bfd_object))
target = bfd_get_target (obj);
(void) bfd_close (obj);
}
}
/* Create an empty archive. */
*abfd_out = bfd_openw (archive_file_name, target);
if (*abfd_out == NULL
|| ! bfd_set_format (*abfd_out, bfd_archive)
|| ! bfd_close (*abfd_out))
bfd_fatal (archive_file_name);
return TRUE;
}
void objdump(const char *path)
{
bfd_init();
bfd *abfd = bfd_openr(path, NULL);
if (abfd == NULL)
errx(1, bfd_errmsg(bfd_get_error()));
if (!bfd_check_format(abfd, bfd_object)) {
bfd_close_all_done(abfd);
errx(1, "File is not a valid object file.");
}
printf("%s: file format %s\n", path, bfd_get_target(abfd));
printf("architecture: %s, flags: 0x%08x\n", bfd_printable_arch_mach(bfd_get_arch(abfd), bfd_get_mach(abfd)), abfd->flags);
printf("start address 0x%016lx", bfd_get_start_address(abfd));
printf("\n");
printf("Sections:\n");
printf("Idx Name Size VMA LMA File off Algn\n");
printf(" Flags Content\n");
object_stats stats = { FALSE, FALSE };
bfd_map_over_sections(abfd, (void (*)(bfd *, asection *, void *))print_section, &stats);
if (stats.contains_hello && stats.contains_world)
printf("\nThis file might be a hello world program!\n");
bfd_close(abfd);
}
static void
maintenance_info_sections (char *arg, int from_tty)
{
if (exec_bfd)
{
printf_filtered (_("Exec file:\n"));
printf_filtered (" `%s', ", bfd_get_filename (exec_bfd));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
if (arg && *arg && match_substring (arg, "ALLOBJ"))
{
struct objfile *ofile;
struct obj_section *osect;
/* Only this function cares about the 'ALLOBJ' argument;
if 'ALLOBJ' is the only argument, discard it rather than
passing it down to print_objfile_section_info (which
wouldn't know how to handle it). */
if (strcmp (arg, "ALLOBJ") == 0)
arg = NULL;
ALL_OBJFILES (ofile)
{
printf_filtered (_(" Object file: %s\n"),
bfd_get_filename (ofile->obfd));
ALL_OBJFILE_OSECTIONS (ofile, osect)
{
print_objfile_section_info (ofile->obfd, osect, arg);
}
}
}
else
void
print_section_info (struct target_ops *t, bfd *abfd)
{
struct target_section *p;
/* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
int wid = gdbarch_addr_bit (gdbarch_from_bfd (abfd)) <= 32 ? 8 : 16;
printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
if (abfd == exec_bfd)
printf_filtered (_("\tEntry point: %s\n"),
paddress (bfd_get_start_address (abfd)));
for (p = t->to_sections; p < t->to_sections_end; p++)
{
printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
/* FIXME: A format of "08l" is not wide enough for file offsets
larger than 4GB. OTOH, making it "016l" isn't desirable either
since most output will then be much wider than necessary. It
may make sense to test the size of the file and choose the
format string accordingly. */
/* FIXME: i18n: Need to rewrite this sentence. */
if (info_verbose)
printf_filtered (" @ %s",
hex_string_custom (p->the_bfd_section->filepos, 8));
printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
if (p->bfd != abfd)
printf_filtered (" in %s", bfd_get_filename (p->bfd));
printf_filtered ("\n");
}
}
const bfd_arch_info_type *
bfd_arch_get_compatible (const bfd *abfd,
const bfd *bbfd,
bfd_boolean accept_unknowns)
{
const bfd * ubfd = NULL;
/* Look for an unknown architecture. */
if (((ubfd = abfd) && ubfd->arch_info->arch == bfd_arch_unknown)
|| ((ubfd = bbfd) && ubfd->arch_info->arch == bfd_arch_unknown))
{
/* We can allow an unknown architecture if accept_unknowns
is true, or if the target is the "binary" format, which
has an unknown architecture. Since the binary format can
only be set by explicit request from the user, it is safe
to assume that they know what they are doing. */
if (accept_unknowns
|| strcmp (bfd_get_target (ubfd), "binary") == 0)
return ubfd->arch_info;
return NULL;
}
/* Otherwise architecture-specific code has to decide. */
return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
}
static enum gdb_osabi
i386lynx_coff_osabi_sniffer (bfd *abfd)
{
if (strcmp (bfd_get_target (abfd), "coff-i386-lynx") == 0)
return GDB_OSABI_LYNXOS;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
armobsd_core_osabi_sniffer (bfd *abfd)
{
if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
return GDB_OSABI_OPENBSD_ELF;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
hppaobsd_core_osabi_sniffer(bfd *abfd)
{
if (strcmp(bfd_get_target(abfd), "netbsd-core") == 0)
return GDB_OSABI_NETBSD_CORE;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
vaxobsd_aout_osabi_sniffer (bfd *abfd)
{
if (strcmp (bfd_get_target (abfd), "a.out-vax-netbsd") == 0)
return GDB_OSABI_OPENBSD_AOUT;
return GDB_OSABI_UNKNOWN;
}
static char *
default_gcore_target (void)
{
/* FIXME: This may only work for ELF targets. */
if (exec_bfd == NULL)
return NULL;
else
return bfd_get_target (exec_bfd);
}
CORE_ADDR
pe_text_section_offset (struct bfd *abfd)
{
unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
unsigned long export_rva, export_size, nsections, secptr, expptr;
unsigned long exp_funcbase;
unsigned char *expdata, *erva;
unsigned long name_rvas, ordinals, nexp, ordbase;
char *dll_name;
int is_pe64 = 0;
int is_pe32 = 0;
char const *target;
if (!abfd)
return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
target = bfd_get_target (abfd);
is_pe64 = (strcmp (target, "pe-x86-64") == 0
|| strcmp (target, "pei-x86-64") == 0);
is_pe32 = (strcmp (target, "pe-i386") == 0
|| strcmp (target, "pei-i386") == 0
|| strcmp (target, "pe-arm-wince-little") == 0
|| strcmp (target, "pei-arm-wince-little") == 0);
if (!is_pe32 && !is_pe64)
{
/* This is not a recognized PE format file. Abort now, because
the code is untested on anything else. *FIXME* test on
further architectures and loosen or remove this test. */
return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
}
/* Get pe_header, optional header and numbers of sections. */
pe_header_offset = pe_get32 (abfd, 0x3c);
opthdr_ofs = pe_header_offset + 4 + 20;
nsections = pe_get16 (abfd, pe_header_offset + 4 + 2);
secptr = (pe_header_offset + 4 + 20 +
pe_get16 (abfd, pe_header_offset + 4 + 16));
/* Get the rva and size of the export section. */
for (i = 0; i < nsections; i++)
{
char sname[SCNNMLEN + 1];
unsigned long secptr1 = secptr + 40 * i;
unsigned long vaddr = pe_get32 (abfd, secptr1 + 12);
bfd_seek (abfd, (file_ptr) secptr1, SEEK_SET);
bfd_bread (sname, (bfd_size_type) SCNNMLEN, abfd);
sname[SCNNMLEN] = '\0';
if (strcmp (sname, ".text") == 0)
return vaddr;
}
return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
}
static enum gdb_osabi
arm_wince_osabi_sniffer (bfd *abfd)
{
const char *target_name = bfd_get_target (abfd);
if (strcmp (target_name, "pei-arm-wince-little") == 0)
return GDB_OSABI_WINCE;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
i386_dicos_osabi_sniffer (bfd *abfd)
{
char *target_name = bfd_get_target (abfd);
/* On x86-DICOS, the Load Module's "header" section is 36 bytes. */
if (strcmp (target_name, "elf32-i386") == 0
&& dicos_load_module_p (abfd, 36))
return GDB_OSABI_DICOS;
return GDB_OSABI_UNKNOWN;
}
static enum gdb_osabi
amd64_dicos_osabi_sniffer (bfd *abfd)
{
char *target_name = bfd_get_target (abfd);
/* On amd64-DICOS, the Load Module's "header" section is 72
bytes. */
if (strcmp (target_name, "elf64-x86-64") == 0
&& dicos_load_module_p (abfd, 72))
return GDB_OSABI_DICOS;
return GDB_OSABI_UNKNOWN;
}
static const char *
default_gcore_target (void)
{
/* The gdbarch may define a target to use for core files. */
if (gdbarch_gcore_bfd_target_p (target_gdbarch ()))
return gdbarch_gcore_bfd_target (target_gdbarch ());
/* Otherwise, try to fall back to the exec_bfd target. This will probably
not work for non-ELF targets. */
if (exec_bfd == NULL)
return NULL;
else
return bfd_get_target (exec_bfd);
}
void showStats()
{
(void)printf("Filename: %s\n\n", bfd_get_filename(abfd));
(void)printf("File's target: %s\n", bfd_get_target(abfd));
(void)printf("File's endianess: ");
if (bfd_little_endian(abfd)) (void)printf("little endian\n");
else (void)printf("big endian\n");
(void)printf("Bits per byte on file's arch: %u bits\n",
bfd_arch_bits_per_byte(abfd));
(void)printf("Bits per address on file's arch: %u bits\n\n",
bfd_arch_bits_per_address(abfd));
(void)printf("Start address: %p\n",
(void *)bfd_get_start_address(abfd));
}
static enum gdb_osabi
i386_cygwin_osabi_sniffer (bfd *abfd)
{
char *target_name = bfd_get_target (abfd);
if (strcmp (target_name, "pei-i386") == 0)
return GDB_OSABI_CYGWIN;
/* Cygwin uses elf core dumps. Do not claim all ELF executables,
check whether there is a .reg section of proper size. */
if (strcmp (target_name, "elf32-i386") == 0)
{
asection *section = bfd_get_section_by_name (abfd, ".reg");
if (section
&& bfd_section_size (abfd, section) == I386_WINDOWS_SIZEOF_GREGSET)
return GDB_OSABI_CYGWIN;
}
return GDB_OSABI_UNKNOWN;
}
void
print_section_info (struct target_ops *t, bfd *abfd)
{
struct section_table *p;
/* FIXME: "016l" is not wide enough when TARGET_ADDR_BIT > 64. */
char *fmt = TARGET_ADDR_BIT <= 32 ? "08l" : "016l";
printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
wrap_here (" ");
printf_filtered ("file type %s.\n", bfd_get_target (abfd));
if (abfd == exec_bfd)
{
printf_filtered ("\tEntry point: ");
print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
printf_filtered ("\n");
}
for (p = t->to_sections; p < t->to_sections_end; p++)
{
printf_filtered ("\t%s", local_hex_string_custom (p->addr, fmt));
printf_filtered (" - %s", local_hex_string_custom (p->endaddr, fmt));
/* FIXME: A format of "08l" is not wide enough for file offsets
larger than 4GB. OTOH, making it "016l" isn't desirable either
since most output will then be much wider than necessary. It
may make sense to test the size of the file and choose the
format string accordingly. */
if (info_verbose)
printf_filtered (" @ %s",
local_hex_string_custom (p->the_bfd_section->filepos, "08l"));
printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
if (p->bfd != abfd)
{
printf_filtered (" in %s", bfd_get_filename (p->bfd));
}
printf_filtered ("\n");
}
}
void
ldctor_build_sets (void)
{
static bfd_boolean called;
bfd_boolean header_printed;
struct set_info *p;
/* The emulation code may call us directly, but we only want to do
this once. */
if (called)
return;
called = TRUE;
if (constructors_sorted)
{
for (p = sets; p != NULL; p = p->next)
{
int c, i;
struct set_element *e;
struct set_element **array;
if (p->elements == NULL)
continue;
c = 0;
for (e = p->elements; e != NULL; e = e->next)
++c;
array = xmalloc (c * sizeof *array);
i = 0;
for (e = p->elements; e != NULL; e = e->next)
{
array[i] = e;
++i;
}
qsort (array, c, sizeof *array, ctor_cmp);
e = array[0];
p->elements = e;
for (i = 0; i < c - 1; i++)
array[i]->next = array[i + 1];
array[i]->next = NULL;
free (array);
}
}
lang_list_init (&constructor_list);
push_stat_ptr (&constructor_list);
header_printed = FALSE;
for (p = sets; p != NULL; p = p->next)
{
struct set_element *e;
reloc_howto_type *howto;
int reloc_size, size;
/* If the symbol is defined, we may have been invoked from
collect, and the sets may already have been built, so we do
not do anything. */
if (p->h->type == bfd_link_hash_defined
|| p->h->type == bfd_link_hash_defweak)
continue;
/* For each set we build:
set:
.long number_of_elements
.long element0
...
.long elementN
.long 0
except that we use the right size instead of .long. When
generating relocatable output, we generate relocs instead of
addresses. */
howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
if (howto == NULL)
{
if (link_info.relocatable)
{
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
bfd_get_target (link_info.output_bfd),
bfd_get_reloc_code_name (p->reloc),
p->h->root.string);
continue;
}
/* If this is not a relocatable link, all we need is the
size, which we can get from the input BFD. */
if (p->elements->section->owner != NULL)
howto = bfd_reloc_type_lookup (p->elements->section->owner,
p->reloc);
if (howto == NULL)
{
einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
bfd_get_target (p->elements->section->owner),
bfd_get_reloc_code_name (p->reloc),
p->h->root.string);
continue;
}
}
reloc_size = bfd_get_reloc_size (howto);
switch (reloc_size)
{
case 1: size = BYTE; break;
case 2: size = SHORT; break;
case 4: size = LONG; break;
case 8:
if (howto->complain_on_overflow == complain_overflow_signed)
size = SQUAD;
else
size = QUAD;
break;
default:
einfo (_("%P%X: Unsupported size %d for set %s\n"),
bfd_get_reloc_size (howto), p->h->root.string);
size = LONG;
break;
}
lang_add_assignment (exp_assop ('=', ".",
exp_unop (ALIGN_K,
exp_intop (reloc_size))));
lang_add_assignment (exp_assop ('=', p->h->root.string,
exp_nameop (NAME, ".")));
lang_add_data (size, exp_intop (p->count));
for (e = p->elements; e != NULL; e = e->next)
{
if (config.map_file != NULL)
{
int len;
if (! header_printed)
{
minfo (_("\nSet Symbol\n\n"));
header_printed = TRUE;
}
minfo ("%s", p->h->root.string);
len = strlen (p->h->root.string);
if (len >= 19)
{
print_nl ();
len = 0;
}
while (len < 20)
{
print_space ();
++len;
}
if (e->name != NULL)
minfo ("%T\n", e->name);
else
minfo ("%G\n", e->section->owner, e->section, e->value);
}
/* Need SEC_KEEP for --gc-sections. */
if (! bfd_is_abs_section (e->section))
e->section->flags |= SEC_KEEP;
if (link_info.relocatable)
lang_add_reloc (p->reloc, howto, e->section, e->name,
exp_intop (e->value));
else
lang_add_data (size, exp_relop (e->section, e->value));
}
lang_add_data (size, exp_intop (0));
}
pop_stat_ptr ();
}
void
m32c_load (bfd * prog)
{
asection *s;
unsigned long mach = bfd_get_mach (prog);
unsigned long highest_addr_loaded = 0;
if (mach == 0 && default_machine != 0)
mach = default_machine;
m32c_set_mach (mach);
for (s = prog->sections; s; s = s->next)
{
#if 0
/* This was a good idea until we started storing the RAM data in
ROM, at which point everything was all messed up. The code
remains as a reminder. */
if ((s->flags & SEC_ALLOC) && !(s->flags & SEC_READONLY))
{
if (strcmp (bfd_get_section_name (prog, s), ".stack"))
{
int secend =
bfd_get_section_size (s) + bfd_section_lma (prog, s);
if (heaptop < secend && bfd_section_lma (prog, s) < 0x10000)
{
heaptop = heapbottom = secend;
}
}
}
#endif
if (s->flags & SEC_LOAD)
{
char *buf;
bfd_size_type size;
size = bfd_get_section_size (s);
if (size <= 0)
continue;
bfd_vma base = bfd_section_lma (prog, s);
if (verbose)
fprintf (stderr, "[load a=%08x s=%08x %s]\n",
(int) base, (int) size, bfd_get_section_name (prog, s));
buf = (char *) malloc (size);
bfd_get_section_contents (prog, s, buf, 0, size);
mem_put_blk (base, buf, size);
free (buf);
if (highest_addr_loaded < base + size - 1 && size >= 4)
highest_addr_loaded = base + size - 1;
}
}
if (strcmp (bfd_get_target (prog), "srec") == 0)
{
heaptop = heapbottom = 0;
switch (mach)
{
case bfd_mach_m16c:
if (highest_addr_loaded > 0x10000)
regs.r_pc = mem_get_si (0x000ffffc) & membus_mask;
else
regs.r_pc = mem_get_si (0x000fffc) & membus_mask;
break;
case bfd_mach_m32c:
regs.r_pc = mem_get_si (0x00fffffc) & membus_mask;
break;
}
}
else
regs.r_pc = prog->start_address;
if (verbose)
fprintf (stderr, "[start pc=%08x]\n", (unsigned int) regs.r_pc);
}
void
rl78_load (bfd *prog, host_callback *callbacks, const char * const simname)
{
Elf_Internal_Phdr * phdrs;
long sizeof_phdrs;
int num_headers;
int i;
int max_rom = 0;
init_cpu ();
/* Note we load by ELF program header not by BFD sections.
This is because BFD sections get their information from
the ELF section structure, which only includes a VMA value
and not an LMA value. */
sizeof_phdrs = bfd_get_elf_phdr_upper_bound (prog);
if (sizeof_phdrs == 0)
{
fprintf (stderr, "%s: Failed to get size of program headers\n", simname);
return;
}
phdrs = xmalloc (sizeof_phdrs);
num_headers = bfd_get_elf_phdrs (prog, phdrs);
if (num_headers < 1)
{
fprintf (stderr, "%s: Failed to read program headers\n", simname);
return;
}
for (i = 0; i < num_headers; i++)
{
Elf_Internal_Phdr * p = phdrs + i;
char *buf;
bfd_vma size;
bfd_vma base;
file_ptr offset;
size = p->p_filesz;
if (size <= 0)
continue;
base = p->p_paddr;
if (verbose > 1)
fprintf (stderr, "[load segment: lma=%08x vma=%08x size=%08x]\n",
(int) base, (int) p->p_vaddr, (int) size);
if (callbacks)
xprintf (callbacks,
"Loading section %s, size %#lx lma %08lx vma %08lx\n",
find_section_name_by_offset (prog, p->p_offset),
size, base, p->p_vaddr);
buf = xmalloc (size);
offset = p->p_offset;
if (prog->iovec->bseek (prog, offset, SEEK_SET) != 0)
{
fprintf (stderr, "%s, Failed to seek to offset %lx\n", simname, (long) offset);
continue;
}
if (prog->iovec->bread (prog, buf, size) != size)
{
fprintf (stderr, "%s: Failed to read %lx bytes\n", simname, size);
continue;
}
if (base > 0xeffff || base + size > 0xeffff)
{
fprintf (stderr, "%s, Can't load image to RAM/SFR space: 0x%lx - 0x%lx\n",
simname, base, base+size);
continue;
}
if (max_rom < base + size)
max_rom = base + size;
mem_put_blk (base, buf, size);
free (buf);
}
free (phdrs);
mem_rom_size (max_rom);
pc = prog->start_address;
if (strcmp (bfd_get_target (prog), "srec") == 0
|| pc == 0)
{
pc = mem_get_hi (0);
}
if (verbose > 1)
fprintf (stderr, "[start pc=%08x]\n", (unsigned int) pc);
}
static bfd_boolean
gldelf64ltsmip_try_needed (const char *name, int force)
{
bfd *abfd;
const char *soname;
abfd = bfd_openr (name, bfd_get_target (output_bfd));
if (abfd == NULL)
return FALSE;
if (! bfd_check_format (abfd, bfd_object))
{
bfd_close (abfd);
return FALSE;
}
if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
{
bfd_close (abfd);
return FALSE;
}
/* For DT_NEEDED, they have to match. */
if (abfd->xvec != output_bfd->xvec)
{
bfd_close (abfd);
return FALSE;
}
/* Check whether this object would include any conflicting library
versions. If FORCE is set, then we skip this check; we use this
the second time around, if we couldn't find any compatible
instance of the shared library. */
if (! force)
{
struct bfd_link_needed_list *needed;
if (! bfd_elf_get_bfd_needed_list (abfd, &needed))
einfo ("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n", abfd);
if (needed != NULL)
{
global_vercheck_needed = needed;
global_vercheck_failed = FALSE;
lang_for_each_input_file (gldelf64ltsmip_vercheck);
if (global_vercheck_failed)
{
bfd_close (abfd);
/* Return FALSE to force the caller to move on to try
another file on the search path. */
return FALSE;
}
/* But wait! It gets much worse. On Linux, if a shared
library does not use libc at all, we are supposed to skip
it the first time around in case we encounter a shared
library later on with the same name which does use the
version of libc that we want. This is much too horrible
to use on any system other than Linux. */
{
struct bfd_link_needed_list *l;
for (l = needed; l != NULL; l = l->next)
if (strncmp (l->name, "libc.so", 7) == 0)
break;
if (l == NULL)
{
bfd_close (abfd);
return FALSE;
}
}
}
}
/* We've found a dynamic object matching the DT_NEEDED entry. */
/* We have already checked that there is no other input file of the
same name. We must now check again that we are not including the
same file twice. We need to do this because on many systems
libc.so is a symlink to, e.g., libc.so.1. The SONAME entry will
reference libc.so.1. If we have already included libc.so, we
don't want to include libc.so.1 if they are the same file, and we
can only check that using stat. */
if (bfd_stat (abfd, &global_stat) != 0)
einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
/* First strip off everything before the last '/'. */
soname = lbasename (abfd->filename);
if (trace_file_tries)
info_msg (_("found %s at %s\n"), soname, name);
global_found = FALSE;
lang_for_each_input_file (gldelf64ltsmip_stat_needed);
if (global_found)
{
/* Return TRUE to indicate that we found the file, even though
we aren't going to do anything with it. */
return TRUE;
}
/* Tell the ELF backend that we don't want the output file to have a
DT_NEEDED entry for this file. */
bfd_elf_set_dt_needed_name (abfd, "");
/* Tell the ELF backend that the output file needs a DT_NEEDED
entry for this file if it is used to resolve the reference in
a regular object. */
bfd_elf_set_dt_needed_soname (abfd, soname);
/* Add this file into the symbol table. */
if (! bfd_link_add_symbols (abfd, &link_info))
einfo ("%F%B: could not read symbols: %E\n", abfd);
return TRUE;
}
void
rx_load (bfd *prog)
{
unsigned long highest_addr_loaded = 0;
Elf_Internal_Phdr * phdrs;
long sizeof_phdrs;
int num_headers;
int i;
rx_big_endian = bfd_big_endian (prog);
/* Note we load by ELF program header not by BFD sections.
This is because BFD sections get their information from
the ELF section structure, which only includes a VMA value
and not an LMA value. */
sizeof_phdrs = bfd_get_elf_phdr_upper_bound (prog);
if (sizeof_phdrs == 0)
{
fprintf (stderr, "Failed to get size of program headers\n");
return;
}
phdrs = malloc (sizeof_phdrs);
if (phdrs == NULL)
{
fprintf (stderr, "Failed allocate memory to hold program headers\n");
return;
}
num_headers = bfd_get_elf_phdrs (prog, phdrs);
if (num_headers < 1)
{
fprintf (stderr, "Failed to read program headers\n");
return;
}
for (i = 0; i < num_headers; i++)
{
Elf_Internal_Phdr * p = phdrs + i;
char *buf;
bfd_vma size;
bfd_vma base;
file_ptr offset;
size = p->p_filesz;
if (size <= 0)
continue;
base = p->p_paddr;
if (verbose > 1)
fprintf (stderr, "[load segment: lma=%08x vma=%08x size=%08x]\n",
(int) base, (int) p->p_vaddr, (int) size);
buf = malloc (size);
if (buf == NULL)
{
fprintf (stderr, "Failed to allocate buffer to hold program segment\n");
continue;
}
offset = p->p_offset;
if (prog->iovec->bseek (prog, offset, SEEK_SET) != 0)
{
fprintf (stderr, "Failed to seek to offset %lx\n", (long) offset);
continue;
}
if (prog->iovec->bread (prog, buf, size) != size)
{
fprintf (stderr, "Failed to read %lx bytes\n", size);
continue;
}
mem_put_blk (base, buf, size);
free (buf);
if (highest_addr_loaded < base + size - 1 && size >= 4)
highest_addr_loaded = base + size - 1;
}
free (phdrs);
regs.r_pc = prog->start_address;
if (strcmp (bfd_get_target (prog), "srec") == 0
|| regs.r_pc == 0)
{
regs.r_pc = mem_get_si (0xfffffffc);
heaptop = heapbottom = 0;
}
if (verbose > 1)
fprintf (stderr, "[start pc=%08x %s]\n",
(unsigned int) regs.r_pc,
rx_big_endian ? "BE" : "LE");
}
main (int argc, char **argv) {
bfd *ibfd, *obfd;
asection *p;
static asymbol **osympp, **delsympp;
long symsize, symcount, delsymcount;
int i;
int c;
int idx;
struct add_reloc_struct *new_reloc;
struct change_reloc_struct *new_change;
struct delete_reloc_struct *new_delete;
struct modify_byte_struct *new_modify;
struct globalize_sym_struct *new_globalize;
while ((c = getopt (argc, argv, "a:d:c:m:G:")) != -1) {
switch (c) {
case 'a':
/* check to see if we have two args: name and loc */
if ((index(optarg, ',') == NULL) ||
(index(optarg, ',') != rindex(optarg, ','))) {
fprintf(stderr, "usage: -a argument should be <symbolname>,<location>, not \"%s\"\n", optarg);
exit(1);
}
/* record the add reloc command in the global array */
new_reloc = (add_reloc_struct *)malloc(sizeof(add_reloc_struct));
new_reloc->symbol_name = strndup(optarg, (index(optarg, ',') - optarg));
new_reloc->loc = strtol(index(optarg, ',') + 1, NULL, 0);
if (errno == EINVAL) {
fprintf(stderr, "the value %s is not a valid location for the add command\n", index(optarg, ',') + 1);
exit(1);
}
new_reloc->next = additional_relocs;
additional_relocs = new_reloc;
break;
case 'c':
/* check to see if we have two args */
if ((index(optarg, ',') == NULL) ||
(index(optarg, ',') != rindex(optarg, ','))) {
fprintf(stderr, "usage: -c argument should be <symbolname>,<symbolname>, not \"%s\"\n", optarg);
exit(1);
}
new_change = (change_reloc_struct *)malloc(sizeof(change_reloc_struct));
new_change->old_symbol_name = strndup(optarg, strlen(optarg) - strlen(index(optarg, ',')));
new_change->new_symbol_name = strdup(index(optarg, ',') + 1);
new_change->next = change_relocs;
change_relocs = new_change;
break;
case 'd':
new_delete = (delete_reloc_struct *)malloc(sizeof(delete_reloc_struct));
new_delete->symbol_name = strdup(optarg);
new_delete->next = delete_relocs;
delete_relocs = new_delete;
break;
case 'm':
if ((index(optarg, '=') == NULL) ||
(index(optarg, '=') != rindex(optarg, '='))) {
fprintf(stderr, "usage: -m argument should be <location>=<value>, not \"%s\"\n", optarg);
exit(1);
}
new_modify = (modify_byte_struct *)malloc(sizeof(modify_byte_struct));
new_modify->location = strtol(optarg, NULL, 0);
new_modify->value = strtol(index(optarg, '=') + 1, NULL, 0);
if (new_modify->value > 0xff) {
fprintf(stderr, "requested modify value %lx for location %lx exceeds 0xff\n",
new_modify->value, new_modify->location);
exit(1);
}
new_modify->next = modify_bytes;
modify_bytes = new_modify;
break;
case 'G':
new_globalize = (globalize_sym_struct *)malloc(sizeof(globalize_sym_struct));
new_globalize->symbol_name = strdup(optarg);
new_globalize->next = globalize_syms;
globalize_syms = new_globalize;
break;
default:
fprintf(stderr, "unrecognized argument character |%c|\n", c);
}
}
if ((argc - optind) != 2) {
fprintf(stderr, "usage: fixup_relocs [-a newsymbol,location] [-c oldsymbol,newsymbol] [-d symbol] infile.o outfile.o\n");
exit(1);
}
ibfd = bfd_openr(argv[optind], NULL);
if (ibfd == NULL) {
bfd_perror("while opening input object file");
exit(1);
}
/* if I don't do "check_format", there's no data in the bfd object. wtf? */
if (!bfd_check_format(ibfd, bfd_object)) {
fprintf(stderr, "input file %s seems to NOT be an object file! exiting.\n", argv[optind]);
exit(1);
}
obfd = bfd_openw(argv[optind+1], bfd_get_target(ibfd));
if (obfd == NULL) {
bfd_perror("while opening output object file");
exit(1);
}
if (!bfd_set_format(obfd, bfd_get_format(ibfd))) {
bfd_perror("while setting output object file format");
}
/* copy a bunch of necessary global stuff */
bfd_set_start_address(obfd, bfd_get_start_address(ibfd));
bfd_set_file_flags(obfd, bfd_get_file_flags(ibfd));
bfd_set_arch_mach(obfd, bfd_get_arch(ibfd), bfd_get_mach(ibfd));
/* BOZO objcopy sets format again at this point. why? */
bfd_map_over_sections (ibfd, setup_section, obfd);
setup_bfd_headers (ibfd, obfd);
/* Symbol filtering must happen after the output sections
have been created, but before their contents are set. */
symsize = bfd_get_symtab_upper_bound (ibfd);
if (symsize < 0) {
fprintf(stderr, "problem processing %s\n", bfd_get_filename (ibfd));
return FALSE;
}
/* count the added relocations so we can put extra space in the output symbol table for them */
int reloc_add_cnt, reloc_delete_cnt;
reloc_add_cnt = 0;
reloc_delete_cnt = 0;
for (new_reloc = additional_relocs; new_reloc != NULL; new_reloc = new_reloc->next) {
reloc_add_cnt++;
}
/* the "change" symbols might also not be in the symbol table yet */
for (new_change = change_relocs; new_change != NULL; new_change = new_change->next) {
reloc_add_cnt++;
/* the old symbol may be deleted, also */
reloc_delete_cnt++;
}
for (new_delete = delete_relocs; new_delete != NULL; new_delete = new_delete->next) {
reloc_delete_cnt++;
}
/* filter symbol table in two steps: */
/* 1) move symbols bound for deletion to the end of the output symbol table array */
/* 2) truncate the table at the first of those */
/* this makes it possible to do the reloc processing with the symbol table intact, */
/* and remove the deleted symbols afterwards, without corrupting the reloc data structures */
isympp = malloc (symsize);
osympp = malloc (symsize + reloc_add_cnt * sizeof(asymbol *));
delsympp = malloc (reloc_delete_cnt * sizeof(asymbol *));
symcount = bfd_canonicalize_symtab (ibfd, isympp);
if (symcount < 0) {
fprintf(stderr, "problem processing %s\n", bfd_get_filename (ibfd));
return FALSE;
}
/* remove any undefined symbols whose relocation entries were deleted or changed */
int osym_idx, delsym_idx;
osym_idx = delsym_idx = 0;
delsymcount = 0;
for (i = 0; i < symcount; i++) {
if ((is_delete_reloc(bfd_asymbol_name(isympp[i]), delete_relocs) ||
(find_change_reloc(bfd_asymbol_name(isympp[i]), change_relocs) != NULL)) &&
(isympp[i]->section != NULL) &&
(strcmp(isympp[i]->section->name, BFD_UND_SECTION_NAME) == 0)) {
delsympp[delsym_idx++] = isympp[i];
}
else {
if (is_globalize_sym(bfd_asymbol_name(isympp[i]), globalize_syms)) {
isympp[i]->flags = BSF_GLOBAL;
}
osympp[osym_idx++] = isympp[i];
}
}
symcount = osym_idx;
delsymcount = delsym_idx;
osympp[symcount] = NULL;
/* add the symbols for additional relocs to the table */
int added_symbol_cnt = 0;
for (new_reloc = additional_relocs; new_reloc != NULL; new_reloc = new_reloc->next) {
if (find_symbol(osympp, new_reloc->symbol_name) < 0) {
/* not yet present, so add it */
asymbol *new_sym;
new_sym = bfd_make_empty_symbol(obfd);
new_sym->name = strdup(new_reloc->symbol_name);
new_sym->section = bfd_get_section_by_name (obfd, ".text");
new_sym->value = new_reloc->loc;
new_sym->flags = BSF_GLOBAL;
osympp[symcount + added_symbol_cnt++] = new_sym;
osympp[symcount + added_symbol_cnt] = NULL;
}
}
/* do the same for changed relocs */
for (new_change = change_relocs; new_change != NULL; new_change = new_change->next) {
if (find_symbol(osympp, new_change->new_symbol_name) < 0) {
/* not yet present, so add it */
/* since this is a name change, we will reuse the existing address (value field of reloc) */
int old_symbol_idx;
if ((old_symbol_idx = find_symbol(isympp, new_change->old_symbol_name)) < 0) {
fprintf(stderr, "change command old symbol name %s not found in symbol table! Exiting.\n", new_change->old_symbol_name);
exit(1);
}
asymbol *new_sym;
new_sym = bfd_make_empty_symbol(obfd);
new_sym->name = strdup(new_change->new_symbol_name);
new_sym->section = bfd_und_section_ptr;
new_sym->value = isympp[old_symbol_idx]->value;
new_sym->flags = BSF_GLOBAL;
fprintf(stderr, "adding new symbol %s for change reloc command\n", new_sym->name);
osympp[symcount + added_symbol_cnt++] = new_sym;
osympp[symcount + added_symbol_cnt] = NULL;
}
}
/* append the soon-to-be deleted symbols to the end of the output symbol table */
for (i = 0; i < delsymcount; i++) {
osympp[symcount + added_symbol_cnt + i] = delsympp[i];
}
osympp[symcount + added_symbol_cnt + delsymcount] = NULL;
bfd_set_symtab (obfd, osympp, symcount + added_symbol_cnt + delsymcount);
/* This has to happen after the symbol table has been set. */
bfd_map_over_sections (ibfd, copy_section_relocs_edit, obfd);
/* now truncate the symbol table to eliminate the deleted symbols */
osympp[symcount + added_symbol_cnt] = NULL;
bfd_set_symtab (obfd, osympp, symcount + added_symbol_cnt);
/* now that we've set the relocs and cleaned the symtab, can call this */
bfd_map_over_sections (ibfd, copy_section_data, obfd);
bfd_close(obfd);
bfd_close(ibfd);
return 0;
}
void replace_hello(const char *input_path, const char *output_path)
{
bfd_init();
bfd *ibfd = bfd_openr(input_path, NULL);
if (ibfd == NULL)
errx(1, bfd_errmsg(bfd_get_error()));
if (!bfd_check_format(ibfd, bfd_object)) {
bfd_close_all_done(ibfd);
errx(1, "Input file is not a valid object file.");
}
bfd *obfd = bfd_openw(output_path, bfd_get_target(ibfd));
if (obfd == NULL) {
bfd_close_all_done(ibfd);
errx(1, bfd_errmsg(bfd_get_error()));
}
if (!bfd_set_format(obfd, bfd_get_format(ibfd))) {
bfd_close_all_done(ibfd);
bfd_close_all_done(obfd);
errx(1, "Setting obfd format failed: %s\n", bfd_errmsg(bfd_get_error()));
}
bfd_set_arch_info(obfd, bfd_get_arch_info(ibfd));
// Create sections for .data
asection *section = bfd_get_section_by_name(ibfd, ".data");
while (section != NULL) {
if (section->flags & SEC_HAS_CONTENTS) {
char *section_contents = (char *)malloc(section->size);
bfd_get_section_contents(ibfd, section, section_contents, 0, section->size);
char *hello_pos = (char *)memmem(section_contents, section->size, "hello", 5);
if (hello_pos != NULL) {
if (bfd_make_section_anyway_with_flags(obfd, ".data", section->flags) == NULL) {
free(section_contents);
bfd_close_all_done(ibfd);
bfd_close_all_done(obfd);
errx(1, bfd_errmsg(bfd_get_error()));
}
}
free(section_contents);
}
section = bfd_get_next_section_by_name(ibfd, section);
}
asection *comment_section = bfd_make_section_anyway_with_flags(obfd, ".comment.my_objcopy", SEC_HAS_CONTENTS);
if (comment_section == NULL) {
bfd_close_all_done(ibfd);
bfd_close_all_done(obfd);
errx(1, bfd_errmsg(bfd_get_error()));
}
if (!bfd_set_section_size(obfd, comment_section, 3)) {
bfd_close_all_done(ibfd);
bfd_close_all_done(obfd);
errx(1, bfd_errmsg(bfd_get_error()));
}
if (!bfd_set_section_contents(obfd, comment_section, "moo", 0, 3)) {
bfd_close_all_done(ibfd);
bfd_close_all_done(obfd);
errx(1, bfd_errmsg(bfd_get_error()));
}
// section = bfd_get_section_by_name(ibfd, ".data");
// asection *osection = bfd_get_section_by_name(obfd, ".data");
// if (osection == NULL) {
// bfd_close_all_done(ibfd);
// bfd_close_all_done(obfd);
// errx(1, bfd_errmsg(bfd_get_error()));
// }
// while (section != NULL) {
// if (section->flags & SEC_HAS_CONTENTS) {
// char *section_contents = (char *)malloc(section->size);
// bfd_get_section_contents(ibfd, section, section_contents, 0, section->size);
//
// char *hello_pos = (char *)memmem(section_contents, section->size, "hello", 5);
// if (hello_pos != NULL) {
// hello_pos[1] = 'o';
// hello_pos[4] = 'a';
// if (bfd_set_section_contents(obfd, osection, section_contents, 0, section->size)) {
// free(section_contents);
// bfd_close_all_done(ibfd);
// bfd_close_all_done(obfd);
// errx(1, bfd_errmsg(bfd_get_error()));
// }
// }
//
// free(section_contents);
// osection = bfd_get_next_section_by_name(obfd, osection);
// }
//
// section = bfd_get_next_section_by_name(ibfd, section);
// }
if (!bfd_close(obfd))
errx(1, "Closing obfd failed: %s\n", bfd_errmsg(bfd_get_error()));
if (!bfd_close(ibfd))
errx(1, "Closing ibfd failed: %s\n", bfd_errmsg(bfd_get_error()));
}
void
read_pe_exported_syms (minimal_symbol_reader &reader,
struct objfile *objfile)
{
bfd *dll = objfile->obfd;
unsigned long nbnormal, nbforward;
unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
unsigned long export_opthdrrva, export_opthdrsize;
unsigned long export_rva, export_size, nsections, secptr, expptr;
unsigned long exp_funcbase;
unsigned char *expdata, *erva;
unsigned long name_rvas, ordinals, nexp, ordbase;
char *dll_name = (char *) dll->filename;
int otherix = PE_SECTION_TABLE_SIZE;
int is_pe64 = 0;
int is_pe32 = 0;
/* Array elements are for text, data and bss in that order
Initialization with RVA_START > RVA_END guarantees that
unused sections won't be matched. */
struct read_pe_section_data *section_data;
struct pe_sections_info pe_sections_info;
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
char const *target = bfd_get_target (objfile->obfd);
section_data = XCNEWVEC (struct read_pe_section_data, PE_SECTION_TABLE_SIZE);
make_cleanup (free_current_contents, §ion_data);
for (i=0; i < PE_SECTION_TABLE_SIZE; i++)
{
section_data[i].vma_offset = 0;
section_data[i].rva_start = 1;
section_data[i].rva_end = 0;
};
section_data[PE_SECTION_INDEX_TEXT].ms_type = mst_text;
section_data[PE_SECTION_INDEX_TEXT].section_name = ".text";
section_data[PE_SECTION_INDEX_DATA].ms_type = mst_data;
section_data[PE_SECTION_INDEX_DATA].section_name = ".data";
section_data[PE_SECTION_INDEX_BSS].ms_type = mst_bss;
section_data[PE_SECTION_INDEX_BSS].section_name = ".bss";
is_pe64 = (strcmp (target, "pe-x86-64") == 0
|| strcmp (target, "pei-x86-64") == 0);
is_pe32 = (strcmp (target, "pe-i386") == 0
|| strcmp (target, "pei-i386") == 0
|| strcmp (target, "pe-arm-wince-little") == 0
|| strcmp (target, "pei-arm-wince-little") == 0);
if (!is_pe32 && !is_pe64)
{
/* This is not a recognized PE format file. Abort now, because
the code is untested on anything else. *FIXME* test on
further architectures and loosen or remove this test. */
do_cleanups (back_to);
return;
}
/* Get pe_header, optional header and numbers of export entries. */
pe_header_offset = pe_get32 (dll, 0x3c);
opthdr_ofs = pe_header_offset + 4 + 20;
if (is_pe64)
num_entries = pe_get32 (dll, opthdr_ofs + 108);
else
num_entries = pe_get32 (dll, opthdr_ofs + 92);
if (num_entries < 1) /* No exports. */
{
do_cleanups (back_to);
return;
}
if (is_pe64)
{
export_opthdrrva = pe_get32 (dll, opthdr_ofs + 112);
export_opthdrsize = pe_get32 (dll, opthdr_ofs + 116);
}
else
{
export_opthdrrva = pe_get32 (dll, opthdr_ofs + 96);
export_opthdrsize = pe_get32 (dll, opthdr_ofs + 100);
}
nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
secptr = (pe_header_offset + 4 + 20 +
pe_get16 (dll, pe_header_offset + 4 + 16));
expptr = 0;
export_size = 0;
/* Get the rva and size of the export section. */
for (i = 0; i < nsections; i++)
{
char sname[8];
unsigned long secptr1 = secptr + 40 * i;
unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
unsigned long vsize = pe_get32 (dll, secptr1 + 16);
unsigned long fptr = pe_get32 (dll, secptr1 + 20);
bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
bfd_bread (sname, (bfd_size_type) sizeof (sname), dll);
if ((strcmp (sname, ".edata") == 0)
|| (vaddr <= export_opthdrrva && export_opthdrrva < vaddr + vsize))
{
if (strcmp (sname, ".edata") != 0)
{
if (debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("Export RVA for dll "
"\"%s\" is in section \"%s\"\n"),
dll_name, sname);
}
else if (export_opthdrrva != vaddr && debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("Wrong value of export RVA"
" for dll \"%s\": 0x%lx instead of 0x%lx\n"),
dll_name, export_opthdrrva, vaddr);
expptr = fptr + (export_opthdrrva - vaddr);
break;
}
}
export_rva = export_opthdrrva;
export_size = export_opthdrsize;
if (export_size == 0)
{
/* Empty export table. */
do_cleanups (back_to);
return;
}
/* Scan sections and store the base and size of the relevant
sections. */
for (i = 0; i < nsections; i++)
{
unsigned long secptr1 = secptr + 40 * i;
unsigned long vsize = pe_get32 (dll, secptr1 + 8);
unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
unsigned long characteristics = pe_get32 (dll, secptr1 + 36);
char sec_name[SCNNMLEN + 1];
int sectix;
unsigned int bfd_section_index;
asection *section;
bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
bfd_bread (sec_name, (bfd_size_type) SCNNMLEN, dll);
sec_name[SCNNMLEN] = '\0';
sectix = read_pe_section_index (sec_name);
section = bfd_get_section_by_name (dll, sec_name);
if (section)
bfd_section_index = section->index;
else
bfd_section_index = -1;
if (sectix != PE_SECTION_INDEX_INVALID)
{
section_data[sectix].rva_start = vaddr;
section_data[sectix].rva_end = vaddr + vsize;
section_data[sectix].index = bfd_section_index;
}
else
{
char *name;
section_data = XRESIZEVEC (struct read_pe_section_data, section_data,
otherix + 1);
name = xstrdup (sec_name);
section_data[otherix].section_name = name;
make_cleanup (xfree, name);
section_data[otherix].rva_start = vaddr;
section_data[otherix].rva_end = vaddr + vsize;
section_data[otherix].vma_offset = 0;
section_data[otherix].index = bfd_section_index;
if (characteristics & IMAGE_SCN_CNT_CODE)
section_data[otherix].ms_type = mst_text;
else if (characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
section_data[otherix].ms_type = mst_data;
else if (characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
section_data[otherix].ms_type = mst_bss;
else
section_data[otherix].ms_type = mst_unknown;
otherix++;
}
}
expdata = (unsigned char *) xmalloc (export_size);
make_cleanup (xfree, expdata);
bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
bfd_bread (expdata, (bfd_size_type) export_size, dll);
erva = expdata - export_rva;
nexp = pe_as32 (expdata + 24);
name_rvas = pe_as32 (expdata + 32);
ordinals = pe_as32 (expdata + 36);
ordbase = pe_as32 (expdata + 16);
exp_funcbase = pe_as32 (expdata + 28);
/* Use internal dll name instead of full pathname. */
dll_name = (char *) (pe_as32 (expdata + 12) + erva);
pe_sections_info.nb_sections = otherix;
pe_sections_info.sections = section_data;
bfd_map_over_sections (dll, get_section_vmas, &pe_sections_info);
/* Truncate name at first dot. Should maybe also convert to all
lower case for convenience on Windows. */
read_pe_truncate_name (dll_name);
if (debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("DLL \"%s\" has %ld export entries,"
" base=%ld\n"), dll_name, nexp, ordbase);
nbforward = 0;
nbnormal = 0;
/* Iterate through the list of symbols. */
for (i = 0; i < nexp; i++)
{
/* Pointer to the names vector. */
unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
/* Retrieve ordinal value. */
unsigned long ordinal = pe_as16 (erva + ordinals + i * 2);
/* Pointer to the function address vector. */
/* This is relatived to ordinal value. */
unsigned long func_rva = pe_as32 (erva + exp_funcbase +
ordinal * 4);
/* Find this symbol's section in our own array. */
int sectix = 0;
int section_found = 0;
/* First handle forward cases. */
if (func_rva >= export_rva && func_rva < export_rva + export_size)
{
char *forward_name = (char *) (erva + func_rva);
char *funcname = (char *) (erva + name_rva);
char *forward_dll_name = forward_name;
char *forward_func_name = forward_name;
char *sep = strrchr (forward_name, '.');
if (sep)
{
int len = (int) (sep - forward_name);
forward_dll_name = (char *) alloca (len + 1);
strncpy (forward_dll_name, forward_name, len);
forward_dll_name[len] = '\0';
forward_func_name = ++sep;
}
if (add_pe_forwarded_sym (reader, funcname, forward_dll_name,
forward_func_name, ordinal,
dll_name, objfile) != 0)
++nbforward;
continue;
}
for (sectix = 0; sectix < otherix; ++sectix)
{
if ((func_rva >= section_data[sectix].rva_start)
&& (func_rva < section_data[sectix].rva_end))
{
char *sym_name = (char *) (erva + name_rva);
section_found = 1;
add_pe_exported_sym (reader, sym_name, func_rva, ordinal,
section_data + sectix, dll_name, objfile);
++nbnormal;
break;
}
}
if (!section_found)
{
char *funcname = (char *) (erva + name_rva);
if (name_rva == 0)
{
add_pe_exported_sym (reader, NULL, func_rva, ordinal,
section_data, dll_name, objfile);
++nbnormal;
}
else if (debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("Export name \"%s\" ord. %lu,"
" RVA 0x%lx in dll \"%s\" not handled\n"),
funcname, ordinal, func_rva, dll_name);
}
}
if (debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("Finished reading \"%s\", exports %ld,"
" forwards %ld, total %ld/%ld.\n"), dll_name, nbnormal,
nbforward, nbnormal + nbforward, nexp);
/* Discard expdata and section_data. */
do_cleanups (back_to);
}
void
ldctor_add_set_entry (struct bfd_link_hash_entry *h,
bfd_reloc_code_real_type reloc,
const char *name,
asection *section,
bfd_vma value)
{
struct set_info *p;
struct set_element *e;
struct set_element **epp;
for (p = sets; p != NULL; p = p->next)
if (p->h == h)
break;
if (p == NULL)
{
p = xmalloc (sizeof (struct set_info));
p->next = sets;
sets = p;
p->h = h;
p->reloc = reloc;
p->count = 0;
p->elements = NULL;
}
else
{
if (p->reloc != reloc)
{
einfo (_("%P%X: Different relocs used in set %s\n"),
h->root.string);
return;
}
/* Don't permit a set to be constructed from different object
file formats. The same reloc may have different results. We
actually could sometimes handle this, but the case is
unlikely to ever arise. Sometimes constructor symbols are in
unusual sections, such as the absolute section--this appears
to be the case in Linux a.out--and in such cases we just
assume everything is OK. */
if (p->elements != NULL
&& section->owner != NULL
&& p->elements->section->owner != NULL
&& strcmp (bfd_get_target (section->owner),
bfd_get_target (p->elements->section->owner)) != 0)
{
einfo (_("%P%X: Different object file formats composing set %s\n"),
h->root.string);
return;
}
}
e = xmalloc (sizeof (struct set_element));
e->next = NULL;
e->name = name;
e->section = section;
e->value = value;
for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
;
*epp = e;
++p->count;
}
void
read_pe_exported_syms (struct objfile *objfile)
{
bfd *dll = objfile->obfd;
unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
unsigned long export_rva, export_size, nsections, secptr, expptr;
unsigned long exp_funcbase;
unsigned char *expdata, *erva;
unsigned long name_rvas, ordinals, nexp, ordbase;
char *dll_name;
/* Array elements are for text, data and bss in that order
Initialization with start_rva > end_rva guarantees that
unused sections won't be matched. */
struct read_pe_section_data section_data[PE_SECTION_TABLE_SIZE]
= { {0, 1, 0, mst_text},
{0, 1, 0, mst_data},
{0, 1, 0, mst_bss}
};
struct cleanup *back_to = 0;
char const *target = bfd_get_target (objfile->obfd);
if ((strcmp (target, "pe-i386") != 0) && (strcmp (target, "pei-i386") != 0))
{
/* This is not an i386 format file. Abort now, because the code
is untested on anything else. *FIXME* test on further
architectures and loosen or remove this test. */
return;
}
/* Get pe_header, optional header and numbers of export entries. */
pe_header_offset = pe_get32 (dll, 0x3c);
opthdr_ofs = pe_header_offset + 4 + 20;
num_entries = pe_get32 (dll, opthdr_ofs + 92);
if (num_entries < 1) /* No exports. */
{
return;
}
export_rva = pe_get32 (dll, opthdr_ofs + 96);
export_size = pe_get32 (dll, opthdr_ofs + 100);
nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
secptr = (pe_header_offset + 4 + 20 +
pe_get16 (dll, pe_header_offset + 4 + 16));
expptr = 0;
/* Get the rva and size of the export section. */
for (i = 0; i < nsections; i++)
{
char sname[8];
unsigned long secptr1 = secptr + 40 * i;
unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
unsigned long vsize = pe_get32 (dll, secptr1 + 16);
unsigned long fptr = pe_get32 (dll, secptr1 + 20);
bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
bfd_bread (sname, (bfd_size_type) 8, dll);
if (vaddr <= export_rva && vaddr + vsize > export_rva)
{
expptr = fptr + (export_rva - vaddr);
if (export_rva + export_size > vaddr + vsize)
export_size = vsize - (export_rva - vaddr);
break;
}
}
if (export_size == 0)
{
/* Empty export table. */
return;
}
/* Scan sections and store the base and size of the relevant sections. */
for (i = 0; i < nsections; i++)
{
unsigned long secptr1 = secptr + 40 * i;
unsigned long vsize = pe_get32 (dll, secptr1 + 8);
unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
unsigned long flags = pe_get32 (dll, secptr1 + 36);
char sec_name[9];
int sectix;
sec_name[8] = '\0';
bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
bfd_bread (sec_name, (bfd_size_type) 8, dll);
sectix = read_pe_section_index (sec_name);
if (sectix != PE_SECTION_INDEX_INVALID)
{
section_data[sectix].rva_start = vaddr;
section_data[sectix].rva_end = vaddr + vsize;
}
}
expdata = (unsigned char *) xmalloc (export_size);
back_to = make_cleanup (xfree, expdata);
bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
bfd_bread (expdata, (bfd_size_type) export_size, dll);
erva = expdata - export_rva;
nexp = pe_as32 (expdata + 24);
name_rvas = pe_as32 (expdata + 32);
ordinals = pe_as32 (expdata + 36);
ordbase = pe_as32 (expdata + 16);
exp_funcbase = pe_as32 (expdata + 28);
/* Use internal dll name instead of full pathname. */
dll_name = pe_as32 (expdata + 12) + erva;
bfd_map_over_sections (dll, get_section_vmas, section_data);
/* Adjust the vma_offsets in case this PE got relocated. This
assumes that *all* sections share the same relocation offset
as the text section. */
for (i = 0; i < PE_SECTION_TABLE_SIZE; i++)
{
section_data[i].vma_offset
+= ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
}
printf_filtered ("Minimal symbols from %s...", dll_name);
wrap_here ("");
/* Truncate name at first dot. Should maybe also convert to all
lower case for convenience on Windows. */
read_pe_truncate_name (dll_name);
/* Iterate through the list of symbols. */
for (i = 0; i < nexp; i++)
{
/* Pointer to the names vector. */
unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
/* Pointer to the function address vector. */
unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
/* Find this symbol's section in our own array. */
int sectix = 0;
for (sectix = 0; sectix < PE_SECTION_TABLE_SIZE; ++sectix)
{
if ((func_rva >= section_data[sectix].rva_start)
&& (func_rva < section_data[sectix].rva_end))
{
add_pe_exported_sym (erva + name_rva,
func_rva,
section_data + sectix, dll_name, objfile);
break;
}
}
}
/* discard expdata. */
do_cleanups (back_to);
}
