+ /* Set the default boolean type to be TYPE. If NAME is not nullptr then
+ before using TYPE a symbol called NAME will be looked up, and the type
+ of this symbol will be used instead. Should only be called once when
+ performing setup for a particular language in combination with a
+ particular gdbarch. */
+ void set_bool_type (struct type *type, const char *name = nullptr)
+ {
+ gdb_assert (m_bool_type_default == nullptr);
+ gdb_assert (m_bool_type_name == nullptr);
+ gdb_assert (type != nullptr);
+ m_bool_type_default = type;
+ m_bool_type_name = name;
+ }
+
+ /* Set the type to be used for characters within a string. Should only
+ be called once when performing setup for a particular language in
+ combination with a particular gdbarch. */
+ void set_string_char_type (struct type *type)
+ {
+ gdb_assert (m_string_char_type == nullptr);
+ gdb_assert (type != nullptr);
+ m_string_char_type = type;
+ }
+
+ /* Return the type for characters within a string. */
+ struct type *string_char_type () const
+ { return m_string_char_type; }
+
+ /* Return the type to be used for booleans. */
+ struct type *bool_type () const;
+
+ /* Add TYPE to the list of primitive types for this particular language,
+ with this OS/ABI combination. */
+ void add_primitive_type (struct type *type)
+ {
+ gdb_assert (type != nullptr);
+ primitive_types_and_symbols.push_back (type_and_symbol (type));
+ }
+
+ /* Lookup a primitive type called NAME. Will return nullptr if no
+ matching type is found. */
+ struct type *lookup_primitive_type (const char *name);
+
+ /* Lookup a primitive type for which FILTER returns true. Will return
+ nullptr if no matching type is found. */
+ struct type *lookup_primitive_type
+ (gdb::function_view<bool (struct type *)> filter);
+
+ /* Lookup a primitive type called NAME and return the type as a symbol.
+ LANG is the language for which type is being looked up. */
+ struct symbol *lookup_primitive_type_as_symbol (const char *name,
+ enum language lang);
+private:
+
+ /* A structure storing a type and a corresponding symbol. The type is
+ defined at construction time, while the symbol is lazily created only
+ when asked for, but is then cached for future use. */
+ struct type_and_symbol
+ {
+ /* Constructor. */
+ explicit type_and_symbol (struct type *type)
+ : m_type (type)
+ { /* Nothing. */ }
+
+ /* Default move constructor. */
+ type_and_symbol (type_and_symbol&&) = default;
+
+ DISABLE_COPY_AND_ASSIGN (type_and_symbol);
+
+ /* Return the type from this object. */
+ struct type *type () const
+ { return m_type; }
+
+ /* Create and return a symbol wrapping M_TYPE from this object. */
+ struct symbol *symbol (enum language lang)
+ {
+ if (m_symbol == nullptr)
+ m_symbol = alloc_type_symbol (lang, m_type);
+ return m_symbol;
+ }
+
+ private:
+ /* The type primitive type. */
+ struct type *m_type = nullptr;
+
+ /* A symbol wrapping M_TYPE, only created when first asked for. */
+ struct symbol *m_symbol = nullptr;
+
+ /* Helper function for type lookup as a symbol. Create the symbol
+ corresponding to type TYPE in language LANG. */
+ static struct symbol *alloc_type_symbol (enum language lang,
+ struct type *type);
+ };
+
+ /* Lookup a type_and_symbol entry from the primitive_types_and_symbols
+ vector for a type matching NAME. Return a pointer to the
+ type_and_symbol object from the vector. This will return nullptr if
+ there is no type matching NAME found. */
+ type_and_symbol *lookup_primitive_type_and_symbol (const char *name);
+
+ /* Vector of the primitive types added through add_primitive_type. These
+ types can be specified by name in parsing types in expressions,
+ regardless of whether the program being debugged actually defines such
+ a type.
+
+ Within the vector each type is paired with a lazily created symbol,
+ which can be fetched by the symbol lookup machinery, should they be
+ needed. */
+ std::vector<type_and_symbol> primitive_types_and_symbols;
projects / binutils-gdb.git / blobdiff