mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2026-08-27 00:26:02 -04:00
4abc1ce2cc
This updates the copyright headers to include 2026. I did this by running gdb/copyright.py and then manually modifying a few files as noted by the script.
133 lines
3.8 KiB
C
133 lines
3.8 KiB
C
/* Self tests for blockvectors
|
|
|
|
Copyright (C) 2025-2026 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 and contains (). returns false. If not,
|
|
lookup () return static block and contains() returns true. */
|
|
if (with_map)
|
|
{
|
|
SELF_CHECK (bv->lookup (0x2500) == nullptr);
|
|
SELF_CHECK (bv->contains (0x2500) == false);
|
|
}
|
|
else
|
|
{
|
|
SELF_CHECK (bv->lookup (0x2500) == bv->block (STATIC_BLOCK));
|
|
SELF_CHECK (bv->contains (0x2500) == true);
|
|
}
|
|
|
|
/* 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);
|
|
}
|