From 46f29a9a260da1a03176682aff63bad03d8f2e8b Mon Sep 17 00:00:00 2001 From: Andrew Burgess Date: Mon, 16 Sep 2019 09:12:27 -0400 Subject: [PATCH] gdb: Remove a VEC from gdbsupport/btrace-common.h Converts a VEC into a std::vector in gdbsupport/btrace-common.h. This commit just performs a mechanical conversion and doesn't do any refactoring. One consequence of this is that the std::vector must actually be a pointer to std::vector as it is placed within a union. It might be possible in future to refactor to a class hierarchy and remove the need for a union, but I'd rather have that be a separate change to make it easier to see the evolution of the code. gdb/ChangeLog: * 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) : Change to std::vector. * nat/linux-btrace.c (perf_event_read_bts): Update for std::vector. (linux_read_bts): Likewise. gdb/gdbserver/ChangeLog: * linux-low.c (linux_low_read_btrace): Update for change to std::vector. --- gdb/ChangeLog | 22 +++++++++++++ gdb/btrace.c | 58 ++++++++++++++-------------------- gdb/gdbserver/ChangeLog | 5 +++ gdb/gdbserver/linux-low.c | 8 ++--- gdb/gdbsupport/btrace-common.c | 18 +++++------ gdb/gdbsupport/btrace-common.h | 17 ++++++---- gdb/nat/linux-btrace.c | 16 +++++----- 7 files changed, 79 insertions(+), 65 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index be51e38a500..a5a87df1f42 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,25 @@ +2019-10-02 Andrew Burgess + + * 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) : 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 * cli/cli-logging.c (show_logging_filename): Use styled_string. diff --git a/gdb/btrace.c b/gdb/btrace.c index 1b809fb5c08..b6a11136444 100644 --- a/gdb/btrace.c +++ b/gdb/btrace.c @@ -1059,7 +1059,7 @@ btrace_compute_ftrace_bts (struct thread_info *tp, 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; @@ -1068,13 +1068,12 @@ btrace_compute_ftrace_bts (struct thread_info *tp, 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 (;;) { @@ -1083,7 +1082,7 @@ btrace_compute_ftrace_bts (struct thread_info *tp, 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); @@ -1119,7 +1118,7 @@ btrace_compute_ftrace_bts (struct thread_info *tp, 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. */ @@ -1573,7 +1572,6 @@ static void btrace_add_pc (struct thread_info *tp) { struct btrace_data btrace; - struct btrace_block *block; struct regcache *regcache; CORE_ADDR pc; @@ -1581,11 +1579,9 @@ btrace_add_pc (struct thread_info *tp) pc = regcache_read_pc (regcache); btrace.format = BTRACE_FORMAT_BTS; - btrace.variant.bts.blocks = NULL; + btrace.variant.bts.blocks = new std::vector ; - 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); } @@ -1692,11 +1688,11 @@ btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp) { 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 (); @@ -1705,14 +1701,14 @@ btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp) 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 @@ -1723,10 +1719,9 @@ btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp) 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; } @@ -2030,7 +2025,6 @@ parse_xml_btrace_block (struct gdb_xml_parser *parser, std::vector &attributes) { struct btrace_data *btrace; - struct btrace_block *block; ULONGEST *begin, *end; btrace = (struct btrace_data *) user_data; @@ -2042,7 +2036,7 @@ parse_xml_btrace_block (struct gdb_xml_parser *parser, case BTRACE_FORMAT_NONE: btrace->format = BTRACE_FORMAT_BTS; - btrace->variant.bts.blocks = NULL; + btrace->variant.bts.blocks = new std::vector ; break; default: @@ -2051,10 +2045,7 @@ parse_xml_btrace_block (struct gdb_xml_parser *parser, 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. */ @@ -3095,7 +3086,7 @@ btrace_maint_update_packets (struct btrace_thread_info *btinfo, 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; @@ -3128,19 +3119,17 @@ btrace_maint_print_packets (struct btrace_thread_info *btinfo, case BTRACE_FORMAT_BTS: { - VEC (btrace_block_s) *blocks; + const std::vector &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; @@ -3443,9 +3432,8 @@ maint_info_btrace_cmd (const char *args, int from_tty) 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) diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog index c0c6f51a069..7eef2c54cba 100644 --- a/gdb/gdbserver/ChangeLog +++ b/gdb/gdbserver/ChangeLog @@ -1,3 +1,8 @@ +2019-10-02 Andrew Burgess + + * linux-low.c (linux_low_read_btrace): Update for change to + std::vector. + 2019-09-20 Christian Biesinger * debug.c (debug_threads): Remove comment in favor of the header. diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index d64c3641ffb..0e4b14e3655 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -7115,9 +7115,7 @@ linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer, 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) @@ -7140,11 +7138,9 @@ linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer, buffer_grow_str (buffer, "\n"); buffer_grow_str (buffer, "\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, "\n", - paddress (block->begin), paddress (block->end)); + paddress (block.begin), paddress (block.end)); buffer_grow_str0 (buffer, "\n"); break; diff --git a/gdb/gdbsupport/btrace-common.c b/gdb/gdbsupport/btrace-common.c index 13f1f1a0fdd..d6d3ab50c9e 100644 --- a/gdb/gdbsupport/btrace-common.c +++ b/gdb/gdbsupport/btrace-common.c @@ -73,7 +73,8 @@ btrace_data::fini () 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: @@ -95,7 +96,7 @@ btrace_data::empty () const 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); @@ -132,7 +133,7 @@ btrace_data_append (struct btrace_data *dst, case BTRACE_FORMAT_NONE: dst->format = BTRACE_FORMAT_BTS; - dst->variant.bts.blocks = NULL; + dst->variant.bts.blocks = new std::vector ; /* Fall-through. */ case BTRACE_FORMAT_BTS: @@ -141,15 +142,12 @@ btrace_data_append (struct btrace_data *dst, /* 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); } } } diff --git a/gdb/gdbsupport/btrace-common.h b/gdb/gdbsupport/btrace-common.h index 0b18924882c..9c57645ffb1 100644 --- a/gdb/gdbsupport/btrace-common.h +++ b/gdb/gdbsupport/btrace-common.h @@ -43,11 +43,15 @@ struct btrace_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. */ @@ -137,8 +141,9 @@ struct btrace_config 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 *blocks; }; /* Configuration information to go with the trace data. */ diff --git a/gdb/nat/linux-btrace.c b/gdb/nat/linux-btrace.c index 8625291cce9..a63973d569d 100644 --- a/gdb/nat/linux-btrace.c +++ b/gdb/nat/linux-btrace.c @@ -271,11 +271,11 @@ perf_event_sample_ok (const struct perf_event_sample *sample) 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 * 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 = new std::vector ; struct perf_event_sample sample; size_t read = 0; struct btrace_block block = { 0, 0 }; @@ -343,7 +343,7 @@ perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin, /* 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; @@ -354,7 +354,7 @@ perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin, 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; } @@ -785,7 +785,8 @@ linux_read_bts (struct btrace_data_bts *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) { @@ -843,9 +844,8 @@ linux_read_bts (struct btrace_data_bts *btrace, /* 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; } -- 2.30.2