/* Code dealing with blocks for GDB.
- Copyright (C) 2003-2022 Free Software Foundation, Inc.
+ Copyright (C) 2003-2023 Free Software Foundation, Inc.
This file is part of GDB.
/* Return a view on this block's ranges. */
gdb::array_view<blockrange> ranges ()
- { return gdb::make_array_view (m_ranges->range, m_ranges->nranges); }
+ {
+ if (m_ranges == nullptr)
+ return {};
+ else
+ return gdb::make_array_view (m_ranges->range, m_ranges->nranges);
+ }
/* Const version of the above. */
gdb::array_view<const blockrange> ranges () const
- { return gdb::make_array_view (m_ranges->range, m_ranges->nranges); }
+ {
+ if (m_ranges == nullptr)
+ return {};
+ else
+ return gdb::make_array_view (m_ranges->range, m_ranges->nranges);
+ }
/* Set this block's ranges array. */
void set_ranges (blockranges *ranges)
bool is_contiguous () const
{ return this->ranges ().size () <= 1; }
+ /* Return the "entry PC" of this block.
+
+ The entry PC is the lowest (start) address for the block when all addresses
+ within the block are contiguous. If non-contiguous, then use the start
+ address for the first range in the block.
+
+ At the moment, this almost matches what DWARF specifies as the entry
+ pc. (The missing bit is support for DW_AT_entry_pc which should be
+ preferred over range data and the low_pc.)
+
+ Once support for DW_AT_entry_pc is added, I expect that an entry_pc
+ field will be added to one of these data structures. Once that's done,
+ the entry_pc field can be set from the dwarf reader (and other readers
+ too). ENTRY_PC can then be redefined to be less DWARF-centric. */
+
+ CORE_ADDR entry_pc () const
+ {
+ if (this->is_contiguous ())
+ return this->start ();
+ else
+ return this->ranges ()[0].start ();
+ }
+
/* Addresses in the executable code that are in this block. */
CORE_ADDR m_start;
struct compunit_symtab *compunit_symtab;
};
-/* Define the "entry pc" for a block BL to be the lowest (start) address
- for the block when all addresses within the block are contiguous. If
- non-contiguous, then use the start address for the first range in the
- block.
+struct blockvector
+{
+ /* Return a view on the blocks of this blockvector. */
+ gdb::array_view<struct block *> blocks ()
+ {
+ return gdb::array_view<struct block *> (m_blocks, m_num_blocks);
+ }
- At the moment, this almost matches what DWARF specifies as the entry
- pc. (The missing bit is support for DW_AT_entry_pc which should be
- preferred over range data and the low_pc.)
+ /* Const version of the above. */
+ gdb::array_view<const struct block *const> blocks () const
+ {
+ const struct block **blocks = (const struct block **) m_blocks;
+ return gdb::array_view<const struct block *const> (blocks, m_num_blocks);
+ }
- Once support for DW_AT_entry_pc is added, I expect that an entry_pc
- field will be added to one of these data structures. Once that's done,
- the entry_pc field can be set from the dwarf reader (and other readers
- too). BLOCK_ENTRY_PC can then be redefined to be less DWARF-centric. */
+ /* Return the block at index I. */
+ struct block *block (size_t i)
+ { return this->blocks ()[i]; }
-#define BLOCK_ENTRY_PC(bl) (bl->is_contiguous () \
- ? bl->start () \
- : bl->ranges ()[0].start ())
+ /* Const version of the above. */
+ const struct block *block (size_t i) const
+ { return this->blocks ()[i]; }
-struct blockvector
-{
- /* Number of blocks in the list. */
- int nblocks;
+ /* Set the block at index I. */
+ void set_block (int i, struct block *block)
+ { m_blocks[i] = block; }
+
+ /* Set the number of blocks of this blockvector.
+
+ The storage of blocks is done using a flexible array member, so the number
+ of blocks set here must agree with what was effectively allocated. */
+ void set_num_blocks (int num_blocks)
+ { m_num_blocks = num_blocks; }
+
+ /* Return the number of blocks in this blockvector. */
+ int num_blocks () const
+ { return m_num_blocks; }
+
+ /* Return the global block of this blockvector. */
+ struct block *global_block ()
+ { return this->block (GLOBAL_BLOCK); }
+
+ /* Const version of the above. */
+ const struct block *global_block () const
+ { return this->block (GLOBAL_BLOCK); }
+
+ /* Return the static block of this blockvector. */
+ struct block *static_block ()
+ { return this->block (STATIC_BLOCK); }
+
+ /* Const version of the above. */
+ const struct block *static_block () const
+ { return this->block (STATIC_BLOCK); }
+
+ /* Return the address -> block map of this blockvector. */
+ addrmap *map ()
+ { return m_map; }
+
+ /* Const version of the above. */
+ const addrmap *map () const
+ { return m_map; }
+
+ /* Set this blockvector's address -> block map. */
+ void set_map (addrmap *map)
+ { m_map = map; }
+
+private:
/* An address map mapping addresses to blocks in this blockvector.
This pointer is zero if the blocks' start and end addresses are
enough. */
- struct addrmap *map;
+ struct addrmap *m_map;
+
+ /* Number of blocks in the list. */
+ int m_num_blocks;
+
/* The blocks themselves. */
- struct block *block[1];
+ struct block *m_blocks[1];
};
-#define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
-#define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
-#define BLOCKVECTOR_MAP(blocklist) ((blocklist)->map)
-
/* Return the objfile of BLOCK, which must be non-NULL. */
extern struct objfile *block_objfile (const struct block *block);
projects / binutils-gdb.git / blobdiff