#include "progspace.h"
#include "registry.h"
#include "gdb_bfd.h"
+#include "psymtab.h"
+#include <bitset>
#include <vector>
#include "common/next-iterator.h"
#include "common/safe-iterator.h"
/* Number of entries in the minimal symbol hash table. */
#define MINIMAL_SYMBOL_HASH_SIZE 2039
+/* An iterator for minimal symbols. */
+
+struct minimal_symbol_iterator
+{
+ typedef minimal_symbol_iterator self_type;
+ typedef struct minimal_symbol *value_type;
+ typedef struct minimal_symbol *&reference;
+ typedef struct minimal_symbol **pointer;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef int difference_type;
+
+ explicit minimal_symbol_iterator (struct minimal_symbol *msym)
+ : m_msym (msym)
+ {
+ }
+
+ value_type operator* () const
+ {
+ return m_msym;
+ }
+
+ bool operator== (const self_type &other) const
+ {
+ return m_msym == other.m_msym;
+ }
+
+ bool operator!= (const self_type &other) const
+ {
+ return m_msym != other.m_msym;
+ }
+
+ self_type &operator++ ()
+ {
+ ++m_msym;
+ return *this;
+ }
+
+private:
+ struct minimal_symbol *m_msym;
+};
+
/* Some objfile data is hung off the BFD. This enables sharing of the
data across all objfiles using the BFD. The data is stored in an
instance of this structure, and associated with the BFD using the
: minsyms_read (false)
{}
+ ~objfile_per_bfd_storage ();
+
/* The storage has an obstack of its own. */
auto_obstack storage_obstack;
/* Byte cache for file names. */
- bcache *filename_cache = NULL;
+ struct bcache filename_cache;
/* Byte cache for macros. */
- bcache *macro_cache = NULL;
+ struct bcache macro_cache;
/* The gdbarch associated with the BFD. Note that this gdbarch is
determined solely from BFD information, without looking at target
name, and the second is the demangled name or just a zero byte
if the name doesn't demangle. */
- htab *demangled_names_hash = NULL;
+ htab_up demangled_names_hash;
/* The per-objfile information about the entry point, the scope (file/func)
containing the entry point, and the scope of the user's main() func. */
name and a zero value for the address. This makes it easy to walk
through the array when passed a pointer to somewhere in the middle
of it. There is also a count of the number of symbols, which does
- not include the terminating null symbol. The array itself, as well
- as all the data that it points to, should be allocated on the
- objfile_obstack for this file. */
+ not include the terminating null symbol. */
- minimal_symbol *msymbols = NULL;
+ gdb::unique_xmalloc_ptr<minimal_symbol> msymbols;
int minimal_symbol_count = 0;
/* The number of minimal symbols read, before any minimal symbol
minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE] {};
/* All the different languages of symbols found in the demangled
- hash table. A flat/vector-based map is more efficient than a map
- or hash table here, since this will only usually contain zero or
- one entries. */
- std::vector<enum language> demangled_hash_languages;
+ hash table. */
+ std::bitset<nr_languages> demangled_hash_languages;
};
/* Master structure for keeping track of each file from which
DISABLE_COPY_AND_ASSIGN (objfile);
+ /* A range adapter that makes it possible to iterate over all
+ psymtabs in one objfile. */
+
+ psymtab_storage::partial_symtab_range psymtabs ()
+ {
+ return partial_symtabs->range ();
+ }
+
+ /* Reset the storage for the partial symbol tables. */
+
+ void reset_psymtabs ()
+ {
+ psymbol_map.clear ();
+ partial_symtabs.reset (new psymtab_storage ());
+ }
+
+ typedef next_adapter<struct compunit_symtab> compunits_range;
+
+ /* A range adapter that makes it possible to iterate over all
+ compunits in one objfile. */
+
+ compunits_range compunits ()
+ {
+ return compunits_range (compunit_symtabs);
+ }
+
+ /* A range adapter that makes it possible to iterate over all
+ minimal symbols of an objfile. */
+
+ class msymbols_range
+ {
+ public:
+
+ explicit msymbols_range (struct objfile *objfile)
+ : m_objfile (objfile)
+ {
+ }
+
+ minimal_symbol_iterator begin () const
+ {
+ return minimal_symbol_iterator (m_objfile->per_bfd->msymbols.get ());
+ }
+
+ minimal_symbol_iterator end () const
+ {
+ return minimal_symbol_iterator
+ (m_objfile->per_bfd->msymbols.get ()
+ + m_objfile->per_bfd->minimal_symbol_count);
+ }
+
+ private:
+
+ struct objfile *m_objfile;
+ };
+
+ /* Return a range adapter for iterating over all minimal
+ symbols. */
+
+ msymbols_range msymbols ()
+ {
+ return msymbols_range (this);
+ }
+
+
/* All struct objfile's are chained together by their next pointers.
The program space field "objfiles" (frequently referenced via
the macro "object_files") points to the first link in this chain. */
struct compunit_symtab *compunit_symtabs = nullptr;
- /* Each objfile points to a linked list of partial symtabs derived from
- this file, one partial symtab structure for each compilation unit
- (source file). */
-
- struct partial_symtab *psymtabs = nullptr;
-
- /* Map addresses to the entries of PSYMTABS. It would be more efficient to
- have a map per the whole process but ADDRMAP cannot selectively remove
- its items during FREE_OBJFILE. This mapping is already present even for
- PARTIAL_SYMTABs which still have no corresponding full SYMTABs read. */
+ /* The partial symbol tables. */
- struct addrmap *psymtabs_addrmap = nullptr;
-
- /* List of freed partial symtabs, available for re-use. */
-
- struct partial_symtab *free_psymtabs = nullptr;
+ std::shared_ptr<psymtab_storage> partial_symtabs;
/* The object file's BFD. Can be null if the objfile contains only
minimal symbols, e.g. the run time common symbols for SunOS4. */
struct obstack objfile_obstack {};
- /* A byte cache where we can stash arbitrary "chunks" of bytes that
- will not change. */
-
- struct psymbol_bcache *psymbol_cache;
-
/* Map symbol addresses to the partial symtab that defines the
object at that address. */
std::vector<std::pair<CORE_ADDR, partial_symtab *>> psymbol_map;
- /* Vectors of all partial symbols read in from file. The actual data
- is stored in the objfile_obstack. */
-
- std::vector<partial_symbol *> global_psymbols;
- std::vector<partial_symbol *> static_psymbols;
-
/* Structure which keeps track of functions that manipulate objfile's
of the same type as this objfile. I.e. the function to read partial
symbols for example. Note that this structure is in statically
Although this is a tree structure, GDB only support one level
(ie a separate debug for a separate debug is not supported). Note that
separate debug object are in the main chain and therefore will be
- visited by ALL_OBJFILES & co iterators. Separate debug objfile always
+ visited by objfiles & co iterators. Separate debug objfile always
has a non-nul separate_debug_objfile_backlink. */
/* Link to the first separate debug object, if any. */
void *cb_data, struct objfile *current_objfile);
\f
-/* An iterarable object that can be used to iterate over all
- objfiles. The basic use is in a foreach, like:
-
- for (objfile *objf : all_objfiles (pspace)) { ... } */
-
-class all_objfiles : public next_adapter<struct objfile>
-{
-public:
-
- explicit all_objfiles (struct program_space *pspace)
- : next_adapter<struct objfile> (pspace->objfiles)
- {
- }
-};
-
-/* An iterarable object that can be used to iterate over all
- objfiles. The basic use is in a foreach, like:
-
- for (objfile *objf : all_objfiles_safe (pspace)) { ... }
-
- This variant uses a basic_safe_iterator so that objfiles can be
- deleted during iteration. */
-
-class all_objfiles_safe
- : public next_adapter<struct objfile,
- basic_safe_iterator<next_iterator<objfile>>>
-{
-public:
-
- explicit all_objfiles_safe (struct program_space *pspace)
- : next_adapter<struct objfile,
- basic_safe_iterator<next_iterator<objfile>>>
- (pspace->objfiles)
- {
- }
-};
-
-
-/* Traverse all object files in the current program space. */
-
-#define ALL_OBJFILES(obj) \
- for ((obj) = current_program_space->objfiles; \
- (obj) != NULL; \
- (obj) = (obj)->next)
-
-/* Traverse all symtabs in one objfile. */
-
-#define ALL_OBJFILE_FILETABS(objfile, cu, s) \
- ALL_OBJFILE_COMPUNITS (objfile, cu) \
- ALL_COMPUNIT_FILETABS (cu, s)
-
-/* Traverse all compunits in one objfile. */
-
-#define ALL_OBJFILE_COMPUNITS(objfile, cu) \
- for ((cu) = (objfile) -> compunit_symtabs; (cu) != NULL; (cu) = (cu) -> next)
-
-/* A range adapter that makes it possible to iterate over all
- minimal symbols of an objfile. */
-
-class objfile_msymbols
-{
-public:
-
- explicit objfile_msymbols (struct objfile *objfile)
- : m_objfile (objfile)
- {
- }
-
- struct iterator
- {
- typedef iterator self_type;
- typedef struct minimal_symbol *value_type;
- typedef struct minimal_symbol *&reference;
- typedef struct minimal_symbol **pointer;
- typedef std::forward_iterator_tag iterator_category;
- typedef int difference_type;
-
- explicit iterator (struct objfile *objfile)
- : m_msym (objfile->per_bfd->msymbols)
- {
- /* Make sure to properly handle the case where there are no
- minsyms. */
- if (MSYMBOL_LINKAGE_NAME (m_msym) == nullptr)
- m_msym = nullptr;
- }
-
- iterator ()
- : m_msym (nullptr)
- {
- }
-
- value_type operator* () const
- {
- return m_msym;
- }
-
- bool operator== (const self_type &other) const
- {
- return m_msym == other.m_msym;
- }
-
- bool operator!= (const self_type &other) const
- {
- return m_msym != other.m_msym;
- }
-
- self_type &operator++ ()
- {
- if (m_msym != nullptr)
- {
- ++m_msym;
- if (MSYMBOL_LINKAGE_NAME (m_msym) == nullptr)
- m_msym = nullptr;
- }
- return *this;
- }
-
- private:
- struct minimal_symbol *m_msym;
- };
-
- iterator begin () const
- {
- return iterator (m_objfile);
- }
-
- iterator end () const
- {
- return iterator ();
- }
-
-private:
-
- struct objfile *m_objfile;
-};
-
-/* Traverse all symtabs in all objfiles in the current symbol
- space. */
-
-#define ALL_FILETABS(objfile, ps, s) \
- ALL_OBJFILES (objfile) \
- ALL_OBJFILE_FILETABS (objfile, ps, s)
-
-/* Traverse all compunits in all objfiles in the current program space. */
-
-#define ALL_COMPUNITS(objfile, cu) \
- ALL_OBJFILES (objfile) \
- ALL_OBJFILE_COMPUNITS (objfile, cu)
-
#define ALL_OBJFILE_OSECTIONS(objfile, osect) \
for (osect = objfile->sections; osect < objfile->sections_end; osect++) \
if (osect->the_bfd_section == NULL) \
} \
else
-/* Traverse all obj_sections in all objfiles in the current program
- space.
-
- Note that this detects a "break" in the inner loop, and exits
- immediately from the outer loop as well, thus, client code doesn't
- need to know that this is implemented with a double for. The extra
- hair is to make sure that a "break;" stops the outer loop iterating
- as well, and both OBJFILE and OSECT are left unmodified:
-
- - The outer loop learns about the inner loop's end condition, and
- stops iterating if it detects the inner loop didn't reach its
- end. In other words, the outer loop keeps going only if the
- inner loop reached its end cleanly [(osect) ==
- (objfile)->sections_end].
-
- - OSECT is initialized in the outer loop initialization
- expressions, such as if the inner loop has reached its end, so
- the check mentioned above succeeds the first time.
-
- - The trick to not clearing OBJFILE on a "break;" is, in the outer
- loop's loop expression, advance OBJFILE, but iff the inner loop
- reached its end. If not, there was a "break;", so leave OBJFILE
- as is; the outer loop's conditional will break immediately as
- well (as OSECT will be different from OBJFILE->sections_end). */
-
-#define ALL_OBJSECTIONS(objfile, osect) \
- for ((objfile) = current_program_space->objfiles, \
- (objfile) != NULL ? ((osect) = (objfile)->sections_end) : 0; \
- (objfile) != NULL \
- && (osect) == (objfile)->sections_end; \
- ((osect) == (objfile)->sections_end \
- ? ((objfile) = (objfile)->next, \
- (objfile) != NULL ? (osect) = (objfile)->sections_end : 0) \
- : 0)) \
- ALL_OBJFILE_OSECTIONS (objfile, osect)
-
#define SECT_OFF_DATA(objfile) \
((objfile->sect_index_data == -1) \
? (internal_error (__FILE__, __LINE__, \
projects / deliverable / binutils-gdb.git / blobdiff