/* MI Command Set.
- Copyright (C) 2000-2017 Free Software Foundation, Inc.
+ Copyright (C) 2000-2018 Free Software Foundation, Inc.
Contributed by Cygnus Solutions (a Red Hat company).
#include "gdbcore.h" /* For write_memory(). */
#include "value.h"
#include "regcache.h"
-#include "gdb.h"
#include "frame.h"
#include "mi-main.h"
#include "mi-common.h"
#include "valprint.h"
#include "inferior.h"
#include "osdata.h"
-#include "splay-tree.h"
+#include "common/gdb_splay_tree.h"
#include "tracepoint.h"
#include "ctf.h"
#include "ada-lang.h"
#include "linespec.h"
#include "extension.h"
#include "gdbcmd.h"
-#include "observer.h"
+#include "observable.h"
#include "common/gdb_optional.h"
+#include "common/byte-vector.h"
#include <ctype.h>
#include "run-time-clock.h"
#include <chrono>
+#include "progspace-and-thread.h"
+#include "common/rsp-low.h"
+#include <algorithm>
+#include <set>
+#include <map>
enum
{
command was issued. */
int mi_proceeded;
-extern void _initialize_mi_main (void);
static void mi_cmd_execute (struct mi_parse *parse);
static void mi_execute_cli_command (const char *cmd, int args_p,
const char *args);
static void mi_execute_async_cli_command (const char *cli_command,
char **argv, int argc);
-static int register_changed_p (int regnum, struct regcache *,
- struct regcache *);
+static bool register_changed_p (int regnum, readonly_detached_regcache *,
+ readonly_detached_regcache *);
static void output_register (struct frame_info *, int regnum, int format,
int skip_unavailable);
static int mi_async_1 = 0;
static void
-set_mi_async_command (char *args, int from_tty,
+set_mi_async_command (const char *args, int from_tty,
struct cmd_list_element *c)
{
if (have_live_inferiors ())
See comment on infcmd.c:proceed_thread_callback for rationale. */
if (current_context->all || current_context->thread_group != -1)
{
+ scoped_restore_current_thread restore_thread;
int pid = 0;
- struct cleanup *back_to = make_cleanup_restore_current_thread ();
if (!current_context->all)
{
pid = inf->pid;
}
iterate_over_threads (proceed_thread_callback, &pid);
- do_cleanups (back_to);
}
else
{
if (current_context->all)
{
- struct cleanup *back_to = save_current_space_and_thread ();
+ scoped_restore_current_pspace_and_thread restore_pspace_thread;
iterate_over_inferiors (run_one_inferior, &start_p);
- do_cleanups (back_to);
}
else
{
void
mi_cmd_thread_select (const char *command, char **argv, int argc)
{
- enum gdb_rc rc;
- char *mi_error_message;
- ptid_t previous_ptid = inferior_ptid;
-
if (argc != 1)
error (_("-thread-select: USAGE: threadnum."));
- rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
+ int num = value_as_long (parse_and_eval (argv[0]));
+ thread_info *thr = find_thread_global_id (num);
+ if (thr == NULL)
+ error (_("Thread ID %d not known."), num);
- /* If thread switch did not succeed don't notify or print. */
- if (rc == GDB_RC_FAIL)
- {
- make_cleanup (xfree, mi_error_message);
- error ("%s", mi_error_message);
- }
+ ptid_t previous_ptid = inferior_ptid;
+
+ thread_select (argv[0], thr);
print_selected_thread_frame (current_uiout,
USER_SELECTED_THREAD | USER_SELECTED_FRAME);
/* Notify if the thread has effectively changed. */
if (!ptid_equal (inferior_ptid, previous_ptid))
{
- observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
- | USER_SELECTED_FRAME);
+ gdb::observers::user_selected_context_changed.notify
+ (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
}
}
void
mi_cmd_thread_list_ids (const char *command, char **argv, int argc)
{
- enum gdb_rc rc;
- char *mi_error_message;
-
if (argc != 0)
error (_("-thread-list-ids: No arguments required."));
- rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
+ int num = 0;
+ int current_thread = -1;
- if (rc == GDB_RC_FAIL)
- {
- make_cleanup (xfree, mi_error_message);
- error ("%s", mi_error_message);
- }
+ update_thread_list ();
+
+ {
+ ui_out_emit_tuple tuple_emitter (current_uiout, "thread-ids");
+
+ struct thread_info *tp;
+ ALL_NON_EXITED_THREADS (tp)
+ {
+ if (tp->ptid == inferior_ptid)
+ current_thread = tp->global_num;
+
+ num++;
+ current_uiout->field_int ("thread-id", tp->global_num);
+ }
+ }
+
+ if (current_thread != -1)
+ current_uiout->field_int ("current-thread-id", current_thread);
+ current_uiout->field_int ("number-of-threads", num);
}
void
struct collect_cores_data
{
int pid;
-
- VEC (int) *cores;
+ std::set<int> cores;
};
static int
int core = target_core_of_thread (ti->ptid);
if (core != -1)
- VEC_safe_push (int, data->cores, core);
+ data->cores.insert (core);
}
return 0;
}
-static int *
-unique (int *b, int *e)
-{
- int *d = b;
-
- while (++b != e)
- if (*d != *b)
- *++d = *b;
- return ++d;
-}
-
struct print_one_inferior_data
{
int recurse;
- VEC (int) *inferiors;
+ const std::set<int> *inferiors;
};
static int
= (struct print_one_inferior_data *) xdata;
struct ui_out *uiout = current_uiout;
- if (VEC_empty (int, top_data->inferiors)
- || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
- VEC_length (int, top_data->inferiors), sizeof (int),
- compare_positive_ints))
+ if (top_data->inferiors->empty ()
+ || (top_data->inferiors->find (inferior->pid)
+ != top_data->inferiors->end ()))
{
struct collect_cores_data data;
ui_out_emit_tuple tuple_emitter (uiout, NULL);
inferior->pspace->pspace_exec_filename);
}
- data.cores = 0;
if (inferior->pid != 0)
{
data.pid = inferior->pid;
iterate_over_threads (collect_cores, &data);
}
- if (!VEC_empty (int, data.cores))
+ if (!data.cores.empty ())
{
- int *b, *e;
ui_out_emit_list list_emitter (uiout, "cores");
- qsort (VEC_address (int, data.cores),
- VEC_length (int, data.cores), sizeof (int),
- compare_positive_ints);
-
- b = VEC_address (int, data.cores);
- e = b + VEC_length (int, data.cores);
- e = unique (b, e);
-
- for (; b != e; ++b)
- uiout->field_int (NULL, *b);
+ for (int b : data.cores)
+ uiout->field_int (NULL, b);
}
if (top_data->recurse)
static void
output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
{
- struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
- field_name);
- char *cores = xstrdup (xcores);
- char *p = cores;
-
- make_cleanup (xfree, cores);
+ ui_out_emit_list list_emitter (uiout, field_name);
+ gdb::unique_xmalloc_ptr<char> cores (xstrdup (xcores));
+ char *p = cores.get ();
for (p = strtok (p, ","); p; p = strtok (NULL, ","))
uiout->field_string (NULL, p);
-
- do_cleanups (back_to);
-}
-
-static void
-free_vector_of_ints (void *xvector)
-{
- VEC (int) **vector = (VEC (int) **) xvector;
-
- VEC_free (int, *vector);
-}
-
-static void
-do_nothing (splay_tree_key k)
-{
-}
-
-static void
-free_vector_of_osdata_items (splay_tree_value xvalue)
-{
- VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
-
- /* We don't free the items itself, it will be done separately. */
- VEC_free (osdata_item_s, value);
-}
-
-static int
-splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
-{
- int a = xa;
- int b = xb;
-
- return a - b;
-}
-
-static void
-free_splay_tree (void *xt)
-{
- splay_tree t = (splay_tree) xt;
- splay_tree_delete (t);
}
static void
-list_available_thread_groups (VEC (int) *ids, int recurse)
+list_available_thread_groups (const std::set<int> &ids, int recurse)
{
- struct osdata *data;
- struct osdata_item *item;
- int ix_items;
struct ui_out *uiout = current_uiout;
- struct cleanup *cleanup;
- /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
- The vector contains information about all threads for the given pid.
- This is assigned an initial value to avoid "may be used uninitialized"
- warning from gcc. */
- splay_tree tree = NULL;
+ /* This keeps a map from integer (pid) to vector of struct osdata_item.
+ The vector contains information about all threads for the given pid. */
+ std::map<int, std::vector<osdata_item>> tree;
/* get_osdata will throw if it cannot return data. */
- data = get_osdata ("processes");
- cleanup = make_cleanup_osdata_free (data);
+ std::unique_ptr<osdata> data = get_osdata ("processes");
if (recurse)
{
- struct osdata *threads = get_osdata ("threads");
+ std::unique_ptr<osdata> threads = get_osdata ("threads");
- make_cleanup_osdata_free (threads);
- tree = splay_tree_new (splay_tree_int_comparator,
- do_nothing,
- free_vector_of_osdata_items);
- make_cleanup (free_splay_tree, tree);
-
- for (ix_items = 0;
- VEC_iterate (osdata_item_s, threads->items,
- ix_items, item);
- ix_items++)
+ for (const osdata_item &item : threads->items)
{
- const char *pid = get_osdata_column (item, "pid");
- int pid_i = strtoul (pid, NULL, 0);
- VEC (osdata_item_s) *vec = 0;
+ const std::string *pid = get_osdata_column (item, "pid");
+ int pid_i = strtoul (pid->c_str (), NULL, 0);
- splay_tree_node n = splay_tree_lookup (tree, pid_i);
- if (!n)
- {
- VEC_safe_push (osdata_item_s, vec, item);
- splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
- }
- else
- {
- vec = (VEC (osdata_item_s) *) n->value;
- VEC_safe_push (osdata_item_s, vec, item);
- n->value = (splay_tree_value) vec;
- }
+ tree[pid_i].push_back (item);
}
}
- make_cleanup_ui_out_list_begin_end (uiout, "groups");
+ ui_out_emit_list list_emitter (uiout, "groups");
- for (ix_items = 0;
- VEC_iterate (osdata_item_s, data->items,
- ix_items, item);
- ix_items++)
+ for (const osdata_item &item : data->items)
{
- const char *pid = get_osdata_column (item, "pid");
- const char *cmd = get_osdata_column (item, "command");
- const char *user = get_osdata_column (item, "user");
- const char *cores = get_osdata_column (item, "cores");
+ const std::string *pid = get_osdata_column (item, "pid");
+ const std::string *cmd = get_osdata_column (item, "command");
+ const std::string *user = get_osdata_column (item, "user");
+ const std::string *cores = get_osdata_column (item, "cores");
- int pid_i = strtoul (pid, NULL, 0);
+ int pid_i = strtoul (pid->c_str (), NULL, 0);
/* At present, the target will return all available processes
and if information about specific ones was required, we filter
undesired processes here. */
- if (ids && bsearch (&pid_i, VEC_address (int, ids),
- VEC_length (int, ids),
- sizeof (int), compare_positive_ints) == NULL)
+ if (!ids.empty () && ids.find (pid_i) == ids.end ())
continue;
-
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- uiout->field_fmt ("id", "%s", pid);
+ uiout->field_fmt ("id", "%s", pid->c_str ());
uiout->field_string ("type", "process");
if (cmd)
- uiout->field_string ("description", cmd);
+ uiout->field_string ("description", cmd->c_str ());
if (user)
- uiout->field_string ("user", user);
+ uiout->field_string ("user", user->c_str ());
if (cores)
- output_cores (uiout, "cores", cores);
+ output_cores (uiout, "cores", cores->c_str ());
if (recurse)
{
- splay_tree_node n = splay_tree_lookup (tree, pid_i);
- if (n)
+ auto n = tree.find (pid_i);
+ if (n != tree.end ())
{
- VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
- struct osdata_item *child;
- int ix_child;
+ std::vector<osdata_item> &children = n->second;
- make_cleanup_ui_out_list_begin_end (uiout, "threads");
+ ui_out_emit_list thread_list_emitter (uiout, "threads");
- for (ix_child = 0;
- VEC_iterate (osdata_item_s, children, ix_child, child);
- ++ix_child)
+ for (const osdata_item &child : children)
{
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- const char *tid = get_osdata_column (child, "tid");
- const char *tcore = get_osdata_column (child, "core");
+ const std::string *tid = get_osdata_column (child, "tid");
+ const std::string *tcore = get_osdata_column (child, "core");
- uiout->field_string ("id", tid);
+ uiout->field_string ("id", tid->c_str ());
if (tcore)
- uiout->field_string ("core", tcore);
+ uiout->field_string ("core", tcore->c_str ());
}
}
}
}
-
- do_cleanups (cleanup);
}
void
mi_cmd_list_thread_groups (const char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
- struct cleanup *back_to;
int available = 0;
int recurse = 0;
- VEC (int) *ids = 0;
+ std::set<int> ids;
enum opt
{
if (*end != '\0')
error (_("invalid syntax of group id '%s'"), argv[oind]);
- VEC_safe_push (int, ids, inf);
+ ids.insert (inf);
}
- if (VEC_length (int, ids) > 1)
- qsort (VEC_address (int, ids),
- VEC_length (int, ids),
- sizeof (int), compare_positive_ints);
-
- back_to = make_cleanup (free_vector_of_ints, &ids);
if (available)
{
list_available_thread_groups (ids, recurse);
}
- else if (VEC_length (int, ids) == 1)
+ else if (ids.size () == 1)
{
/* Local thread groups, single id. */
- int id = *VEC_address (int, ids);
+ int id = *(ids.begin ());
struct inferior *inf = find_inferior_id (id);
if (!inf)
struct print_one_inferior_data data;
data.recurse = recurse;
- data.inferiors = ids;
+ data.inferiors = &ids;
/* Local thread groups. Either no explicit ids -- and we
print everything, or several explicit ids. In both cases,
we print more than one group, and have to use 'groups'
as the top-level element. */
- make_cleanup_ui_out_list_begin_end (uiout, "groups");
+ ui_out_emit_list list_emitter (uiout, "groups");
update_thread_list ();
iterate_over_inferiors (print_one_inferior, &data);
}
-
- do_cleanups (back_to);
}
void
void
mi_cmd_data_list_changed_registers (const char *command, char **argv, int argc)
{
- static struct regcache *this_regs = NULL;
+ static std::unique_ptr<readonly_detached_regcache> this_regs;
struct ui_out *uiout = current_uiout;
- struct regcache *prev_regs;
+ std::unique_ptr<readonly_detached_regcache> prev_regs;
struct gdbarch *gdbarch;
- int regnum, numregs, changed;
+ int regnum, numregs;
int i;
- struct cleanup *cleanup;
/* The last time we visited this function, the current frame's
register contents were saved in THIS_REGS. Move THIS_REGS over
to PREV_REGS, and refresh THIS_REGS with the now-current register
contents. */
- prev_regs = this_regs;
+ prev_regs = std::move (this_regs);
this_regs = frame_save_as_regcache (get_selected_frame (NULL));
- cleanup = make_cleanup_regcache_xfree (prev_regs);
/* Note that the test for a valid register must include checking the
gdbarch_register_name because gdbarch_num_regs may be allocated
will change depending upon the particular processor being
debugged. */
- gdbarch = get_regcache_arch (this_regs);
+ gdbarch = this_regs->arch ();
numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
- make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
+ ui_out_emit_list list_emitter (uiout, "changed-registers");
if (argc == 0)
{
if (gdbarch_register_name (gdbarch, regnum) == NULL
|| *(gdbarch_register_name (gdbarch, regnum)) == '\0')
continue;
- changed = register_changed_p (regnum, prev_regs, this_regs);
- if (changed < 0)
- error (_("-data-list-changed-registers: "
- "Unable to read register contents."));
- else if (changed)
+
+ if (register_changed_p (regnum, prev_regs.get (),
+ this_regs.get ()))
uiout->field_int (NULL, regnum);
}
}
&& gdbarch_register_name (gdbarch, regnum) != NULL
&& *gdbarch_register_name (gdbarch, regnum) != '\000')
{
- changed = register_changed_p (regnum, prev_regs, this_regs);
- if (changed < 0)
- error (_("-data-list-changed-registers: "
- "Unable to read register contents."));
- else if (changed)
+ if (register_changed_p (regnum, prev_regs.get (),
+ this_regs.get ()))
uiout->field_int (NULL, regnum);
}
else
error (_("bad register number"));
}
- do_cleanups (cleanup);
}
-static int
-register_changed_p (int regnum, struct regcache *prev_regs,
- struct regcache *this_regs)
+static bool
+register_changed_p (int regnum, readonly_detached_regcache *prev_regs,
+ readonly_detached_regcache *this_regs)
{
- struct gdbarch *gdbarch = get_regcache_arch (this_regs);
- gdb_byte prev_buffer[MAX_REGISTER_SIZE];
- gdb_byte this_buffer[MAX_REGISTER_SIZE];
- enum register_status prev_status;
- enum register_status this_status;
+ struct gdbarch *gdbarch = this_regs->arch ();
+ struct value *prev_value, *this_value;
/* First time through or after gdbarch change consider all registers
as changed. */
- if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
- return 1;
+ if (!prev_regs || prev_regs->arch () != gdbarch)
+ return true;
/* Get register contents and compare. */
- prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
- this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
+ prev_value = prev_regs->cooked_read_value (regnum);
+ this_value = this_regs->cooked_read_value (regnum);
+ gdb_assert (prev_value != NULL);
+ gdb_assert (this_value != NULL);
- if (this_status != prev_status)
- return 1;
- else if (this_status == REG_VALID)
- return memcmp (prev_buffer, this_buffer,
- register_size (gdbarch, regnum)) != 0;
- else
- return 0;
+ auto ret = !value_contents_eq (prev_value, 0, this_value, 0,
+ register_size (gdbarch, regnum));
+
+ release_value (prev_value);
+ release_value (this_value);
+ value_free (prev_value);
+ value_free (this_value);
+ return ret;
}
/* Return a list of register number and value pairs. The valid
debugged. */
regcache = get_current_regcache ();
- gdbarch = get_regcache_arch (regcache);
+ gdbarch = regcache->arch ();
numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
if (argc == 0)
/* Create a buffer and read it in. */
total_bytes = word_size * nr_rows * nr_cols;
- std::unique_ptr<gdb_byte[]> mbuf (new gdb_byte[total_bytes]);
+ gdb::byte_vector mbuf (total_bytes);
/* Dispatch memory reads to the topmost target, not the flattened
current_target. */
nr_bytes = target_read (current_target.beneath,
- TARGET_OBJECT_MEMORY, NULL, mbuf.get (),
+ TARGET_OBJECT_MEMORY, NULL, mbuf.data (),
addr, total_bytes);
if (nr_bytes <= 0)
error (_("Unable to read memory."));
{
int row;
int row_byte;
- struct cleanup *cleanup_list;
string_file stream;
- cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, "memory");
+ ui_out_emit_list list_emitter (uiout, "memory");
for (row = 0, row_byte = 0;
row < nr_rows;
row++, row_byte += nr_cols * word_size)
{
int col;
int col_byte;
- struct cleanup *cleanup_list_data;
struct value_print_options opts;
ui_out_emit_tuple tuple_emitter (uiout, NULL);
uiout->field_core_addr ("addr", gdbarch, addr + row_byte);
/* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
row_byte); */
- cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
- get_formatted_print_options (&opts, word_format);
- for (col = 0, col_byte = row_byte;
- col < nr_cols;
- col++, col_byte += word_size)
- {
- if (col_byte + word_size > nr_bytes)
- {
- uiout->field_string (NULL, "N/A");
- }
- else
- {
- stream.clear ();
- print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
- word_asize, &stream);
- uiout->field_stream (NULL, stream);
- }
- }
- do_cleanups (cleanup_list_data);
+ {
+ ui_out_emit_list list_data_emitter (uiout, "data");
+ get_formatted_print_options (&opts, word_format);
+ for (col = 0, col_byte = row_byte;
+ col < nr_cols;
+ col++, col_byte += word_size)
+ {
+ if (col_byte + word_size > nr_bytes)
+ {
+ uiout->field_string (NULL, "N/A");
+ }
+ else
+ {
+ stream.clear ();
+ print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
+ word_asize, &stream);
+ uiout->field_stream (NULL, stream);
+ }
+ }
+ }
+
if (aschar)
{
int byte;
uiout->field_stream ("ascii", stream);
}
}
- do_cleanups (cleanup_list);
}
}
{
struct gdbarch *gdbarch = get_current_arch ();
struct ui_out *uiout = current_uiout;
- struct cleanup *cleanups;
CORE_ADDR addr;
LONGEST length;
- memory_read_result_s *read_result;
- int ix;
- VEC(memory_read_result_s) *result;
long offset = 0;
int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
int oind = 0;
addr = parse_and_eval_address (argv[0]) + offset;
length = atol (argv[1]);
- result = read_memory_robust (current_target.beneath, addr, length);
-
- cleanups = make_cleanup (free_memory_read_result_vector, &result);
+ std::vector<memory_read_result> result
+ = read_memory_robust (current_target.beneath, addr, length);
- if (VEC_length (memory_read_result_s, result) == 0)
+ if (result.size () == 0)
error (_("Unable to read memory."));
- make_cleanup_ui_out_list_begin_end (uiout, "memory");
- for (ix = 0;
- VEC_iterate (memory_read_result_s, result, ix, read_result);
- ++ix)
+ ui_out_emit_list list_emitter (uiout, "memory");
+ for (const memory_read_result &read_result : result)
{
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- char *data, *p;
- int i;
- int alloc_len;
- uiout->field_core_addr ("begin", gdbarch, read_result->begin);
- uiout->field_core_addr ("offset", gdbarch, read_result->begin - addr);
- uiout->field_core_addr ("end", gdbarch, read_result->end);
+ uiout->field_core_addr ("begin", gdbarch, read_result.begin);
+ uiout->field_core_addr ("offset", gdbarch, read_result.begin - addr);
+ uiout->field_core_addr ("end", gdbarch, read_result.end);
- alloc_len = (read_result->end - read_result->begin) * 2 * unit_size + 1;
- data = (char *) xmalloc (alloc_len);
-
- for (i = 0, p = data;
- i < ((read_result->end - read_result->begin) * unit_size);
- ++i, p += 2)
- {
- sprintf (p, "%02x", read_result->data[i]);
- }
- uiout->field_string ("contents", data);
- xfree (data);
+ std::string data = bin2hex (read_result.data.get (),
+ (read_result.end - read_result.begin)
+ * unit_size);
+ uiout->field_string ("contents", data.c_str ());
}
- do_cleanups (cleanups);
}
/* Implementation of the -data-write_memory command.
/* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
enough when using a compiler other than GCC. */
LONGEST value;
- gdb_byte *buffer;
- struct cleanup *old_chain;
long offset = 0;
int oind = 0;
char *oarg;
/* Get the value as a number. */
value = parse_and_eval_address (argv[3]);
/* Get the value into an array. */
- buffer = (gdb_byte *) xmalloc (word_size);
- old_chain = make_cleanup (xfree, buffer);
- store_signed_integer (buffer, word_size, byte_order, value);
+ gdb::byte_vector buffer (word_size);
+ store_signed_integer (buffer.data (), word_size, byte_order, value);
/* Write it down to memory. */
- write_memory_with_notification (addr, buffer, word_size);
- /* Free the buffer. */
- do_cleanups (old_chain);
+ write_memory_with_notification (addr, buffer.data (), word_size);
}
/* Implementation of the -data-write-memory-bytes command.
{
CORE_ADDR addr;
char *cdata;
- gdb_byte *data;
- gdb_byte *databuf;
size_t len_hex, len_bytes, len_units, i, steps, remaining_units;
long int count_units;
- struct cleanup *back_to;
int unit_size;
if (argc != 2 && argc != 3)
else
count_units = len_units;
- databuf = XNEWVEC (gdb_byte, len_bytes);
- back_to = make_cleanup (xfree, databuf);
+ gdb::byte_vector databuf (len_bytes);
for (i = 0; i < len_bytes; ++i)
{
databuf[i] = (gdb_byte) x;
}
+ gdb::byte_vector data;
if (len_units < count_units)
{
/* Pattern is made of less units than count:
repeat pattern to fill memory. */
- data = (gdb_byte *) xmalloc (count_units * unit_size);
- make_cleanup (xfree, data);
+ data = gdb::byte_vector (count_units * unit_size);
/* Number of times the pattern is entirely repeated. */
steps = count_units / len_units;
/* Number of remaining addressable memory units. */
remaining_units = count_units % len_units;
for (i = 0; i < steps; i++)
- memcpy (data + i * len_bytes, databuf, len_bytes);
+ memcpy (&data[i * len_bytes], &databuf[0], len_bytes);
if (remaining_units > 0)
- memcpy (data + steps * len_bytes, databuf,
+ memcpy (&data[steps * len_bytes], &databuf[0],
remaining_units * unit_size);
}
else
{
/* Pattern is longer than or equal to count:
just copy count addressable memory units. */
- data = databuf;
+ data = std::move (databuf);
}
- write_memory_with_notification (addr, data, count_units);
-
- do_cleanups (back_to);
+ write_memory_with_notification (addr, data.data (), count_units);
}
void
Return <0 for error; >=0 for ok.
args->action will tell mi_execute_command what action
- to perfrom after the given command has executed (display/suppress
+ to perform after the given command has executed (display/suppress
prompt, display error). */
static void
captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
{
struct mi_interp *mi = (struct mi_interp *) command_interp ();
- struct cleanup *cleanup;
if (do_timings)
current_command_ts = context->cmd_start;
- current_token = xstrdup (context->token);
- cleanup = make_cleanup (free_current_contents, ¤t_token);
+ scoped_restore save_token = make_scoped_restore (¤t_token,
+ context->token);
running_result_record_printed = 0;
mi_proceeded = 0;
break;
}
}
-
- do_cleanups (cleanup);
}
/* Print a gdb exception to the MI output stream. */
if (report_change)
{
- observer_notify_user_selected_context_changed
- (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
+ gdb::observers::user_selected_context_changed.notify
+ (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
}
}
}
static void
mi_cmd_execute (struct mi_parse *parse)
{
- struct cleanup *cleanup;
-
- cleanup = prepare_execute_command ();
+ scoped_value_mark cleanup = prepare_execute_command ();
if (parse->all && parse->thread_group != -1)
error (_("Cannot specify --thread-group together with --all"));
error (_("Invalid frame id: %d"), frame);
}
+ gdb::optional<scoped_restore_current_language> lang_saver;
if (parse->language != language_unknown)
{
- make_cleanup_restore_current_language ();
+ lang_saver.emplace ();
set_language (parse->language);
}
error_stream (stb);
}
- do_cleanups (cleanup);
}
/* FIXME: This is just a hack so we can get some extra commands going.
{
if (cmd != 0)
{
- struct cleanup *old_cleanups;
- char *run;
+ std::string run = cmd;
if (args_p)
- run = xstrprintf ("%s %s", cmd, args);
- else
- run = xstrdup (cmd);
+ run = run + " " + args;
if (mi_debug_p)
/* FIXME: gdb_???? */
fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
- cmd, run);
- old_cleanups = make_cleanup (xfree, run);
- execute_command (run, 0 /* from_tty */ );
- do_cleanups (old_cleanups);
- return;
+ cmd, run.c_str ());
+ execute_command (run.c_str (), 0 /* from_tty */ );
}
}
void
mi_execute_async_cli_command (const char *cli_command, char **argv, int argc)
{
- struct cleanup *old_cleanups;
- char *run;
+ std::string run = cli_command;
+ if (argc)
+ run = run + " " + *argv;
if (mi_async_p ())
- run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
- else
- run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
- old_cleanups = make_cleanup (xfree, run);
-
- execute_command (run, 0 /* from_tty */ );
+ run += "&";
- /* Do this before doing any printing. It would appear that some
- print code leaves garbage around in the buffer. */
- do_cleanups (old_cleanups);
+ execute_command (run.c_str (), 0 /* from_tty */ );
}
void
static steady_clock::time_point last_update;
static char *previous_sect_name = NULL;
int new_section;
- struct ui_out *saved_uiout;
- struct ui_out *uiout;
struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
/* This function is called through deprecated_show_load_progress
which means uiout may not be correct. Fix it for the duration
of this function. */
- saved_uiout = current_uiout;
+
+ std::unique_ptr<ui_out> uiout;
if (current_interp_named_p (INTERP_MI)
|| current_interp_named_p (INTERP_MI2))
- current_uiout = mi_out_new (2);
+ uiout.reset (mi_out_new (2));
else if (current_interp_named_p (INTERP_MI1))
- current_uiout = mi_out_new (1);
+ uiout.reset (mi_out_new (1));
else if (current_interp_named_p (INTERP_MI3))
- current_uiout = mi_out_new (3);
+ uiout.reset (mi_out_new (3));
else
return;
- uiout = current_uiout;
+ scoped_restore save_uiout
+ = make_scoped_restore (¤t_uiout, uiout.get ());
new_section = (previous_sect_name ?
strcmp (previous_sect_name, section_name) : 1);
fputs_unfiltered (current_token, mi->raw_stdout);
fputs_unfiltered ("+download", mi->raw_stdout);
{
- ui_out_emit_tuple tuple_emitter (uiout, NULL);
+ ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
uiout->field_string ("section", section_name);
uiout->field_int ("section-size", total_section);
uiout->field_int ("total-size", grand_total);
}
- mi_out_put (uiout, mi->raw_stdout);
+ mi_out_put (uiout.get (), mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
fputs_unfiltered (current_token, mi->raw_stdout);
fputs_unfiltered ("+download", mi->raw_stdout);
{
- ui_out_emit_tuple tuple_emitter (uiout, NULL);
+ ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
uiout->field_string ("section", section_name);
uiout->field_int ("section-sent", sent_so_far);
uiout->field_int ("section-size", total_section);
uiout->field_int ("total-sent", total_sent);
uiout->field_int ("total-size", grand_total);
}
- mi_out_put (uiout, mi->raw_stdout);
+ mi_out_put (uiout.get (), mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
-
- xfree (uiout);
- current_uiout = saved_uiout;
}
static void
}
else if (strcmp (mode, "line") == 0)
{
- struct symtabs_and_lines sals;
- struct symtab_and_line sal;
- static CORE_ADDR start_pc, end_pc;
- struct cleanup *back_to;
-
if (argc != 2)
error (_("Line is required"));
- sals = decode_line_with_current_source (argv[1],
- DECODE_LINE_FUNFIRSTLINE);
- back_to = make_cleanup (xfree, sals.sals);
-
- sal = sals.sals[0];
+ std::vector<symtab_and_line> sals
+ = decode_line_with_current_source (argv[1],
+ DECODE_LINE_FUNFIRSTLINE);
+ const symtab_and_line &sal = sals[0];
if (sal.symtab == 0)
error (_("Could not find the specified line"));
+ CORE_ADDR start_pc, end_pc;
if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
else
error (_("Could not find the specified line"));
-
- do_cleanups (back_to);
}
else
error (_("Invalid mode '%s'"), mode);
void
mi_cmd_trace_frame_collected (const char *command, char **argv, int argc)
{
- struct cleanup *old_chain;
struct bp_location *tloc;
int stepping_frame;
struct collection_list *clist;
/* This command only makes sense for the current frame, not the
selected frame. */
- old_chain = make_cleanup_restore_current_thread ();
+ scoped_restore_current_thread restore_thread;
select_frame (get_current_frame ());
encode_actions (tloc, &tracepoint_list, &stepping_list);
/* Explicitly wholly collected variables. */
{
- int i;
-
ui_out_emit_list list_emitter (uiout, "explicit-variables");
const std::vector<std::string> &wholly_collected
= clist->wholly_collected ();
/* Computed expressions. */
{
- char *p;
- int i;
-
ui_out_emit_list list_emitter (uiout, "computed-expressions");
const std::vector<std::string> &computed = clist->computed ();
/* Trace state variables. */
{
- struct cleanup *list_cleanup;
- int tvar;
- char *tsvname;
- int i;
-
- list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");
+ ui_out_emit_list list_emitter (uiout, "tvars");
- tsvname = NULL;
- make_cleanup (free_current_contents, &tsvname);
-
- for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
+ for (int tvar : tinfo->tvars)
{
struct trace_state_variable *tsv;
if (tsv != NULL)
{
- tsvname = (char *) xrealloc (tsvname, strlen (tsv->name) + 2);
- tsvname[0] = '$';
- strcpy (tsvname + 1, tsv->name);
- uiout->field_string ("name", tsvname);
+ uiout->field_fmt ("name", "$%s", tsv->name);
tsv->value_known = target_get_trace_state_variable_value (tsv->number,
&tsv->value);
uiout->field_skip ("current");
}
}
-
- do_cleanups (list_cleanup);
}
/* Memory. */
{
- struct cleanup *list_cleanup;
- VEC(mem_range_s) *available_memory = NULL;
- struct mem_range *r;
- int i;
+ std::vector<mem_range> available_memory;
traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
- make_cleanup (VEC_cleanup(mem_range_s), &available_memory);
- list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");
+ ui_out_emit_list list_emitter (uiout, "memory");
- for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
+ for (const mem_range &r : available_memory)
{
- struct cleanup *cleanup_child;
- gdb_byte *data;
struct gdbarch *gdbarch = target_gdbarch ();
- cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ ui_out_emit_tuple tuple_emitter (uiout, NULL);
- uiout->field_core_addr ("address", gdbarch, r->start);
- uiout->field_int ("length", r->length);
+ uiout->field_core_addr ("address", gdbarch, r.start);
+ uiout->field_int ("length", r.length);
- data = (gdb_byte *) xmalloc (r->length);
- make_cleanup (xfree, data);
+ gdb::byte_vector data (r.length);
if (memory_contents)
{
- if (target_read_memory (r->start, data, r->length) == 0)
+ if (target_read_memory (r.start, data.data (), r.length) == 0)
{
- int m;
- char *data_str, *p;
-
- data_str = (char *) xmalloc (r->length * 2 + 1);
- make_cleanup (xfree, data_str);
-
- for (m = 0, p = data_str; m < r->length; ++m, p += 2)
- sprintf (p, "%02x", data[m]);
- uiout->field_string ("contents", data_str);
+ std::string data_str = bin2hex (data.data (), r.length);
+ uiout->field_string ("contents", data_str.c_str ());
}
else
uiout->field_skip ("contents");
}
- do_cleanups (cleanup_child);
}
-
- do_cleanups (list_cleanup);
}
-
- do_cleanups (old_chain);
}
void
projects / deliverable / binutils-gdb.git / blobdiff