static void
bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
{
struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
struct vmap *vp;
vp = vmap_bfd->pvmap;
if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
return;
if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
{
vp->tstart = bfd_section_vma (abfd, sect);
vp->tend = vp->tstart + bfd_section_size (abfd, sect);
vp->tvma = bfd_section_vma (abfd, sect);
vp->toffs = sect->filepos;
}
else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
{
vp->dstart = bfd_section_vma (abfd, sect);
vp->dend = vp->dstart + bfd_section_size (abfd, sect);
vp->dvma = bfd_section_vma (abfd, sect);
}
/* Silently ignore other types of sections. (FIXME?) */
}
void
core_target::get_core_register_section (struct regcache *regcache,
const struct regset *regset,
const char *name,
int section_min_size,
int which,
const char *human_name,
bool required)
{
struct bfd_section *section;
bfd_size_type size;
char *contents;
bool variable_size_section = (regset != NULL
&& regset->flags & REGSET_VARIABLE_SIZE);
thread_section_name section_name (name, regcache->ptid ());
section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
if (! section)
{
if (required)
warning (_("Couldn't find %s registers in core file."),
human_name);
return;
}
size = bfd_section_size (core_bfd, section);
if (size < section_min_size)
{
warning (_("Section `%s' in core file too small."),
section_name.c_str ());
return;
}
if (size != section_min_size && !variable_size_section)
{
warning (_("Unexpected size of section `%s' in core file."),
section_name.c_str ());
}
contents = (char *) alloca (size);
if (! bfd_get_section_contents (core_bfd, section, contents,
(file_ptr) 0, size))
{
warning (_("Couldn't read %s registers from `%s' section in core file."),
human_name, section_name.c_str ());
return;
}
if (regset != NULL)
{
regset->supply_regset (regset, regcache, -1, contents, size);
return;
}
gdb_assert (m_core_vec != nullptr);
m_core_vec->core_read_registers (regcache, contents, size, which,
((CORE_ADDR)
bfd_section_vma (core_bfd, section)));
}
uint32_t v2f(struct psect *s, bfd_vma addr)
{
uint32_t dest;
dest= (uint32_t)(addr - (bfd_vma)&s->data[0]);
dest += bfd_section_vma(tmp_bfd, s->sec);
return dest;
}
bfd_vma f2v(struct psect *s, uint32_t addr)
{
bfd_vma dest;
dest= (bfd_vma)addr;
dest -= bfd_section_vma(tmp_bfd, s->sec);
dest += (bfd_vma)&s->data[0];
return dest;
}
static int
sim_prepare_for_program (SIM_DESC sd, bfd* abfd)
{
sim_cpu *cpu;
int elf_flags = 0;
cpu = STATE_CPU (sd, 0);
if (abfd != NULL)
{
asection *s;
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
elf_flags = elf_elfheader (abfd)->e_flags;
cpu->cpu_elf_start = bfd_get_start_address (abfd);
/* See if any section sets the reset address */
cpu->cpu_use_elf_start = 1;
for (s = abfd->sections; s && cpu->cpu_use_elf_start; s = s->next)
{
if (s->flags & SEC_LOAD)
{
bfd_size_type size;
size = bfd_get_section_size (s);
if (size > 0)
{
bfd_vma lma;
if (STATE_LOAD_AT_LMA_P (sd))
lma = bfd_section_lma (abfd, s);
else
lma = bfd_section_vma (abfd, s);
if (lma <= 0xFFFE && lma+size >= 0x10000)
cpu->cpu_use_elf_start = 0;
}
}
}
if (elf_flags & E_M68HC12_BANKS)
{
if (sim_get_bank_parameters (sd, abfd) != 0)
sim_io_eprintf (sd, "Memory bank parameters are not initialized\n");
}
}
if (!sim_hw_configure (sd))
return SIM_RC_FAIL;
/* reset all state information */
sim_board_reset (sd);
return SIM_RC_OK;
}
bool isCall(bfd_byte **p, uint32_t& val)
{
// call 0x12345678
if (*p[0] == 0xe8) {
val= *(uint32_t *)(*p+1);
val += (uint32_t)(*p - secText.data + bfd_section_vma(tmp_bfd, secText.sec));
val += 5;
*p += 5;
return true;
}
return false;
}
/**
* Compute the mapping offset for the program / library.
*
* The .text section could say 0x500000 but the actual virtual memory
* address where the library was mapped could be 0x600000. Hence looking
* for addresses at 0x6xxxxx would not create any match with the symbol
* addresses held in the file.
*
* The base given here should be the actual VM address where the kernel
* loaded the first section.
*
* The computed offset will then be automatically used to adjust the given
* addresses being looked at, remapping them to the proper range for lookup
* purposes.
*
* @param bc the BFD context (NULL allowed for convenience)
* @param base the VM mapping address of the text segment
*/
void
bfd_util_compute_offset(bfd_ctx_t *bc, ulong base)
{
asection *sec;
bfd *b;
if (NULL == bc)
return; /* Convenience */
bfd_ctx_check(bc);
if (bc->offseted || NULL == bc->handle)
return;
mutex_lock_fast(&bc->lock);
if (bc->offseted) {
mutex_unlock_fast(&bc->lock);
return;
}
b = bc->handle;
if (NULL == b) {
mutex_unlock_fast(&bc->lock);
return;
}
/*
* Take the first section of the file and look where its page would start.
* Then compare that to the advertised mapping base for the object to
* know the offset we have to apply for proper symbol resolution.
*/
sec = b->sections;
/*
* Notes for later: sections are linked through sec->next.
*
* It is possible to gather the section name via:
* const char *name = bfd_section_name(b, sec);
*/
if (sec != NULL) {
bfd_vma addr = bfd_section_vma(b, sec);
bc->offset = ptr_diff(vmm_page_start(ulong_to_pointer(addr)),
vmm_page_start(ulong_to_pointer(base)));
}
bc->offseted = TRUE;
mutex_unlock_fast(&bc->lock);
}
static void
print_bfd_section_info(bfd *abfd, asection *asect, void *arg)
{
flagword flags = bfd_get_section_flags(abfd, asect);
const char *name = bfd_section_name(abfd, asect);
if ((arg == NULL) || (*((char *)arg) == '\0')
|| match_substring((char *)arg, name)
|| match_bfd_flags((char *)arg, flags))
{
CORE_ADDR addr, endaddr;
addr = bfd_section_vma(abfd, asect);
endaddr = (addr + bfd_section_size(abfd, asect));
maint_print_section_info(name, flags, addr, endaddr,
(unsigned long)asect->filepos);
}
}
static void
add_to_section_table (bfd *abfd, struct bfd_section *asect,
void *table_pp_char)
{
struct section_table **table_pp = (struct section_table **) table_pp_char;
flagword aflag;
aflag = bfd_get_section_flags (abfd, asect);
if (!(aflag & SEC_ALLOC))
return;
if (0 == bfd_section_size (abfd, asect))
return;
(*table_pp)->bfd = abfd;
(*table_pp)->the_bfd_section = asect;
(*table_pp)->addr = bfd_section_vma (abfd, asect);
(*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
(*table_pp)++;
}
CORE_ADDR
ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
CORE_ADDR addr,
struct target_ops *targ)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct target_section *s = target_section_by_addr (targ, addr);
/* Check if ADDR points to a function descriptor. */
if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
{
/* There may be relocations that need to be applied to the .opd
section. Unfortunately, this function may be called at a time
where these relocations have not yet been performed -- this can
happen for example shortly after a library has been loaded with
dlopen, but ld.so has not yet applied the relocations.
To cope with both the case where the relocation has been applied,
and the case where it has not yet been applied, we do *not* read
the (maybe) relocated value from target memory, but we instead
read the non-relocated value from the BFD, and apply the relocation
offset manually.
This makes the assumption that all .opd entries are always relocated
by the same offset the section itself was relocated. This should
always be the case for GNU/Linux executables and shared libraries.
Note that other kind of object files (e.g. those added via
add-symbol-files) will currently never end up here anyway, as this
function accesses *target* sections only; only the main exec and
shared libraries are ever added to the target. */
gdb_byte buf[8];
int res;
res = bfd_get_section_contents (s->the_bfd_section->owner,
s->the_bfd_section,
&buf, addr - s->addr, 8);
if (res != 0)
return extract_unsigned_integer (buf, 8, byte_order)
- bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr;
}
return addr;
}
static void
add_to_section_table (struct bfd *abfd, struct bfd_section *asect,
void *closure)
{
struct section_closure *pp = closure;
flagword aflag;
/* NOTE: cagney/2003-10-22: Is this pruning useful? */
aflag = bfd_get_section_flags (abfd, asect);
if (!(aflag & SEC_ALLOC))
return;
if (bfd_section_size (abfd, asect) == 0)
return;
pp->end->bfd = abfd;
pp->end->the_bfd_section = asect;
pp->end->addr = bfd_section_vma (abfd, asect);
pp->end->endaddr = pp->end->addr + bfd_section_size (abfd, asect);
pp->end++;
}
static void
print_bfd_section_info (bfd *abfd,
asection *asect,
void *arg)
{
flagword flags = bfd_get_section_flags (abfd, asect);
const char *name = bfd_section_name (abfd, asect);
if (arg == NULL || *((char *) arg) == '\0'
|| match_substring ((char *) arg, name)
|| match_bfd_flags ((char *) arg, flags))
{
struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
int addr_size = gdbarch_addr_bit (gdbarch) / 8;
CORE_ADDR addr, endaddr;
addr = bfd_section_vma (abfd, asect);
endaddr = addr + bfd_section_size (abfd, asect);
maint_print_section_info (name, flags, addr, endaddr,
asect->filepos, addr_size);
}
}
static void
add_to_section_table (bfd *abfd, struct bfd_section *asect,
void *table_pp_char)
{
struct target_section **table_pp = (struct target_section **) table_pp_char;
flagword aflag;
/* Check the section flags, but do not discard zero-length sections, since
some symbols may still be attached to this section. For instance, we
encountered on sparc-solaris 2.10 a shared library with an empty .bss
section to which a symbol named "_end" was attached. The address
of this symbol still needs to be relocated. */
aflag = bfd_get_section_flags (abfd, asect);
if (!(aflag & SEC_ALLOC))
return;
(*table_pp)->bfd = abfd;
(*table_pp)->the_bfd_section = asect;
(*table_pp)->addr = bfd_section_vma (abfd, asect);
(*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
(*table_pp)++;
}
static void
add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
void *objfile_p_char)
{
struct objfile *objfile = (struct objfile *) objfile_p_char;
struct obj_section section;
flagword aflag;
aflag = bfd_get_section_flags (abfd, asect);
if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
return;
if (0 == bfd_section_size (abfd, asect))
return;
section.offset = 0;
section.objfile = objfile;
section.the_bfd_section = asect;
section.ovly_mapped = 0;
section.addr = bfd_section_vma (abfd, asect);
section.endaddr = section.addr + bfd_section_size (abfd, asect);
obstack_grow (&objfile->objfile_obstack, (char *) §ion, sizeof (section));
objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1);
}
static CORE_ADDR
bss_data_overlap (struct objfile *objfile)
{
struct obj_section *osect;
struct bfd_section *data = NULL;
struct bfd_section *bss = NULL;
/* First, find the .data and .bss sections. */
ALL_OBJFILE_OSECTIONS (objfile, osect)
{
if (strcmp (bfd_section_name (objfile->obfd,
osect->the_bfd_section),
".data") == 0)
data = osect->the_bfd_section;
else if (strcmp (bfd_section_name (objfile->obfd,
osect->the_bfd_section),
".bss") == 0)
bss = osect->the_bfd_section;
}
/* If either section is not defined, there can be no overlap. */
if (data == NULL || bss == NULL)
return 0;
/* Assume the problem only occurs with linkers that place the .bss
section after the .data section (the problem has only been
observed when using the GNU linker, and the default linker
script always places the .data and .bss sections in that order). */
if (bfd_section_vma (objfile->obfd, bss)
< bfd_section_vma (objfile->obfd, data))
return 0;
if (bfd_section_vma (objfile->obfd, bss)
< bfd_section_vma (objfile->obfd, data) + bfd_get_section_size (data))
return ((bfd_section_vma (objfile->obfd, data)
+ bfd_get_section_size (data))
- bfd_section_vma (objfile->obfd, bss));
return 0;
}
static void
get_core_register_section (struct regcache *regcache,
const char *name,
int which,
const char *human_name,
int required)
{
static char *section_name = NULL;
struct bfd_section *section;
bfd_size_type size;
char *contents;
xfree (section_name);
if (ptid_get_lwp (inferior_ptid))
section_name = xstrprintf ("%s/%ld", name,
ptid_get_lwp (inferior_ptid));
else
section_name = xstrdup (name);
section = bfd_get_section_by_name (core_bfd, section_name);
if (! section)
{
if (required)
warning (_("Couldn't find %s registers in core file."),
human_name);
return;
}
size = bfd_section_size (core_bfd, section);
contents = alloca (size);
if (! bfd_get_section_contents (core_bfd, section, contents,
(file_ptr) 0, size))
{
warning (_("Couldn't read %s registers from `%s' section in core file."),
human_name, name);
return;
}
if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
{
const struct regset *regset;
regset = gdbarch_regset_from_core_section (core_gdbarch,
name, size);
if (regset == NULL)
{
if (required)
warning (_("Couldn't recognize %s registers in core file."),
human_name);
return;
}
regset->supply_regset (regset, regcache, -1, contents, size);
return;
}
gdb_assert (core_vec);
core_vec->core_read_registers (regcache, contents, size, which,
((CORE_ADDR)
bfd_section_vma (core_bfd, section)));
}
static void
aix5_relocate_main_executable (void)
{
struct so_list *so;
struct section_offsets *new_offsets;
int i;
int changed = 0;
struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
/* Fetch the mappings for the main executable from the map file. */
so = build_so_list_from_mapfile (PIDGET (inferior_ptid),
MA_MAINEXEC, MA_MAINEXEC);
/* Make sure we actually have some mappings to work with. */
if (so == NULL)
{
warning (_("Could not find main executable in map file"));
do_cleanups (old_chain);
return;
}
/* Allocate the data structure which'll contain the new offsets to
relocate by. Initialize it so it contains the current offsets. */
new_offsets = xcalloc (symfile_objfile->num_sections,
sizeof (struct section_offsets));
make_cleanup (xfree, new_offsets);
for (i = 0; i < symfile_objfile->num_sections; i++)
new_offsets->offsets[i] = ANOFFSET (symfile_objfile->section_offsets, i);
/* Iterate over the mappings in the main executable and compute
the new offset value as appropriate. */
for (i = 0; i < so->lm_info->nmappings; i++)
{
CORE_ADDR increment = 0;
struct obj_section *sect;
bfd *obfd = symfile_objfile->obfd;
struct lm_mapping *mapping = &so->lm_info->mapping[i];
ALL_OBJFILE_OSECTIONS (symfile_objfile, sect)
{
int flags = bfd_get_section_flags (obfd, sect->the_bfd_section);
if (flags & SEC_ALLOC)
{
file_ptr filepos = sect->the_bfd_section->filepos;
if (map_index_vs_section_name_okay (i,
bfd_get_section_name (obfd, sect->the_bfd_section)))
{
int idx = sect->the_bfd_section->index;
if (increment == 0)
increment = mapping->addr
- (bfd_section_vma (obfd, sect->the_bfd_section)
& SECTMAPMASK);
if (increment != ANOFFSET (new_offsets, idx))
{
new_offsets->offsets[idx] = increment;
changed = 1;
}
}
}
}
}
static int
enable_break (void)
{
int success = 0;
struct minimal_symbol *msymbol;
char **bkpt_namep;
asection *interp_sect;
/* First, remove all the solib event breakpoints. Their addresses
may have changed since the last time we ran the program. */
remove_solib_event_breakpoints ();
interp_text_sect_low = interp_text_sect_high = 0;
interp_plt_sect_low = interp_plt_sect_high = 0;
/* Find the .interp section; if not found, warn the user and drop
into the old breakpoint at symbol code. */
interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
if (interp_sect)
{
unsigned int interp_sect_size;
char *buf;
CORE_ADDR load_addr;
bfd *tmp_bfd;
CORE_ADDR sym_addr = 0;
/* Read the contents of the .interp section into a local buffer;
the contents specify the dynamic linker this program uses. */
interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
buf = alloca (interp_sect_size);
bfd_get_section_contents (exec_bfd, interp_sect,
buf, 0, interp_sect_size);
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
in the dynamic linker itself.
This address is stored on the stack. However, I've been unable
to find any magic formula to find it for Solaris (appears to
be trivial on GNU/Linux). Therefore, we have to try an alternate
mechanism to find the dynamic linker's base address. */
tmp_bfd = bfd_openr (buf, gnutarget);
if (tmp_bfd == NULL)
goto bkpt_at_symbol;
/* Make sure the dynamic linker's really a useful object. */
if (!bfd_check_format (tmp_bfd, bfd_object))
{
warning (_("Unable to grok dynamic linker %s as an object file"), buf);
bfd_close (tmp_bfd);
goto bkpt_at_symbol;
}
/* We find the dynamic linker's base address by examining the
current pc (which point at the entry point for the dynamic
linker) and subtracting the offset of the entry point. */
load_addr = read_pc () - tmp_bfd->start_address;
/* Record the relocated start and end address of the dynamic linker
text and plt section for aix5_in_dynsym_resolve_code. */
interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
if (interp_sect)
{
interp_text_sect_low =
bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
interp_text_sect_high =
interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
if (interp_sect)
{
interp_plt_sect_low =
bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
interp_plt_sect_high =
interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
/* Now try to set a breakpoint in the dynamic linker. */
for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
if (sym_addr != 0)
break;
}
/* We're done with the temporary bfd. */
bfd_close (tmp_bfd);
if (sym_addr != 0)
{
create_solib_event_breakpoint (load_addr + sym_addr);
return 1;
}
/* For whatever reason we couldn't set a breakpoint in the dynamic
linker. Warn and drop into the old code. */
bkpt_at_symbol:
warning (_("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code."));
}
/* Nothing good happened. */
success = 0;
return (success);
}
/* load program text and initialized data into simulated virtual memory
space and initialize program segment range variables */
void
ld_load_prog(char *fname, /* program to load */
int argc, char **argv, /* simulated program cmd line args */
char **envp, /* simulated program environment */
struct regs_t *regs, /* registers to initialize for load */
struct mem_t *mem, /* memory space to load prog into */
int zero_bss_segs) /* zero uninit data segment? */
{
int i;
qword_t temp;
md_addr_t sp, data_break = 0, null_ptr = 0, argv_addr, envp_addr;
if (eio_valid(fname))
{
if (argc != 1)
{
fprintf(stderr, "error: EIO file has arguments\n");
exit(1);
}
fprintf(stderr, "sim: loading EIO file: %s\n", fname);
sim_eio_fname = mystrdup(fname);
/* open the EIO file stream */
sim_eio_fd = eio_open(fname);
/* load initial state checkpoint */
if (eio_read_chkpt(regs, mem, sim_eio_fd) != -1)
fatal("bad initial checkpoint in EIO file");
/* load checkpoint? */
if (sim_chkpt_fname != NULL)
{
counter_t restore_icnt;
FILE *chkpt_fd;
fprintf(stderr, "sim: loading checkpoint file: %s\n",
sim_chkpt_fname);
if (!eio_valid(sim_chkpt_fname))
fatal("file `%s' does not appear to be a checkpoint file",
sim_chkpt_fname);
/* open the checkpoint file */
chkpt_fd = eio_open(sim_chkpt_fname);
/* load the state image */
restore_icnt = eio_read_chkpt(regs, mem, chkpt_fd);
/* fast forward the baseline EIO trace to checkpoint location */
myfprintf(stderr, "sim: fast forwarding to instruction %n\n",
restore_icnt);
eio_fast_forward(sim_eio_fd, restore_icnt);
}
/* computed state... */
ld_environ_base = regs->regs_R[MD_REG_SP];
ld_prog_entry = regs->regs_PC;
/* fini... */
return;
}
#ifdef MD_CROSS_ENDIAN
else
{
warn("endian of `%s' does not match host", fname);
warn("running with experimental cross-endian execution support");
warn("****************************************");
warn("**>> please check results carefully <<**");
warn("****************************************");
#if 0
fatal("SimpleScalar/Alpha only supports binary execution on\n"
" little-endian hosts, use EIO files on big-endian hosts");
#endif
}
#endif /* MD_CROSS_ENDIAN */
if (sim_chkpt_fname != NULL)
fatal("checkpoints only supported while EIO tracing");
#ifdef BFD_LOADER
{
bfd *abfd;
asection *sect;
/* set up a local stack pointer, this is where the argv and envp
data is written into program memory */
ld_stack_base = MD_STACK_BASE;
sp = ROUND_DOWN(MD_STACK_BASE - MD_MAX_ENVIRON, sizeof(MD_DOUBLE_TYPE));
ld_stack_size = ld_stack_base - sp;
printf("Thread 0 stack size (3)%d\n", current->ld_stack_size);
/* initial stack pointer value */
ld_environ_base = sp;
/* load the program into memory, try both endians */
if (!(abfd = bfd_openr(argv[0], "ss-coff-big")))
if (!(abfd = bfd_openr(argv[0], "ss-coff-little")))
fatal("cannot open executable `%s'", argv[0]);
/* this call is mainly for its side effect of reading in the sections.
we follow the traditional behavior of `strings' in that we don't
complain if we don't recognize a file to be an object file. */
if (!bfd_check_format(abfd, bfd_object))
{
bfd_close(abfd);
fatal("cannot open executable `%s'", argv[0]);
}
/* record profile file name */
ld_prog_fname = argv[0];
/* record endian of target */
ld_target_big_endian = abfd->xvec->byteorder_big_p;
debug("processing %d sections in `%s'...",
bfd_count_sections(abfd), argv[0]);
/* read all sections in file */
for (sect=abfd->sections; sect; sect=sect->next)
{
char *p;
debug("processing section `%s', %d bytes @ 0x%08x...",
bfd_section_name(abfd, sect), bfd_section_size(abfd, sect),
bfd_section_vma(abfd, sect));
/* read the section data, if allocated and loadable and non-NULL */
if ((bfd_get_section_flags(abfd, sect) & SEC_ALLOC)
&& (bfd_get_section_flags(abfd, sect) & SEC_LOAD)
&& bfd_section_vma(abfd, sect)
&& bfd_section_size(abfd, sect))
{
/* allocate a section buffer */
p = calloc(bfd_section_size(abfd, sect), sizeof(char));
if (!p)
fatal("cannot allocate %d bytes for section `%s'",
bfd_section_size(abfd, sect),
bfd_section_name(abfd, sect));
if (!bfd_get_section_contents(abfd, sect, p, (file_ptr)0,
bfd_section_size(abfd, sect)))
fatal("could not read entire `%s' section from executable",
bfd_section_name(abfd, sect));
/* copy program section it into simulator target memory */
mem_bcopy(mem_fn, Write, bfd_section_vma(abfd, sect),
p, bfd_section_size(abfd, sect));
/* release the section buffer */
free(p);
}
/* zero out the section if it is loadable but not allocated in exec */
else if (zero_bss_segs
&& (bfd_get_section_flags(abfd, sect) & SEC_LOAD)
&& bfd_section_vma(abfd, sect)
&& bfd_section_size(abfd, sect))
{
/* zero out the section region */
mem_bzero(mem_fn,
bfd_section_vma(abfd, sect),
bfd_section_size(abfd, sect));
}
else
{
/* else do nothing with this section, it's probably debug data */
debug("ignoring section `%s' during load...",
bfd_section_name(abfd, sect));
}
/* expected text section */
if (!strcmp(bfd_section_name(abfd, sect), ".text"))
{
/* .text section processing */
ld_text_size =
((bfd_section_vma(abfd, sect) + bfd_section_size(abfd, sect))
- MD_TEXT_BASE)
+ /* for speculative fetches/decodes */TEXT_TAIL_PADDING;
/* create tail padding and copy into simulator target memory */
#if 0
mem_bzero(mem_fn,
bfd_section_vma(abfd, sect)
+ bfd_section_size(abfd, sect),
TEXT_TAIL_PADDING);
#endif
}
/* expected data sections */
else if (!strcmp(bfd_section_name(abfd, sect), ".rdata")
|| !strcmp(bfd_section_name(abfd, sect), ".data")
|| !strcmp(bfd_section_name(abfd, sect), ".sdata")
|| !strcmp(bfd_section_name(abfd, sect), ".bss")
|| !strcmp(bfd_section_name(abfd, sect), ".sbss"))
{
/* data section processing */
if (bfd_section_vma(abfd, sect) + bfd_section_size(abfd, sect) >
data_break)
data_break = (bfd_section_vma(abfd, sect) +
bfd_section_size(abfd, sect));
}
else
{
/* what is this section??? */
fatal("encountered unknown section `%s', %d bytes @ 0x%08x",
bfd_section_name(abfd, sect), bfd_section_size(abfd, sect),
bfd_section_vma(abfd, sect));
}
}
/* compute data segment size from data break point */
ld_text_base = MD_TEXT_BASE;
ld_data_base = MD_DATA_BASE;
ld_prog_entry = bfd_get_start_address(abfd);
ld_data_size = data_break - ld_data_base;
/* done with the executable, close it */
if (!bfd_close(abfd))
fatal("could not close executable `%s'", argv[0]);
}
#else /* !BFD_LOADER, i.e., standalone loader */
{
FILE *fobj;
long floc;
struct ecoff_filehdr fhdr;
struct ecoff_aouthdr ahdr;
struct ecoff_scnhdr shdr;
/* record profile file name */
ld_prog_fname = argv[0];
/* load the program into memory, try both endians */
#if defined(__CYGWIN32__) || defined(_MSC_VER)
fobj = fopen(argv[0], "rb");
#else
fobj = fopen(argv[0], "r");
#endif
if (!fobj)
fatal("cannot open executable `%s'", argv[0]);
if (fread(&fhdr, sizeof(struct ecoff_filehdr), 1, fobj) < 1)
fatal("cannot read header from executable `%s'", argv[0]);
/* record endian of target */
if (fhdr.f_magic == MD_SWAPH(ECOFF_ALPHAMAGIC))
ld_target_big_endian = FALSE;
else if (fhdr.f_magic == MD_SWAPH(ECOFF_EB_MAGIC)
|| fhdr.f_magic == MD_SWAPH(ECOFF_EL_MAGIC)
|| fhdr.f_magic == MD_SWAPH(ECOFF_EB_OTHER)
|| fhdr.f_magic == MD_SWAPH(ECOFF_EL_OTHER))
fatal("Alpha simulator cannot run PISA binary `%s'", argv[0]);
else
fatal("bad magic number in executable `%s' (not an executable)",
argv[0]);
if (fread(&ahdr, sizeof(struct ecoff_aouthdr), 1, fobj) < 1)
fatal("cannot read AOUT header from executable `%s'", argv[0]);
ld_text_base = MD_SWAPQ(ahdr.text_start);
ld_text_size = MD_SWAPQ(ahdr.tsize);
ld_prog_entry = MD_SWAPQ(ahdr.entry);
ld_data_base = MD_SWAPQ(ahdr.data_start);
ld_data_size = MD_SWAPQ(ahdr.dsize) + MD_SWAPQ(ahdr.bsize);
regs->regs_R[MD_REG_GP] = MD_SWAPQ(ahdr.gp_value);
/* compute data segment size from data break point */
data_break = ld_data_base + ld_data_size;
/* seek to the beginning of the first section header, the file header comes
first, followed by the optional header (this is the aouthdr), the size
of the aouthdr is given in Fdhr.f_opthdr */
fseek(fobj, sizeof(struct ecoff_filehdr) + MD_SWAPH(fhdr.f_opthdr), 0);
debug("processing %d sections in `%s'...",
MD_SWAPH(fhdr.f_nscns), argv[0]);
/* loop through the section headers */
floc = ftell(fobj);
for (i = 0; i < MD_SWAPH(fhdr.f_nscns); i++)
{
char *p;
if (fseek(fobj, floc, 0) == -1)
fatal("could not reset location in executable");
if (fread(&shdr, sizeof(struct ecoff_scnhdr), 1, fobj) < 1)
fatal("could not read section %d from executable", i);
floc = ftell(fobj);
switch (MD_SWAPW(shdr.s_flags))
{
case ECOFF_STYP_TEXT:
p = calloc(MD_SWAPQ(shdr.s_size), sizeof(char));
if (!p)
fatal("out of virtual memory");
if (fseek(fobj, MD_SWAPQ(shdr.s_scnptr), 0) == -1)
fatal("could not read `.text' from executable", i);
if (fread(p, MD_SWAPQ(shdr.s_size), 1, fobj) < 1)
fatal("could not read text section from executable");
/* copy program section into simulator target memory */
mem_bcopy(mem_access, mem, Write,
MD_SWAPQ(shdr.s_vaddr), p, MD_SWAPQ(shdr.s_size));
#if 0
/* create tail padding and copy into simulator target memory */
mem_bzero(mem_access, mem,
MD_SWAPQ(shdr.s_vaddr) + MD_SWAPQ(shdr.s_size),
TEXT_TAIL_PADDING);
#endif
/* release the section buffer */
free(p);
#if 0
Text_seek = MD_SWAPQ(shdr.s_scnptr);
Text_start = MD_SWAPQ(shdr.s_vaddr);
Text_size = MD_SWAPQ(shdr.s_size) / 4;
/* there is a null routine after the supposed end of text */
Text_size += 10;
Text_end = Text_start + Text_size * 4;
/* create_text_reloc(shdr.s_relptr, shdr.s_nreloc); */
#endif
break;
case ECOFF_STYP_INIT:
case ECOFF_STYP_FINI:
if (MD_SWAPQ(shdr.s_size) > 0)
{
p = calloc(MD_SWAPQ(shdr.s_size), sizeof(char));
if (!p)
fatal("out of virtual memory");
if (fseek(fobj, MD_SWAPQ(shdr.s_scnptr), 0) == -1)
fatal("could not read `.text' from executable", i);
if (fread(p, MD_SWAPQ(shdr.s_size), 1, fobj) < 1)
fatal("could not read text section from executable");
/* copy program section into simulator target memory */
mem_bcopy(mem_access, mem,
Write, MD_SWAPQ(shdr.s_vaddr),
p, MD_SWAPQ(shdr.s_size));
/* release the section buffer */
free(p);
}
else
warn("section `%s' is empty...", shdr.s_name);
break;
case ECOFF_STYP_LITA:
case ECOFF_STYP_LIT8:
case ECOFF_STYP_LIT4:
case ECOFF_STYP_XDATA:
case ECOFF_STYP_PDATA:
case ECOFF_STYP_RCONST:
/* fall through */
case ECOFF_STYP_RDATA:
/* The .rdata section is sometimes placed before the text
* section instead of being contiguous with the .data section.
*/
#if 0
Rdata_start = MD_SWAPQ(shdr.s_vaddr);
Rdata_size = MD_SWAPQ(shdr.s_size);
Rdata_seek = MD_SWAPQ(shdr.s_scnptr);
#endif
/* fall through */
case ECOFF_STYP_DATA:
#if 0
Data_seek = MD_SWAPQ(shdr.s_scnptr);
#endif
/* fall through */
case ECOFF_STYP_SDATA:
#if 0
Sdata_seek = MD_SWAPQ(shdr.s_scnptr);
#endif
if (MD_SWAPQ(shdr.s_size) > 0)
{
p = calloc(MD_SWAPQ(shdr.s_size), sizeof(char));
if (!p)
fatal("out of virtual memory");
if (fseek(fobj, MD_SWAPQ(shdr.s_scnptr), 0) == -1)
fatal("could not read `.text' from executable", i);
if (fread(p, MD_SWAPQ(shdr.s_size), 1, fobj) < 1)
fatal("could not read text section from executable");
/* copy program section it into simulator target memory */
mem_bcopy(mem_access, mem,
Write, MD_SWAPQ(shdr.s_vaddr),
p, MD_SWAPQ(shdr.s_size));
/* release the section buffer */
free(p);
}
else
warn("section `%s' is empty...", shdr.s_name);
break;
case ECOFF_STYP_BSS:
case ECOFF_STYP_SBSS:
/* no data to read... */
break;
default:
warn("section `%s' ignored...", shdr.s_name);
}
}
/* done with the executable, close it */
if (fclose(fobj))
fatal("could not close executable `%s'", argv[0]);
}
#endif /* BFD_LOADER */
/* perform sanity checks on segment ranges */
if (!ld_text_base || !ld_text_size)
fatal("executable is missing a `.text' section");
if (!ld_data_base || !ld_data_size)
fatal("executable is missing a `.data' section");
if (!ld_prog_entry)
fatal("program entry point not specified");
/* determine byte/words swapping required to execute on this host */
sim_swap_bytes = (endian_host_byte_order() != endian_target_byte_order());
if (sim_swap_bytes)
{
#if 0 /* FIXME: disabled until further notice... */
/* cross-endian is never reliable, why this is so is beyond the scope
of this comment, e-mail me for details... */
fprintf(stderr, "sim: *WARNING*: swapping bytes to match host...\n");
fprintf(stderr, "sim: *WARNING*: swapping may break your program!\n");
/* #else */
fatal("binary endian does not match host endian");
#endif
}
sim_swap_words = (endian_host_word_order() != endian_target_word_order());
if (sim_swap_words)
{
#if 0 /* FIXME: disabled until further notice... */
/* cross-endian is never reliable, why this is so is beyond the scope
of this comment, e-mail me for details... */
fprintf(stderr, "sim: *WARNING*: swapping words to match host...\n");
fprintf(stderr, "sim: *WARNING*: swapping may break your program!\n");
/* #else */
fatal("binary endian does not match host endian");
#endif
}
/* set up a local stack pointer, this is where the argv and envp
data is written into program memory */
ld_stack_base = ld_text_base - (409600+4096);
#if 0
sp = ROUND_DOWN(ld_stack_base - MD_MAX_ENVIRON, sizeof(MD_DOUBLE_TYPE));
#endif
sp = ld_stack_base - MD_MAX_ENVIRON;
ld_stack_size = ld_stack_base - sp;
printf("Thread 0 stack size (4)%d\n", current->ld_stack_size);
/* initial stack pointer value */
ld_environ_base = sp;
/* write [argc] to stack */
temp = MD_SWAPQ(argc);
mem_access(mem, Write, sp, &temp, sizeof(qword_t));
regs->regs_R[MD_REG_A0] = temp;
sp += sizeof(qword_t);
/* skip past argv array and NULL */
argv_addr = sp;
regs->regs_R[MD_REG_A1] = argv_addr;
sp = sp + (argc + 1) * sizeof(md_addr_t);
/* save space for envp array and NULL */
envp_addr = sp;
for (i=0; envp[i]; i++)
sp += sizeof(md_addr_t);
sp += sizeof(md_addr_t);
/* fill in the argv pointer array and data */
for (i=0; i<argc; i++)
{
/* write the argv pointer array entry */
temp = MD_SWAPQ(sp);
mem_access(mem, Write, argv_addr + i*sizeof(md_addr_t),
&temp, sizeof(md_addr_t));
/* and the data */
mem_strcpy(mem_access, mem, Write, sp, argv[i]);
sp += strlen(argv[i])+1;
}
/* terminate argv array with a NULL */
mem_access(mem, Write, argv_addr + i*sizeof(md_addr_t),
&null_ptr, sizeof(md_addr_t));
/* write envp pointer array and data to stack */
for (i = 0; envp[i]; i++)
{
/* write the envp pointer array entry */
temp = MD_SWAPQ(sp);
mem_access(mem, Write, envp_addr + i*sizeof(md_addr_t),
&temp, sizeof(md_addr_t));
/* and the data */
mem_strcpy(mem_access, mem, Write, sp, envp[i]);
sp += strlen(envp[i]) + 1;
}
/* terminate the envp array with a NULL */
mem_access(mem, Write, envp_addr + i*sizeof(md_addr_t),
&null_ptr, sizeof(md_addr_t));
/* did we tromp off the stop of the stack? */
if (sp > ld_stack_base)
{
/* we did, indicate to the user that MD_MAX_ENVIRON must be increased,
alternatively, you can use a smaller environment, or fewer
command line arguments */
fatal("environment overflow, increase MD_MAX_ENVIRON in alpha.h");
}
/* initialize the bottom of heap to top of data segment */
ld_brk_point = ROUND_UP(ld_data_base + ld_data_size, MD_PAGE_SIZE);
/* set initial minimum stack pointer value to initial stack value */
ld_stack_min = regs->regs_R[MD_REG_SP];
regs->regs_R[MD_REG_SP] = ld_environ_base;
regs->regs_PC = ld_prog_entry;
printf("ld_text_base: 0x%08x ld_text_size: 0x%08x",
ld_text_base, ld_text_size);
printf("ld_data_base: 0x%08x ld_data_size: 0x%08x",
ld_data_base, ld_data_size);
printf("ld_stack_base: 0x%08x ld_stack_size: 0x%08x",
ld_stack_base, ld_stack_size);
printf("ld_prog_entry: 0x%08x", ld_prog_entry);
debug("ld_text_base: 0x%08x ld_text_size: 0x%08x",
ld_text_base, ld_text_size);
debug("ld_data_base: 0x%08x ld_data_size: 0x%08x",
ld_data_base, ld_data_size);
debug("ld_stack_base: 0x%08x ld_stack_size: 0x%08x",
ld_stack_base, ld_stack_size);
debug("ld_prog_entry: 0x%08x", ld_prog_entry);
}
static int
enable_break2 (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int success = 0;
char **bkpt_namep;
asection *interp_sect;
struct dsbt_info *info = get_dsbt_info ();
if (exec_bfd == NULL)
return 0;
if (!target_has_execution)
return 0;
if (info->enable_break2_done)
return 1;
info->interp_text_sect_low = 0;
info->interp_text_sect_high = 0;
info->interp_plt_sect_low = 0;
info->interp_plt_sect_high = 0;
/* Find the .interp section; if not found, warn the user and drop
into the old breakpoint at symbol code. */
interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
if (interp_sect)
{
unsigned int interp_sect_size;
gdb_byte *buf;
bfd *tmp_bfd = NULL;
int status;
CORE_ADDR addr, interp_loadmap_addr;
gdb_byte addr_buf[TIC6X_PTR_SIZE];
struct int_elf32_dsbt_loadmap *ldm;
volatile struct gdb_exception ex;
/* Read the contents of the .interp section into a local buffer;
the contents specify the dynamic linker this program uses. */
interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
buf = alloca (interp_sect_size);
bfd_get_section_contents (exec_bfd, interp_sect,
buf, 0, interp_sect_size);
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
in the dynamic linker itself. */
TRY_CATCH (ex, RETURN_MASK_ALL)
{
tmp_bfd = solib_bfd_open (buf);
}
if (tmp_bfd == NULL)
{
enable_break_failure_warning ();
return 0;
}
dsbt_get_initial_loadmaps ();
ldm = info->interp_loadmap;
/* Record the relocated start and end address of the dynamic linker
text and plt section for dsbt_in_dynsym_resolve_code. */
interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
if (interp_sect)
{
info->interp_text_sect_low
= bfd_section_vma (tmp_bfd, interp_sect);
info->interp_text_sect_low
+= displacement_from_map (ldm, info->interp_text_sect_low);
info->interp_text_sect_high
= info->interp_text_sect_low
+ bfd_section_size (tmp_bfd, interp_sect);
}
interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
if (interp_sect)
{
info->interp_plt_sect_low =
bfd_section_vma (tmp_bfd, interp_sect);
info->interp_plt_sect_low
+= displacement_from_map (ldm, info->interp_plt_sect_low);
info->interp_plt_sect_high =
info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_addr");
if (addr == 0)
{
warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_addr (prior to relocation) = %s\n",
hex_string_custom (addr, 8));
addr += displacement_from_map (ldm, addr);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_addr (after relocation) = %s\n",
hex_string_custom (addr, 8));
/* Fetch the address of the r_debug struct. */
if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
{
warning (_("Unable to fetch contents of _dl_debug_addr "
"(at address %s) from dynamic linker"),
hex_string_custom (addr, 8));
}
addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_addr[0..3] = %s\n",
hex_string_custom (addr, 8));
/* If it's zero, then the ldso hasn't initialized yet, and so
there are no shared libs yet loaded. */
if (addr == 0)
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: ldso not yet initialized\n");
/* Do not warn, but mark to run again. */
return 0;
}
/* Fetch the r_brk field. It's 8 bytes from the start of
_dl_debug_addr. */
if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0)
{
warning (_("Unable to fetch _dl_debug_addr->r_brk "
"(at address %s) from dynamic linker"),
hex_string_custom (addr + 8, 8));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
/* We're done with the temporary bfd. */
bfd_close (tmp_bfd);
/* We're also done with the loadmap. */
xfree (ldm);
/* Remove all the solib event breakpoints. Their addresses
may have changed since the last time we ran the program. */
remove_solib_event_breakpoints ();
/* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (target_gdbarch, addr);
info->enable_break2_done = 1;
return 1;
}
static int
scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
{
int arch_size, step, sect_size;
long dyn_tag;
CORE_ADDR dyn_ptr, dyn_addr;
gdb_byte *bufend, *bufstart, *buf;
Elf32_External_Dyn *x_dynp_32;
Elf64_External_Dyn *x_dynp_64;
struct bfd_section *sect;
struct target_section *target_section;
if (abfd == NULL)
return 0;
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
return 0;
arch_size = bfd_get_arch_size (abfd);
if (arch_size == -1)
return 0;
/* Find the start address of the .dynamic section. */
sect = bfd_get_section_by_name (abfd, ".dynamic");
if (sect == NULL)
return 0;
for (target_section = current_target_sections->sections;
target_section < current_target_sections->sections_end;
target_section++)
if (sect == target_section->the_bfd_section)
break;
if (target_section < current_target_sections->sections_end)
dyn_addr = target_section->addr;
else
{
/* ABFD may come from OBJFILE acting only as a symbol file without being
loaded into the target (see add_symbol_file_command). This case is
such fallback to the file VMA address without the possibility of
having the section relocated to its actual in-memory address. */
dyn_addr = bfd_section_vma (abfd, sect);
}
/* Read in .dynamic from the BFD. We will get the actual value
from memory later. */
sect_size = bfd_section_size (abfd, sect);
buf = bufstart = alloca (sect_size);
if (!bfd_get_section_contents (abfd, sect,
buf, 0, sect_size))
return 0;
/* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
: sizeof (Elf64_External_Dyn);
for (bufend = buf + sect_size;
buf < bufend;
buf += step)
{
if (arch_size == 32)
{
x_dynp_32 = (Elf32_External_Dyn *) buf;
dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
}
else
{
x_dynp_64 = (Elf64_External_Dyn *) buf;
dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
}
if (dyn_tag == DT_NULL)
return 0;
if (dyn_tag == dyntag)
{
/* If requested, try to read the runtime value of this .dynamic
entry. */
if (ptr)
{
struct type *ptr_type;
gdb_byte ptr_buf[8];
CORE_ADDR ptr_addr;
ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
*ptr = dyn_ptr;
}
return 1;
}
}
return 0;
}
static void
setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
{
bfd *obfd = obfdarg;
struct section_list *p;
sec_ptr osection;
bfd_size_type size;
bfd_vma vma;
bfd_vma lma;
const char *err;
const char * name;
name = bfd_section_name (ibfd, isection);
osection = bfd_make_section_anyway (obfd, name);
if (osection == NULL)
{
perror("setup_section: making");
}
size = bfd_section_size (ibfd, isection);
if (! bfd_set_section_size (obfd, osection, size))
{
perror("setup_section: size");
}
vma = bfd_section_vma (ibfd, isection);
if (! bfd_set_section_vma (obfd, osection, vma))
{
perror("setup_section: vma");
}
lma = isection->lma;
osection->lma = lma;
/* FIXME: This is probably not enough. If we change the LMA we
may have to recompute the header for the file as well. */
if (!bfd_set_section_alignment (obfd,
osection,
bfd_section_alignment (ibfd, isection)))
{
perror("setup_section: alignment");
}
if (!bfd_set_section_flags (obfd, osection, bfd_get_section_flags(ibfd, isection)))
{
perror("setup_section: flags");
}
/* Copy merge entity size. */
osection->entsize = isection->entsize;
/* This used to be mangle_section; we do here to avoid using
bfd_get_section_by_name since some formats allow multiple
sections with the same name. */
isection->output_section = osection;
isection->output_offset = 0;
/* Allow the BFD backend to copy any private data it understands
from the input section to the output section. */
if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
{
perror("setup_section: private data");
}
/* All went well. */
return;
perror("setup_section: %s: section `%s': error in %s: %s"),
bfd_get_filename (ibfd),
bfd_section_name (ibfd, isection),
err, bfd_errmsg (bfd_get_error ());
}
static int
enable_break2 (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int success = 0;
char **bkpt_namep;
asection *interp_sect;
if (!enable_break1_done || enable_break2_done)
return 1;
enable_break2_done = 1;
/* First, remove all the solib event breakpoints. Their addresses
may have changed since the last time we ran the program. */
remove_solib_event_breakpoints ();
interp_text_sect_low = interp_text_sect_high = 0;
interp_plt_sect_low = interp_plt_sect_high = 0;
/* Find the .interp section; if not found, warn the user and drop
into the old breakpoint at symbol code. */
interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
if (interp_sect)
{
unsigned int interp_sect_size;
gdb_byte *buf;
bfd *tmp_bfd = NULL;
int status;
CORE_ADDR addr, interp_loadmap_addr;
gdb_byte addr_buf[FRV_PTR_SIZE];
struct int_elf32_fdpic_loadmap *ldm;
volatile struct gdb_exception ex;
/* Read the contents of the .interp section into a local buffer;
the contents specify the dynamic linker this program uses. */
interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
buf = alloca (interp_sect_size);
bfd_get_section_contents (exec_bfd, interp_sect,
buf, 0, interp_sect_size);
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
in the dynamic linker itself.
This address is stored on the stack. However, I've been unable
to find any magic formula to find it for Solaris (appears to
be trivial on GNU/Linux). Therefore, we have to try an alternate
mechanism to find the dynamic linker's base address. */
TRY_CATCH (ex, RETURN_MASK_ALL)
{
tmp_bfd = solib_bfd_open (buf);
}
if (tmp_bfd == NULL)
{
enable_break_failure_warning ();
return 0;
}
status = frv_fdpic_loadmap_addresses (target_gdbarch,
&interp_loadmap_addr, 0);
if (status < 0)
{
warning (_("Unable to determine dynamic linker loadmap address."));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: interp_loadmap_addr = %s\n",
hex_string_custom (interp_loadmap_addr, 8));
ldm = fetch_loadmap (interp_loadmap_addr);
if (ldm == NULL)
{
warning (_("Unable to load dynamic linker loadmap at address %s."),
hex_string_custom (interp_loadmap_addr, 8));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
/* Record the relocated start and end address of the dynamic linker
text and plt section for svr4_in_dynsym_resolve_code. */
interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
if (interp_sect)
{
interp_text_sect_low
= bfd_section_vma (tmp_bfd, interp_sect);
interp_text_sect_low
+= displacement_from_map (ldm, interp_text_sect_low);
interp_text_sect_high
= interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
if (interp_sect)
{
interp_plt_sect_low =
bfd_section_vma (tmp_bfd, interp_sect);
interp_plt_sect_low
+= displacement_from_map (ldm, interp_plt_sect_low);
interp_plt_sect_high =
interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr");
if (addr == 0)
{
warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_addr (prior to relocation) = %s\n",
hex_string_custom (addr, 8));
addr += displacement_from_map (ldm, addr);
if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_addr (after relocation) = %s\n",
hex_string_custom (addr, 8));
/* Fetch the address of the r_debug struct. */
if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
{
warning (_("Unable to fetch contents of _dl_debug_addr (at address %s) from dynamic linker"),
hex_string_custom (addr, 8));
}
addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
/* Fetch the r_brk field. It's 8 bytes from the start of
_dl_debug_addr. */
if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0)
{
warning (_("Unable to fetch _dl_debug_addr->r_brk (at address %s) from dynamic linker"),
hex_string_custom (addr + 8, 8));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
/* Now fetch the function entry point. */
if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0)
{
warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point (at address %s) from dynamic linker"),
hex_string_custom (addr, 8));
enable_break_failure_warning ();
bfd_close (tmp_bfd);
return 0;
}
addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order);
/* We're done with the temporary bfd. */
bfd_close (tmp_bfd);
/* We're also done with the loadmap. */
xfree (ldm);
/* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (target_gdbarch, addr);
return 1;
}
static void
restore_section_callback(bfd *ibfd, asection *isec, void *args)
{
struct callback_data *data = (struct callback_data *)args;
bfd_vma sec_start = bfd_section_vma(ibfd, isec);
bfd_size_type size = bfd_section_size(ibfd, isec);
bfd_vma sec_end = (sec_start + size);
bfd_size_type sec_offset = 0UL;
bfd_size_type sec_load_count = size;
struct cleanup *old_chain;
gdb_byte *buf;
int ret;
/* Ignore non-loadable sections, eg. from elf files: */
if (!(bfd_get_section_flags(ibfd, isec) & SEC_LOAD))
return;
/* Does the section overlap with the desired restore range? */
if ((sec_end <= data->load_start)
|| ((data->load_end > 0) && (sec_start >= data->load_end)))
{
/* No, no useable data in this section. */
printf_filtered(_("skipping section %s...\n"),
bfd_section_name(ibfd, isec));
return;
}
/* Compare section address range with user-requested
address range (if any). Compute where the actual
transfer should start and end. */
if (sec_start < data->load_start)
sec_offset = (data->load_start - sec_start);
/* Size of a partial transfer: */
sec_load_count -= sec_offset;
if ((data->load_end > 0) && (sec_end > data->load_end))
sec_load_count -= (sec_end - data->load_end);
/* Get the data. */
buf = (gdb_byte *)xmalloc((size_t)size);
old_chain = make_cleanup(xfree, buf);
if (!bfd_get_section_contents(ibfd, isec, buf, 0, size))
error(_("Failed to read bfd file %s: '%s'."), bfd_get_filename(ibfd),
bfd_errmsg(bfd_get_error()));
printf_filtered("Restoring section %s (0x%lx to 0x%lx)",
bfd_section_name(ibfd, isec),
(unsigned long)sec_start, (unsigned long)sec_end);
if ((data->load_offset != 0) || (data->load_start != 0) || (data->load_end != 0))
printf_filtered(" into memory (0x%s to 0x%s)\n",
paddr_nz((unsigned long)sec_start
+ sec_offset + data->load_offset),
paddr_nz((unsigned long)sec_start + sec_offset
+ data->load_offset + sec_load_count));
else
puts_filtered("\n");
/* Write the data: */
ret = target_write_memory((sec_start + sec_offset + data->load_offset),
(buf + sec_offset), (int)sec_load_count);
if (ret != 0)
warning(_("restore: memory write failed (%s)."), safe_strerror(ret));
do_cleanups(old_chain);
return;
}
static int
enable_break (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
asection *interp_sect;
struct dsbt_info *info;
if (exec_bfd == NULL)
return 0;
if (!target_has_execution)
return 0;
info = get_dsbt_info ();
info->interp_text_sect_low = 0;
info->interp_text_sect_high = 0;
info->interp_plt_sect_low = 0;
info->interp_plt_sect_high = 0;
/* Find the .interp section; if not found, warn the user and drop
into the old breakpoint at symbol code. */
interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
if (interp_sect)
{
unsigned int interp_sect_size;
char *buf;
bfd *tmp_bfd = NULL;
CORE_ADDR addr;
gdb_byte addr_buf[TIC6X_PTR_SIZE];
struct int_elf32_dsbt_loadmap *ldm;
volatile struct gdb_exception ex;
int ret;
/* Read the contents of the .interp section into a local buffer;
the contents specify the dynamic linker this program uses. */
interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
buf = alloca (interp_sect_size);
bfd_get_section_contents (exec_bfd, interp_sect,
buf, 0, interp_sect_size);
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
in the dynamic linker itself. */
TRY_CATCH (ex, RETURN_MASK_ALL)
{
tmp_bfd = solib_bfd_open (buf);
}
if (tmp_bfd == NULL)
{
enable_break_failure_warning ();
return 0;
}
dsbt_get_initial_loadmaps ();
ldm = info->interp_loadmap;
/* Record the relocated start and end address of the dynamic linker
text and plt section for dsbt_in_dynsym_resolve_code. */
interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
if (interp_sect)
{
info->interp_text_sect_low
= bfd_section_vma (tmp_bfd, interp_sect);
info->interp_text_sect_low
+= displacement_from_map (ldm, info->interp_text_sect_low);
info->interp_text_sect_high
= info->interp_text_sect_low
+ bfd_section_size (tmp_bfd, interp_sect);
}
interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
if (interp_sect)
{
info->interp_plt_sect_low =
bfd_section_vma (tmp_bfd, interp_sect);
info->interp_plt_sect_low
+= displacement_from_map (ldm, info->interp_plt_sect_low);
info->interp_plt_sect_high =
info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
}
addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_state");
if (addr != 0)
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_state (prior to relocation) = %s\n",
hex_string_custom (addr, 8));
addr += displacement_from_map (ldm, addr);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_state (after relocation) = %s\n",
hex_string_custom (addr, 8));
/* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (target_gdbarch (), addr);
ret = 1;
}
else
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"enable_break: _dl_debug_state is not found\n");
ret = 0;
}
/* We're done with the temporary bfd. */
gdb_bfd_unref (tmp_bfd);
/* We're also done with the loadmap. */
xfree (ldm);
return ret;
}
