From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2126) id F169C3857374; Sun, 12 Jun 2022 16:55:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org F169C3857374 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Tom Tromey To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Move addrmap classes to addrmap.h X-Act-Checkin: binutils-gdb X-Git-Author: Tom Tromey X-Git-Refname: refs/heads/master X-Git-Oldrev: 9d45ec63a5e60aae846dfc9dc8ee950c3bce2ad4 X-Git-Newrev: 1b3261edfb7b0c66f538c778a07f0bf2547c906d Message-Id: <20220612165540.F169C3857374@sourceware.org> Date: Sun, 12 Jun 2022 16:55:40 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 12 Jun 2022 16:55:41 -0000 https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D1b3261edfb7b= 0c66f538c778a07f0bf2547c906d commit 1b3261edfb7b0c66f538c778a07f0bf2547c906d Author: Tom Tromey Date: Sat Apr 16 09:23:26 2022 -0600 Move addrmap classes to addrmap.h =20 This moves the addrmap class definitions to addrmap.h. This is safe to do now that the contents are private. Diff: --- gdb/addrmap.c | 114 ---------------------------------------------------- gdb/addrmap.h | 125 ++++++++++++++++++++++++++++++++++++++++++++++++++++++= ---- 2 files changed, 118 insertions(+), 121 deletions(-) diff --git a/gdb/addrmap.c b/gdb/addrmap.c index 30db7e78408..eddf084d822 100644 --- a/gdb/addrmap.c +++ b/gdb/addrmap.c @@ -18,7 +18,6 @@ along with this program. If not, see . = */ =20 #include "defs.h" -#include "splay-tree.h" #include "gdbsupport/gdb_obstack.h" #include "addrmap.h" #include "gdbsupport/selftest.h" @@ -29,21 +28,6 @@ gdb_static_assert (sizeof (splay_tree_key) >=3D sizeof (= CORE_ADDR *)); gdb_static_assert (sizeof (splay_tree_value) >=3D sizeof (void *)); =20 =0C -/* The base class for addrmaps. */ - -struct addrmap : public allocate_on_obstack -{ - virtual ~addrmap () =3D default; - - virtual void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, - void *obj) =3D 0; - virtual void *find (CORE_ADDR addr) const =3D 0; - virtual struct addrmap *create_fixed (struct obstack *obstack) =3D 0; - virtual void relocate (CORE_ADDR offset) =3D 0; - virtual int foreach (addrmap_foreach_fn fn) =3D 0; -}; - - void addrmap_set_empty (struct addrmap *map, CORE_ADDR start, CORE_ADDR end_inclusive, @@ -84,45 +68,6 @@ addrmap_foreach (struct addrmap *map, addrmap_foreach_fn= fn) =0C /* Fixed address maps. */ =20 -struct addrmap_mutable; - -struct addrmap_fixed : public addrmap -{ -public: - - addrmap_fixed (struct obstack *obstack, addrmap_mutable *mut); - DISABLE_COPY_AND_ASSIGN (addrmap_fixed); - - void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, - void *obj) override; - void *find (CORE_ADDR addr) const override; - struct addrmap *create_fixed (struct obstack *obstack) override; - void relocate (CORE_ADDR offset) override; - int foreach (addrmap_foreach_fn fn) override; - -private: - - /* A transition: a point in an address map where the value changes. - The map maps ADDR to VALUE, but if ADDR > 0, it maps ADDR-1 to - something else. */ - struct addrmap_transition - { - CORE_ADDR addr; - void *value; - }; - - /* The number of transitions in TRANSITIONS. */ - size_t num_transitions; - - /* An array of transitions, sorted by address. For every point in - the map where either ADDR =3D=3D 0 or ADDR is mapped to one value and - ADDR - 1 is mapped to something different, we have an entry here - containing ADDR and VALUE. (Note that this means we always have - an entry for address 0). */ - struct addrmap_transition *transitions; -}; - - void addrmap_fixed::set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, void *obj) @@ -204,65 +149,6 @@ addrmap_fixed::foreach (addrmap_foreach_fn fn) =0C /* Mutable address maps. */ =20 -struct addrmap_mutable : public addrmap -{ -public: - - explicit addrmap_mutable (struct obstack *obs); - DISABLE_COPY_AND_ASSIGN (addrmap_mutable); - - void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, - void *obj) override; - void *find (CORE_ADDR addr) const override; - struct addrmap *create_fixed (struct obstack *obstack) override; - void relocate (CORE_ADDR offset) override; - int foreach (addrmap_foreach_fn fn) override; - -private: - - /* The obstack to use for allocations for this map. */ - struct obstack *obstack; - - /* A freelist for splay tree nodes, allocated on obstack, and - chained together by their 'right' pointers. */ - /* splay_tree_new_with_allocator uses the provided allocation - function to allocate the main splay_tree structure itself, so our - free list has to be initialized before we create the tree. */ - splay_tree_node free_nodes =3D nullptr; - - /* A splay tree, with a node for each transition; there is a - transition at address T if T-1 and T map to different objects. - - Any addresses below the first node map to NULL. (Unlike - fixed maps, we have no entry at (CORE_ADDR) 0; it doesn't=20 - simplify enough.) - - The last region is assumed to end at CORE_ADDR_MAX. - - Since we can't know whether CORE_ADDR is larger or smaller than - splay_tree_key (unsigned long) --- I think both are possible, - given all combinations of 32- and 64-bit hosts and targets --- - our keys are pointers to CORE_ADDR values. Since the splay tree - library doesn't pass any closure pointer to the key free - function, we can't keep a freelist for keys. Since mutable - addrmaps are only used temporarily right now, we just leak keys - from deleted nodes; they'll be freed when the obstack is freed. */ - splay_tree tree; - - /* Various helper methods. */ - splay_tree_key allocate_key (CORE_ADDR addr); - void force_transition (CORE_ADDR addr); - splay_tree_node splay_tree_lookup (CORE_ADDR addr) const; - splay_tree_node splay_tree_predecessor (CORE_ADDR addr) const; - splay_tree_node splay_tree_successor (CORE_ADDR addr); - void splay_tree_remove (CORE_ADDR addr); - void splay_tree_insert (CORE_ADDR key, void *value); - - static void *splay_obstack_alloc (int size, void *closure); - static void splay_obstack_free (void *obj, void *closure); -}; - - /* Allocate a copy of CORE_ADDR in the obstack. */ splay_tree_key addrmap_mutable::allocate_key (CORE_ADDR addr) diff --git a/gdb/addrmap.h b/gdb/addrmap.h index 412e4288897..c530200e4a9 100644 --- a/gdb/addrmap.h +++ b/gdb/addrmap.h @@ -20,6 +20,7 @@ #ifndef ADDRMAP_H #define ADDRMAP_H =20 +#include "splay-tree.h" #include "gdbsupport/function-view.h" =20 /* An address map is essentially a table mapping CORE_ADDRs onto GDB @@ -33,8 +34,123 @@ A fixed address map, once constructed (from a mutable address map), can't be edited. Both kinds of map are allocated in obstacks. */ =20 -/* The opaque type representing address maps. */ -struct addrmap; +/* The type of a function used to iterate over the map. + OBJ is NULL for unmapped regions. */ +typedef gdb::function_view + addrmap_foreach_fn; + +/* The base class for addrmaps. */ +struct addrmap : public allocate_on_obstack +{ + virtual ~addrmap () =3D default; + + virtual void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, + void *obj) =3D 0; + virtual void *find (CORE_ADDR addr) const =3D 0; + virtual struct addrmap *create_fixed (struct obstack *obstack) =3D 0; + virtual void relocate (CORE_ADDR offset) =3D 0; + virtual int foreach (addrmap_foreach_fn fn) =3D 0; +}; + +struct addrmap_mutable; + +/* Fixed address maps. */ +struct addrmap_fixed : public addrmap +{ +public: + + addrmap_fixed (struct obstack *obstack, addrmap_mutable *mut); + DISABLE_COPY_AND_ASSIGN (addrmap_fixed); + + void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, + void *obj) override; + void *find (CORE_ADDR addr) const override; + struct addrmap *create_fixed (struct obstack *obstack) override; + void relocate (CORE_ADDR offset) override; + int foreach (addrmap_foreach_fn fn) override; + +private: + + /* A transition: a point in an address map where the value changes. + The map maps ADDR to VALUE, but if ADDR > 0, it maps ADDR-1 to + something else. */ + struct addrmap_transition + { + CORE_ADDR addr; + void *value; + }; + + /* The number of transitions in TRANSITIONS. */ + size_t num_transitions; + + /* An array of transitions, sorted by address. For every point in + the map where either ADDR =3D=3D 0 or ADDR is mapped to one value and + ADDR - 1 is mapped to something different, we have an entry here + containing ADDR and VALUE. (Note that this means we always have + an entry for address 0). */ + struct addrmap_transition *transitions; +}; + +/* Mutable address maps. */ + +struct addrmap_mutable : public addrmap +{ +public: + + explicit addrmap_mutable (struct obstack *obs); + DISABLE_COPY_AND_ASSIGN (addrmap_mutable); + + void set_empty (CORE_ADDR start, CORE_ADDR end_inclusive, + void *obj) override; + void *find (CORE_ADDR addr) const override; + struct addrmap *create_fixed (struct obstack *obstack) override; + void relocate (CORE_ADDR offset) override; + int foreach (addrmap_foreach_fn fn) override; + +private: + + /* The obstack to use for allocations for this map. */ + struct obstack *obstack; + + /* A freelist for splay tree nodes, allocated on obstack, and + chained together by their 'right' pointers. */ + /* splay_tree_new_with_allocator uses the provided allocation + function to allocate the main splay_tree structure itself, so our + free list has to be initialized before we create the tree. */ + splay_tree_node free_nodes =3D nullptr; + + /* A splay tree, with a node for each transition; there is a + transition at address T if T-1 and T map to different objects. + + Any addresses below the first node map to NULL. (Unlike + fixed maps, we have no entry at (CORE_ADDR) 0; it doesn't=20 + simplify enough.) + + The last region is assumed to end at CORE_ADDR_MAX. + + Since we can't know whether CORE_ADDR is larger or smaller than + splay_tree_key (unsigned long) --- I think both are possible, + given all combinations of 32- and 64-bit hosts and targets --- + our keys are pointers to CORE_ADDR values. Since the splay tree + library doesn't pass any closure pointer to the key free + function, we can't keep a freelist for keys. Since mutable + addrmaps are only used temporarily right now, we just leak keys + from deleted nodes; they'll be freed when the obstack is freed. */ + splay_tree tree; + + /* Various helper methods. */ + splay_tree_key allocate_key (CORE_ADDR addr); + void force_transition (CORE_ADDR addr); + splay_tree_node splay_tree_lookup (CORE_ADDR addr) const; + splay_tree_node splay_tree_predecessor (CORE_ADDR addr) const; + splay_tree_node splay_tree_successor (CORE_ADDR addr); + void splay_tree_remove (CORE_ADDR addr); + void splay_tree_insert (CORE_ADDR key, void *value); + + static void *splay_obstack_alloc (int size, void *closure); + static void splay_obstack_free (void *obj, void *closure); +}; + =20 /* Create a mutable address map which maps every address to NULL. Allocate entries in OBSTACK. */ @@ -93,11 +209,6 @@ struct addrmap *addrmap_create_fixed (struct addrmap *o= riginal, to either mutable or immutable maps.) */ void addrmap_relocate (struct addrmap *map, CORE_ADDR offset); =20 -/* The type of a function used to iterate over the map. - OBJ is NULL for unmapped regions. */ -typedef gdb::function_view - addrmap_foreach_fn; - /* Call FN for every address in MAP, following an in-order traversal. If FN ever returns a non-zero value, the iteration ceases immediately, and the value is returned. Otherwise, this function