From patchwork Mon Sep 23 22:09:37 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Burgess X-Patchwork-Id: 34640 Received: (qmail 115834 invoked by alias); 23 Sep 2019 22:09:50 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 115618 invoked by uid 89); 23 Sep 2019 22:09:48 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-23.9 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy=DOCTYPE, !DOCTYPE, !doctype, doctype X-HELO: mail-wm1-f68.google.com Received: from mail-wm1-f68.google.com (HELO mail-wm1-f68.google.com) (209.85.128.68) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 23 Sep 2019 22:09:45 +0000 Received: by mail-wm1-f68.google.com with SMTP id 3so10872454wmi.3 for ; Mon, 23 Sep 2019 15:09:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :in-reply-to:references; bh=8giADG5xFkKYjY7YNVoUh48xkS3MJRFMC5vxZHSPIbE=; b=DkEb8Sbwp+LHLKxijpzHd5d6ccAyBTUdVbPAbT4K26yqeZ/9u24PDNy4gx6oKGCmJ3 8VvB4+anq3fCyTWbeaasM9o5432AZL/RqPkjRqjwLza9vgHfYFu6NaPHH/Acley3MDiu wSG1uOon6Aad35KQNsojNkcY9RTLr/sR2MFUjOvS1hyVfB1WALKBCJG1sC8MNwMV9Pwm Q4GfTUNeidQY+GunxEbhUflkdULbs/TxN/q9PZ3kNFsq/G1rygxPmdSMbK+CYpwI2AaV bbo10F17YLr/pAXGLv9EtT/aCTe2eqk338/s7tLrPdg7o7xYSbpI9lX0EE5tS1fl3/90 8+Gw== Return-Path: Received: from localhost (host86-128-12-122.range86-128.btcentralplus.com. [86.128.12.122]) by smtp.gmail.com with ESMTPSA id u83sm290272wme.0.2019.09.23.15.09.42 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 23 Sep 2019 15:09:42 -0700 (PDT) From: Andrew Burgess To: gdb-patches Cc: Andrew Burgess Subject: [PATCH 1/2] gdb: Remove a VEC from gdbsupport/btrace-common.h Date: Mon, 23 Sep 2019 23:09:37 +0100 Message-Id: <0b4986ad14493ae77db1dfd87d2a54d30c9ad65d.1569276387.git.andrew.burgess@embecosm.com> In-Reply-To: References: In-Reply-To: References: X-IsSubscribed: yes 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. (btrace_add_pc): Likewise. (btrace_stitch_bts): Likewise. (parse_xml_btrace_block): Likewise. (btrace_maint_update_packets): Likewise. (btrace_maint_print_packets): Likewise. (maint_info_btrace_cmd): Likewise. * btrace.h: Add 'gdbsupport/vec.h' include. * gdbsupport/btrace-common.c (btrace_data::fini): Likewise. (btrace_data::empty): Likewise. (btrace_data_append): Likewise. * gdbsupport/btrace-common.h: Remove 'vec.h' include. (struct btrace_block): Add constructor, and delete default 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 | 21 +++++++++++++++++++ gdb/btrace.c | 47 ++++++++++++++++++------------------------ gdb/btrace.h | 1 + gdb/gdbserver/ChangeLog | 5 +++++ gdb/gdbserver/linux-low.c | 8 ++----- gdb/gdbsupport/btrace-common.c | 17 +++++++-------- gdb/gdbsupport/btrace-common.h | 20 +++++++++++++----- gdb/nat/linux-btrace.c | 14 ++++++------- 8 files changed, 78 insertions(+), 55 deletions(-) diff --git a/gdb/btrace.c b/gdb/btrace.c index 1b809fb5c08..5013b568a45 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; @@ -1073,7 +1073,7 @@ btrace_compute_ftrace_bts (struct thread_info *tp, blk -= 1; - block = VEC_index (btrace_block_s, btrace->blocks, blk); + block = &btrace->blocks->at (blk); pc = block->begin; for (;;) @@ -1573,7 +1573,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 +1580,10 @@ 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_block block (pc, pc); + btrace.variant.bts.blocks->push_back (block); btrace_compute_ftrace (tp, &btrace, NULL); } @@ -1696,7 +1694,7 @@ btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp) 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 +1703,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 @@ -1724,9 +1722,9 @@ btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp) 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) + && btrace->blocks->size () == 1) { - VEC_pop (btrace_block_s, btrace->blocks); + btrace->blocks->pop_back (); return 0; } @@ -2030,7 +2028,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 +2039,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: @@ -2052,9 +2049,8 @@ 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_block block (*begin, *end); + btrace->variant.bts.blocks->push_back (block); } /* Parse a "raw" xml record. */ @@ -3095,7 +3091,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 +3124,17 @@ btrace_maint_print_packets (struct btrace_thread_info *btinfo, case BTRACE_FORMAT_BTS: { - VEC (btrace_block_s) *blocks; + std::vector *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_s &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 +3437,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/btrace.h b/gdb/btrace.h index ba8d27c879c..d09c424804b 100644 --- a/gdb/btrace.h +++ b/gdb/btrace.h @@ -29,6 +29,7 @@ #include "gdbsupport/btrace-common.h" #include "target/waitstatus.h" /* For enum target_stop_reason. */ #include "gdbsupport/enum-flags.h" +#include "gdbsupport/vec.h" #if defined (HAVE_LIBIPT) # include diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index d64c3641ffb..ec2731b12a9 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 struct 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..337ac1479c4 100644 --- a/gdb/gdbsupport/btrace-common.c +++ b/gdb/gdbsupport/btrace-common.c @@ -73,7 +73,7 @@ btrace_data::fini () return; case BTRACE_FORMAT_BTS: - VEC_free (btrace_block_s, variant.bts.blocks); + delete variant.bts.blocks; return; case BTRACE_FORMAT_PT: @@ -95,7 +95,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 +132,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 +141,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); + btrace_block_s 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..cb8d1ba387a 100644 --- a/gdb/gdbsupport/btrace-common.h +++ b/gdb/gdbsupport/btrace-common.h @@ -26,8 +26,6 @@ inferior. For presentation purposes, the branch trace is represented as a list of sequential control-flow blocks, one such list per thread. */ -#include "vec.h" - /* A branch trace block. This represents a block of sequential control-flow. Adjacent blocks will be @@ -43,11 +41,22 @@ struct btrace_block /* The address of the first byte of the last instruction in the block. */ CORE_ADDR end; + + /* Simple constructor. */ + btrace_block (CORE_ADDR begin, CORE_ADDR end) + : begin (begin), + end (end) + { + /* Nothing. */ + } + +private: + /* Don't create blocks without initialization. */ + btrace_block () = delete; }; /* Define functions operating on a vector of branch trace blocks. */ typedef struct btrace_block btrace_block_s; -DEF_VEC_O (btrace_block_s); /* Enumeration of btrace formats. */ @@ -137,8 +146,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..e1da4a1645b 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,7 @@ 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); if (type == BTRACE_READ_DELTA) { @@ -843,9 +843,9 @@ 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) + if (!btrace->blocks->empty () && type != BTRACE_READ_DELTA) - VEC_pop (btrace_block_s, btrace->blocks); + btrace->blocks->pop_back (); return BTRACE_ERR_NONE; }