#include "language.h"
#include "valprint.h"
#include "osdata.h"
-#include "common/gdb_splay_tree.h"
+#include "gdbsupport/gdb_splay_tree.h"
#include "tracepoint.h"
-#include "ctf.h"
#include "ada-lang.h"
#include "linespec.h"
#include "extension.h"
#include "gdbcmd.h"
#include "observable.h"
-#include "common/gdb_optional.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/gdb_optional.h"
+#include "gdbsupport/byte-vector.h"
#include <ctype.h>
-#include "common/run-time-clock.h"
+#include "gdbsupport/run-time-clock.h"
#include <chrono>
#include "progspace-and-thread.h"
-#include "common/rsp-low.h"
+#include "gdbsupport/rsp-low.h"
#include <algorithm>
#include <set>
#include <map>
int skip_unavailable);
/* Controls whether the frontend wants MI in async mode. */
-static int mi_async = 0;
+static bool mi_async = false;
/* The set command writes to this variable. If the inferior is
executing, mi_async is *not* updated. */
-static int mi_async_1 = 0;
+static bool mi_async_1 = false;
static void
set_mi_async_command (const char *args, int from_tty,
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
-static int
-proceed_thread_callback (struct thread_info *thread, void *arg)
-{
- int pid = *(int *)arg;
-
- proceed_thread (thread, pid);
- return 0;
-}
-
static void
exec_continue (char **argv, int argc)
{
pid = inf->pid;
}
- iterate_over_threads (proceed_thread_callback, &pid);
+
+ /* Proceed the threads in global number order. This is not necessary,
+ it's just to avoid breaking some tests like gdb.mi/mi-nsintrall.exp
+ that expect the *running notifications in that order. In the end,
+ we should instead fix the test to accept the notifications in any
+ order. */
+ std::vector<thread_info *> threads;
+ for (thread_info *tp : all_threads ())
+ threads.push_back (tp);
+
+ std::sort (threads.begin (), threads.end (),
+ [] (thread_info *a, thread_info *b)
+ {
+ return a->global_num < b->global_num;
+ });
+
+ for (thread_info *tp : threads)
+ proceed_thread (tp, pid);
}
else
{
current_thread = tp->global_num;
num++;
- current_uiout->field_int ("thread-id", tp->global_num);
+ current_uiout->field_signed ("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);
+ current_uiout->field_signed ("current-thread-id", current_thread);
+ current_uiout->field_signed ("number-of-threads", num);
}
void
uiout->field_string ("exit-code",
int_string (inferior->exit_code, 8, 0, 0, 1));
if (inferior->pid != 0)
- uiout->field_int ("pid", inferior->pid);
+ uiout->field_signed ("pid", inferior->pid);
if (inferior->pspace->pspace_exec_filename != NULL)
{
ui_out_emit_list list_emitter (uiout, "cores");
for (int b : data.cores)
- uiout->field_int (NULL, b);
+ uiout->field_signed (NULL, b);
}
if (top_data->recurse)
output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
{
ui_out_emit_list list_emitter (uiout, field_name);
- gdb::unique_xmalloc_ptr<char> cores (xstrdup (xcores));
+ auto cores = make_unique_xstrdup (xcores);
char *p = cores.get ();
+ char *saveptr;
- for (p = strtok (p, ","); p; p = strtok (NULL, ","))
+ for (p = strtok_r (p, ",", &saveptr); p; p = strtok_r (NULL, ",", &saveptr))
uiout->field_string (NULL, p);
}
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- uiout->field_fmt ("id", "%s", pid->c_str ());
+ uiout->field_string ("id", pid->c_str ());
uiout->field_string ("type", "process");
if (cmd)
uiout->field_string ("description", cmd->c_str ());
if (register_changed_p (regnum, prev_regs.get (),
this_regs.get ()))
- uiout->field_int (NULL, regnum);
+ uiout->field_signed (NULL, regnum);
}
}
{
if (register_changed_p (regnum, prev_regs.get (),
this_regs.get ()))
- uiout->field_int (NULL, regnum);
+ uiout->field_signed (NULL, regnum);
}
else
error (_("bad register number"));
return;
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- uiout->field_int ("number", regnum);
+ uiout->field_signed ("number", regnum);
if (format == 'N')
format = 0;
the ``x'' command.
WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
NR_ROW: Number of rows.
- NR_COL: The number of colums (words per row).
+ NR_COL: The number of columns (words per row).
ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
ASCHAR for unprintable characters.
Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
- displayes them. Returns:
+ displays them. Returns:
{addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
/* Output the header information. */
uiout->field_core_addr ("addr", gdbarch, addr);
- uiout->field_int ("nr-bytes", nr_bytes);
- uiout->field_int ("total-bytes", total_bytes);
+ uiout->field_signed ("nr-bytes", nr_bytes);
+ uiout->field_signed ("total-bytes", total_bytes);
uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols);
uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols);
uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes);
uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes);
- /* Build the result as a two dimentional table. */
+ /* Build the result as a two dimensional table. */
{
int row;
int row_byte;
{
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);
+ uiout->field_signed ("section-size", total_section);
+ uiout->field_signed ("total-size", grand_total);
}
mi_out_put (uiout.get (), mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
{
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);
+ uiout->field_signed ("section-sent", sent_so_far);
+ uiout->field_signed ("section-size", total_section);
+ uiout->field_signed ("total-sent", total_sent);
+ uiout->field_signed ("total-size", grand_total);
}
mi_out_put (uiout.get (), mi->raw_stdout);
fputs_unfiltered ("\n", mi->raw_stdout);
tsv->value_known = target_get_trace_state_variable_value (tsv->number,
&tsv->value);
- uiout->field_int ("current", tsv->value);
+ uiout->field_signed ("current", tsv->value);
}
else
{
ui_out_emit_tuple tuple_emitter (uiout, NULL);
uiout->field_core_addr ("address", gdbarch, r.start);
- uiout->field_int ("length", r.length);
+ uiout->field_signed ("length", r.length);
gdb::byte_vector data (r.length);
projects / deliverable / binutils-gdb.git / blobdiff