gdb: add unittests for blockvector lookup functions

This commit adds new unittest - blockvector-lookup - that tests
blockvector::lookup () and blockvector::contains ().

Approved-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 538d10a824df1c1e33dad47810111fdecc039809..ed29f1703cd825e0296b06689f55d5391319ca42 100644 (file)
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -451,6 +451,7 @@ SUBDIR_PYTHON_LDFLAGS =
 SUBDIR_PYTHON_CFLAGS =
 
 SELFTESTS_SRCS = \
+       block-selftests.c \
        disasm-selftests.c \
        gdbarch-selftests.c \
        selftest-arch.c \

diff --git a/gdb/block-selftests.c b/gdb/block-selftests.c
new file mode 100644 (file)
index 0000000..f5883f1
--- /dev/null
+++ b/gdb/block-selftests.c
@@ -0,0 +1,128 @@
+/* Self tests for blockvectors
+
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "gdbsupport/selftest.h"
+#include "block.h"
+#include "addrmap.h"
+
+
+namespace selftests {
+
+/* Create and add new block to given blockvector.  */
+static struct block *
+make_block (struct blockvector &bv, struct obstack &ob, CORE_ADDR start,
+           CORE_ADDR end, struct block *superblock = nullptr)
+{
+  auto b = new (&ob) struct block;
+  b->set_start (start);
+  b->set_end (end);
+  b->set_superblock (superblock);
+  b->set_multidict (mdict_create_linear_expandable (language_unknown));
+
+  bv.append_block (b);
+
+  return b;
+}
+
+/* A helper to create and set address map given a blockvector.  */
+static void
+make_map (struct blockvector &bv, struct obstack &ob)
+{
+  struct addrmap_mutable map;
+
+  for (int i = bv.num_blocks () - 1; i > STATIC_BLOCK; i--)
+    {
+      auto b = bv.block (i);
+      map.set_empty (b->start (), b->end () - 1, b);
+    }
+
+  bv.set_map (new (&ob) addrmap_fixed (&ob, &map));
+}
+
+/* Create and return blockvector with following blocks:
+
+       B0    0x1000 - 0x4000   (global block)
+       B1    0x1000 - 0x4000   (static block)
+        B2   0x1000 - 0x2000
+                               (hole)
+        B3   0x3000 - 0x4000
+
+  If USE_MAP is true, then also set blockvector's address map.
+*/
+static blockvector_up
+make_blockvector (struct obstack &ob, bool use_map)
+{
+  auto bv = std::make_unique<struct blockvector> (0);
+
+  auto global_block = make_block (*bv.get (), ob, 0x1000, 0x4000);
+  auto static_block = make_block (*bv.get (), ob, 0x1000, 0x4000,
+                                 global_block);
+  make_block (*bv.get (), ob, 0x1000, 0x2000, static_block);
+  make_block (*bv.get (), ob, 0x3000, 0x4000, static_block);
+
+  if (use_map)
+    make_map (*bv.get (), ob);
+
+  return bv;
+}
+
+static void
+test_blockvector_lookup_contains ()
+{
+  for (bool with_map : { false, true })
+    {
+      /* Test blockvector without an address map.  */
+      auto_obstack ob;
+      blockvector_up bv = make_blockvector (ob, with_map);
+
+      /* Test address outside global block's range.  */
+      SELF_CHECK (bv->lookup (0x0500) == nullptr);
+      SELF_CHECK (bv->contains (0x0500) == false);
+
+      /* Test address falling into a block.  */
+      SELF_CHECK (bv->lookup (0x1500) == bv->block (2));
+      SELF_CHECK (bv->contains (0x1500) == true);
+
+      /* Test address falling into a "hole".  If BV has an address map,
+        lookup () returns nullptr. If not, lookup () return static block.
+        contains() returns false in both cases.  */
+      if (with_map)
+       SELF_CHECK (bv->lookup (0x2500) == nullptr);
+      else
+       SELF_CHECK (bv->lookup (0x2500) == bv->block (STATIC_BLOCK));
+      SELF_CHECK (bv->contains (0x2500) == false);
+
+      /* Test address falling into a block above the "hole".  */
+      SELF_CHECK (bv->lookup (0x3500) == bv->block (3));
+      SELF_CHECK (bv->contains (0x3500) == true);
+
+      /* Test address outside global block's range.  */
+      SELF_CHECK (bv->lookup (0x4000) == nullptr);
+      SELF_CHECK (bv->contains (0x4000) == false);
+    }
+}
+
+} /* namespace selftests */
+
+
+INIT_GDB_FILE (block_selftest)
+{
+  selftests::register_test ("blockvector-lookup-contains",
+                           selftests::test_blockvector_lookup_contains);
+}