#include "inferior.h"
#include "symtab.h"
#include "command.h"
+#include "gdbcmd.h"
#include "bfd.h"
#include "target.h"
#include "gdbcore.h"
#include "dis-asm.h"
+#include "language.h"
extern char registers[];
int status;
CORE_ADDR memaddr;
{
-
+ /* FIXME-32x64--casting CORE_ADDR to unsigned long */
if (status == EIO)
{
/* Actually, address between memaddr and memaddr + len
was out of bounds. */
- error ("Cannot access memory at address %s.", local_hex_string(memaddr));
+ error ("Cannot access memory at address %s.",
+ local_hex_string((unsigned long) memaddr));
}
else
{
error ("Error accessing memory address %s: %s.",
- local_hex_string (memaddr), safe_strerror (status));
+ local_hex_string ((unsigned long) memaddr),
+ safe_strerror (status));
}
}
}
/* Like target_read_memory, but slightly different parameters. */
+
int
dis_asm_read_memory (memaddr, myaddr, len, info)
bfd_vma memaddr;
int len;
disassemble_info *info;
{
- return target_read_memory (memaddr, myaddr, len);
+ return target_read_memory (memaddr, (char *) myaddr, len);
}
/* Like memory_error with slightly different parameters. */
memory_error (status, memaddr);
}
+/* Like print_address with slightly different parameters. */
+void
+dis_asm_print_address (addr, info)
+ bfd_vma addr;
+ struct disassemble_info *info;
+{
+ print_address (addr, info->stream);
+}
+
/* Same as target_write_memory, but report an error if can't write. */
void
write_memory (memaddr, myaddr, len)
/* Read an integer from debugged memory, given address and number of bytes. */
-long
+LONGEST
read_memory_integer (memaddr, len)
CORE_ADDR memaddr;
int len;
{
- char cbuf;
- short sbuf;
- int ibuf;
- long lbuf;
+ char buf[sizeof (LONGEST)];
- if (len == sizeof (char))
- {
- read_memory (memaddr, &cbuf, len);
- return cbuf;
- }
- if (len == sizeof (short))
- {
- read_memory (memaddr, (char *)&sbuf, len);
- SWAP_TARGET_AND_HOST (&sbuf, sizeof (short));
- return sbuf;
- }
- if (len == sizeof (int))
- {
- read_memory (memaddr, (char *)&ibuf, len);
- SWAP_TARGET_AND_HOST (&ibuf, sizeof (int));
- return ibuf;
- }
- if (len == sizeof (lbuf))
+ read_memory (memaddr, buf, len);
+ return extract_signed_integer (buf, len);
+}
+
+unsigned LONGEST
+read_memory_unsigned_integer (memaddr, len)
+ CORE_ADDR memaddr;
+ int len;
+{
+ char buf[sizeof (unsigned LONGEST)];
+
+ read_memory (memaddr, buf, len);
+ return extract_unsigned_integer (buf, len);
+}
+\f
+#if 0
+/* Enable after 4.12. It is not tested. */
+
+/* Search code. Targets can just make this their search function, or
+ if the protocol has a less general search function, they can call this
+ in the cases it can't handle. */
+void
+generic_search (len, data, mask, startaddr, increment, lorange, hirange
+ addr_found, data_found)
+ int len;
+ char *data;
+ char *mask;
+ CORE_ADDR startaddr;
+ int increment;
+ CORE_ADDR lorange;
+ CORE_ADDR hirange;
+ CORE_ADDR *addr_found;
+ char *data_found;
+{
+ int i;
+ CORE_ADDR curaddr = startaddr;
+
+ while (curaddr >= lorange && curaddr < hirange)
{
- read_memory (memaddr, (char *)&lbuf, len);
- SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf));
- return lbuf;
+ read_memory (curaddr, data_found, len);
+ for (i = 0; i < len; ++i)
+ if ((data_found[i] & mask[i]) != data[i])
+ goto try_again;
+ /* It matches. */
+ *addr_found = curaddr;
+ return;
+
+ try_again:
+ curaddr += increment;
}
- error ("Cannot handle integers of %d bytes.", len);
- return -1; /* for lint */
+ *addr_found = (CORE_ADDR)0;
+ return;
}
+#endif /* 0 */
\f
+/* The current default bfd target. Points to storage allocated for
+ gnutarget_string. */
+char *gnutarget;
+
+/* Same thing, except it is "auto" not NULL for the default case. */
+static char *gnutarget_string;
+
+static void set_gnutarget_command
+ PARAMS ((char *, int, struct cmd_list_element *));
+
+static void
+set_gnutarget_command (ignore, from_tty, c)
+ char *ignore;
+ int from_tty;
+ struct cmd_list_element *c;
+{
+ if (STREQ (gnutarget_string, "auto"))
+ gnutarget = NULL;
+ else
+ gnutarget = gnutarget_string;
+}
+
+/* Set the gnutarget. */
void
-_initialize_core()
+set_gnutarget (newtarget)
+ char *newtarget;
{
+ if (gnutarget_string != NULL)
+ free (gnutarget_string);
+ gnutarget_string = savestring (newtarget, strlen (newtarget));
+ set_gnutarget_command (NULL, 0, NULL);
+}
- add_com ("core-file", class_files, core_file_command,
- "Use FILE as core dump for examining memory and registers.\n\
+void
+_initialize_core()
+{
+ struct cmd_list_element *c;
+ c = add_cmd ("core-file", class_files, core_file_command,
+ "Use FILE as core dump for examining memory and registers.\n\
No arg means have no core file. This command has been superseded by the\n\
-`target core' and `detach' commands.");
-
+`target core' and `detach' commands.", &cmdlist);
+ c->completer = filename_completer;
+
+ c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
+ (char *) &gnutarget_string,
+ "Set the current BFD target.\n\
+Use `set gnutarget auto' to specify automatic detection.",
+ &setlist);
+ c->function.sfunc = set_gnutarget_command;
+ add_show_from_set (c, &showlist);
+
+ if (getenv ("GNUTARGET"))
+ set_gnutarget (getenv ("GNUTARGET"));
+ else
+ set_gnutarget ("auto");
}
projects / deliverable / binutils-gdb.git / blobdiff