static void
ada_val_print_enum (struct type *type, const gdb_byte *valaddr,
int offset, int offset_aligned, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
int i;
unsigned int len;
LONGEST val;
if (options->format)
{
val_print_scalar_formatted (type, offset_aligned,
original_value, options, 0, stream);
return;
}
len = TYPE_NFIELDS (type);
val = unpack_long (type, valaddr + offset_aligned);
for (i = 0; i < len; i++)
{
QUIT;
if (val == TYPE_FIELD_ENUMVAL (type, i))
break;
}
if (i < len)
{
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
if (name[0] == '\'')
fprintf_filtered (stream, "%ld %s", (long) val, name);
else
fputs_filtered (name, stream);
}
else
print_longest (stream, 'd', 0, val);
}
void
c_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int i = 0; /* Number of characters printed. */
unsigned len;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
unsigned eltlen;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
{
LONGEST low_bound, high_bound;
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
eltlen = TYPE_LENGTH (elttype);
len = high_bound - low_bound + 1;
if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* Print arrays of textual chars with a string syntax, as
long as the entire array is valid. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& value_bytes_available (original_value, embedded_offset,
TYPE_LENGTH (type))
&& value_bits_valid (original_value,
TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
int force_ellipses = 0;
/* If requested, look for the first null char and only
print elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
for (temp_len = 0;
(temp_len < len
&& temp_len < options->print_max
&& extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order) != 0);
++temp_len)
;
/* Force LA_PRINT_STRING to print ellipses if
we've printed the maximum characters and
the next character is not \000. */
if (temp_len == options->print_max && temp_len < len)
{
ULONGEST val
= extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order);
if (val != 0)
force_ellipses = 1;
}
len = temp_len;
}
LA_PRINT_STRING (stream, unresolved_elttype,
valaddr + embedded_offset, len,
NULL, force_ellipses, options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members
normally. */
if (cp_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, _("%d vtable entries"),
len - 1);
}
else
{
i = 0;
}
val_print_array_elements (type, valaddr, embedded_offset,
address, stream,
recurse, original_value, options, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first
elt. */
addr = address + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_METHODPTR:
cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
break;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
if (options->vtblprint && cp_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if we ARE using
-fvtable_thunks. (Otherwise, look under
TYPE_CODE_STRUCT.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
print_function_pointer_address (options, gdbarch, addr, stream);
break;
}
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
{
int want_space;
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
want_space = 0;
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (options, gdbarch, addr, stream);
return;
}
if (options->symbol_print)
want_space = print_address_demangle (options, gdbarch, addr,
stream, demangle);
else if (options->addressprint)
{
fputs_filtered (paddress (gdbarch, addr), stream);
want_space = 1;
}
/* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& addr != 0)
{
if (want_space)
fputs_filtered (" ", stream);
i = val_print_string (unresolved_elttype, NULL,
addr, -1,
stream, options);
}
else if (cp_is_vtbl_member (type))
{
/* Print vtbl's nicely. */
CORE_ADDR vt_address = unpack_pointer (type,
valaddr
+ embedded_offset);
struct bound_minimal_symbol msymbol =
lookup_minimal_symbol_by_pc (vt_address);
/* If 'symbol_print' is set, we did the work above. */
if (!options->symbol_print
&& (msymbol.minsym != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
if (vt_address && options->vtblprint)
{
struct value *vt_val;
struct symbol *wsym = (struct symbol *) NULL;
struct type *wtype;
struct block *block = (struct block *) NULL;
struct field_of_this_result is_this_fld;
if (want_space)
fputs_filtered (" ", stream);
if (msymbol.minsym != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
block, VAR_DOMAIN,
&is_this_fld);
if (wsym)
{
wtype = SYMBOL_TYPE (wsym);
}
else
{
wtype = unresolved_elttype;
}
vt_val = value_at (wtype, vt_address);
common_val_print (vt_val, stream, recurse + 1,
options, current_language);
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
}
}
return;
}
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
/*FIXME: Abstract this away. */
if (options->vtblprint && cp_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if NOT using
-fvtable_thunks. (Otherwise, look under
TYPE_CODE_PTR.) */
int offset = (embedded_offset
+ TYPE_FIELD_BITPOS (type,
VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type,
VTBL_FNADDR_OFFSET);
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
print_function_pointer_address (options, gdbarch, addr, stream);
}
else
cp_print_value_fields_rtti (type, valaddr,
embedded_offset, address,
stream, recurse,
original_value, options,
NULL, 0);
break;
case TYPE_CODE_INT:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, &opts, 0, stream);
}
else
{
val_print_type_code_int (type, valaddr + embedded_offset,
stream);
/* C and C++ has no single byte int type, char is used
instead. Since we don't know whether the value is really
intended to be used as an integer or a character, print
the character equivalent as well. */
if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
unresolved_type, stream);
}
}
break;
case TYPE_CODE_MEMBERPTR:
if (!options->format)
{
cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
break;
}
/* FALLTHROUGH */
case TYPE_CODE_REF:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLAGS:
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
case TYPE_CODE_BOOL:
case TYPE_CODE_RANGE:
case TYPE_CODE_FLT:
case TYPE_CODE_DECFLOAT:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
case TYPE_CODE_UNDEF:
case TYPE_CODE_COMPLEX:
case TYPE_CODE_CHAR:
default:
generic_val_print (type, valaddr, embedded_offset, address,
stream, recurse, original_value, options,
&c_decorations);
break;
}
gdb_flush (stream);
}
void
pascal_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int i = 0; /* Number of characters printed */
unsigned len;
LONGEST low_bound, high_bound;
struct type *elttype;
unsigned eltlen;
int length_pos, length_size, string_pos;
struct type *char_type;
CORE_ADDR addr;
int want_space = 0;
type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
if (get_array_bounds (type, &low_bound, &high_bound))
{
len = high_bound - low_bound + 1;
elttype = check_typedef (TYPE_TARGET_TYPE (type));
eltlen = TYPE_LENGTH (elttype);
if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* If 's' format is used, try to print out as string.
If no format is given, print as string if element type
is of TYPE_CODE_CHAR and element size is 1,2 or 4. */
if (options->format == 's'
|| ((eltlen == 1 || eltlen == 2 || eltlen == 4)
&& TYPE_CODE (elttype) == TYPE_CODE_CHAR
&& options->format == 0))
{
/* If requested, look for the first null char and only print
elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
extract_unsigned_integer (valaddr + embedded_offset +
temp_len * eltlen, eltlen,
byte_order)
&& temp_len < len && temp_len < options->print_max;
temp_len++);
len = temp_len;
}
LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
valaddr + embedded_offset, len, NULL, 0,
options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members normally. */
if (pascal_object_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, "%d vtable entries", len - 1);
}
else
{
i = 0;
}
val_print_array_elements (type, valaddr, embedded_offset,
address, stream, recurse,
original_value, options, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
addr = address + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if we ARE using
-fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
/* Extract the address, assume that it is unsigned. */
addr = extract_unsigned_integer (valaddr + embedded_offset,
TYPE_LENGTH (type), byte_order);
print_address_demangle (options, gdbarch, addr, stream, demangle);
break;
}
check_typedef (TYPE_TARGET_TYPE (type));
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_address_demangle (options, gdbarch, addr, stream, demangle);
return;
}
if (options->addressprint && options->format != 's')
{
fputs_filtered (paddress (gdbarch, addr), stream);
want_space = 1;
}
/* For a pointer to char or unsigned char, also print the string
pointed to, unless pointer is null. */
if (((TYPE_LENGTH (elttype) == 1
&& (TYPE_CODE (elttype) == TYPE_CODE_INT
|| TYPE_CODE (elttype) == TYPE_CODE_CHAR))
|| ((TYPE_LENGTH (elttype) == 2 || TYPE_LENGTH (elttype) == 4)
&& TYPE_CODE (elttype) == TYPE_CODE_CHAR))
&& (options->format == 0 || options->format == 's')
&& addr != 0)
{
if (want_space)
fputs_filtered (" ", stream);
/* No wide string yet. */
i = val_print_string (elttype, NULL, addr, -1, stream, options);
}
/* Also for pointers to pascal strings. */
/* Note: this is Free Pascal specific:
as GDB does not recognize stabs pascal strings
Pascal strings are mapped to records
with lowercase names PM. */
if (is_pascal_string_type (elttype, &length_pos, &length_size,
&string_pos, &char_type, NULL)
&& addr != 0)
{
ULONGEST string_length;
gdb_byte *buffer;
if (want_space)
fputs_filtered (" ", stream);
buffer = (gdb_byte *) xmalloc (length_size);
read_memory (addr + length_pos, buffer, length_size);
string_length = extract_unsigned_integer (buffer, length_size,
byte_order);
xfree (buffer);
i = val_print_string (char_type, NULL,
addr + string_pos, string_length,
stream, options);
}
else if (pascal_object_is_vtbl_member (type))
{
/* Print vtbl's nicely. */
CORE_ADDR vt_address = unpack_pointer (type,
valaddr + embedded_offset);
struct bound_minimal_symbol msymbol =
lookup_minimal_symbol_by_pc (vt_address);
/* If 'symbol_print' is set, we did the work above. */
if (!options->symbol_print
&& (msymbol.minsym != NULL)
&& (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered ("<", stream);
fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
if (vt_address && options->vtblprint)
{
struct value *vt_val;
struct symbol *wsym = NULL;
struct type *wtype;
struct block *block = NULL;
struct field_of_this_result is_this_fld;
if (want_space)
fputs_filtered (" ", stream);
if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
block,
VAR_DOMAIN, &is_this_fld).symbol;
if (wsym)
{
wtype = SYMBOL_TYPE (wsym);
}
else
{
wtype = TYPE_TARGET_TYPE (type);
}
vt_val = value_at (wtype, vt_address);
common_val_print (vt_val, stream, recurse + 1, options,
current_language);
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
}
}
return;
case TYPE_CODE_REF:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLAGS:
case TYPE_CODE_FUNC:
case TYPE_CODE_RANGE:
case TYPE_CODE_INT:
case TYPE_CODE_FLT:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
case TYPE_CODE_UNDEF:
case TYPE_CODE_BOOL:
case TYPE_CODE_CHAR:
generic_val_print (type, valaddr, embedded_offset, address,
stream, recurse, original_value, options,
&p_decorations);
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if NOT using
-fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
/* Extract the address, assume that it is unsigned. */
print_address_demangle
(options, gdbarch,
extract_unsigned_integer (valaddr + embedded_offset
+ TYPE_FIELD_BITPOS (type,
VTBL_FNADDR_OFFSET) / 8,
TYPE_LENGTH (TYPE_FIELD_TYPE (type,
VTBL_FNADDR_OFFSET)),
byte_order),
stream, demangle);
}
else
{
if (is_pascal_string_type (type, &length_pos, &length_size,
&string_pos, &char_type, NULL))
{
len = extract_unsigned_integer (valaddr + embedded_offset
+ length_pos, length_size,
byte_order);
LA_PRINT_STRING (stream, char_type,
valaddr + embedded_offset + string_pos,
len, NULL, 0, options);
}
else
pascal_object_print_value_fields (type, valaddr, embedded_offset,
address, stream, recurse,
original_value, options,
NULL, 0);
}
break;
case TYPE_CODE_SET:
elttype = TYPE_INDEX_TYPE (type);
elttype = check_typedef (elttype);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, "<incomplete type>");
gdb_flush (stream);
break;
}
else
{
struct type *range = elttype;
LONGEST low_bound, high_bound;
int i;
int need_comma = 0;
fputs_filtered ("[", stream);
i = get_discrete_bounds (range, &low_bound, &high_bound);
if (low_bound == 0 && high_bound == -1 && TYPE_LENGTH (type) > 0)
{
/* If we know the size of the set type, we can figure out the
maximum value. */
i = 0;
high_bound = TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1;
TYPE_HIGH_BOUND (range) = high_bound;
}
maybe_bad_bstring:
if (i < 0)
{
fputs_filtered ("<error value>", stream);
goto done;
}
for (i = low_bound; i <= high_bound; i++)
{
int element = value_bit_index (type,
valaddr + embedded_offset, i);
if (element < 0)
{
i = element;
goto maybe_bad_bstring;
}
if (element)
{
if (need_comma)
fputs_filtered (", ", stream);
print_type_scalar (range, i, stream);
need_comma = 1;
if (i + 1 <= high_bound
&& value_bit_index (type,
valaddr + embedded_offset, ++i))
{
int j = i;
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
&& value_bit_index (type,
valaddr + embedded_offset,
++i))
j = i;
print_type_scalar (range, j, stream);
}
}
}
done:
fputs_filtered ("]", stream);
}
break;
default:
error (_("Invalid pascal type code %d in symbol table."),
TYPE_CODE (type));
}
gdb_flush (stream);
}
void
java_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
struct type *target_type;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
val, options, 0, stream);
break;
}
addr = unpack_pointer (type, valaddr + embedded_offset);
if (addr == 0)
{
fputs_filtered ("null", stream);
return;
}
target_type = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_address_demangle (options, gdbarch, addr, stream, demangle);
return;
}
if (options->addressprint && options->format != 's')
{
fputs_filtered ("@", stream);
print_longest (stream, 'x', 0, (ULONGEST) addr);
}
return;
case TYPE_CODE_CHAR:
case TYPE_CODE_INT:
/* Can't just call c_val_print because that prints bytes as C
chars. */
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
val, &opts, 0, stream);
}
else if (TYPE_CODE (type) == TYPE_CODE_CHAR
|| (TYPE_CODE (type) == TYPE_CODE_INT
&& TYPE_LENGTH (type) == 2
&& strcmp (TYPE_NAME (type), "char") == 0))
LA_PRINT_CHAR ((int) unpack_long (type, valaddr + embedded_offset),
type, stream);
else
val_print_type_code_int (type, valaddr + embedded_offset, stream);
break;
case TYPE_CODE_STRUCT:
java_print_value_fields (type, valaddr, embedded_offset,
address, stream, recurse, val, options);
break;
default:
c_val_print (type, valaddr, embedded_offset, address, stream,
recurse, val, options);
break;
}
}
static void
ada_val_print_num (struct type *type, const gdb_byte *valaddr,
int offset, int offset_aligned, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
if (ada_is_fixed_point_type (type))
{
LONGEST v = unpack_long (type, valaddr + offset_aligned);
fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
(double) ada_fixed_to_float (type, v));
return;
}
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
struct type *target_type = TYPE_TARGET_TYPE (type);
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
{
/* Obscure case of range type that has different length from
its base type. Perform a conversion, or we will get a
nonsense value. Actually, we could use the same
code regardless of lengths; I'm just avoiding a cast. */
struct value *v1
= value_from_contents_and_address (type, valaddr + offset, 0);
struct value *v = value_cast (target_type, v1);
val_print (target_type,
value_embedded_offset (v), 0, stream,
recurse + 1, v, options, language);
}
else
val_print (TYPE_TARGET_TYPE (type), offset,
address, stream, recurse, original_value,
options, language);
return;
}
else
{
int format = (options->format ? options->format
: options->output_format);
if (format)
{
struct value_print_options opts = *options;
opts.format = format;
val_print_scalar_formatted (type, offset_aligned,
original_value, &opts, 0, stream);
}
else if (ada_is_system_address_type (type))
{
/* FIXME: We want to print System.Address variables using
the same format as for any access type. But for some
reason GNAT encodes the System.Address type as an int,
so we have to work-around this deficiency by handling
System.Address values as a special case. */
struct gdbarch *gdbarch = get_type_arch (type);
struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
ptr_type);
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
fputs_filtered (paddress (gdbarch, addr), stream);
}
else
{
val_print_type_code_int (type, valaddr + offset_aligned, stream);
if (ada_is_character_type (type))
{
LONGEST c;
fputs_filtered (" ", stream);
c = unpack_long (type, valaddr + offset_aligned);
ada_printchar (c, type, stream);
}
}
return;
}
}
int
c_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int i = 0; /* Number of characters printed. */
unsigned len;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
unsigned eltlen;
LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
{
LONGEST low_bound, high_bound;
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
eltlen = TYPE_LENGTH (elttype);
len = high_bound - low_bound + 1;
if (options->prettyprint_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* Print arrays of textual chars with a string syntax, as
long as the entire array is valid. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& value_bytes_available (original_value, embedded_offset,
TYPE_LENGTH (type))
&& value_bits_valid (original_value,
TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
/* If requested, look for the first null char and only
print elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
for (temp_len = 0;
(temp_len < len
&& temp_len < options->print_max
&& extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order) != 0);
++temp_len)
;
len = temp_len;
}
LA_PRINT_STRING (stream, unresolved_elttype,
valaddr + embedded_offset, len,
NULL, 0, options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members
normally. */
if (cp_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, _("%d vtable entries"),
len - 1);
}
else
{
i = 0;
}
val_print_array_elements (type, valaddr, embedded_offset,
address, stream,
recurse, original_value, options, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first
elt. */
addr = address + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_MEMBERPTR:
if (options->format)
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
break;
case TYPE_CODE_METHODPTR:
cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
break;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
if (options->vtblprint && cp_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if we ARE using
-fvtable_thunks. (Otherwise, look under
TYPE_CODE_STRUCT.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
break;
}
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
{
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
/* Return value is irrelevant except for string
pointers. */
return (0);
}
if (options->addressprint)
fputs_filtered (paddress (gdbarch, addr), stream);
/* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& addr != 0)
{
i = val_print_string (unresolved_elttype, NULL,
addr, -1,
stream, options);
}
else if (cp_is_vtbl_member (type))
{
/* Print vtbl's nicely. */
CORE_ADDR vt_address = unpack_pointer (type,
valaddr
+ embedded_offset);
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
if ((msymbol != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && options->vtblprint)
{
struct value *vt_val;
struct symbol *wsym = (struct symbol *) NULL;
struct type *wtype;
struct block *block = (struct block *) NULL;
int is_this_fld;
if (msymbol != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
block, VAR_DOMAIN,
&is_this_fld);
if (wsym)
{
wtype = SYMBOL_TYPE (wsym);
}
else
{
wtype = unresolved_elttype;
}
vt_val = value_at (wtype, vt_address);
common_val_print (vt_val, stream, recurse + 1,
options, current_language);
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
}
}
/* Return number of characters printed, including the
terminating '\0' if we reached the end. val_print_string
takes care including the terminating '\0' if
necessary. */
return i;
}
break;
case TYPE_CODE_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (options->addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
fputs_filtered (paddress (gdbarch, addr), stream);
if (options->deref_ref)
fputs_filtered (": ", stream);
}
/* De-reference the reference. */
if (options->deref_ref)
{
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
struct value *deref_val;
deref_val = coerce_ref_if_computed (original_value);
if (deref_val != NULL)
{
/* More complicated computed references are not supported. */
gdb_assert (embedded_offset == 0);
}
else
deref_val = value_at (TYPE_TARGET_TYPE (type),
unpack_pointer (type,
(valaddr
+ embedded_offset)));
common_val_print (deref_val, stream, recurse, options,
current_language);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
/*FIXME: Abstract this away. */
if (options->vtblprint && cp_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if NOT using
-fvtable_thunks. (Otherwise, look under
TYPE_CODE_PTR.) */
int offset = (embedded_offset
+ TYPE_FIELD_BITPOS (type,
VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type,
VTBL_FNADDR_OFFSET);
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
}
else
cp_print_value_fields_rtti (type, valaddr,
embedded_offset, address,
stream, recurse,
original_value, options,
NULL, 0);
break;
case TYPE_CODE_ENUM:
if (options->format)
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
len = TYPE_NFIELDS (type);
val = unpack_long (type, valaddr + embedded_offset);
for (i = 0; i < len; i++)
{
QUIT;
if (val == TYPE_FIELD_BITPOS (type, i))
{
break;
}
}
if (i < len)
{
fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
}
else if (TYPE_FLAG_ENUM (type))
{
int first = 1;
/* We have a "flag" enum, so we try to decompose it into
pieces as appropriate. A flag enum has disjoint
constants by definition. */
fputs_filtered ("(", stream);
for (i = 0; i < len; ++i)
{
QUIT;
if ((val & TYPE_FIELD_BITPOS (type, i)) != 0)
{
if (!first)
fputs_filtered (" | ", stream);
first = 0;
val &= ~TYPE_FIELD_BITPOS (type, i);
fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
}
}
if (first || val != 0)
{
if (!first)
fputs_filtered (" | ", stream);
fputs_filtered ("unknown: ", stream);
print_longest (stream, 'd', 0, val);
}
fputs_filtered (")", stream);
}
else
print_longest (stream, 'd', 0, val);
break;
case TYPE_CODE_FLAGS:
if (options->format)
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
else
val_print_type_code_flags (type, valaddr + embedded_offset,
stream);
break;
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (options->format)
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
/* FIXME, we should consider, at least for ANSI C language,
eliminating the distinction made between FUNCs and POINTERs
to FUNCs. */
fprintf_filtered (stream, "{");
type_print (type, "", stream, -1);
fprintf_filtered (stream, "} ");
/* Try to print what function it points to, and its address. */
print_address_demangle (gdbarch, address, stream, demangle);
break;
case TYPE_CODE_BOOL:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, &opts, 0, stream);
}
else
{
val = unpack_long (type, valaddr + embedded_offset);
if (val == 0)
fputs_filtered ("false", stream);
else if (val == 1)
fputs_filtered ("true", stream);
else
print_longest (stream, 'd', 0, val);
}
break;
case TYPE_CODE_RANGE:
/* FIXME: create_range_type does not set the unsigned bit in a
range type (I think it probably should copy it from the
target type), so we won't print values which are too large to
fit in a signed integer correctly. */
/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
print with the target type, though, because the size of our
type and the target type might differ). */
/* FALLTHROUGH */
case TYPE_CODE_INT:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, &opts, 0, stream);
}
else
{
val_print_type_code_int (type, valaddr + embedded_offset,
stream);
/* C and C++ has no single byte int type, char is used
instead. Since we don't know whether the value is really
intended to be used as an integer or a character, print
the character equivalent as well. */
if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
unresolved_type, stream);
}
}
break;
case TYPE_CODE_CHAR:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, &opts, 0, stream);
}
else
{
val = unpack_long (type, valaddr + embedded_offset);
if (TYPE_UNSIGNED (type))
fprintf_filtered (stream, "%u", (unsigned int) val);
else
fprintf_filtered (stream, "%d", (int) val);
fputs_filtered (" ", stream);
LA_PRINT_CHAR (val, unresolved_type, stream);
}
break;
case TYPE_CODE_FLT:
if (options->format)
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
}
else
{
print_floating (valaddr + embedded_offset, type, stream);
}
break;
case TYPE_CODE_DECFLOAT:
if (options->format)
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
else
print_decimal_floating (valaddr + embedded_offset,
type, stream);
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
break;
case TYPE_CODE_UNDEF:
/* This happens (without TYPE_FLAG_STUB set) on systems which
don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
"struct foo *bar" and no complete type for struct foo in that
file. */
fprintf_filtered (stream, _("<incomplete type>"));
break;
case TYPE_CODE_COMPLEX:
if (options->format)
val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
valaddr, embedded_offset,
original_value, options, 0, stream);
else
print_floating (valaddr + embedded_offset,
TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " + ");
if (options->format)
val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
valaddr,
embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
original_value,
options, 0, stream);
else
print_floating (valaddr + embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " * I");
break;
default:
error (_("Invalid C/C++ type code %d in symbol table."),
TYPE_CODE (type));
}
gdb_flush (stream);
return (0);
}
void
m2_val_print (struct type *type, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
unsigned len;
struct type *elttype;
CORE_ADDR addr;
const gdb_byte *valaddr = value_contents_for_printing (original_value);
type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
elttype = check_typedef (TYPE_TARGET_TYPE (type));
len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
if (options->prettyformat_arrays)
print_spaces_filtered (2 + 2 * recurse, stream);
/* For an array of chars, print with string syntax. */
if (TYPE_LENGTH (elttype) == 1 &&
((TYPE_CODE (elttype) == TYPE_CODE_INT)
|| ((current_language->la_language == language_m2)
&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
&& (options->format == 0 || options->format == 's'))
{
/* If requested, look for the first null char and only print
elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
(valaddr + embedded_offset)[temp_len]
&& temp_len < len && temp_len < options->print_max;
temp_len++);
len = temp_len;
}
LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
valaddr + embedded_offset, len, NULL,
0, options);
}
else
{
fprintf_filtered (stream, "{");
val_print_array_elements (type, embedded_offset,
address, stream,
recurse, original_value,
options, 0);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
print_unpacked_pointer (type, address, address, options, stream);
break;
case TYPE_CODE_PTR:
if (TYPE_CONST (type))
print_variable_at_address (type, valaddr + embedded_offset,
stream, recurse, options);
else if (options->format && options->format != 's')
val_print_scalar_formatted (type, embedded_offset,
original_value, options, 0, stream);
else
{
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer (type, addr, address, options, stream);
}
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
if (m2_is_long_set (type))
m2_print_long_set (type, valaddr, embedded_offset, address,
stream);
else if (m2_is_unbounded_array (type))
m2_print_unbounded_array (type, valaddr, embedded_offset,
address, stream, recurse, options);
else
cp_print_value_fields (type, type, embedded_offset,
address, stream, recurse, original_value,
options, NULL, 0);
break;
case TYPE_CODE_SET:
elttype = TYPE_INDEX_TYPE (type);
elttype = check_typedef (elttype);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, _("<incomplete type>"));
gdb_flush (stream);
break;
}
else
{
struct type *range = elttype;
LONGEST low_bound, high_bound;
int i;
int need_comma = 0;
fputs_filtered ("{", stream);
i = get_discrete_bounds (range, &low_bound, &high_bound);
maybe_bad_bstring:
if (i < 0)
{
fputs_filtered (_("<error value>"), stream);
goto done;
}
for (i = low_bound; i <= high_bound; i++)
{
int element = value_bit_index (type, valaddr + embedded_offset,
i);
if (element < 0)
{
i = element;
goto maybe_bad_bstring;
}
if (element)
{
if (need_comma)
fputs_filtered (", ", stream);
print_type_scalar (range, i, stream);
need_comma = 1;
if (i + 1 <= high_bound
&& value_bit_index (type, valaddr + embedded_offset,
++i))
{
int j = i;
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
&& value_bit_index (type,
valaddr + embedded_offset,
++i))
j = i;
print_type_scalar (range, j, stream);
}
}
}
done:
fputs_filtered ("}", stream);
}
break;
case TYPE_CODE_RANGE:
if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
{
m2_val_print (TYPE_TARGET_TYPE (type), embedded_offset,
address, stream, recurse, original_value, options);
break;
}
/* FIXME: create_static_range_type does not set the unsigned bit in a
range type (I think it probably should copy it from the target
type), so we won't print values which are too large to
fit in a signed integer correctly. */
/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
print with the target type, though, because the size of our type
and the target type might differ). */
/* FALLTHROUGH */
case TYPE_CODE_REF:
case TYPE_CODE_ENUM:
case TYPE_CODE_FUNC:
case TYPE_CODE_INT:
case TYPE_CODE_FLT:
case TYPE_CODE_METHOD:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
case TYPE_CODE_UNDEF:
case TYPE_CODE_BOOL:
case TYPE_CODE_CHAR:
default:
generic_val_print (type, embedded_offset, address,
stream, recurse, original_value, options,
&m2_decorations);
break;
}
gdb_flush (stream);
}
