From patchwork Wed Feb 7 10:32:43 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yao Qi X-Patchwork-Id: 25843 Received: (qmail 21122 invoked by alias); 7 Feb 2018 10:33:06 -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 20983 invoked by uid 89); 7 Feb 2018 10:33:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=12727, H*r:sk:static. X-HELO: mail-wm0-f41.google.com Received: from mail-wm0-f41.google.com (HELO mail-wm0-f41.google.com) (74.125.82.41) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 07 Feb 2018 10:33:00 +0000 Received: by mail-wm0-f41.google.com with SMTP id v71so2332753wmv.2 for ; Wed, 07 Feb 2018 02:32:59 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references; bh=zhVgwfSIOlqbLvaw+2dKMnmtmVz3mTG9F62eY8Cw2/U=; b=MKYco2vDFxZ+BrCVGiKWAIJqcW1VTU5Uy0KdjDtmfKLYFS9UnDS7MoACNmbcF+6inv 6/aJDYTMVujtM57vSmi/MTWW4pmrpb3gbHX3aGInN5TYdMgmXD2dgw3MP/sQlUYPFX5Q BLB+SeZitmUWNucGcxbAmCqSw8sM9Ud7rLSt7M0ccyvOGYd2eZt36GhJxJxsNnGvNA44 krVFoSclCQ8RSEcognoQN0vNXZq2sxJIIKaiQ++eNAVjGMyQhxZbxqfHe30O5qoLaHCj 4fve5WIcny1cEtyA7WGn5ObgbGUmUkIgQNSF7EN5X6HkNKt3YFQebIMJw40fncuGbibW hxuQ== X-Gm-Message-State: APf1xPCYOFnoOrbACkzqu5PfnODNezgz/zVPzB/wAOeI3o1NpLFrgXVm DkThM4Cr8P653rNzYDJ47PPeEw== X-Google-Smtp-Source: AH8x2276q/aQx1KWeuuWAKjoenDJSKaCC/1RHpQ/XwwArSGTPc+Z0VvZoHCvNu081E0nqvauDwwcag== X-Received: by 10.28.182.5 with SMTP id g5mr4153916wmf.44.1517999577790; Wed, 07 Feb 2018 02:32:57 -0800 (PST) Received: from E107787-LIN.cambridge.arm.com (static.42.136.251.148.clients.your-server.de. [148.251.136.42]) by smtp.gmail.com with ESMTPSA id x135sm1138884wmf.35.2018.02.07.02.32.57 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 07 Feb 2018 02:32:57 -0800 (PST) From: Yao Qi X-Google-Original-From: Yao Qi To: gdb-patches@sourceware.org Subject: [PATCH 01/10] Class reg_buffer Date: Wed, 7 Feb 2018 10:32:43 +0000 Message-Id: <1517999572-14987-2-git-send-email-yao.qi@linaro.org> In-Reply-To: <1517999572-14987-1-git-send-email-yao.qi@linaro.org> References: <1517999572-14987-1-git-send-email-yao.qi@linaro.org> X-IsSubscribed: yes This patch adds a new class reg_buffer, and regcache inherits it. Class reg_buffer is a very simple class, which has the buffer for register contents and status only. It doesn't have any methods to set contents and status, and it is expected that its children classes can inherit it and add different access methods. Another reason I keep class reg_buffer so simple is that I think reg_buffer can be even reused in other classes which need to record the registers contents and status, like frame cache for example. gdb: 2017-11-27 Yao Qi * regcache.c (regcache::regcache): Call reg_buffer ctor. (regcache::arch): Move it to reg_buffer::arch. (regcache::register_buffer): Likewise. (regcache::assert_regnum): Likewise. (regcache::num_raw_registers): Likewise. * regcache.h (reg_buffer): New class. (regcache): Inherit reg_buffer. --- gdb/regcache.c | 31 ++++++++++++++++++++--------- gdb/regcache.h | 62 ++++++++++++++++++++++++++++++++++------------------------ 2 files changed, 58 insertions(+), 35 deletions(-) diff --git a/gdb/regcache.c b/gdb/regcache.c index ab750c6..8addc82 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -181,14 +181,13 @@ regcache_register_size (const struct regcache *regcache, int n) return register_size (regcache->arch (), n); } -regcache::regcache (gdbarch *gdbarch, const address_space *aspace_, - bool readonly_p_) - : m_aspace (aspace_), m_readonly_p (readonly_p_) +reg_buffer::reg_buffer (gdbarch *gdbarch, bool has_pseudo) + : m_has_pseudo (has_pseudo) { gdb_assert (gdbarch != NULL); m_descr = regcache_descr (gdbarch); - if (m_readonly_p) + if (has_pseudo) { m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_cooked_registers); m_register_status = XCNEWVEC (signed char, @@ -199,6 +198,16 @@ regcache::regcache (gdbarch *gdbarch, const address_space *aspace_, m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_raw_registers); m_register_status = XCNEWVEC (signed char, gdbarch_num_regs (gdbarch)); } +} + +regcache::regcache (gdbarch *gdbarch, const address_space *aspace_, + bool readonly_p_) +/* The register buffers. A read-only register cache can hold the + full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a + read/write register cache can only hold [0 .. gdbarch_num_regs). */ + : reg_buffer (gdbarch, readonly_p_), + m_aspace (aspace_), m_readonly_p (readonly_p_) +{ m_ptid = minus_one_ptid; } @@ -218,7 +227,7 @@ regcache::regcache (readonly_t, const regcache &src) } gdbarch * -regcache::arch () const +reg_buffer::arch () const { return m_descr->gdbarch; } @@ -267,7 +276,7 @@ private: /* Return a pointer to register REGNUM's buffer cache. */ gdb_byte * -regcache::register_buffer (int regnum) const +reg_buffer::register_buffer (int regnum) const { return m_registers + m_descr->register_offset[regnum]; } @@ -390,9 +399,13 @@ regcache::invalidate (int regnum) } void -regcache::assert_regnum (int regnum) const +reg_buffer::assert_regnum (int regnum) const { - gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (arch ())); + gdb_assert (regnum >= 0); + if (m_has_pseudo) + gdb_assert (regnum < m_descr->nr_cooked_registers); + else + gdb_assert (regnum < gdbarch_num_regs (arch ())); } /* Global structure containing the current regcache. */ @@ -1272,7 +1285,7 @@ regcache_write_pc (struct regcache *regcache, CORE_ADDR pc) } int -regcache::num_raw_registers () const +reg_buffer::num_raw_registers () const { return gdbarch_num_regs (arch ()); } diff --git a/gdb/regcache.h b/gdb/regcache.h index 9e3da8c..e2c7621 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -227,9 +227,44 @@ typedef struct cached_reg gdb_byte *data; } cached_reg_t; +/* Buffer of registers. */ + +class reg_buffer +{ +public: + reg_buffer (gdbarch *gdbarch, bool has_pseudo); + + DISABLE_COPY_AND_ASSIGN (reg_buffer); + + /* Return regcache's architecture. */ + gdbarch *arch () const; + + virtual ~reg_buffer () + { + xfree (m_registers); + xfree (m_register_status); + } + +protected: + /* Assert on the range of REGNUM. */ + void assert_regnum (int regnum) const; + + int num_raw_registers () const; + + gdb_byte *register_buffer (int regnum) const; + + struct regcache_descr *m_descr; + + bool m_has_pseudo; + /* The register buffers. */ + gdb_byte *m_registers; + /* Register cache status. */ + signed char *m_register_status; +}; + /* The register cache for storing raw register values. */ -class regcache +class regcache : public reg_buffer { public: regcache (gdbarch *gdbarch) @@ -244,15 +279,6 @@ public: DISABLE_COPY_AND_ASSIGN (regcache); - ~regcache () - { - xfree (m_registers); - xfree (m_register_status); - } - - /* Return regcache's architecture. */ - gdbarch *arch () const; - /* Return REGCACHE's address space. */ const address_space *aspace () const { @@ -339,14 +365,9 @@ public: static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid); protected: regcache (gdbarch *gdbarch, const address_space *aspace_, bool readonly_p_); - - int num_raw_registers () const; - static std::forward_list current_regcache; private: - gdb_byte *register_buffer (int regnum) const; - void restore (struct regcache *src); enum register_status xfer_part (int regnum, int offset, int len, void *in, @@ -357,21 +378,10 @@ private: int regnum, const void *in_buf, void *out_buf, size_t size) const; - /* Assert on the range of REGNUM. */ - void assert_regnum (int regnum) const; - - struct regcache_descr *m_descr; - /* The address space of this register cache (for registers where it makes sense, like PC or SP). */ const address_space * const m_aspace; - /* The register buffers. A read-only register cache can hold the - full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write - register cache can only hold [0 .. gdbarch_num_regs). */ - gdb_byte *m_registers; - /* Register cache status. */ - signed char *m_register_status; /* Is this a read-only cache? A read-only cache is used for saving the target's register state (e.g, across an inferior function call or just before forcing a function return). A read-only