= init_float_type (alloc, gdbarch_long_double_bit (gdbarch),
"real", gdbarch_long_double_format (gdbarch));
- builtin_d_type->builtin_byte->set_instance_flags
- (builtin_d_type->builtin_byte->instance_flags ()
- | TYPE_INSTANCE_FLAG_NOTTEXT);
-
- builtin_d_type->builtin_ubyte->set_instance_flags
- (builtin_d_type->builtin_ubyte->instance_flags ()
- | TYPE_INSTANCE_FLAG_NOTTEXT);
+ builtin_d_type->builtin_byte->set_nottext (true);
+ builtin_d_type->builtin_ubyte->set_nottext (true);
/* Imaginary and complex types. */
builtin_d_type->builtin_ifloat
return false;
}
+static inline bool
+check_objfile (type_instance_flags val, struct objfile *objfile)
+{
+ return false;
+}
+
template<typename T>
static inline bool
check_objfile (const std::vector<T> &collection, struct objfile *objfile)
type_instance_flags flags)
{
gdb_printf (stream, _("%*sType flags: "), depth, "");
- if (flags & TYPE_INSTANCE_FLAG_CONST)
+ if (flags.is_const)
gdb_puts ("const ", stream);
- if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
+ if (flags.is_volatile)
gdb_puts ("volatile", stream);
gdb_printf (stream, "\n");
}
CORE_ADDR addr
= extract_unsigned_integer (buf, type->length (), byte_order);
- if (TYPE_ADDRESS_CLASS_1 (type))
+ if (TYPE_ADDRESS_CLASS (type) == 1)
return addr;
else
return addr | RAM_BIAS;
func_void_type = lookup_function_type (void_type);
tdep->pc_type = init_pointer_type (alloc, 4 * TARGET_CHAR_BIT, NULL,
func_void_type);
- tdep->pc_type->set_instance_flags (tdep->pc_type->instance_flags ()
- | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1);
+ tdep->pc_type->set_address_class (1);
set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
import gdb
-class TypeFlag:
- """A class that allows us to store a flag name, its short name,
- and its value.
-
- In the GDB sources, struct type has a component called instance_flags
- in which the value is the addition of various flags. These flags are
- defined by the enumerates type_instance_flag_value. This class helps us
- recreate a list with all these flags that is easy to manipulate and sort.
- Because all flag names start with TYPE_INSTANCE_FLAG_, a short_name
- attribute is provided that strips this prefix.
-
- ATTRIBUTES
- name: The enumeration name (eg: "TYPE_INSTANCE_FLAG_CONST").
- value: The associated value.
- short_name: The enumeration name, with the suffix stripped.
- """
-
- def __init__(self, name, value):
- self.name = name
- self.value = value
- self.short_name = name.replace("TYPE_INSTANCE_FLAG_", "")
-
- def __lt__(self, other):
- """Sort by value order."""
- return self.value < other.value
-
-
-# A list of all existing TYPE_INSTANCE_FLAGS_* enumerations,
-# stored as TypeFlags objects. Lazy-initialized.
-TYPE_FLAGS = None
-
-
-class TypeFlagsPrinter:
- """A class that prints a decoded form of an instance_flags value.
-
- This class uses a global named TYPE_FLAGS, which is a list of
- all defined TypeFlag values. Using a global allows us to compute
- this list only once.
-
- This class relies on a couple of enumeration types being defined.
- If not, then printing of the instance_flag is going to be degraded,
- but it's not a fatal error.
- """
+class StructTypeInstanceFlagsPrettyPrinter:
+ """Pretty-print an object of type struct type_instance_flags"""
def __init__(self, val):
self.val = val
def __str__(self):
- global TYPE_FLAGS
- if TYPE_FLAGS is None:
- self.init_TYPE_FLAGS()
- if not self.val:
- return "0"
- if TYPE_FLAGS:
- flag_list = [
- flag.short_name for flag in TYPE_FLAGS if self.val & flag.value
- ]
- else:
- flag_list = ["???"]
- return "0x%x [%s]" % (self.val, "|".join(flag_list))
-
- def init_TYPE_FLAGS(self):
- """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
- This operation requires the search of a couple of enumeration types.
- If not found, a warning is printed on stdout, and TYPE_FLAGS is
- set to the empty list.
-
- The resulting list is sorted by increasing value, to facilitate
- printing of the list of flags used in an instance_flags value.
- """
- global TYPE_FLAGS
- TYPE_FLAGS = []
- try:
- iflags = gdb.lookup_type("enum type_instance_flag_value")
- except:
- print("Warning: Cannot find enum type_instance_flag_value type.")
- print(" `struct type' pretty-printer will be degraded")
- return
- TYPE_FLAGS = [TypeFlag(field.name, field.enumval) for field in iflags.fields()]
- TYPE_FLAGS.sort()
+ fields = []
+ if self.val["is_const"]:
+ fields.append("CONST")
+ if self.val["is_volatile"]:
+ fields.append("VOLATILE")
+ if self.val["harvard_aspace"] == 1: # HARVARD_ASPACE_CODE
+ fields.append("CODE_SPACE")
+ elif self.val["harvard_aspace"] == 2: # HARVARD_ASPACE_DATA
+ fields.append("DATA_SPACE")
+ if self.val["address_class"] != 0:
+ fields.append("ADDRESS_CLASS(%d)" % self.val["address_class"])
+ if self.val["is_nottext"]:
+ fields.append("NOTTEXT")
+ if self.val["is_restrict"]:
+ fields.append("RESTRICT")
+ if self.val["is_atomic"]:
+ fields.append("ATOMIC")
+
+ return "[" + "|".join(fields) + "]"
class StructTypePrettyPrinter:
fields.append("reference_type = %s" % self.val["reference_type"])
fields.append("chain = %s" % self.val["reference_type"])
fields.append(
- "instance_flags = %s" % TypeFlagsPrinter(self.val["m_instance_flags"])
+ "instance_flags = %s"
+ % StructTypeInstanceFlagsPrettyPrinter(self.val["m_instance_flags"])
)
fields.append("length = %d" % self.val["m_length"])
fields.append("main_type = %s" % self.val["main_type"])
make_type_with_harvard_address_space (struct type *type,
enum harvard_address_space aspace)
{
- type_instance_flags new_flags
- = (enum type_instance_flag_value) (aspace << 2);
-
- gdb_assert ((new_flags & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE)) == 0);
- new_flags |= (type->instance_flags ()
- & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE));
+ gdb_assert (aspace == HARVARD_ASPACE_NONE
+ || aspace == HARVARD_ASPACE_CODE
+ || aspace == HARVARD_ASPACE_DATA);
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.harvard_aspace = aspace;
return make_qualified_type (type, new_flags, nullptr);
}
make_type_with_address_class (struct type *type,
unsigned int address_class)
{
- type_instance_flags new_flags
- = (enum type_instance_flag_value) (address_class << 4);
-
- gdb_assert ((new_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) == 0);
-
- new_flags |= (type->instance_flags ()
- & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL);
+ gdb_assert (address_class < 4); /* We use two bits for this field. */
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.address_class = address_class;
return make_qualified_type (type, new_flags, nullptr);
}
type *
make_cv_type (int cnst, int voltl, type *type)
{
- type_instance_flags new_flags = (type->instance_flags ()
- & ~(TYPE_INSTANCE_FLAG_CONST
- | TYPE_INSTANCE_FLAG_VOLATILE));
-
- if (cnst)
- new_flags |= TYPE_INSTANCE_FLAG_CONST;
-
- if (voltl)
- new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.is_const = cnst;
+ new_flags.is_volatile = voltl;
return make_qualified_type (type, new_flags, nullptr);
}
struct type *
make_restrict_type (struct type *type)
{
- return make_qualified_type (type,
- (type->instance_flags ()
- | TYPE_INSTANCE_FLAG_RESTRICT),
- NULL);
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.is_restrict = true;
+
+ return make_qualified_type (type, new_flags, nullptr);
}
/* Make a type without const, volatile, or restrict. */
struct type *
make_unqualified_type (struct type *type)
{
- return make_qualified_type (type,
- (type->instance_flags ()
- & ~(TYPE_INSTANCE_FLAG_CONST
- | TYPE_INSTANCE_FLAG_VOLATILE
- | TYPE_INSTANCE_FLAG_RESTRICT)),
- NULL);
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.is_const = false;
+ new_flags.is_volatile = false;
+ new_flags.is_restrict = false;
+
+ return make_qualified_type (type, new_flags, nullptr);
}
/* Make a '_Atomic'-qualified version of TYPE. */
struct type *
make_atomic_type (struct type *type)
{
- return make_qualified_type (type,
- (type->instance_flags ()
- | TYPE_INSTANCE_FLAG_ATOMIC),
- NULL);
+ type_instance_flags new_flags = type->instance_flags ();
+ new_flags.is_atomic = true;
+
+ return make_qualified_type (type, new_flags, nullptr);
}
/* Replace the contents of ntype with the type *type. This changes the
variants. This assertion shouldn't ever be triggered because
symbol readers which do construct address-class variants don't
call replace_type(). */
- gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
+ gdb_assert (TYPE_ADDRESS_CLASS (chain) == 0);
chain->set_length (type->length ());
chain = chain->chain;
elt_type = inner_array->target_type ();
if (elt_type->code () == TYPE_CODE_INT)
{
- type_instance_flags flags
- = elt_type->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT;
+ type_instance_flags flags = elt_type->instance_flags ();
+ flags.is_nottext = true;
elt_type = make_qualified_type (elt_type, flags, NULL);
inner_array->set_target_type (elt_type);
}
outer cast in a chain of casting win), instead of assuming
"it can't happen". */
{
- const type_instance_flags ALL_SPACES
- = (TYPE_INSTANCE_FLAG_CODE_SPACE
- | TYPE_INSTANCE_FLAG_DATA_SPACE);
- const type_instance_flags ALL_CLASSES
- = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
-
type_instance_flags new_instance_flags = type->instance_flags ();
/* Treat code vs data spaces and address classes separately. */
- if ((instance_flags & ALL_SPACES) != 0)
- new_instance_flags &= ~ALL_SPACES;
- if ((instance_flags & ALL_CLASSES) != 0)
- new_instance_flags &= ~ALL_CLASSES;
+ if (instance_flags.harvard_aspace != HARVARD_ASPACE_NONE)
+ new_instance_flags.harvard_aspace = HARVARD_ASPACE_NONE;
+ if (instance_flags.address_class != 0)
+ new_instance_flags.address_class = 0;
instance_flags |= new_instance_flags;
}
host_address_to_string (type->reference_type));
gdb_printf ("%*stype_chain %s\n", spaces, "",
host_address_to_string (type->chain));
- gdb_printf ("%*sinstance_flags 0x%x", spaces, "",
- (unsigned) type->instance_flags ());
+ gdb_printf ("%*sinstance_flags [", spaces, "");
if (TYPE_CONST (type))
{
gdb_puts (" TYPE_CONST");
{
gdb_puts (" TYPE_DATA_SPACE");
}
- if (TYPE_ADDRESS_CLASS_1 (type))
+ if (TYPE_ADDRESS_CLASS (type) != 0)
{
- gdb_puts (" TYPE_ADDRESS_CLASS_1");
- }
- if (TYPE_ADDRESS_CLASS_2 (type))
- {
- gdb_puts (" TYPE_ADDRESS_CLASS_2");
+ gdb_printf (" TYPE_ADDRESS_CLASS(%u)", TYPE_ADDRESS_CLASS (type));
}
if (TYPE_RESTRICT (type))
{
{
gdb_puts (" TYPE_ATOMIC");
}
- gdb_puts ("\n");
+ gdb_puts ("]\n");
gdb_printf ("%*sflags", spaces, "");
if (type->is_unsigned ())
builtin_type->builtin_uint128
= init_integer_type (alloc, 128, 1, "uint128_t");
- builtin_type->builtin_int8->set_instance_flags
- (builtin_type->builtin_int8->instance_flags ()
- | TYPE_INSTANCE_FLAG_NOTTEXT);
-
- builtin_type->builtin_uint8->set_instance_flags
- (builtin_type->builtin_uint8->instance_flags ()
- | TYPE_INSTANCE_FLAG_NOTTEXT);
+ builtin_type->builtin_int8->set_nottext (true);
+ builtin_type->builtin_uint8->set_nottext (true);
/* Wide character types. */
builtin_type->builtin_char16
HARVARD_ASPACE_DATA = 2,
};
-/* Some bits for the type's instance_flags word. See the macros
- below for documentation on each bit. */
+/* A type's instance_flags. */
-enum type_instance_flag_value : unsigned
+struct type_instance_flags
{
- TYPE_INSTANCE_FLAG_CONST = (1 << 0),
- TYPE_INSTANCE_FLAG_VOLATILE = (1 << 1),
- TYPE_INSTANCE_FLAG_CODE_SPACE = (1 << 2),
- TYPE_INSTANCE_FLAG_DATA_SPACE = (1 << 3),
- TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 = (1 << 4),
- TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5),
- TYPE_INSTANCE_FLAG_NOTTEXT = (1 << 6),
- TYPE_INSTANCE_FLAG_RESTRICT = (1 << 7),
- TYPE_INSTANCE_FLAG_ATOMIC = (1 << 8)
-};
+ bool operator== (const type_instance_flags &other) const
+ {
+ return (is_const == other.is_const
+ && is_volatile == other.is_volatile
+ && harvard_aspace == other.harvard_aspace
+ && address_class == other.address_class
+ && is_nottext == other.is_nottext
+ && is_restrict == other.is_restrict
+ && is_atomic == other.is_atomic);
+ }
-DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags);
+ bool operator!= (const type_instance_flags &other) const
+ {
+ return !(*this == other);
+ }
-/* Not textual. By default, GDB treats all single byte integers as
- characters (or elements of strings) unless this flag is set. */
+ type_instance_flags &operator|= (const type_instance_flags &other)
+ {
+ is_const = is_const || other.is_const;
+ is_volatile = is_volatile || other.is_volatile;
+
+ gdb_assert (harvard_aspace == 0);
+ harvard_aspace = other.harvard_aspace;
-#define TYPE_NOTTEXT(t) (((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_NOTTEXT)
+ gdb_assert (address_class == 0);
+ address_class = other.address_class;
+
+ is_nottext = is_nottext || other.is_nottext;
+ is_restrict = is_restrict || other.is_restrict;
+ is_atomic = is_atomic || other.is_atomic;
+ return *this;
+ }
-/* Constant type. If this is set, the corresponding type has a
- const modifier. */
+ /* Constant type. If this is set, the corresponding type has a
+ const modifier. */
+ bool is_const : 1;
-#define TYPE_CONST(t) ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CONST) != 0)
+ /* Volatile type. If this is set, the corresponding type has a
+ volatile modifier. */
+ bool is_volatile : 1;
-/* Volatile type. If this is set, the corresponding type has a
- volatile modifier. */
+ /* See enum harvard_address_space above. */
+ harvard_address_space harvard_aspace : 2;
-#define TYPE_VOLATILE(t) \
- ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_VOLATILE) != 0)
+ /* Address class field. Some environments provide for pointers
+ whose size is different from that of a normal pointer or address
+ types where the bits are interpreted differently than normal
+ addresses. The ADDRESS_CLASS field may be used in target
+ specific ways to represent these different types of address
+ classes. */
+ unsigned int address_class : 2;
-/* Restrict type. If this is set, the corresponding type has a
- restrict modifier. */
+ /* Not textual. By default, GDB treats all single byte integers as
+ characters (or elements of strings) unless this flag is set. */
+ bool is_nottext : 1;
-#define TYPE_RESTRICT(t) \
- ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_RESTRICT) != 0)
+ /* Restrict type. If this is set, the corresponding type has a
+ restrict modifier. */
+ bool is_restrict : 1;
-/* Atomic type. If this is set, the corresponding type has an
- _Atomic modifier. */
+ /* Atomic type. If this is set, the corresponding type has an
+ _Atomic modifier. */
+ bool is_atomic : 1;
+};
-#define TYPE_ATOMIC(t) \
- ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_ATOMIC) != 0)
+#define TYPE_NOTTEXT(t) (((t)->instance_flags ()).is_nottext)
+#define TYPE_CONST(t) (((t)->instance_flags ()).is_const)
+#define TYPE_VOLATILE(t) (((t)->instance_flags ()).is_volatile)
+#define TYPE_RESTRICT(t) (((t)->instance_flags ()).is_restrict)
+#define TYPE_ATOMIC(t) (((t)->instance_flags ()).is_atomic)
/* True if this type represents either an lvalue or lvalue reference type. */
(((t)->dyn_prop (DYN_PROP_BYTE_SIZE) != nullptr) \
|| ((t)->dyn_prop (DYN_PROP_BIT_SIZE) != nullptr))
-/* See enum harvard_address_space above. */
-
#define TYPE_CODE_SPACE(t) \
- ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0)
+ (((t)->instance_flags ()).harvard_aspace == HARVARD_ASPACE_CODE)
#define TYPE_DATA_SPACE(t) \
- ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0)
-
-/* Address class flags. Some environments provide for pointers
- whose size is different from that of a normal pointer or address
- types where the bits are interpreted differently than normal
- addresses. The TYPE_INSTANCE_FLAG_ADDRESS_CLASS_n flags may be used in
- target specific ways to represent these different types of address
- classes. */
-
-#define TYPE_ADDRESS_CLASS_1(t) (((t)->instance_flags ()) \
- & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
-#define TYPE_ADDRESS_CLASS_2(t) (((t)->instance_flags ()) \
- & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
-#define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \
- (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
-#define TYPE_ADDRESS_CLASS_ALL(t) (((t)->instance_flags ()) \
- & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
-#define TYPE_ADDRESS_CLASS_FROM_INSTANCE_FLAGS(t) \
- ((unsigned int) ((t) & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) >> 4)
+ (((t)->instance_flags ()).harvard_aspace == HARVARD_ASPACE_DATA)
+
#define TYPE_ADDRESS_CLASS(t) \
- (TYPE_ADDRESS_CLASS_FROM_INSTANCE_FLAGS ((t)->instance_flags ()))
+ (((t)->instance_flags ()).address_class)
/* Information about a single discriminant. */
this->field (0).set_type (index_type);
}
- /* Return the instance flags converted to the correct type. */
+ /* Return the instance flags. */
const type_instance_flags instance_flags () const
{
- return (enum type_instance_flag_value) this->m_instance_flags;
+ return this->m_instance_flags;
}
/* Set the instance flags. */
this->m_instance_flags = flags;
}
+ /* Set the address class id. */
+ void set_address_class (unsigned int address_class)
+ {
+ this->m_instance_flags.address_class = address_class;
+ }
+
+ /* Set the is_nottext flag. */
+ void set_nottext (bool flag)
+ {
+ this->m_instance_flags.is_nottext = flag;
+ }
+
/* Get the bounds bounds of this type. The type must be a range type. */
range_bounds *bounds () const
{
instance flags are completely inherited from the target type. No
qualifiers can be cleared by the typedef. See also
check_typedef. */
- unsigned m_instance_flags : 9;
+ type_instance_flags m_instance_flags;
/* Length of storage for a value of this type. The value is the
expression in host bytes of what sizeof(type) would return. This
gdb_assert (val_type != nullptr);
- if ((flags & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0)
+ if (flags.harvard_aspace != HARVARD_ASPACE_NONE)
val_type = make_type_with_harvard_address_space (val_type,
- HARVARD_ASPACE_CODE);
- else if ((flags & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0)
- val_type = make_type_with_harvard_address_space (val_type,
- HARVARD_ASPACE_DATA);
+ flags.harvard_aspace);
- unsigned int aclass
- = (unsigned int) (flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) >> 4;
- if (aclass != 0)
- val_type = make_type_with_address_class (val_type, aclass);
+ if (flags.address_class != 0)
+ val_type = make_type_with_address_class (val_type, flags.address_class);
return val_type;
}
else
next_address = value_as_address (val);
- type_instance_flags flags = 0;
+ type_instance_flags flags {};
if (val->type ()->is_pointer_or_reference ())
flags = val->type ()->target_type ()->instance_flags ();
if (d->format.format == 'i')
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
- type_instance_flags flags = 0;
+ type_instance_flags flags {};
if (val->type ()->is_pointer_or_reference ())
flags = val->type ()->target_type ()->instance_flags ();
set msg "maint print type"
gdb_test_multiple "maint print type argc" $msg {
- -re "type node $hex\r\nname .int. \\($hex\\)\r\ncode $hex \\(TYPE_CODE_INT\\)\r\nlength \[24\]\r\nobjfile $hex\r\ntarget_type $hex\r\npointer_type $hex\r\nreference_type $hex\r\ntype_chain $hex\r\ninstance_flags $hex\r\nflags\r\nnfields 0 $hex\r\n$gdb_prompt $" {
+ -re "type node $hex\r\nname .int. \\($hex\\)\r\ncode $hex \\(TYPE_CODE_INT\\)\r\nlength \[24\]\r\nobjfile $hex\r\ntarget_type $hex\r\npointer_type $hex\r\nreference_type $hex\r\ntype_chain $hex\r\ninstance_flags \\\[\\\]\r\nflags\r\nnfields 0 $hex\r\n$gdb_prompt $" {
pass $msg
}
}
"\{pointer_type = 0x0," \
" reference_type = 0x0," \
" chain = 0x0," \
- " instance_flags = 0," \
+ " instance_flags = \\\[\\\]," \
" length = $decimal," \
" main_type = $hex\}"]
gdb_test -prompt $outer_prompt_re "print *val->m_type" $answer "pretty print type"
" int_stuff = \{ bit_size = $decimal, bit_offset = $decimal \}\}"]
gdb_test -prompt $outer_prompt_re "print *val->m_type->main_type" $answer "pretty print type->main_type"
+ # Test printing instance flags using an artificial type.
+ set answer [string_to_regexp {instance_flags = [VOLATILE|DATA_SPACE|ADDRESS_CLASS(3)]}]
+ gdb_test -prompt $outer_prompt_re \
+ "print *make_type_with_harvard_address_space (make_cv_type (0, 1, make_type_with_address_class (val->m_type, 3)), 2)" \
+ "${answer}.*" "pretty print type instance flags"
+
# Send the continue to the outer GDB, which resumes the inner GDB,
# we then detect the prompt from the inner GDB, hence the use of
# -i here.
type_instance_flags
type_stack::follow_type_instance_flags ()
{
- type_instance_flags flags = 0;
+ type_instance_flags flags {};
for (;;)
switch (pop ())
case tp_end:
return flags;
case tp_const:
- flags |= TYPE_INSTANCE_FLAG_CONST;
+ flags.is_const = true;
break;
case tp_volatile:
- flags |= TYPE_INSTANCE_FLAG_VOLATILE;
+ flags.is_volatile = true;
break;
case tp_atomic:
- flags |= TYPE_INSTANCE_FLAG_ATOMIC;
+ flags.is_atomic = true;
break;
case tp_restrict:
- flags |= TYPE_INSTANCE_FLAG_RESTRICT;
+ flags.is_restrict = true;
break;
default:
gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
projects / thirdparty / binutils-gdb.git / commitdiff
