From patchwork Fri Dec 1 10:47:58 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yao Qi X-Patchwork-Id: 24670 Received: (qmail 75509 invoked by alias); 1 Dec 2017 10:48:45 -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 74825 invoked by uid 89); 1 Dec 2017 10:48:27 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.7 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KB_WAM_FROM_NAME_SINGLEWORD, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=Hx-spam-relays-external:sk:static., H*RU:sk:static., H*r:sk:static. X-HELO: mail-wr0-f178.google.com Received: from mail-wr0-f178.google.com (HELO mail-wr0-f178.google.com) (209.85.128.178) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 01 Dec 2017 10:48:24 +0000 Received: by mail-wr0-f178.google.com with SMTP id x49so9590143wrb.13 for ; Fri, 01 Dec 2017 02:48:21 -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=wlBr7slMuM2qRvz/3NPyve64/uTn8RU1JutK9AR95ec=; b=uPOpfo6UlnnewQBeRpE7I8f8Bev4Eum6nG3HwIvUWvD1Fgx3qGuV7jD8YAeP3PCRqf Foy6qv84QyBM0ms4eneanjbO2glb4KhPEM3EcEajbFgB7gM7Je4OhoHyzvws8DaV8JBr 8JvahJHzTKVULCnZEUy1dPCRv88I3BNTvxMp29mW7tcaiQLt6JfA8kA7e4495J0q8nfS RN27vHc4piBiLSAJWKo/8TkAtEP6dQDeAaJe9vP8SOEJoCcjw86fnaPfR+WpX/DEWUUh 22JhVFU7T3xJRI/PtSe7ljz0EioX/t6JqcJQDjX/WptPchTTitQ4Hz9XBCZQZy+DtmmO ieEw== X-Gm-Message-State: AJaThX6JAxj16LdaztOIvqXaMBYDgVzbopIIYZ9TZVY2eMxtU0nebEnY aZem1d46Nk70GIXj9cz7hII1Vw== X-Google-Smtp-Source: AGs4zMb4L5LW+QTlQsNqCZU4+sb7HUUFFMagd3a6ZgBQsyncL32aWKoaUBofv3zdiksAoZjunzMqqA== X-Received: by 10.223.182.73 with SMTP id i9mr4668745wre.113.1512125299407; Fri, 01 Dec 2017 02:48:19 -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 o10sm5316833wrg.5.2017.12.01.02.48.18 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 01 Dec 2017 02:48:18 -0800 (PST) From: Yao Qi X-Google-Original-From: Yao Qi To: gdb-patches@sourceware.org Subject: [PATCH 07/15] Class reg_buffer Date: Fri, 1 Dec 2017 10:47:58 +0000 Message-Id: <1512125286-29788-8-git-send-email-yao.qi@linaro.org> In-Reply-To: <1512125286-29788-1-git-send-email-yao.qi@linaro.org> References: <1512125286-29788-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 4577913..8cc9c98 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 c5ef41b..a133de1 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