+2019-10-02 Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * btrace.c (btrace_compute_ftrace_bts): Update for std::vector,
+ make accesses into the vector constant references.
+ (btrace_add_pc): Update for std::vector.
+ (btrace_stitch_bts): Likewise.
+ (parse_xml_btrace_block): Likewise.
+ (btrace_maint_update_packets): Likewise.
+ (btrace_maint_print_packets): Likewise.
+ (maint_info_btrace_cmd): Likewise.
+ * gdbsupport/btrace-common.c (btrace_data::fini): Update for
+ std::vector.
+ (btrace_data::empty): Likewise.
+ (btrace_data_append): Likewise.
+ * gdbsupport/btrace-common.h: Remove use of DEF_VEC_O.
+ (typedef btrace_block_s): Delete.
+ (struct btrace_block): Add constructor.
+ (struct btrace_data_bts) <blocks>: Change to std::vector.
+ * nat/linux-btrace.c (perf_event_read_bts): Update for
+ std::vector.
+ (linux_read_bts): Likewise.
+
2019-10-01 Tom Tromey <tom@tromey.com>
* cli/cli-logging.c (show_logging_filename): Use styled_string.
gdbarch = target_gdbarch ();
btinfo = &tp->btrace;
- blk = VEC_length (btrace_block_s, btrace->blocks);
+ blk = btrace->blocks->size ();
if (btinfo->functions.empty ())
level = INT_MAX;
while (blk != 0)
{
- btrace_block_s *block;
CORE_ADDR pc;
blk -= 1;
- block = VEC_index (btrace_block_s, btrace->blocks, blk);
- pc = block->begin;
+ const btrace_block &block = btrace->blocks->at (blk);
+ pc = block.begin;
for (;;)
{
int size;
/* We should hit the end of the block. Warn if we went too far. */
- if (block->end < pc)
+ if (block.end < pc)
{
/* Indicate the gap in the trace. */
bfun = ftrace_new_gap (btinfo, BDE_BTS_OVERFLOW, gaps);
ftrace_update_insns (bfun, insn);
/* We're done once we pushed the instruction at the end. */
- if (block->end == pc)
+ if (block.end == pc)
break;
/* We can't continue if we fail to compute the size. */
btrace_add_pc (struct thread_info *tp)
{
struct btrace_data btrace;
- struct btrace_block *block;
struct regcache *regcache;
CORE_ADDR pc;
pc = regcache_read_pc (regcache);
btrace.format = BTRACE_FORMAT_BTS;
- btrace.variant.bts.blocks = NULL;
+ btrace.variant.bts.blocks = new std::vector <btrace_block>;
- block = VEC_safe_push (btrace_block_s, btrace.variant.bts.blocks, NULL);
- block->begin = pc;
- block->end = pc;
+ btrace.variant.bts.blocks->emplace_back (pc, pc);
btrace_compute_ftrace (tp, &btrace, NULL);
}
{
struct btrace_thread_info *btinfo;
struct btrace_function *last_bfun;
- btrace_block_s *first_new_block;
+ btrace_block *first_new_block;
btinfo = &tp->btrace;
gdb_assert (!btinfo->functions.empty ());
- gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
+ gdb_assert (!btrace->blocks->empty ());
last_bfun = &btinfo->functions.back ();
of the new trace, though, since we can't fill in the start address.*/
if (last_bfun->insn.empty ())
{
- VEC_pop (btrace_block_s, btrace->blocks);
+ btrace->blocks->pop_back ();
return 0;
}
/* Beware that block trace starts with the most recent block, so the
chronologically first block in the new trace is the last block in
the new trace's block vector. */
- first_new_block = VEC_last (btrace_block_s, btrace->blocks);
+ first_new_block = &btrace->blocks->back ();
const btrace_insn &last_insn = last_bfun->insn.back ();
/* If the current PC at the end of the block is the same as in our current
entries.
In the second case, the delta trace vector should contain exactly one
entry for the partial block containing the current PC. Remove it. */
- if (first_new_block->end == last_insn.pc
- && VEC_length (btrace_block_s, btrace->blocks) == 1)
+ if (first_new_block->end == last_insn.pc && btrace->blocks->size () == 1)
{
- VEC_pop (btrace_block_s, btrace->blocks);
+ btrace->blocks->pop_back ();
return 0;
}
std::vector<gdb_xml_value> &attributes)
{
struct btrace_data *btrace;
- struct btrace_block *block;
ULONGEST *begin, *end;
btrace = (struct btrace_data *) user_data;
case BTRACE_FORMAT_NONE:
btrace->format = BTRACE_FORMAT_BTS;
- btrace->variant.bts.blocks = NULL;
+ btrace->variant.bts.blocks = new std::vector <btrace_block>;
break;
default:
begin = (ULONGEST *) xml_find_attribute (attributes, "begin")->value.get ();
end = (ULONGEST *) xml_find_attribute (attributes, "end")->value.get ();
-
- block = VEC_safe_push (btrace_block_s, btrace->variant.bts.blocks, NULL);
- block->begin = *begin;
- block->end = *end;
+ btrace->variant.bts.blocks->emplace_back (*begin, *end);
}
/* Parse a "raw" xml record. */
case BTRACE_FORMAT_BTS:
/* Nothing to do - we operate directly on BTINFO->DATA. */
*begin = 0;
- *end = VEC_length (btrace_block_s, btinfo->data.variant.bts.blocks);
+ *end = btinfo->data.variant.bts.blocks->size ();
*from = btinfo->maint.variant.bts.packet_history.begin;
*to = btinfo->maint.variant.bts.packet_history.end;
break;
case BTRACE_FORMAT_BTS:
{
- VEC (btrace_block_s) *blocks;
+ const std::vector <btrace_block> &blocks
+ = *btinfo->data.variant.bts.blocks;
unsigned int blk;
- blocks = btinfo->data.variant.bts.blocks;
for (blk = begin; blk < end; ++blk)
{
- const btrace_block_s *block;
-
- block = VEC_index (btrace_block_s, blocks, blk);
+ const btrace_block &block = blocks.at (blk);
printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk,
- core_addr_to_string_nz (block->begin),
- core_addr_to_string_nz (block->end));
+ core_addr_to_string_nz (block.begin),
+ core_addr_to_string_nz (block.end));
}
btinfo->maint.variant.bts.packet_history.begin = begin;
break;
case BTRACE_FORMAT_BTS:
- printf_unfiltered (_("Number of packets: %u.\n"),
- VEC_length (btrace_block_s,
- btinfo->data.variant.bts.blocks));
+ printf_unfiltered (_("Number of packets: %zu.\n"),
+ btinfo->data.variant.bts.blocks->size ());
break;
#if defined (HAVE_LIBIPT)
+2019-10-02 Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * linux-low.c (linux_low_read_btrace): Update for change to
+ std::vector.
+
2019-09-20 Christian Biesinger <cbiesinger@google.com>
* debug.c (debug_threads): Remove comment in favor of the header.
enum btrace_read_type type)
{
struct btrace_data btrace;
- struct btrace_block *block;
enum btrace_error err;
- int i;
err = linux_read_btrace (&btrace, tinfo, type);
if (err != BTRACE_ERR_NONE)
buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
- for (i = 0;
- VEC_iterate (btrace_block_s, btrace.variant.bts.blocks, i, block);
- i++)
+ for (const btrace_block &block : *btrace.variant.bts.blocks)
buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
- paddress (block->begin), paddress (block->end));
+ paddress (block.begin), paddress (block.end));
buffer_grow_str0 (buffer, "</btrace>\n");
break;
return;
case BTRACE_FORMAT_BTS:
- VEC_free (btrace_block_s, variant.bts.blocks);
+ delete variant.bts.blocks;
+ variant.bts.blocks = nullptr;
return;
case BTRACE_FORMAT_PT:
return true;
case BTRACE_FORMAT_BTS:
- return VEC_empty (btrace_block_s, variant.bts.blocks);
+ return variant.bts.blocks->empty ();
case BTRACE_FORMAT_PT:
return (variant.pt.size == 0);
case BTRACE_FORMAT_NONE:
dst->format = BTRACE_FORMAT_BTS;
- dst->variant.bts.blocks = NULL;
+ dst->variant.bts.blocks = new std::vector <btrace_block>;
/* Fall-through. */
case BTRACE_FORMAT_BTS:
/* We copy blocks in reverse order to have the oldest block at
index zero. */
- blk = VEC_length (btrace_block_s, src->variant.bts.blocks);
+ blk = src->variant.bts.blocks->size ();
while (blk != 0)
{
- btrace_block_s *block;
-
- block = VEC_index (btrace_block_s, src->variant.bts.blocks,
- --blk);
-
- VEC_safe_push (btrace_block_s, dst->variant.bts.blocks, block);
+ const btrace_block &block
+ = src->variant.bts.blocks->at (--blk);
+ dst->variant.bts.blocks->push_back (block);
}
}
}
/* The address of the first byte of the last instruction in the block. */
CORE_ADDR end;
-};
-/* Define functions operating on a vector of branch trace blocks. */
-typedef struct btrace_block btrace_block_s;
-DEF_VEC_O (btrace_block_s);
+ /* Simple constructor. */
+ btrace_block (CORE_ADDR begin, CORE_ADDR end)
+ : begin (begin),
+ end (end)
+ {
+ /* Nothing. */
+ }
+};
/* Enumeration of btrace formats. */
struct btrace_data_bts
{
/* Branch trace is represented as a vector of branch trace blocks starting
- with the most recent block. */
- VEC (btrace_block_s) *blocks;
+ with the most recent block. This needs to be a pointer as we place
+ btrace_data_bts into a union. */
+ std::vector <btrace_block> *blocks;
};
/* Configuration information to go with the trace data. */
In case the buffer overflows during sampling, one sample may have its lower
part at the end and its upper part at the beginning of the buffer. */
-static VEC (btrace_block_s) *
+static std::vector <btrace_block> *
perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin,
const uint8_t *end, const uint8_t *start, size_t size)
{
- VEC (btrace_block_s) *btrace = NULL;
+ std::vector <btrace_block> *btrace = new std::vector <btrace_block>;
struct perf_event_sample sample;
size_t read = 0;
struct btrace_block block = { 0, 0 };
/* We found a valid sample, so we can complete the current block. */
block.begin = psample->bts.to;
- VEC_safe_push (btrace_block_s, btrace, &block);
+ btrace->push_back (block);
/* Start the next block. */
block.end = psample->bts.from;
reading delta trace, we can fill in the start address later on.
Otherwise we will prune it. */
block.begin = 0;
- VEC_safe_push (btrace_block_s, btrace, &block);
+ btrace->push_back (block);
return btrace;
}
data_head = *pevent->data_head;
/* Delete any leftover trace from the previous iteration. */
- VEC_free (btrace_block_s, btrace->blocks);
+ delete btrace->blocks;
+ btrace->blocks = nullptr;
if (type == BTRACE_READ_DELTA)
{
/* Prune the incomplete last block (i.e. the first one of inferior execution)
if we're not doing a delta read. There is no way of filling in its zeroed
BEGIN element. */
- if (!VEC_empty (btrace_block_s, btrace->blocks)
- && type != BTRACE_READ_DELTA)
- VEC_pop (btrace_block_s, btrace->blocks);
+ if (!btrace->blocks->empty () && type != BTRACE_READ_DELTA)
+ btrace->blocks->pop_back ();
return BTRACE_ERR_NONE;
}
projects / deliverable / binutils-gdb.git / commitdiff
