static struct embedded_symbol *analyze_traceback_table (CORE_ADDR pc)
{
struct traceback_table table;
static embedded_symbol symbol;
static char namebuf[256];
struct embedded_symbol *result = NULL;
size_t offset;
int status;
symbol.name = NULL;
symbol.language = language_unknown;
status = target_read_memory (pc, (char *) &table, sizeof (table));
if (status != 0) {
return NULL;
}
offset = sizeof (struct traceback_table);
if ((table.lang != TB_C) && (table.lang != TB_CPLUSPLUS)) {
return NULL;
}
if (table.fixedparams) { offset += 4; }
if (table.flags5 & TB_FLOATPARAMS) { offset += 4; }
if (table.flags1 & TB_HAS_TBOFF) { offset += 4; }
if (table.flags2 & TB_INT_HNDL) { offset += 4; }
if (table.flags1 & TB_HAS_CTL) {
struct traceback_table_anchors anchors;
status = target_read_memory (pc + offset, (char *) &anchors, sizeof (anchors));
if (status != 0) {
return NULL;
}
offset += 4;
if ((anchors.ctl_info < 0) || (anchors.ctl_info > 1024)) {
return NULL;
}
offset += anchors.ctl_info * 4;
}
if (table.flags2 & TB_NAME_PRESENT) {
struct traceback_table_routine name;
unsigned short rlen;
status = target_read_memory (pc + offset, (char *) &name, sizeof (name));
if (status != 0) {
return NULL;
}
rlen = name.name_len;
if (rlen >= sizeof (namebuf)) {
rlen = sizeof (namebuf) - 1;
}
status = target_read_memory (pc + offset + 2, namebuf, rlen);
if (status != 0) {
return NULL;
}
namebuf[rlen] = '\0';
if ((table.lang > 0) && (table.lang <= TB_ASM)) {
symbol.language = traceback_table_languages[table.lang];
} else {
symbol.language = language_unknown;
}
/* strip leading period inserted by compiler */
if (namebuf[0] == '.') {
symbol.name = &namebuf[1];
} else {
symbol.name = &namebuf[0];
}
result = &symbol;
}
return result;
}
static int
ia64_vms_find_proc_info_x (unw_addr_space_t as, unw_word_t ip,
unw_proc_info_t *pi,
int need_unwind_info, void *arg)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
unw_dyn_info_t di;
int ret;
gdb_byte buf[32];
const char *annex = core_addr_to_string (ip);
LONGEST res;
CORE_ADDR table_addr;
unsigned int info_len;
res = target_read (¤t_target, TARGET_OBJECT_OPENVMS_UIB,
annex + 2, buf, 0, sizeof (buf));
if (res != sizeof (buf))
return -UNW_ENOINFO;
pi->format = UNW_INFO_FORMAT_REMOTE_TABLE;
pi->start_ip = extract_unsigned_integer (buf + 0, 8, byte_order);
pi->end_ip = extract_unsigned_integer (buf + 8, 8, byte_order);
pi->gp = extract_unsigned_integer (buf + 24, 8, byte_order);
table_addr = extract_unsigned_integer (buf + 16, 8, byte_order);
if (table_addr == 0)
{
/* No unwind data. */
pi->unwind_info = NULL;
pi->unwind_info_size = 0;
return 0;
}
res = target_read_memory (table_addr, buf, 8);
if (res != 0)
return -UNW_ENOINFO;
/* Check version. */
if (extract_unsigned_integer (buf + 6, 2, byte_order) != 1)
return -UNW_EBADVERSION;
info_len = extract_unsigned_integer (buf + 0, 4, byte_order);
pi->unwind_info_size = 8 * info_len;
/* Read info. */
pi->unwind_info = xmalloc (pi->unwind_info_size);
res = target_read_memory (table_addr + 8,
pi->unwind_info, pi->unwind_info_size);
if (res != 0)
{
xfree (pi->unwind_info);
pi->unwind_info = NULL;
return -UNW_ENOINFO;
}
/* FIXME: Handle OSSD (OS Specific Data). This extension to ia64 unwind
information by OpenVMS is currently not handled by libunwind, but
looks to be used only in very specific context, and is not generated by
GCC. */
pi->lsda = table_addr + 8 + pi->unwind_info_size;
if (extract_unsigned_integer (buf + 4, 2, byte_order) & 3)
{
pi->lsda += 8;
/* There might be an handler, but this is not used for unwinding. */
pi->handler = 0;
}
return 0;
}
static LONGEST
frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
CORE_ADDR *sc_addr_cache_ptr)
{
CORE_ADDR sc_addr;
if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
{
sc_addr = *sc_addr_cache_ptr;
}
else
{
CORE_ADDR pc, sp;
char buf[4];
int tramp_type;
pc = get_frame_pc (this_frame);
tramp_type = frv_linux_pc_in_sigtramp (pc, 0);
get_frame_register (this_frame, sp_regnum, buf);
sp = extract_unsigned_integer (buf, sizeof buf);
if (tramp_type == NORMAL_SIGTRAMP)
{
/* For a normal sigtramp frame, the sigcontext struct starts
at SP + 8. */
sc_addr = sp + 8;
}
else if (tramp_type == RT_SIGTRAMP)
{
/* For a realtime sigtramp frame, SP + 12 contains a pointer
to a ucontext struct. The ucontext struct contains a
sigcontext struct starting 24 bytes in. (The offset of
uc_mcontext within struct ucontext is derived as follows:
stack_t is a 12-byte struct and struct sigcontext is
8-byte aligned. This gives an offset of 8 + 12 + 4 (for
padding) = 24.) */
if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
{
warning (_("Can't read realtime sigtramp frame."));
return 0;
}
sc_addr = extract_unsigned_integer (buf, sizeof buf);
sc_addr += 24;
}
else
internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
if (sc_addr_cache_ptr)
*sc_addr_cache_ptr = sc_addr;
}
switch (regno)
{
case psr_regnum :
return sc_addr + 0;
/* sc_addr + 4 has "isr", the Integer Status Register. */
case ccr_regnum :
return sc_addr + 8;
case cccr_regnum :
return sc_addr + 12;
case lr_regnum :
return sc_addr + 16;
case lcr_regnum :
return sc_addr + 20;
case pc_regnum :
return sc_addr + 24;
/* sc_addr + 28 is __status, the exception status.
sc_addr + 32 is syscallno, the syscall number or -1.
sc_addr + 36 is orig_gr8, the original syscall arg #1.
sc_addr + 40 is gner[0].
sc_addr + 44 is gner[1]. */
case iacc0h_regnum :
return sc_addr + 48;
case iacc0l_regnum :
return sc_addr + 52;
default :
if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
else
return -1; /* not saved. */
}
}
int
agent_run_command (int pid, const char *cmd, int len)
{
int fd;
int tid = agent_get_helper_thread_id ();
ptid_t ptid = ptid_build (pid, tid, 0);
#ifdef GDBSERVER
int ret = write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
(const unsigned char *) cmd, len);
#else
int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf, cmd, len);
#endif
if (ret != 0)
{
warning (_("unable to write"));
return -1;
}
DEBUG_AGENT ("agent: resumed helper thread\n");
/* Resume helper thread. */
#ifdef GDBSERVER
{
struct thread_resume resume_info;
resume_info.thread = ptid;
resume_info.kind = resume_continue;
resume_info.sig = GDB_SIGNAL_0;
(*the_target->resume) (&resume_info, 1);
}
#else
target_resume (ptid, 0, GDB_SIGNAL_0);
#endif
fd = gdb_connect_sync_socket (pid);
if (fd >= 0)
{
char buf[1] = "";
int ret;
DEBUG_AGENT ("agent: signalling helper thread\n");
do
{
ret = write (fd, buf, 1);
} while (ret == -1 && errno == EINTR);
DEBUG_AGENT ("agent: waiting for helper thread's response\n");
do
{
ret = read (fd, buf, 1);
} while (ret == -1 && errno == EINTR);
close (fd);
DEBUG_AGENT ("agent: helper thread's response received\n");
}
else
return -1;
/* Need to read response with the inferior stopped. */
if (!ptid_equal (ptid, null_ptid))
{
struct target_waitstatus status;
int was_non_stop = non_stop;
/* Stop thread PTID. */
DEBUG_AGENT ("agent: stop helper thread\n");
#ifdef GDBSERVER
{
struct thread_resume resume_info;
resume_info.thread = ptid;
resume_info.kind = resume_stop;
resume_info.sig = GDB_SIGNAL_0;
(*the_target->resume) (&resume_info, 1);
}
non_stop = 1;
mywait (ptid, &status, 0, 0);
#else
non_stop = 1;
target_stop (ptid);
memset (&status, 0, sizeof (status));
target_wait (ptid, &status, 0);
#endif
non_stop = was_non_stop;
}
if (fd >= 0)
{
#ifdef GDBSERVER
if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
(unsigned char *) cmd, IPA_CMD_BUF_SIZE))
#else
if (target_read_memory (ipa_sym_addrs.addr_cmd_buf, (gdb_byte *) cmd,
IPA_CMD_BUF_SIZE))
#endif
{
warning (_("Error reading command response"));
return -1;
}
}
return 0;
}
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;
CORE_ADDR 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
amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
struct amd64_windows_frame_cache *cache)
{
/* According to MSDN an epilogue "must consist of either an add RSP,constant
or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
register pops and a return or a jmp".
Furthermore, according to RtlVirtualUnwind, the complete list of
epilog marker is:
- ret [c3]
- ret n [c2 imm16]
- rep ret [f3 c3]
- jmp imm8 | imm32 [eb rel8] or [e9 rel32]
- jmp qword ptr imm32 - not handled
- rex.w jmp reg [4X ff eY]
*/
CORE_ADDR pc = cache->pc;
CORE_ADDR cur_sp = cache->sp;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte op;
gdb_byte rex;
/* We don't care about the instruction deallocating the frame:
if it hasn't been executed, the pc is still in the body,
if it has been executed, the following epilog decoding will work. */
/* First decode:
- pop reg [41 58-5f] or [58-5f]. */
while (1)
{
/* Read opcode. */
if (target_read_memory (pc, &op, 1) != 0)
return -1;
if (op >= 0x40 && op <= 0x4f)
{
/* REX prefix. */
rex = op;
/* Read opcode. */
if (target_read_memory (pc + 1, &op, 1) != 0)
return -1;
}
else
rex = 0;
if (op >= 0x58 && op <= 0x5f)
{
/* pop reg */
gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);
cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
cur_sp += 8;
}
else
break;
/* Allow the user to break this loop. This shouldn't happen as the
number of consecutive pop should be small. */
QUIT;
}
/* Then decode the marker. */
/* Read opcode. */
if (target_read_memory (pc, &op, 1) != 0)
return -1;
switch (op)
{
case 0xc3:
/* Ret. */
cache->prev_rip_addr = cur_sp;
cache->prev_sp = cur_sp + 8;
return 1;
case 0xeb:
{
/* jmp rel8 */
gdb_byte rel8;
CORE_ADDR npc;
if (target_read_memory (pc + 1, &rel8, 1) != 0)
return -1;
npc = pc + 2 + (signed char) rel8;
/* If the jump is within the function, then this is not a marker,
otherwise this is a tail-call. */
return !pc_in_range (npc, cache);
}
case 0xec:
{
/* jmp rel32 */
gdb_byte rel32[4];
CORE_ADDR npc;
if (target_read_memory (pc + 1, rel32, 4) != 0)
return -1;
npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
/* If the jump is within the function, then this is not a marker,
otherwise this is a tail-call. */
return !pc_in_range (npc, cache);
}
case 0xc2:
{
/* ret n */
gdb_byte imm16[2];
if (target_read_memory (pc + 1, imm16, 2) != 0)
return -1;
cache->prev_rip_addr = cur_sp;
cache->prev_sp = cur_sp
+ extract_unsigned_integer (imm16, 4, byte_order);
return 1;
}
case 0xf3:
{
/* rep; ret */
gdb_byte op1;
if (target_read_memory (pc + 2, &op1, 1) != 0)
return -1;
if (op1 != 0xc3)
return 0;
cache->prev_rip_addr = cur_sp;
cache->prev_sp = cur_sp + 8;
return 1;
}
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
/* Got a REX prefix, read next byte. */
rex = op;
if (target_read_memory (pc + 1, &op, 1) != 0)
return -1;
if (op == 0xff)
{
/* rex jmp reg */
gdb_byte op1;
unsigned int reg;
gdb_byte buf[8];
if (target_read_memory (pc + 2, &op1, 1) != 0)
return -1;
return (op1 & 0xf8) == 0xe0;
}
else
return 0;
default:
/* Not REX, so unknown. */
return 0;
}
}
static CORE_ADDR
ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
gdb_byte buf[4];
struct obj_section *sect;
struct objfile *objfile;
unsigned long insn;
CORE_ADDR plt_start = 0;
CORE_ADDR symtab = 0;
CORE_ADDR strtab = 0;
int num_slots = -1;
int reloc_index = -1;
CORE_ADDR plt_table;
CORE_ADDR reloc;
CORE_ADDR sym;
long symidx;
char symname[1024];
struct minimal_symbol *msymbol;
/* Find the section pc is in; return if not in .plt */
sect = find_pc_section (pc);
if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0)
return 0;
objfile = sect->objfile;
/* Pick up the instruction at pc. It had better be of the
form
li r11, IDX
where IDX is an index into the plt_table. */
if (target_read_memory (pc, buf, 4) != 0)
return 0;
insn = extract_unsigned_integer (buf, 4);
if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ )
return 0;
reloc_index = (insn << 16) >> 16;
/* Find the objfile that pc is in and obtain the information
necessary for finding the symbol name. */
for (sect = objfile->sections; sect < objfile->sections_end; ++sect)
{
const char *secname = sect->the_bfd_section->name;
if (strcmp (secname, ".plt") == 0)
plt_start = sect->addr;
else if (strcmp (secname, ".rela.plt") == 0)
num_slots = ((int) sect->endaddr - (int) sect->addr) / 12;
else if (strcmp (secname, ".dynsym") == 0)
symtab = sect->addr;
else if (strcmp (secname, ".dynstr") == 0)
strtab = sect->addr;
}
/* Make sure we have all the information we need. */
if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0)
return 0;
/* Compute the value of the plt table */
plt_table = plt_start + 72 + 8 * num_slots;
/* Get address of the relocation entry (Elf32_Rela) */
if (target_read_memory (plt_table + reloc_index, buf, 4) != 0)
return 0;
reloc = extract_unsigned_integer (buf, 4);
sect = find_pc_section (reloc);
if (!sect)
return 0;
if (strcmp (sect->the_bfd_section->name, ".text") == 0)
return reloc;
/* Now get the r_info field which is the relocation type and symbol
index. */
if (target_read_memory (reloc + 4, buf, 4) != 0)
return 0;
symidx = extract_unsigned_integer (buf, 4);
/* Shift out the relocation type leaving just the symbol index */
/* symidx = ELF32_R_SYM(symidx); */
symidx = symidx >> 8;
/* compute the address of the symbol */
sym = symtab + symidx * 4;
/* Fetch the string table index */
if (target_read_memory (sym, buf, 4) != 0)
return 0;
symidx = extract_unsigned_integer (buf, 4);
/* Fetch the string; we don't know how long it is. Is it possible
that the following will fail because we're trying to fetch too
much? */
if (target_read_memory (strtab + symidx, (gdb_byte *) symname,
sizeof (symname)) != 0)
return 0;
/* This might not work right if we have multiple symbols with the
same name; the only way to really get it right is to perform
the same sort of lookup as the dynamic linker. */
msymbol = lookup_minimal_symbol_text (symname, NULL);
if (!msymbol)
return 0;
return SYMBOL_VALUE_ADDRESS (msymbol);
}
static CORE_ADDR
lm_base (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
struct minimal_symbol *got_sym;
CORE_ADDR addr;
gdb_byte buf[TIC6X_PTR_SIZE];
struct dsbt_info *info = get_dsbt_info ();
/* One of our assumptions is that the main executable has been relocated.
Bail out if this has not happened. (Note that post_create_inferior
in infcmd.c will call solib_add prior to solib_create_inferior_hook.
If we allow this to happen, lm_base_cache will be initialized with
a bogus value. */
if (info->main_executable_lm_info == 0)
return 0;
/* If we already have a cached value, return it. */
if (info->lm_base_cache)
return info->lm_base_cache;
got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
symfile_objfile);
if (got_sym != 0)
{
addr = SYMBOL_VALUE_ADDRESS (got_sym);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
(unsigned int) addr);
}
else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
{
struct int_elf32_dsbt_loadmap *ldm;
dsbt_get_initial_loadmaps ();
ldm = info->exec_loadmap;
addr += displacement_from_map (ldm, addr);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"lm_base: get addr %x by DT_PLTGOT.\n",
(unsigned int) addr);
}
else
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
return 0;
}
addr += GOT_MODULE_OFFSET;
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
GOT_MODULE_OFFSET, hex_string_custom (addr, 8));
if (target_read_memory (addr, buf, sizeof buf) != 0)
return 0;
info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"lm_base: lm_base_cache = %s\n",
hex_string_custom (info->lm_base_cache, 8));
return info->lm_base_cache;
}
/* Scan an FR-V prologue, starting at PC, until frame->PC.
If FRAME is non-zero, fill in its saved_regs with appropriate addresses.
We assume FRAME's saved_regs array has already been allocated and cleared.
Return the first PC value after the prologue.
Note that, for unoptimized code, we almost don't need this function
at all; all arguments and locals live on the stack, so we just need
the FP to find everything. The catch: structures passed by value
have their addresses living in registers; they're never spilled to
the stack. So if you ever want to be able to get to these
arguments in any frame but the top, you'll need to do this serious
prologue analysis. */
static CORE_ADDR
frv_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
struct frame_info *this_frame,
struct frv_unwind_cache *info)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* When writing out instruction bitpatterns, we use the following
letters to label instruction fields:
P - The parallel bit. We don't use this.
J - The register number of GRj in the instruction description.
K - The register number of GRk in the instruction description.
I - The register number of GRi.
S - a signed imediate offset.
U - an unsigned immediate offset.
The dots below the numbers indicate where hex digit boundaries
fall, to make it easier to check the numbers. */
/* Non-zero iff we've seen the instruction that initializes the
frame pointer for this function's frame. */
int fp_set = 0;
/* If fp_set is non_zero, then this is the distance from
the stack pointer to frame pointer: fp = sp + fp_offset. */
int fp_offset = 0;
/* Total size of frame prior to any alloca operations. */
int framesize = 0;
/* Flag indicating if lr has been saved on the stack. */
int lr_saved_on_stack = 0;
/* The number of the general-purpose register we saved the return
address ("link register") in, or -1 if we haven't moved it yet. */
int lr_save_reg = -1;
/* Offset (from sp) at which lr has been saved on the stack. */
int lr_sp_offset = 0;
/* If gr_saved[i] is non-zero, then we've noticed that general
register i has been saved at gr_sp_offset[i] from the stack
pointer. */
char gr_saved[64];
int gr_sp_offset[64];
/* The address of the most recently scanned prologue instruction. */
CORE_ADDR last_prologue_pc;
/* The address of the next instruction. */
CORE_ADDR next_pc;
/* The upper bound to of the pc values to scan. */
CORE_ADDR lim_pc;
memset (gr_saved, 0, sizeof (gr_saved));
last_prologue_pc = pc;
/* Try to compute an upper limit (on how far to scan) based on the
line number info. */
lim_pc = skip_prologue_using_sal (gdbarch, pc);
/* If there's no line number info, lim_pc will be 0. In that case,
set the limit to be 100 instructions away from pc. Hopefully, this
will be far enough away to account for the entire prologue. Don't
worry about overshooting the end of the function. The scan loop
below contains some checks to avoid scanning unreasonably far. */
if (lim_pc == 0)
lim_pc = pc + 400;
/* If we have a frame, we don't want to scan past the frame's pc. This
will catch those cases where the pc is in the prologue. */
if (this_frame)
{
CORE_ADDR frame_pc = get_frame_pc (this_frame);
if (frame_pc < lim_pc)
lim_pc = frame_pc;
}
/* Scan the prologue. */
while (pc < lim_pc)
{
gdb_byte buf[frv_instr_size];
LONGEST op;
if (target_read_memory (pc, buf, sizeof buf) != 0)
break;
op = extract_signed_integer (buf, sizeof buf, byte_order);
next_pc = pc + 4;
/* The tests in this chain of ifs should be in order of
decreasing selectivity, so that more particular patterns get
to fire before less particular patterns. */
/* Some sort of control transfer instruction: stop scanning prologue.
Integer Conditional Branch:
X XXXX XX 0000110 XX XXXXXXXXXXXXXXXX
Floating-point / media Conditional Branch:
X XXXX XX 0000111 XX XXXXXXXXXXXXXXXX
LCR Conditional Branch to LR
X XXXX XX 0001110 XX XX 001 X XXXXXXXXXX
Integer conditional Branches to LR
X XXXX XX 0001110 XX XX 010 X XXXXXXXXXX
X XXXX XX 0001110 XX XX 011 X XXXXXXXXXX
Floating-point/Media Branches to LR
X XXXX XX 0001110 XX XX 110 X XXXXXXXXXX
X XXXX XX 0001110 XX XX 111 X XXXXXXXXXX
Jump and Link
X XXXXX X 0001100 XXXXXX XXXXXX XXXXXX
X XXXXX X 0001101 XXXXXX XXXXXX XXXXXX
Call
X XXXXXX 0001111 XXXXXXXXXXXXXXXXXX
Return from Trap
X XXXXX X 0000101 XXXXXX XXXXXX XXXXXX
Integer Conditional Trap
X XXXX XX 0000100 XXXXXX XXXX 00 XXXXXX
X XXXX XX 0011100 XXXXXX XXXXXXXXXXXX
Floating-point /media Conditional Trap
X XXXX XX 0000100 XXXXXX XXXX 01 XXXXXX
X XXXX XX 0011101 XXXXXX XXXXXXXXXXXX
Break
X XXXX XX 0000100 XXXXXX XXXX 11 XXXXXX
Media Trap
X XXXX XX 0000100 XXXXXX XXXX 10 XXXXXX */
if ((op & 0x01d80000) == 0x00180000 /* Conditional branches and Call */
|| (op & 0x01f80000) == 0x00300000 /* Jump and Link */
|| (op & 0x01f80000) == 0x00100000 /* Return from Trap, Trap */
|| (op & 0x01f80000) == 0x00700000) /* Trap immediate */
{
/* Stop scanning; not in prologue any longer. */
break;
}
/* Loading something from memory into fp probably means that
we're in the epilogue. Stop scanning the prologue.
ld @(GRi, GRk), fp
X 000010 0000010 XXXXXX 000100 XXXXXX
ldi @(GRi, d12), fp
X 000010 0110010 XXXXXX XXXXXXXXXXXX */
else if ((op & 0x7ffc0fc0) == 0x04080100
|| (op & 0x7ffc0000) == 0x04c80000)
{
break;
}
/* Setting the FP from the SP:
ori sp, 0, fp
P 000010 0100010 000001 000000000000 = 0x04881000
0 111111 1111111 111111 111111111111 = 0x7fffffff
. . . . . . . .
We treat this as part of the prologue. */
else if ((op & 0x7fffffff) == 0x04881000)
{
fp_set = 1;
fp_offset = 0;
last_prologue_pc = next_pc;
}
/* Move the link register to the scratch register grJ, before saving:
movsg lr, grJ
P 000100 0000011 010000 000111 JJJJJJ = 0x080d01c0
0 111111 1111111 111111 111111 000000 = 0x7fffffc0
. . . . . . . .
We treat this as part of the prologue. */
else if ((op & 0x7fffffc0) == 0x080d01c0)
{
int gr_j = op & 0x3f;
/* If we're moving it to a scratch register, that's fine. */
if (is_caller_saves_reg (gr_j))
{
lr_save_reg = gr_j;
last_prologue_pc = next_pc;
}
}
/* To save multiple callee-saves registers on the stack, at
offset zero:
std grK,@(sp,gr0)
P KKKKKK 0000011 000001 000011 000000 = 0x000c10c0
0 000000 1111111 111111 111111 111111 = 0x01ffffff
stq grK,@(sp,gr0)
P KKKKKK 0000011 000001 000100 000000 = 0x000c1100
0 000000 1111111 111111 111111 111111 = 0x01ffffff
. . . . . . . .
We treat this as part of the prologue, and record the register's
saved address in the frame structure. */
else if ((op & 0x01ffffff) == 0x000c10c0
|| (op & 0x01ffffff) == 0x000c1100)
{
int gr_k = ((op >> 25) & 0x3f);
int ope = ((op >> 6) & 0x3f);
int count;
int i;
/* Is it an std or an stq? */
if (ope == 0x03)
count = 2;
else
count = 4;
/* Is it really a callee-saves register? */
if (is_callee_saves_reg (gr_k))
{
for (i = 0; i < count; i++)
{
gr_saved[gr_k + i] = 1;
gr_sp_offset[gr_k + i] = 4 * i;
}
last_prologue_pc = next_pc;
}
}
/* Adjusting the stack pointer. (The stack pointer is GR1.)
addi sp, S, sp
P 000001 0010000 000001 SSSSSSSSSSSS = 0x02401000
0 111111 1111111 111111 000000000000 = 0x7ffff000
. . . . . . . .
We treat this as part of the prologue. */
else if ((op & 0x7ffff000) == 0x02401000)
static struct so_list *
frv_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm_addr, mgot;
struct so_list *sos_head = NULL;
struct so_list **sos_next_ptr = &sos_head;
/* Make sure that the main executable has been relocated. This is
required in order to find the address of the global offset table,
which in turn is used to find the link map info. (See lm_base()
for details.)
Note that the relocation of the main executable is also performed
by solib_create_inferior_hook(), however, in the case of core
files, this hook is called too late in order to be of benefit to
solib_add. solib_add eventually calls this this function,
frv_current_sos, and also precedes the call to
solib_create_inferior_hook(). (See post_create_inferior() in
infcmd.c.) */
if (main_executable_lm_info == 0 && core_bfd != NULL)
frv_relocate_main_executable ();
/* Fetch the GOT corresponding to the main executable. */
mgot = main_got ();
/* Locate the address of the first link map struct. */
lm_addr = lm_base ();
/* We have at least one link map entry. Fetch the lot of them,
building the solist chain. */
while (lm_addr)
{
struct ext_link_map lm_buf;
CORE_ADDR got_addr;
if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog,
"current_sos: reading link_map entry at %s\n",
hex_string_custom (lm_addr, 8));
if (target_read_memory (lm_addr, (gdb_byte *) &lm_buf,
sizeof (lm_buf)) != 0)
{
warning (_("frv_current_sos: Unable to read link map entry. "
"Shared object chain may be incomplete."));
break;
}
got_addr
= extract_unsigned_integer (lm_buf.l_addr.got_value,
sizeof (lm_buf.l_addr.got_value),
byte_order);
/* If the got_addr is the same as mgotr, then we're looking at the
entry for the main executable. By convention, we don't include
this in the list of shared objects. */
if (got_addr != mgot)
{
int errcode;
char *name_buf;
struct int_elf32_fdpic_loadmap *loadmap;
struct so_list *sop;
CORE_ADDR addr;
/* Fetch the load map address. */
addr = extract_unsigned_integer (lm_buf.l_addr.map,
sizeof lm_buf.l_addr.map,
byte_order);
loadmap = fetch_loadmap (addr);
if (loadmap == NULL)
{
warning (_("frv_current_sos: Unable to fetch load map. "
"Shared object chain may be incomplete."));
break;
}
sop = XCNEW (struct so_list);
sop->lm_info = XCNEW (struct lm_info);
sop->lm_info->map = loadmap;
sop->lm_info->got_value = got_addr;
sop->lm_info->lm_addr = lm_addr;
/* Fetch the name. */
addr = extract_unsigned_integer (lm_buf.l_name,
sizeof (lm_buf.l_name),
byte_order);
target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
&errcode);
if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
name_buf);
if (errcode != 0)
warning (_("Can't read pathname for link map entry: %s."),
safe_strerror (errcode));
else
{
strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
xfree (name_buf);
strcpy (sop->so_original_name, sop->so_name);
}
*sos_next_ptr = sop;
sos_next_ptr = &sop->next;
}
else
{
static void
pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
int offset,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value *val,
const struct value_print_options *options,
struct type **dont_print_vb)
{
struct type **last_dont_print
= (struct type **) obstack_next_free (&dont_print_vb_obstack);
struct obstack tmp_obstack = dont_print_vb_obstack;
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
if (dont_print_vb == 0)
{
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
/* Bump up the high-water mark. Now alpha is omega. */
obstack_finish (&dont_print_vb_obstack);
}
for (i = 0; i < n_baseclasses; i++)
{
int boffset = 0;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
const char *basename = type_name_no_tag (baseclass);
const gdb_byte *base_valaddr = NULL;
int thisoffset;
int skip = 0;
if (BASETYPE_VIA_VIRTUAL (type, i))
{
struct type **first_dont_print
= (struct type **) obstack_base (&dont_print_vb_obstack);
int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
- first_dont_print;
while (--j >= 0)
if (baseclass == first_dont_print[j])
goto flush_it;
obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
}
thisoffset = offset;
TRY
{
boffset = baseclass_offset (type, i, valaddr, offset, address, val);
}
CATCH (ex, RETURN_MASK_ERROR)
{
if (ex.error == NOT_AVAILABLE_ERROR)
skip = -1;
else
skip = 1;
}
END_CATCH
if (skip == 0)
{
/* The virtual base class pointer might have been clobbered by the
user program. Make sure that it still points to a valid memory
location. */
if (boffset < 0 || boffset >= TYPE_LENGTH (type))
{
gdb_byte *buf;
struct cleanup *back_to;
buf = xmalloc (TYPE_LENGTH (baseclass));
back_to = make_cleanup (xfree, buf);
base_valaddr = buf;
if (target_read_memory (address + boffset, buf,
TYPE_LENGTH (baseclass)) != 0)
skip = 1;
address = address + boffset;
thisoffset = 0;
boffset = 0;
do_cleanups (back_to);
}
else
base_valaddr = valaddr;
}
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
fputs_filtered ("<", stream);
/* Not sure what the best notation is in the case where there is no
baseclass name. */
fputs_filtered (basename ? basename : "", stream);
fputs_filtered ("> = ", stream);
if (skip < 0)
val_print_unavailable (stream);
else if (skip > 0)
val_print_invalid_address (stream);
else
pascal_object_print_value_fields (baseclass, base_valaddr,
thisoffset + boffset, address,
stream, recurse, val, options,
(struct type **) obstack_base (&dont_print_vb_obstack),
0);
fputs_filtered (", ", stream);
flush_it:
;
}
if (dont_print_vb == 0)
{
/* Free the space used to deal with the printing
of this type from top level. */
obstack_free (&dont_print_vb_obstack, last_dont_print);
/* Reset watermark so that we can continue protecting
ourselves from whatever we were protecting ourselves. */
dont_print_vb_obstack = tmp_obstack;
}
}
static int
amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
CORE_ADDR *unwind_info,
CORE_ADDR *image_base,
CORE_ADDR *start_rva,
CORE_ADDR *end_rva)
{
struct obj_section *sec;
pe_data_type *pe;
IMAGE_DATA_DIRECTORY *dir;
struct objfile *objfile;
unsigned long lo, hi;
CORE_ADDR base;
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Get the corresponding exception directory. */
sec = find_pc_section (pc);
if (sec == NULL)
return -1;
objfile = sec->objfile;
pe = pe_data (sec->objfile->obfd);
dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
base = pe->pe_opthdr.ImageBase
+ ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
*image_base = base;
/* Find the entry.
Note: This does not handle dynamically added entries (for JIT
engines). For this, we would need to ask the kernel directly,
which means getting some info from the native layer. For the
rest of the code, however, it's probably faster to search
the entry ourselves. */
lo = 0;
hi = dir->Size / sizeof (struct external_pex64_runtime_function);
*unwind_info = 0;
while (lo <= hi)
{
unsigned long mid = lo + (hi - lo) / 2;
struct external_pex64_runtime_function d;
CORE_ADDR sa, ea;
if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
(gdb_byte *) &d, sizeof (d)) != 0)
return -1;
sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
if (pc < base + sa)
hi = mid - 1;
else if (pc >= base + ea)
lo = mid + 1;
else if (pc >= base + sa && pc < base + ea)
{
/* Got it. */
*start_rva = sa;
*end_rva = ea;
*unwind_info =
extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
break;
}
else
break;
}
if (frame_debug)
fprintf_unfiltered
(gdb_stdlog,
"amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
if (*unwind_info & 1)
{
/* Unofficially documented unwind info redirection, when UNWIND_INFO
address is odd (http://www.codemachine.com/article_x64deepdive.html).
*/
struct external_pex64_runtime_function d;
CORE_ADDR sa, ea;
if (target_read_memory (base + (*unwind_info & ~1),
(gdb_byte *) &d, sizeof (d)) != 0)
return -1;
*start_rva =
extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
*end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
*unwind_info =
extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
}
return 0;
}
static void
amd64_windows_frame_decode_insns (struct frame_info *this_frame,
struct amd64_windows_frame_cache *cache,
CORE_ADDR unwind_info)
{
CORE_ADDR save_addr = 0;
CORE_ADDR cur_sp = cache->sp;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int j;
for (j = 0; ; j++)
{
struct external_pex64_unwind_info ex_ui;
/* There are at most 256 16-bit unwind insns. */
gdb_byte insns[2 * 256];
gdb_byte *p;
gdb_byte *end_insns;
unsigned char codes_count;
unsigned char frame_reg;
unsigned char frame_off;
/* Read and decode header. */
if (target_read_memory (cache->image_base + unwind_info,
(gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
return;
if (frame_debug)
fprintf_unfiltered
(gdb_stdlog,
"amd64_windows_frame_decodes_insn: "
"%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
paddress (gdbarch, unwind_info),
ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);
/* Check version. */
if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
&& PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
return;
if (j == 0
&& (cache->pc >=
cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue))
{
/* Not in the prologue. We want to detect if the PC points to an
epilogue. If so, the epilogue detection+decoding function is
sufficient. Otherwise, the unwinder will consider that the PC
is in the body of the function and will need to decode unwind
info. */
if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
return;
/* Not in an epilog. Clear possible side effects. */
memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
}
codes_count = ex_ui.CountOfCodes;
frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
if (frame_reg != 0)
{
/* According to msdn:
If an FP reg is used, then any unwind code taking an offset must
only be used after the FP reg is established in the prolog. */
gdb_byte buf[8];
int frreg = amd64_windows_w2gdb_regnum[frame_reg];
get_frame_register (this_frame, frreg, buf);
save_addr = extract_unsigned_integer (buf, 8, byte_order);
if (frame_debug)
fprintf_unfiltered (gdb_stdlog, " frame_reg=%s, val=%s\n",
gdbarch_register_name (gdbarch, frreg),
paddress (gdbarch, save_addr));
}
/* Read opcodes. */
if (codes_count != 0
&& target_read_memory (cache->image_base + unwind_info
+ sizeof (ex_ui),
insns, codes_count * 2) != 0)
return;
end_insns = &insns[codes_count * 2];
p = insns;
/* Skip opcodes 6 of version 2. This opcode is not documented. */
if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
{
for (; p < end_insns; p += 2)
if (PEX64_UNWCODE_CODE (p[1]) != 6)
break;
}
for (; p < end_insns; p += 2)
{
int reg;
if (frame_debug)
fprintf_unfiltered
(gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n",
(unsigned) (p - insns), p[0], p[1]);
/* Virtually execute the operation. */
if (cache->pc >= cache->image_base + cache->start_rva + p[0])
{
/* If there is no frame registers defined, the current value of
rsp is used instead. */
if (frame_reg == 0)
save_addr = cur_sp;
switch (PEX64_UNWCODE_CODE (p[1]))
{
case UWOP_PUSH_NONVOL:
/* Push pre-decrements RSP. */
reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
cache->prev_reg_addr[reg] = cur_sp;
cur_sp += 8;
break;
case UWOP_ALLOC_LARGE:
if (PEX64_UNWCODE_INFO (p[1]) == 0)
cur_sp +=
8 * extract_unsigned_integer (p + 2, 2, byte_order);
else if (PEX64_UNWCODE_INFO (p[1]) == 1)
cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
else
return;
break;
case UWOP_ALLOC_SMALL:
cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
break;
case UWOP_SET_FPREG:
cur_sp = save_addr
- PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
break;
case UWOP_SAVE_NONVOL:
reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
cache->prev_reg_addr[reg] = save_addr
- 8 * extract_unsigned_integer (p + 2, 2, byte_order);
break;
case UWOP_SAVE_NONVOL_FAR:
reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
cache->prev_reg_addr[reg] = save_addr
- 8 * extract_unsigned_integer (p + 2, 4, byte_order);
break;
case UWOP_SAVE_XMM128:
cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
save_addr
- 16 * extract_unsigned_integer (p + 2, 2, byte_order);
break;
case UWOP_SAVE_XMM128_FAR:
cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
save_addr
- 16 * extract_unsigned_integer (p + 2, 4, byte_order);
break;
case UWOP_PUSH_MACHFRAME:
if (PEX64_UNWCODE_INFO (p[1]) == 0)
{
cache->prev_rip_addr = cur_sp + 0;
cache->prev_rsp_addr = cur_sp + 24;
cur_sp += 40;
}
else if (PEX64_UNWCODE_INFO (p[1]) == 1)
{
cache->prev_rip_addr = cur_sp + 8;
cache->prev_rsp_addr = cur_sp + 32;
cur_sp += 48;
}
else
return;
break;
default:
return;
}
}
/* Adjust with the length of the opcode. */
switch (PEX64_UNWCODE_CODE (p[1]))
{
case UWOP_PUSH_NONVOL:
case UWOP_ALLOC_SMALL:
case UWOP_SET_FPREG:
case UWOP_PUSH_MACHFRAME:
break;
case UWOP_ALLOC_LARGE:
if (PEX64_UNWCODE_INFO (p[1]) == 0)
p += 2;
else if (PEX64_UNWCODE_INFO (p[1]) == 1)
p += 4;
else
return;
break;
case UWOP_SAVE_NONVOL:
case UWOP_SAVE_XMM128:
p += 2;
break;
case UWOP_SAVE_NONVOL_FAR:
case UWOP_SAVE_XMM128_FAR:
p += 4;
break;
default:
return;
}
}
if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
break;
else
{
/* Read the chained unwind info. */
struct external_pex64_runtime_function d;
CORE_ADDR chain_vma;
chain_vma = cache->image_base + unwind_info
+ sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2;
if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
return;
cache->start_rva =
extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
cache->end_rva =
extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
unwind_info =
extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
if (frame_debug)
fprintf_unfiltered
(gdb_stdlog,
"amd64_windows_frame_decodes_insn (next in chain):"
" unwind_data=%s, start_rva=%s, end_rva=%s\n",
paddress (gdbarch, unwind_info),
paddress (gdbarch, cache->start_rva),
paddress (gdbarch, cache->end_rva));
}
/* Allow the user to break this loop. */
QUIT;
}
/* PC is saved by the call. */
if (cache->prev_rip_addr == 0)
cache->prev_rip_addr = cur_sp;
cache->prev_sp = cur_sp + 8;
if (frame_debug)
fprintf_unfiltered (gdb_stdlog, " prev_sp: %s, prev_pc @%s\n",
paddress (gdbarch, cache->prev_sp),
paddress (gdbarch, cache->prev_rip_addr));
}
static struct int_elf32_dsbt_loadmap *
fetch_loadmap (CORE_ADDR ldmaddr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
struct int_elf32_dsbt_loadmap *int_ldmbuf;
int ext_ldmbuf_size, int_ldmbuf_size;
int version, seg, nsegs;
/* Fetch initial portion of the loadmap. */
if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
sizeof ext_ldmbuf_partial))
{
/* Problem reading the target's memory. */
return NULL;
}
/* Extract the version. */
version = extract_unsigned_integer (ext_ldmbuf_partial.version,
sizeof ext_ldmbuf_partial.version,
byte_order);
if (version != 0)
{
/* We only handle version 0. */
return NULL;
}
/* Extract the number of segments. */
nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
sizeof ext_ldmbuf_partial.nsegs,
byte_order);
if (nsegs <= 0)
return NULL;
/* Allocate space for the complete (external) loadmap. */
ext_ldmbuf_size = sizeof (struct ext_elf32_dsbt_loadmap)
+ (nsegs - 1) * sizeof (struct ext_elf32_dsbt_loadseg);
ext_ldmbuf = xmalloc (ext_ldmbuf_size);
/* Copy over the portion of the loadmap that's already been read. */
memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
/* Read the rest of the loadmap from the target. */
if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
(gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
{
/* Couldn't read rest of the loadmap. */
xfree (ext_ldmbuf);
return NULL;
}
/* Allocate space into which to put information extract from the
external loadsegs. I.e, allocate the internal loadsegs. */
int_ldmbuf_size = sizeof (struct int_elf32_dsbt_loadmap)
+ (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg);
int_ldmbuf = xmalloc (int_ldmbuf_size);
/* Place extracted information in internal structs. */
int_ldmbuf->version = version;
int_ldmbuf->nsegs = nsegs;
for (seg = 0; seg < nsegs; seg++)
{
int_ldmbuf->segs[seg].addr
= extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
sizeof (ext_ldmbuf->segs[seg].addr),
byte_order);
int_ldmbuf->segs[seg].p_vaddr
= extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
sizeof (ext_ldmbuf->segs[seg].p_vaddr),
byte_order);
int_ldmbuf->segs[seg].p_memsz
= extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
sizeof (ext_ldmbuf->segs[seg].p_memsz),
byte_order);
}
xfree (ext_ldmbuf);
return int_ldmbuf;
}
static enum target_xfer_status
ld_so_xfer_auxv (gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset,
ULONGEST len, ULONGEST *xfered_len)
{
struct bound_minimal_symbol msym;
CORE_ADDR data_address, pointer_address;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
size_t ptr_size = TYPE_LENGTH (ptr_type);
size_t auxv_pair_size = 2 * ptr_size;
gdb_byte *ptr_buf = alloca (ptr_size);
LONGEST retval;
size_t block;
msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
if (msym.minsym == NULL)
return TARGET_XFER_E_IO;
if (MSYMBOL_SIZE (msym.minsym) != ptr_size)
return TARGET_XFER_E_IO;
/* POINTER_ADDRESS is a location where the `_dl_auxv' variable
resides. DATA_ADDRESS is the inferior value present in
`_dl_auxv', therefore the real inferior AUXV address. */
pointer_address = BMSYMBOL_VALUE_ADDRESS (msym);
/* The location of the _dl_auxv symbol may no longer be correct if
ld.so runs at a different address than the one present in the
file. This is very common case - for unprelinked ld.so or with a
PIE executable. PIE executable forces random address even for
libraries already being prelinked to some address. PIE
executables themselves are never prelinked even on prelinked
systems. Prelinking of a PIE executable would block their
purpose of randomizing load of everything including the
executable.
If the memory read fails, return -1 to fallback on another
mechanism for retrieving the AUXV.
In most cases of a PIE running under valgrind there is no way to
find out the base addresses of any of ld.so, executable or AUXV
as everything is randomized and /proc information is not relevant
for the virtual executable running under valgrind. We think that
we might need a valgrind extension to make it work. This is PR
11440. */
if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
return TARGET_XFER_E_IO;
data_address = extract_typed_address (ptr_buf, ptr_type);
/* Possibly still not initialized such as during an inferior
startup. */
if (data_address == 0)
return TARGET_XFER_E_IO;
data_address += offset;
if (writebuf != NULL)
{
if (target_write_memory (data_address, writebuf, len) == 0)
{
*xfered_len = (ULONGEST) len;
return TARGET_XFER_OK;
}
else
return TARGET_XFER_E_IO;
}
/* Stop if trying to read past the existing AUXV block. The final
AT_NULL was already returned before. */
if (offset >= auxv_pair_size)
{
if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
ptr_size) != 0)
return TARGET_XFER_E_IO;
if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
return TARGET_XFER_EOF;
}
retval = 0;
block = 0x400;
gdb_assert (block % auxv_pair_size == 0);
while (len > 0)
{
if (block > len)
block = len;
/* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
Tails unaligned to AUXV_PAIR_SIZE will not be read during a
call (they should be completed during next read with
new/extended buffer). */
block &= -auxv_pair_size;
if (block == 0)
break;
if (target_read_memory (data_address, readbuf, block) != 0)
{
if (block <= auxv_pair_size)
break;
block = auxv_pair_size;
continue;
}
data_address += block;
len -= block;
/* Check terminal AT_NULL. This function is being called
indefinitely being extended its READBUF until it returns EOF
(0). */
while (block >= auxv_pair_size)
{
retval += auxv_pair_size;
if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
{
*xfered_len = (ULONGEST) retval;
return TARGET_XFER_OK;
}
readbuf += auxv_pair_size;
block -= auxv_pair_size;
}
}
*xfered_len = (ULONGEST) retval;
return TARGET_XFER_OK;
}
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 int do_semihosting(struct target *target)
{
struct arm *arm = target_to_arm(target);
struct gdb_fileio_info *fileio_info = target->fileio_info;
uint32_t r0 = buf_get_u32(arm->core_cache->reg_list[0].value, 0, 32);
uint32_t r1 = buf_get_u32(arm->core_cache->reg_list[1].value, 0, 32);
uint8_t params[16];
int retval;
/*
* TODO: lots of security issues are not considered yet, such as:
* - no validation on target provided file descriptors
* - no safety checks on opened/deleted/renamed file paths
* Beware the target app you use this support with.
*
* TODO: unsupported semihosting fileio operations could be
* implemented if we had a small working area at our disposal.
*/
switch ((arm->semihosting_op = r0)) {
case 0x01: /* SYS_OPEN */
retval = target_read_memory(target, r1, 4, 3, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t a = target_buffer_get_u32(target, params+0);
uint32_t m = target_buffer_get_u32(target, params+4);
uint32_t l = target_buffer_get_u32(target, params+8);
uint8_t fn[256];
retval = target_read_memory(target, a, 1, l, fn);
if (retval != ERROR_OK)
return retval;
fn[l] = 0;
if (arm->is_semihosting_fileio) {
if (strcmp((char *)fn, ":tt") == 0)
arm->semihosting_result = 0;
else {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "open";
fileio_info->param_1 = a;
fileio_info->param_2 = l;
fileio_info->param_3 = open_modeflags[m];
fileio_info->param_4 = 0644;
}
} else {
if (l <= 255 && m <= 11) {
if (strcmp((char *)fn, ":tt") == 0) {
if (m < 4)
arm->semihosting_result = dup(STDIN_FILENO);
else
arm->semihosting_result = dup(STDOUT_FILENO);
} else {
/* cygwin requires the permission setting
* otherwise it will fail to reopen a previously
* written file */
arm->semihosting_result = open((char *)fn, open_modeflags[m], 0644);
}
arm->semihosting_errno = errno;
} else {
arm->semihosting_result = -1;
arm->semihosting_errno = EINVAL;
}
}
}
break;
case 0x02: /* SYS_CLOSE */
retval = target_read_memory(target, r1, 4, 1, params);
if (retval != ERROR_OK)
return retval;
else {
int fd = target_buffer_get_u32(target, params+0);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "close";
fileio_info->param_1 = fd;
} else {
arm->semihosting_result = close(fd);
arm->semihosting_errno = errno;
}
}
break;
case 0x03: /* SYS_WRITEC */
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "write";
fileio_info->param_1 = 1;
fileio_info->param_2 = r1;
fileio_info->param_3 = 1;
} else {
unsigned char c;
retval = target_read_memory(target, r1, 1, 1, &c);
if (retval != ERROR_OK)
return retval;
putchar(c);
arm->semihosting_result = 0;
}
break;
case 0x04: /* SYS_WRITE0 */
if (arm->is_semihosting_fileio) {
size_t count = 0;
for (uint32_t a = r1;; a++) {
unsigned char c;
retval = target_read_memory(target, a, 1, 1, &c);
if (retval != ERROR_OK)
return retval;
if (c == '\0')
break;
count++;
}
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "write";
fileio_info->param_1 = 1;
fileio_info->param_2 = r1;
fileio_info->param_3 = count;
} else {
do {
unsigned char c;
retval = target_read_memory(target, r1++, 1, 1, &c);
if (retval != ERROR_OK)
return retval;
if (!c)
break;
putchar(c);
} while (1);
arm->semihosting_result = 0;
}
break;
case 0x05: /* SYS_WRITE */
retval = target_read_memory(target, r1, 4, 3, params);
if (retval != ERROR_OK)
return retval;
else {
int fd = target_buffer_get_u32(target, params+0);
uint32_t a = target_buffer_get_u32(target, params+4);
size_t l = target_buffer_get_u32(target, params+8);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "write";
fileio_info->param_1 = fd;
fileio_info->param_2 = a;
fileio_info->param_3 = l;
} else {
uint8_t *buf = malloc(l);
if (!buf) {
arm->semihosting_result = -1;
arm->semihosting_errno = ENOMEM;
} else {
retval = target_read_buffer(target, a, l, buf);
if (retval != ERROR_OK) {
free(buf);
return retval;
}
arm->semihosting_result = write(fd, buf, l);
arm->semihosting_errno = errno;
if (arm->semihosting_result >= 0)
arm->semihosting_result = l - arm->semihosting_result;
free(buf);
}
}
}
break;
case 0x06: /* SYS_READ */
retval = target_read_memory(target, r1, 4, 3, params);
if (retval != ERROR_OK)
return retval;
else {
int fd = target_buffer_get_u32(target, params+0);
uint32_t a = target_buffer_get_u32(target, params+4);
ssize_t l = target_buffer_get_u32(target, params+8);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "read";
fileio_info->param_1 = fd;
fileio_info->param_2 = a;
fileio_info->param_3 = l;
} else {
uint8_t *buf = malloc(l);
if (!buf) {
arm->semihosting_result = -1;
arm->semihosting_errno = ENOMEM;
} else {
arm->semihosting_result = read(fd, buf, l);
arm->semihosting_errno = errno;
if (arm->semihosting_result >= 0) {
retval = target_write_buffer(target, a, arm->semihosting_result, buf);
if (retval != ERROR_OK) {
free(buf);
return retval;
}
arm->semihosting_result = l - arm->semihosting_result;
}
free(buf);
}
}
}
break;
case 0x07: /* SYS_READC */
if (arm->is_semihosting_fileio) {
LOG_ERROR("SYS_READC not supported by semihosting fileio");
return ERROR_FAIL;
}
arm->semihosting_result = getchar();
break;
case 0x08: /* SYS_ISERROR */
retval = target_read_memory(target, r1, 4, 1, params);
if (retval != ERROR_OK)
return retval;
arm->semihosting_result = (target_buffer_get_u32(target, params+0) != 0);
break;
case 0x09: /* SYS_ISTTY */
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "isatty";
fileio_info->param_1 = r1;
} else {
retval = target_read_memory(target, r1, 4, 1, params);
if (retval != ERROR_OK)
return retval;
arm->semihosting_result = isatty(target_buffer_get_u32(target, params+0));
}
break;
case 0x0a: /* SYS_SEEK */
retval = target_read_memory(target, r1, 4, 2, params);
if (retval != ERROR_OK)
return retval;
else {
int fd = target_buffer_get_u32(target, params+0);
off_t pos = target_buffer_get_u32(target, params+4);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "lseek";
fileio_info->param_1 = fd;
fileio_info->param_2 = pos;
fileio_info->param_3 = SEEK_SET;
} else {
arm->semihosting_result = lseek(fd, pos, SEEK_SET);
arm->semihosting_errno = errno;
if (arm->semihosting_result == pos)
arm->semihosting_result = 0;
}
}
break;
case 0x0c: /* SYS_FLEN */
if (arm->is_semihosting_fileio) {
LOG_ERROR("SYS_FLEN not supported by semihosting fileio");
return ERROR_FAIL;
}
retval = target_read_memory(target, r1, 4, 1, params);
if (retval != ERROR_OK)
return retval;
else {
int fd = target_buffer_get_u32(target, params+0);
struct stat buf;
arm->semihosting_result = fstat(fd, &buf);
if (arm->semihosting_result == -1) {
arm->semihosting_errno = errno;
arm->semihosting_result = -1;
break;
}
arm->semihosting_result = buf.st_size;
}
break;
case 0x0e: /* SYS_REMOVE */
retval = target_read_memory(target, r1, 4, 2, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t a = target_buffer_get_u32(target, params+0);
uint32_t l = target_buffer_get_u32(target, params+4);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "unlink";
fileio_info->param_1 = a;
fileio_info->param_2 = l;
} else {
if (l <= 255) {
uint8_t fn[256];
retval = target_read_memory(target, a, 1, l, fn);
if (retval != ERROR_OK)
return retval;
fn[l] = 0;
arm->semihosting_result = remove((char *)fn);
arm->semihosting_errno = errno;
} else {
arm->semihosting_result = -1;
arm->semihosting_errno = EINVAL;
}
}
}
break;
case 0x0f: /* SYS_RENAME */
retval = target_read_memory(target, r1, 4, 4, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t a1 = target_buffer_get_u32(target, params+0);
uint32_t l1 = target_buffer_get_u32(target, params+4);
uint32_t a2 = target_buffer_get_u32(target, params+8);
uint32_t l2 = target_buffer_get_u32(target, params+12);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "rename";
fileio_info->param_1 = a1;
fileio_info->param_2 = l1;
fileio_info->param_3 = a2;
fileio_info->param_4 = l2;
} else {
if (l1 <= 255 && l2 <= 255) {
uint8_t fn1[256], fn2[256];
retval = target_read_memory(target, a1, 1, l1, fn1);
if (retval != ERROR_OK)
return retval;
retval = target_read_memory(target, a2, 1, l2, fn2);
if (retval != ERROR_OK)
return retval;
fn1[l1] = 0;
fn2[l2] = 0;
arm->semihosting_result = rename((char *)fn1, (char *)fn2);
arm->semihosting_errno = errno;
} else {
arm->semihosting_result = -1;
arm->semihosting_errno = EINVAL;
}
}
}
break;
case 0x11: /* SYS_TIME */
arm->semihosting_result = time(NULL);
break;
case 0x13: /* SYS_ERRNO */
arm->semihosting_result = arm->semihosting_errno;
break;
case 0x15: /* SYS_GET_CMDLINE */
retval = target_read_memory(target, r1, 4, 2, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t a = target_buffer_get_u32(target, params+0);
uint32_t l = target_buffer_get_u32(target, params+4);
char *arg = arm->semihosting_cmdline != NULL ? arm->semihosting_cmdline : "";
uint32_t s = strlen(arg) + 1;
if (l < s)
arm->semihosting_result = -1;
else {
retval = target_write_buffer(target, a, s, (uint8_t *)arg);
if (retval != ERROR_OK)
return retval;
arm->semihosting_result = 0;
}
}
break;
case 0x16: /* SYS_HEAPINFO */
retval = target_read_memory(target, r1, 4, 1, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t a = target_buffer_get_u32(target, params+0);
/* tell the remote we have no idea */
memset(params, 0, 4*4);
retval = target_write_memory(target, a, 4, 4, params);
if (retval != ERROR_OK)
return retval;
arm->semihosting_result = 0;
}
break;
case 0x18: /* angel_SWIreason_ReportException */
switch (r1) {
case 0x20026: /* ADP_Stopped_ApplicationExit */
fprintf(stderr, "semihosting: *** application exited ***\n");
break;
case 0x20000: /* ADP_Stopped_BranchThroughZero */
case 0x20001: /* ADP_Stopped_UndefinedInstr */
case 0x20002: /* ADP_Stopped_SoftwareInterrupt */
case 0x20003: /* ADP_Stopped_PrefetchAbort */
case 0x20004: /* ADP_Stopped_DataAbort */
case 0x20005: /* ADP_Stopped_AddressException */
case 0x20006: /* ADP_Stopped_IRQ */
case 0x20007: /* ADP_Stopped_FIQ */
case 0x20020: /* ADP_Stopped_BreakPoint */
case 0x20021: /* ADP_Stopped_WatchPoint */
case 0x20022: /* ADP_Stopped_StepComplete */
case 0x20023: /* ADP_Stopped_RunTimeErrorUnknown */
case 0x20024: /* ADP_Stopped_InternalError */
case 0x20025: /* ADP_Stopped_UserInterruption */
case 0x20027: /* ADP_Stopped_StackOverflow */
case 0x20028: /* ADP_Stopped_DivisionByZero */
case 0x20029: /* ADP_Stopped_OSSpecific */
default:
fprintf(stderr, "semihosting: exception %#x\n",
(unsigned) r1);
}
return target_call_event_callbacks(target, TARGET_EVENT_HALTED);
case 0x12: /* SYS_SYSTEM */
/* Provide SYS_SYSTEM functionality. Uses the
* libc system command, there may be a reason *NOT*
* to use this, but as I can't think of one, I
* implemented it this way.
*/
retval = target_read_memory(target, r1, 4, 2, params);
if (retval != ERROR_OK)
return retval;
else {
uint32_t len = target_buffer_get_u32(target, params+4);
uint32_t c_ptr = target_buffer_get_u32(target, params);
if (arm->is_semihosting_fileio) {
arm->semihosting_hit_fileio = true;
fileio_info->identifier = "system";
fileio_info->param_1 = c_ptr;
fileio_info->param_2 = len;
} else {
uint8_t cmd[256];
if (len > 255) {
arm->semihosting_result = -1;
arm->semihosting_errno = EINVAL;
} else {
memset(cmd, 0x0, 256);
retval = target_read_memory(target, c_ptr, 1, len, cmd);
if (retval != ERROR_OK)
return retval;
else
arm->semihosting_result = system((const char *)cmd);
}
}
}
break;
case 0x0d: /* SYS_TMPNAM */
case 0x10: /* SYS_CLOCK */
case 0x17: /* angel_SWIreason_EnterSVC */
case 0x30: /* SYS_ELAPSED */
case 0x31: /* SYS_TICKFREQ */
default:
fprintf(stderr, "semihosting: unsupported call %#x\n",
(unsigned) r0);
arm->semihosting_result = -1;
arm->semihosting_errno = ENOTSUP;
}
return ERROR_OK;
}
static struct so_list *
dsbt_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
CORE_ADDR lm_addr;
struct so_list *sos_head = NULL;
struct so_list **sos_next_ptr = &sos_head;
struct dsbt_info *info = get_dsbt_info ();
/* Make sure that the main executable has been relocated. This is
required in order to find the address of the global offset table,
which in turn is used to find the link map info. (See lm_base
for details.)
Note that the relocation of the main executable is also performed
by SOLIB_CREATE_INFERIOR_HOOK, however, in the case of core
files, this hook is called too late in order to be of benefit to
SOLIB_ADD. SOLIB_ADD eventually calls this function,
dsbt_current_sos, and also precedes the call to
SOLIB_CREATE_INFERIOR_HOOK. (See post_create_inferior in
infcmd.c.) */
if (info->main_executable_lm_info == 0 && core_bfd != NULL)
dsbt_relocate_main_executable ();
/* Locate the address of the first link map struct. */
lm_addr = lm_base ();
/* We have at least one link map entry. Fetch the the lot of them,
building the solist chain. */
while (lm_addr)
{
struct ext_link_map lm_buf;
ext_Elf32_Word indexword;
CORE_ADDR map_addr;
int dsbt_index;
int ret;
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog,
"current_sos: reading link_map entry at %s\n",
hex_string_custom (lm_addr, 8));
ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf));
if (ret)
{
warning (_("dsbt_current_sos: Unable to read link map entry."
" Shared object chain may be incomplete."));
break;
}
/* Fetch the load map address. */
map_addr = extract_unsigned_integer (lm_buf.l_addr.map,
sizeof lm_buf.l_addr.map,
byte_order);
ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword,
sizeof indexword);
if (ret)
{
warning (_("dsbt_current_sos: Unable to read dsbt index."
" Shared object chain may be incomplete."));
break;
}
dsbt_index = extract_unsigned_integer (indexword, sizeof indexword,
byte_order);
/* If the DSBT index is zero, then we're looking at the entry
for the main executable. By convention, we don't include
this in the list of shared objects. */
if (dsbt_index != 0)
{
int errcode;
char *name_buf;
struct int_elf32_dsbt_loadmap *loadmap;
struct so_list *sop;
CORE_ADDR addr;
loadmap = fetch_loadmap (map_addr);
if (loadmap == NULL)
{
warning (_("dsbt_current_sos: Unable to fetch load map."
" Shared object chain may be incomplete."));
break;
}
sop = xcalloc (1, sizeof (struct so_list));
sop->lm_info = xcalloc (1, sizeof (struct lm_info));
sop->lm_info->map = loadmap;
/* Fetch the name. */
addr = extract_unsigned_integer (lm_buf.l_name,
sizeof (lm_buf.l_name),
byte_order);
target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
&errcode);
if (errcode != 0)
warning (_("Can't read pathname for link map entry: %s."),
safe_strerror (errcode));
else
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
name_buf);
strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
xfree (name_buf);
strcpy (sop->so_original_name, sop->so_name);
}
*sos_next_ptr = sop;
sos_next_ptr = &sop->next;
}
else
{
info->main_lm_addr = lm_addr;
}
lm_addr = extract_unsigned_integer (lm_buf.l_next,
sizeof (lm_buf.l_next), byte_order);
}
enable_break2 ();
return sos_head;
}
/**
* Checks for and processes an ARM semihosting request. This is meant
* to be called when the target is stopped due to a debug mode entry.
* If the value 0 is returned then there was nothing to process. A non-zero
* return value signifies that a request was processed and the target resumed,
* or an error was encountered, in which case the caller must return
* immediately.
*
* @param target Pointer to the ARM target to process. This target must
* not represent an ARMv6-M or ARMv7-M processor.
* @param retval Pointer to a location where the return code will be stored
* @return non-zero value if a request was processed or an error encountered
*/
int arm_semihosting(struct target *target, int *retval)
{
struct arm *arm = target_to_arm(target);
struct armv7a_common *armv7a = target_to_armv7a(target);
uint32_t pc, lr, spsr;
struct reg *r;
if (!arm->is_semihosting)
return 0;
if (is_arm7_9(target_to_arm7_9(target)) ||
is_armv7a(armv7a)) {
uint32_t vbar = 0x00000000;
if (arm->core_mode != ARM_MODE_SVC)
return 0;
if (is_armv7a(armv7a)) {
struct arm_dpm *dpm = armv7a->arm.dpm;
*retval = dpm->prepare(dpm);
if (*retval == ERROR_OK) {
*retval = dpm->instr_read_data_r0(dpm,
ARMV4_5_MRC(15, 0, 0, 12, 0, 0),
&vbar);
dpm->finish(dpm);
if (*retval != ERROR_OK)
return 1;
} else {
return 1;
}
}
/* Check for PC == 0x00000008 or 0xffff0008: Supervisor Call vector. */
r = arm->pc;
pc = buf_get_u32(r->value, 0, 32);
if (pc != (vbar + 0x00000008) && pc != 0xffff0008)
return 0;
r = arm_reg_current(arm, 14);
lr = buf_get_u32(r->value, 0, 32);
/* Core-specific code should make sure SPSR is retrieved
* when the above checks pass...
*/
if (!arm->spsr->valid) {
LOG_ERROR("SPSR not valid!");
*retval = ERROR_FAIL;
return 1;
}
spsr = buf_get_u32(arm->spsr->value, 0, 32);
/* check instruction that triggered this trap */
if (spsr & (1 << 5)) {
/* was in Thumb (or ThumbEE) mode */
uint8_t insn_buf[2];
uint16_t insn;
*retval = target_read_memory(target, lr-2, 2, 1, insn_buf);
if (*retval != ERROR_OK)
return 1;
insn = target_buffer_get_u16(target, insn_buf);
/* SVC 0xab */
if (insn != 0xDFAB)
return 0;
} else if (spsr & (1 << 24)) {
/* was in Jazelle mode */
return 0;
} else {
/* was in ARM mode */
uint8_t insn_buf[4];
uint32_t insn;
*retval = target_read_memory(target, lr-4, 4, 1, insn_buf);
if (*retval != ERROR_OK)
return 1;
insn = target_buffer_get_u32(target, insn_buf);
/* SVC 0x123456 */
if (insn != 0xEF123456)
return 0;
}
} else if (is_armv7m(target_to_armv7m(target))) {
uint16_t insn;
if (target->debug_reason != DBG_REASON_BREAKPOINT)
return 0;
r = arm->pc;
pc = buf_get_u32(r->value, 0, 32);
pc &= ~1;
*retval = target_read_u16(target, pc, &insn);
if (*retval != ERROR_OK)
return 1;
/* bkpt 0xAB */
if (insn != 0xBEAB)
return 0;
} else {
LOG_ERROR("Unsupported semi-hosting Target");
return 0;
}
/* Perform semihosting if we are not waiting on a fileio
* operation to complete.
*/
if (!arm->semihosting_hit_fileio) {
*retval = do_semihosting(target);
if (*retval != ERROR_OK) {
LOG_ERROR("Failed semihosting operation");
return 0;
}
}
/* Post result to target if we are not waiting on a fileio
* operation to complete:
*/
if (!arm->semihosting_hit_fileio) {
*retval = post_result(target);
if (*retval != ERROR_OK) {
LOG_ERROR("Failed to post semihosting result");
return 0;
}
*retval = target_resume(target, 1, 0, 0, 0);
if (*retval != ERROR_OK) {
LOG_ERROR("Failed to resume target");
return 0;
}
return 1;
}
return 0;
}
/* Like target_read_memory, but slightly different parameters. */
static int
dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
struct disassemble_info *info)
{
return target_read_memory (memaddr, (char *) myaddr, len);
}
static int
enable_break2 (void)
{
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);
/* 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);
/* 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);
/* 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 (addr);
return 1;
}
