2002-06-04 15:28:49 +00:00
|
|
|
|
/* Support for printing Ada types for GDB, the GNU debugger.
|
2007-01-09 17:59:20 +00:00
|
|
|
|
Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
|
2009-01-03 05:58:08 +00:00
|
|
|
|
2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2007-08-23 18:08:50 +00:00
|
|
|
|
This file is part of GDB.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2007-08-23 18:08:50 +00:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2007-08-23 18:08:50 +00:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2007-08-23 18:08:50 +00:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
2002-07-29 Andrew Cagney <ac131313@redhat.com>
* gdb_obstack.h: New file.
* symtab.h: Include "gdb_obstack.h" instead of "obstack.h".
(obstack_chunk_alloc, obstack_chunk_free): Delete macros.
* objfiles.h: Include "gdb_obstack.h".
* Makefile.in (gdb_obstack_h): Define.
(symtab_h): Add $(gdb_obstack_h).
(objfiles_h): Add $(gdb_obstack_h).
* objfiles.c: Include "gdb_obstack.h" instead of "obstack.h".
* macrotab.c, cp-valprint.c, dbxread.c: Ditto.
* ch-typeprint.c, ch-valprint.c, dstread.c: Ditto.
* macroexp.c, p-typeprint.c, stabsread.c: Ditto.
* symtab.c, f-typeprint.c, mdebugread.c: Ditto.
* p-valprint.c, symmisc.c, typeprint.c: Ditto.
* symfile.c, coffread.c, c-typeprint.c: Ditto.
* buildsym.c, bcache.c, ada-typeprint.c: Ditto.
* Makefile.in (bcache.o): Update dependencies.
(buildsym.o, c-typeprint.o, ch-typeprint.o): Ditto.
(ch-valprint.o, coffread.o, cp-valprint.o): Ditto.
(dbxread.o, dstread.o, f-typeprint.o): Ditto.
(objfiles.o, p-typeprint.o, p-valprint.o): Ditto.
(stabsread.o, symfile.o, symmisc.o): Ditto.
(symtab.o, typeprint.o, macroexp.o): Ditto.
(macrotab.o, mdebugread.o): Ditto.
(f_lang_h, coff_sym_h, coff_symconst_h): Define.
(coff_ecoff_h, aout_aout64_h): Define.
(aout_stabs_gnu_h, libaout_h): Define.
2002-07-29 22:55:26 +00:00
|
|
|
|
#include "gdb_obstack.h"
|
2002-06-04 15:28:49 +00:00
|
|
|
|
#include "bfd.h" /* Binary File Description */
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "expression.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "gdbcore.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "command.h"
|
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
|
#include "language.h"
|
|
|
|
|
#include "demangle.h"
|
|
|
|
|
#include "c-lang.h"
|
|
|
|
|
#include "typeprint.h"
|
|
|
|
|
#include "ada-lang.h"
|
|
|
|
|
|
|
|
|
|
#include <ctype.h>
|
2002-08-18 18:24:29 +00:00
|
|
|
|
#include "gdb_string.h"
|
2002-06-04 15:28:49 +00:00
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static int print_record_field_types (struct type *, struct type *,
|
2002-06-04 15:28:49 +00:00
|
|
|
|
struct ui_file *, int, int);
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static void print_array_type (struct type *, struct ui_file *, int, int);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static void print_choices (struct type *, int, struct ui_file *,
|
|
|
|
|
struct type *);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static void print_range (struct type *, struct ui_file *);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static void print_range_bound (struct type *, char *, int *,
|
|
|
|
|
struct ui_file *);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static void
|
|
|
|
|
print_dynamic_range_bound (struct type *, const char *, int,
|
|
|
|
|
const char *, struct ui_file *);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2009-06-29 17:28:59 +00:00
|
|
|
|
static void print_range_type_named (char *, struct type *, struct ui_file *);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
|
|
|
|
|
static char *name_buffer;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
static int name_buffer_len;
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* The (decoded) Ada name of TYPE. This value persists until the
|
|
|
|
|
next call. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
static char *
|
2004-06-02 09:55:36 +00:00
|
|
|
|
decoded_type_name (struct type *type)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
if (ada_type_name (type) == NULL)
|
|
|
|
|
return NULL;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
char *raw_name = ada_type_name (type);
|
|
|
|
|
char *s, *q;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
|
|
|
|
|
{
|
|
|
|
|
name_buffer_len = 16 + 2 * strlen (raw_name);
|
|
|
|
|
name_buffer = xrealloc (name_buffer, name_buffer_len);
|
|
|
|
|
}
|
|
|
|
|
strcpy (name_buffer, raw_name);
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
s = (char *) strstr (name_buffer, "___");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (s != NULL)
|
|
|
|
|
*s = '\0';
|
|
|
|
|
|
|
|
|
|
s = name_buffer + strlen (name_buffer) - 1;
|
|
|
|
|
while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
|
|
|
|
|
s -= 1;
|
|
|
|
|
|
|
|
|
|
if (s == name_buffer)
|
|
|
|
|
return name_buffer;
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (!islower (s[1]))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (s = q = name_buffer; *s != '\0'; q += 1)
|
|
|
|
|
{
|
|
|
|
|
if (s[0] == '_' && s[1] == '_')
|
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
*q = '.';
|
|
|
|
|
s += 2;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
*q = *s;
|
|
|
|
|
s += 1;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*q = '\0';
|
|
|
|
|
return name_buffer;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print range type TYPE on STREAM. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_range (struct type *type, struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
struct type *target_type;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
target_type = TYPE_TARGET_TYPE (type);
|
|
|
|
|
if (target_type == NULL)
|
|
|
|
|
target_type = type;
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
switch (TYPE_CODE (target_type))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_RANGE:
|
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
case TYPE_CODE_BOOL:
|
|
|
|
|
case TYPE_CODE_CHAR:
|
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
* ada-lang.c (ada_coerce_to_simple_array_type): Use builtin_type_int32
instead of builtin_type_int as default unspecified integral type.
(ada_index_type, ada_array_bound_from_type, ada_variant_discrim_type,
assign_component, to_fixed_range_type): Likewise.
* ada-typeprint.c (print_range, print_range_bound,
print_range_type_named): Likewise.
* ada-valprint.c (print_optional_low_bound, ada_val_print_1): Likewise.
* eval.c (evaluate_subexp_standard): Likewise.
* gnu-v2-abi.c (gnuv2_virtual_fn_field): Likewise.
* gnu-v3-abi.c (gnuv3_get_virtual_fn, gnuv3_baseclass_offset,
build_gdb_vtable_type): Likewise.
* jv-lang.c (java_array_type): Likewise.
* m2-typeprint.c (m2_print_bounds, m2_is_long_set_of_type): Likewise.
* m2-valprint.c (m2_print_long_set): Likewise.
* parse.c (follow_types): Likewise.
* p-typeprint.c (pascal_type_print_base): Likewise.
* valops.c (value_one, value_array, value_string,
value_bitstring): Likewise.
* value.c (allocate_repeat_value, value_from_string): Likewise.
* varobj.c (c_describe_child): Likewise.
* mt-tdep.c (mt_register_type): Likewise.
* sh-tdep.c (sh_sh4_build_float_register_type): Likewise.
* sh64-tdep.c (sh64_build_float_register_type): Likewise.
2008-09-11 14:22:33 +00:00
|
|
|
|
target_type = builtin_type_int32;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (TYPE_NFIELDS (type) < 2)
|
|
|
|
|
{
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* A range needs at least 2 bounds to be printed. If there are less
|
2002-06-04 15:28:49 +00:00
|
|
|
|
than 2, just print the type name instead of the range itself.
|
2004-06-02 09:55:36 +00:00
|
|
|
|
This check handles cases such as characters, for example.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2006-01-02 09:39:21 +00:00
|
|
|
|
If the name is not defined, then we don't print anything.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
*/
|
|
|
|
|
fprintf_filtered (stream, "%.*s",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
ada_name_prefix_len (TYPE_NAME (type)),
|
|
|
|
|
TYPE_NAME (type));
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We extract the range type bounds respectively from the first element
|
|
|
|
|
and the last element of the type->fields array */
|
|
|
|
|
const LONGEST lower_bound = (LONGEST) TYPE_LOW_BOUND (type);
|
Fix TYPE_HIGH_BOUND for TYPE_CODE_RANGE using arbitrary TYPE_NFIELDS in
preparation for supporting DW_AT_byte_stride.
* ada-lang.c (packed_array_type, ada_index_type): Use TYPE_INDEX_TYPE.
(ada_array_bound_from_type): Move `index_type' declaration to the
function start. New variable `retval'. Return the bounds for
TYPE_CODE_RANGE using TYPE_LOW_BOUND and TYPE_HIGH_BOUND. Abort on
invalid index type codes.
* ada-typeprint.c (print_range): Set `upper_bound' for TYPE_CODE_RANGE
now using TYPE_HIGH_BOUND.
* ada-valprint.c (val_print_packed_array_elements): Use `index_type'.
* eval.c (evaluate_subexp_standard): Use TYPE_INDEX_TYPE.
* gdbtypes.c (create_range_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
refer to the number of fields only through TYPE_NFIELDS.
(create_array_type): Use TYPE_INDEX_TYPE.
(check_typedef): Use TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND.
* gdbtypes.h (TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED)
(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED): Use TYPE_INDEX_TYPE.
(TYPE_ARRAY_UPPER_BOUND_VALUE, TYPE_ARRAY_LOWER_BOUND_VALUE): Use
TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
* hppa-tdep.c (hppa_alignof <TYPE_CODE_ARRAY>): Use TYPE_INDEX_TYPE.
* mdebugread.c (parse_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
* valarith.c (value_bit_index): Use TYPE_INDEX_TYPE.
2008-12-28 14:14:19 +00:00
|
|
|
|
const LONGEST upper_bound = (TYPE_CODE (type) == TYPE_CODE_RANGE
|
|
|
|
|
? (LONGEST) TYPE_HIGH_BOUND (type)
|
|
|
|
|
: (LONGEST) TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1));
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
ada_print_scalar (target_type, lower_bound, stream);
|
|
|
|
|
fprintf_filtered (stream, " .. ");
|
|
|
|
|
ada_print_scalar (target_type, upper_bound, stream);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
|
2004-06-02 09:55:36 +00:00
|
|
|
|
set *N past the bound and its delimiter, if any. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_range_bound (struct type *type, char *bounds, int *n,
|
|
|
|
|
struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
LONGEST B;
|
|
|
|
|
if (ada_scan_number (bounds, *n, &B, n))
|
|
|
|
|
{
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* STABS decodes all range types which bounds are 0 .. -1 as
|
|
|
|
|
unsigned integers (ie. the type code is TYPE_CODE_INT, not
|
|
|
|
|
TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
|
|
|
|
|
on the unsigned flag to determine whether the bound should
|
|
|
|
|
be printed as a signed or an unsigned value. This causes
|
|
|
|
|
the upper bound of the 0 .. -1 range types to be printed as
|
|
|
|
|
a very large unsigned number instead of -1.
|
|
|
|
|
To workaround this stabs deficiency, we replace the TYPE by
|
* ada-lang.c (ada_coerce_to_simple_array_type): Use builtin_type_int32
instead of builtin_type_int as default unspecified integral type.
(ada_index_type, ada_array_bound_from_type, ada_variant_discrim_type,
assign_component, to_fixed_range_type): Likewise.
* ada-typeprint.c (print_range, print_range_bound,
print_range_type_named): Likewise.
* ada-valprint.c (print_optional_low_bound, ada_val_print_1): Likewise.
* eval.c (evaluate_subexp_standard): Likewise.
* gnu-v2-abi.c (gnuv2_virtual_fn_field): Likewise.
* gnu-v3-abi.c (gnuv3_get_virtual_fn, gnuv3_baseclass_offset,
build_gdb_vtable_type): Likewise.
* jv-lang.c (java_array_type): Likewise.
* m2-typeprint.c (m2_print_bounds, m2_is_long_set_of_type): Likewise.
* m2-valprint.c (m2_print_long_set): Likewise.
* parse.c (follow_types): Likewise.
* p-typeprint.c (pascal_type_print_base): Likewise.
* valops.c (value_one, value_array, value_string,
value_bitstring): Likewise.
* value.c (allocate_repeat_value, value_from_string): Likewise.
* varobj.c (c_describe_child): Likewise.
* mt-tdep.c (mt_register_type): Likewise.
* sh-tdep.c (sh_sh4_build_float_register_type): Likewise.
* sh64-tdep.c (sh64_build_float_register_type): Likewise.
2008-09-11 14:22:33 +00:00
|
|
|
|
builtin_type_int32 when we detect that the bound is negative,
|
2004-06-02 09:55:36 +00:00
|
|
|
|
and the type is a TYPE_CODE_INT. The bound is negative when
|
|
|
|
|
'm' is the last character of the number scanned in BOUNDS. */
|
|
|
|
|
if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
|
* ada-lang.c (ada_coerce_to_simple_array_type): Use builtin_type_int32
instead of builtin_type_int as default unspecified integral type.
(ada_index_type, ada_array_bound_from_type, ada_variant_discrim_type,
assign_component, to_fixed_range_type): Likewise.
* ada-typeprint.c (print_range, print_range_bound,
print_range_type_named): Likewise.
* ada-valprint.c (print_optional_low_bound, ada_val_print_1): Likewise.
* eval.c (evaluate_subexp_standard): Likewise.
* gnu-v2-abi.c (gnuv2_virtual_fn_field): Likewise.
* gnu-v3-abi.c (gnuv3_get_virtual_fn, gnuv3_baseclass_offset,
build_gdb_vtable_type): Likewise.
* jv-lang.c (java_array_type): Likewise.
* m2-typeprint.c (m2_print_bounds, m2_is_long_set_of_type): Likewise.
* m2-valprint.c (m2_print_long_set): Likewise.
* parse.c (follow_types): Likewise.
* p-typeprint.c (pascal_type_print_base): Likewise.
* valops.c (value_one, value_array, value_string,
value_bitstring): Likewise.
* value.c (allocate_repeat_value, value_from_string): Likewise.
* varobj.c (c_describe_child): Likewise.
* mt-tdep.c (mt_register_type): Likewise.
* sh-tdep.c (sh_sh4_build_float_register_type): Likewise.
* sh64-tdep.c (sh64_build_float_register_type): Likewise.
2008-09-11 14:22:33 +00:00
|
|
|
|
type = builtin_type_int32;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
ada_print_scalar (type, B, stream);
|
|
|
|
|
if (bounds[*n] == '_')
|
|
|
|
|
*n += 2;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int bound_len;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
char *bound = bounds + *n;
|
|
|
|
|
char *pend;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
pend = strstr (bound, "__");
|
|
|
|
|
if (pend == NULL)
|
|
|
|
|
*n += bound_len = strlen (bound);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
bound_len = pend - bound;
|
|
|
|
|
*n += bound_len + 2;
|
|
|
|
|
}
|
|
|
|
|
fprintf_filtered (stream, "%.*s", bound_len, bound);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
|
|
|
|
|
the value (if found) of the bound indicated by SUFFIX ("___L" or
|
2004-06-02 09:55:36 +00:00
|
|
|
|
"___U") according to the ___XD conventions. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_dynamic_range_bound (struct type *type, const char *name, int name_len,
|
|
|
|
|
const char *suffix, struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
static char *name_buf = NULL;
|
|
|
|
|
static size_t name_buf_len = 0;
|
|
|
|
|
LONGEST B;
|
|
|
|
|
int OK;
|
|
|
|
|
|
|
|
|
|
GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
|
|
|
|
|
strncpy (name_buf, name, name_len);
|
|
|
|
|
strcpy (name_buf + name_len, suffix);
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
B = get_int_var_value (name_buf, &OK);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (OK)
|
|
|
|
|
ada_print_scalar (type, B, stream);
|
|
|
|
|
else
|
|
|
|
|
fprintf_filtered (stream, "?");
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-29 17:28:59 +00:00
|
|
|
|
/* Print the range type named NAME. If symbol lookup fails, fall back
|
|
|
|
|
to ORIG_TYPE as base type. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2009-06-29 17:28:59 +00:00
|
|
|
|
print_range_type_named (char *name, struct type *orig_type,
|
|
|
|
|
struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
struct type *raw_type = ada_find_any_type (name);
|
|
|
|
|
struct type *base_type;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
char *subtype_info;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (raw_type == NULL)
|
2009-06-29 17:28:59 +00:00
|
|
|
|
raw_type = orig_type;
|
|
|
|
|
|
|
|
|
|
if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
base_type = TYPE_TARGET_TYPE (raw_type);
|
|
|
|
|
else
|
|
|
|
|
base_type = raw_type;
|
|
|
|
|
|
|
|
|
|
subtype_info = strstr (name, "___XD");
|
2009-06-29 17:28:59 +00:00
|
|
|
|
if (subtype_info == NULL)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
print_range (raw_type, stream);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int prefix_len = subtype_info - name;
|
|
|
|
|
char *bounds_str;
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
subtype_info += 5;
|
|
|
|
|
bounds_str = strchr (subtype_info, '_');
|
|
|
|
|
n = 1;
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (*subtype_info == 'L')
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2004-06-02 09:55:36 +00:00
|
|
|
|
print_range_bound (base_type, bounds_str, &n, stream);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
subtype_info += 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
2004-06-02 09:55:36 +00:00
|
|
|
|
print_dynamic_range_bound (base_type, name, prefix_len, "___L",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
stream);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
fprintf_filtered (stream, " .. ");
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (*subtype_info == 'U')
|
2004-06-02 09:55:36 +00:00
|
|
|
|
print_range_bound (base_type, bounds_str, &n, stream);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
else
|
2004-06-02 09:55:36 +00:00
|
|
|
|
print_dynamic_range_bound (base_type, name, prefix_len, "___U",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
stream);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
2002-08-18 18:11:12 +00:00
|
|
|
|
}
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print enumerated type TYPE on STREAM. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_enum_type (struct type *type, struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int len = TYPE_NFIELDS (type);
|
|
|
|
|
int i, lastval;
|
|
|
|
|
|
|
|
|
|
fprintf_filtered (stream, "(");
|
|
|
|
|
wrap_here (" ");
|
|
|
|
|
|
|
|
|
|
lastval = 0;
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
|
{
|
|
|
|
|
QUIT;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (i)
|
|
|
|
|
fprintf_filtered (stream, ", ");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
wrap_here (" ");
|
|
|
|
|
fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
|
|
|
|
|
if (lastval != TYPE_FIELD_BITPOS (type, i))
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
|
|
|
|
|
lastval = TYPE_FIELD_BITPOS (type, i);
|
|
|
|
|
}
|
|
|
|
|
lastval += 1;
|
|
|
|
|
}
|
|
|
|
|
fprintf_filtered (stream, ")");
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print representation of Ada fixed-point type TYPE on STREAM. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_fixed_point_type (struct type *type, struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
DOUBLEST delta = ada_delta (type);
|
|
|
|
|
DOUBLEST small = ada_fixed_to_float (type, 1.0);
|
|
|
|
|
|
|
|
|
|
if (delta < 0.0)
|
|
|
|
|
fprintf_filtered (stream, "delta ??");
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "delta %g", (double) delta);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (delta != small)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, " <'small = %g>", (double) small);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print representation of special VAX floating-point type TYPE on STREAM. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_vax_floating_point_type (struct type *type, struct ui_file *stream)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "<float format %c>",
|
|
|
|
|
ada_vax_float_type_suffix (type));
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
|
|
|
|
|
recursion (indentation) level, in case the element type itself has
|
2002-06-04 15:28:49 +00:00
|
|
|
|
nested structure, and SHOW is the number of levels of internal
|
2004-06-02 09:55:36 +00:00
|
|
|
|
structure to show (see ada_print_type). */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_array_type (struct type *type, struct ui_file *stream, int show,
|
|
|
|
|
int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int bitsize;
|
|
|
|
|
int n_indices;
|
|
|
|
|
|
2008-01-04 20:45:05 +00:00
|
|
|
|
if (ada_is_packed_array_type (type))
|
|
|
|
|
type = ada_coerce_to_simple_array_type (type);
|
|
|
|
|
|
2002-06-04 15:28:49 +00:00
|
|
|
|
bitsize = 0;
|
|
|
|
|
fprintf_filtered (stream, "array (");
|
|
|
|
|
|
2009-03-20 22:00:11 +00:00
|
|
|
|
if (type == NULL)
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, _("<undecipherable array type>"));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-04 15:28:49 +00:00
|
|
|
|
n_indices = -1;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (show < 0)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, "...");
|
|
|
|
|
else
|
|
|
|
|
{
|
2004-06-02 09:55:36 +00:00
|
|
|
|
if (ada_is_simple_array_type (type))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
struct type *range_desc_type =
|
2002-06-04 15:28:49 +00:00
|
|
|
|
ada_find_parallel_type (type, "___XA");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
struct type *arr_type;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
bitsize = 0;
|
|
|
|
|
if (range_desc_type == NULL)
|
|
|
|
|
{
|
|
|
|
|
for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
|
|
|
|
|
arr_type = TYPE_TARGET_TYPE (arr_type))
|
|
|
|
|
{
|
|
|
|
|
if (arr_type != type)
|
|
|
|
|
fprintf_filtered (stream, ", ");
|
|
|
|
|
print_range (TYPE_INDEX_TYPE (arr_type), stream);
|
|
|
|
|
if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
|
|
|
|
|
bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int k;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
n_indices = TYPE_NFIELDS (range_desc_type);
|
|
|
|
|
for (k = 0, arr_type = type;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
k < n_indices;
|
|
|
|
|
k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
|
|
|
|
|
{
|
|
|
|
|
if (k > 0)
|
|
|
|
|
fprintf_filtered (stream, ", ");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_range_type_named (TYPE_FIELD_NAME
|
2009-06-29 17:28:59 +00:00
|
|
|
|
(range_desc_type, k),
|
|
|
|
|
TYPE_INDEX_TYPE (arr_type), stream);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
|
|
|
|
|
bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
}
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int i, i0;
|
|
|
|
|
for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
|
|
|
|
|
fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fprintf_filtered (stream, ") of ");
|
|
|
|
|
wrap_here ("");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
ada_print_type (ada_array_element_type (type, n_indices), "", stream,
|
|
|
|
|
show == 0 ? 0 : show - 1, level + 1);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (bitsize > 0)
|
|
|
|
|
fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
|
2004-06-02 09:55:36 +00:00
|
|
|
|
STREAM, assuming the VAL_TYPE is the type of the values. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_choices (struct type *type, int field_num, struct ui_file *stream,
|
|
|
|
|
struct type *val_type)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int have_output;
|
|
|
|
|
int p;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
const char *name = TYPE_FIELD_NAME (type, field_num);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
have_output = 0;
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Skip over leading 'V': NOTE soon to be obsolete. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (name[0] == 'V')
|
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (!ada_scan_number (name, 1, NULL, &p))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
goto Huh;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
p = 0;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
switch (name[p])
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
case 'S':
|
|
|
|
|
case 'R':
|
|
|
|
|
case 'O':
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (have_output)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, " | ");
|
|
|
|
|
have_output = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
switch (name[p])
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
case 'S':
|
|
|
|
|
{
|
|
|
|
|
LONGEST W;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (!ada_scan_number (name, p + 1, &W, &p))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
goto Huh;
|
|
|
|
|
ada_print_scalar (val_type, W, stream);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'R':
|
|
|
|
|
{
|
|
|
|
|
LONGEST L, U;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (!ada_scan_number (name, p + 1, &L, &p)
|
|
|
|
|
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
goto Huh;
|
|
|
|
|
ada_print_scalar (val_type, L, stream);
|
|
|
|
|
fprintf_filtered (stream, " .. ");
|
|
|
|
|
ada_print_scalar (val_type, U, stream);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 'O':
|
|
|
|
|
fprintf_filtered (stream, "others");
|
|
|
|
|
p += 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Huh:
|
|
|
|
|
fprintf_filtered (stream, "??");
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
|
|
|
|
|
discriminant is contained in OUTER_TYPE, print its variants on STREAM.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
LEVEL is the recursion
|
|
|
|
|
(indentation) level, in case any of the fields themselves have
|
|
|
|
|
nested structure, and SHOW is the number of levels of internal structure
|
2004-06-02 09:55:36 +00:00
|
|
|
|
to show (see ada_print_type). For this purpose, fields nested in a
|
2002-06-04 15:28:49 +00:00
|
|
|
|
variant part are taken to be at the same level as the fields
|
2004-06-02 09:55:36 +00:00
|
|
|
|
immediately outside the variant part. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_variant_clauses (struct type *type, int field_num,
|
|
|
|
|
struct type *outer_type, struct ui_file *stream,
|
|
|
|
|
int show, int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int i;
|
2004-06-02 09:55:36 +00:00
|
|
|
|
struct type *var_type, *par_type;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
struct type *discr_type;
|
|
|
|
|
|
|
|
|
|
var_type = TYPE_FIELD_TYPE (type, field_num);
|
|
|
|
|
discr_type = ada_variant_discrim_type (var_type, outer_type);
|
|
|
|
|
|
|
|
|
|
if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
|
|
|
|
|
{
|
|
|
|
|
var_type = TYPE_TARGET_TYPE (var_type);
|
2004-06-02 09:55:36 +00:00
|
|
|
|
if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
|
|
|
|
|
return;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
par_type = ada_find_parallel_type (var_type, "___XVU");
|
|
|
|
|
if (par_type != NULL)
|
|
|
|
|
var_type = par_type;
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
|
|
|
|
|
print_choices (var_type, i, stream, discr_type);
|
|
|
|
|
fprintf_filtered (stream, " =>");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
|
|
|
|
|
outer_type, stream, show, level + 4) <= 0)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, " null;");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Assuming that field FIELD_NUM of TYPE is a variant part whose
|
2002-06-04 15:28:49 +00:00
|
|
|
|
discriminants are contained in OUTER_TYPE, print a description of it
|
2004-06-02 09:55:36 +00:00
|
|
|
|
on STREAM. LEVEL is the recursion (indentation) level, in case any of
|
|
|
|
|
the fields themselves have nested structure, and SHOW is the number of
|
|
|
|
|
levels of internal structure to show (see ada_print_type). For this
|
|
|
|
|
purpose, fields nested in a variant part are taken to be at the same
|
|
|
|
|
level as the fields immediately outside the variant part. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_variant_part (struct type *type, int field_num, struct type *outer_type,
|
|
|
|
|
struct ui_file *stream, int show, int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
ada_variant_discrim_name
|
|
|
|
|
(TYPE_FIELD_TYPE (type, field_num)));
|
|
|
|
|
print_variant_clauses (type, field_num, outer_type, stream, show,
|
|
|
|
|
level + 4);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, "\n%*send case;", level + 4, "");
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print a description on STREAM of the fields in record type TYPE, whose
|
|
|
|
|
discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
|
|
|
|
|
level, in case any of the fields themselves have nested structure,
|
|
|
|
|
and SHOW is the number of levels of internal structure to show
|
|
|
|
|
(see ada_print_type). Does not print parent type information of TYPE.
|
|
|
|
|
Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
|
2002-06-04 15:28:49 +00:00
|
|
|
|
Prints each field beginning on a new line, but does not put a new line at
|
2004-06-02 09:55:36 +00:00
|
|
|
|
end. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static int
|
2002-07-25 01:14:26 +00:00
|
|
|
|
print_record_field_types (struct type *type, struct type *outer_type,
|
|
|
|
|
struct ui_file *stream, int show, int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int len, i, flds;
|
|
|
|
|
|
|
|
|
|
flds = 0;
|
|
|
|
|
len = TYPE_NFIELDS (type);
|
|
|
|
|
|
gdb:
* xml-tdesc.c (tdesc_end_union): Update.
* stabsread.c (define_symbol): Update.
(read_type): Update.
(read_struct_type): Update.
(read_enum_type): Update.
* spu-tdep.c (spu_builtin_type_vec128): Update.
* sh-tdep.c (sh_push_dummy_call_fpu): Update.
(sh_push_dummy_call_nofpu): Update.
* mdebugread.c (parse_symbol): Update.
(parse_symbol): Update.
(parse_symbol): Update.
(upgrade_type): Update.
* jv-lang.c (java_lookup_class): Update.
* iq2000-tdep.c (iq2000_pointer_to_address): Update.
* i386-tdep.c (i386_mmx_type): Update.
(i386_sse_type): Update.
* gdbtypes.h (enum type_flag_value): New enum.
(enum type_instance_flag_value): New enum.
(TYPE_FLAG_UNSIGNED, TYPE_FLAG_NOSIGN, TYPE_FLAG_STUB,
TYPE_FLAG_TARGET_STUB, TYPE_FLAG_STATIC, TYPE_FLAG_PROTOTYPED,
TYPE_FLAG_INCOMPLETE, TYPE_FLAG_VARARGS, TYPE_FLAG_VECTOR,
TYPE_FLAG_FIXED_INSTANCE, TYPE_FLAG_STUB_SUPPORTED,
TYPE_FLAG_NOTTEXT): Now enum constants.
(TYPE_FLAG_CONST, TYPE_FLAG_VOLATILE, TYPE_FLAG_CODE_SPACE,
TYPE_FLAG_DATA_SPACE, TYPE_FLAG_ADDRESS_CLASS_1,
TYPE_FLAG_ADDRESS_CLASS_2): Remove.
(TYPE_INSTANCE_FLAG_CONST, TYPE_INSTANCE_FLAG_VOLATILE,
TYPE_INSTANCE_FLAG_CODE_SPACE, TYPE_INSTANCE_FLAG_DATA_SPACE,
TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1,
TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2): New constants.
(TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB, TYPE_TARGET_STUB,
TYPE_STATIC, TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_VARARGS,
TYPE_VECTOR, TYPE_FIXED_INSTANCE, TYPE_STUB_SUPPORTED,
TYPE_NOTTEXT): Update.
(TYPE_FLAG_ADDRESS_CLASS_ALL): Remove.
(TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL): New define.
(TYPE_VOLATILE, TYPE_CODE_SPACE, TYPE_DATA_SPACE,
TYPE_ADDRESS_CLASS_1, TYPE_ADDRESS_CLASS_2,
TYPE_ADDRESS_CLASS_ALL): Update.
(struct main_type) <flags>: Remove.
<flag_unsigned, flag_nosign, flag_stub, flag_target_stub,
flag_static, flag_prototyped, flag_incomplete, flag_varargs,
flag_vector, flag_stub_supported, flag_nottext,
flag_fixed_instance>: New fields.
<nfields, vptr_fieldno>: Move earlier.
(TYPE_FLAGS): Remove.
* gdbtypes.c (make_pointer_type): Update.
(address_space_name_to_int): Update.
(address_space_int_to_name): Update.
(make_type_with_address_space): Update.
(make_cv_type): Update.
(create_range_type): Update.
(get_discrete_bounds): Update.
(create_set_type): Update.
(make_vector_type): Update.
(smash_to_method_type): Update.
(check_typedef): Update.
(check_stub_method): Update.
(init_type): Individually assign flag fields.
(recursive_dump_type): Don't print entire TYPE_FLAGS field. Do
print TYPE_FIXED_INSTANCE, TYPE_STUB_SUPPORTED, and TYPE_NOTTEXT.
(copy_type_recursive): Copy the entire main type. Don't use
TYPE_FLAGS.
* features/rs6000/powerpc-altivec64l.c
(initialize_tdesc_powerpc_altivec64l): Update.
* features/rs6000/powerpc-altivec64.c
(initialize_tdesc_powerpc_altivec64): Update.
* features/rs6000/powerpc-altivec32l.c
(initialize_tdesc_powerpc_altivec32l): Update.
* features/rs6000/powerpc-altivec32.c
(initialize_tdesc_powerpc_altivec32): Update.
* features/rs6000/powerpc-7400.c (initialize_tdesc_powerpc_7400):
Update.
* features/arm-with-iwmmxt.c (initialize_tdesc_arm_with_iwmmxt):
Update.
* dwarf2read.c (read_structure_type): Update.
(read_enumeration_type): Likewise.
(process_enumeration_scope): Likewise.
(read_tag_pointer_type): Likewise.
(read_subroutine_type): Likewise.
(read_subroutine_type): Likewise.
(read_base_type): Likewise.
* coffread.c (coff_read_enum_type): Update.
* ada-valprint.c (adjust_type_signedness): Update.
* ada-typeprint.c (print_record_field_types): Update.
* ada-lang.c (packed_array_type): Update.
(empty_record): Don't reset TYPE_FLAGS.
(ada_template_to_fixed_record_type_1): Update.
(ada_template_to_fixed_record_type_1): Likewise.
(template_to_static_fixed_type): Likewise.
(to_record_with_fixed_variant_part): Likewise.
(to_fixed_record_type): Likewise.
(to_fixed_array_type): Likewise.
(to_static_fixed_type): Likewise.
gdb/testsuite:
* gdb.base/maint.exp: Update "maint print type".
2008-08-24 16:39:57 +00:00
|
|
|
|
if (len == 0 && TYPE_STUB (type))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i += 1)
|
|
|
|
|
{
|
|
|
|
|
QUIT;
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
;
|
|
|
|
|
else if (ada_is_wrapper_field (type, i))
|
|
|
|
|
flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
|
|
|
|
|
stream, show, level);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else if (ada_is_variant_part (type, i))
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
print_variant_part (type, i, outer_type, stream, show, level);
|
|
|
|
|
flds = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
flds += 1;
|
|
|
|
|
fprintf_filtered (stream, "\n%*s", level + 4, "");
|
|
|
|
|
ada_print_type (TYPE_FIELD_TYPE (type, i),
|
|
|
|
|
TYPE_FIELD_NAME (type, i),
|
|
|
|
|
stream, show - 1, level + 4);
|
|
|
|
|
fprintf_filtered (stream, ";");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return flds;
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
/* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
|
|
|
|
|
level, in case the element type itself has nested structure, and SHOW is
|
|
|
|
|
the number of levels of internal structure to show (see ada_print_type). */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_record_type (struct type *type0, struct ui_file *stream, int show,
|
|
|
|
|
int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
struct type *parent_type;
|
|
|
|
|
struct type *type;
|
|
|
|
|
|
2004-06-02 09:55:36 +00:00
|
|
|
|
type = ada_find_parallel_type (type0, "___XVE");
|
|
|
|
|
if (type == NULL)
|
|
|
|
|
type = type0;
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
parent_type = ada_parent_type (type);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (ada_type_name (parent_type) != NULL)
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "new %s with record",
|
2004-06-02 09:55:36 +00:00
|
|
|
|
decoded_type_name (parent_type));
|
|
|
|
|
else if (parent_type == NULL && ada_is_tagged_type (type, 0))
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "tagged record");
|
|
|
|
|
else
|
|
|
|
|
fprintf_filtered (stream, "record");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (show < 0)
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, " ... end record");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int flds;
|
|
|
|
|
|
|
|
|
|
flds = 0;
|
|
|
|
|
if (parent_type != NULL && ada_type_name (parent_type) == NULL)
|
2002-08-18 18:11:12 +00:00
|
|
|
|
flds += print_record_field_types (parent_type, parent_type,
|
2002-06-04 15:28:49 +00:00
|
|
|
|
stream, show, level);
|
|
|
|
|
flds += print_record_field_types (type, type, stream, show, level);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
|
2002-06-04 15:28:49 +00:00
|
|
|
|
if (flds > 0)
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "\n%*send record", level, "");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else if (flds < 0)
|
2004-12-12 17:06:26 +00:00
|
|
|
|
fprintf_filtered (stream, _(" <incomplete type> end record"));
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, " null; end record");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print the unchecked union type TYPE in something resembling Ada
|
2004-06-02 09:55:36 +00:00
|
|
|
|
format on STREAM. LEVEL is the recursion (indentation) level
|
2002-06-04 15:28:49 +00:00
|
|
|
|
in case the element type itself has nested structure, and SHOW is the
|
2004-06-02 09:55:36 +00:00
|
|
|
|
number of levels of internal structure to show (see ada_print_type). */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_unchecked_union_type (struct type *type, struct ui_file *stream,
|
2002-06-04 15:28:49 +00:00
|
|
|
|
int show, int level)
|
|
|
|
|
{
|
|
|
|
|
if (show < 0)
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "record (?) is ... end record");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else if (TYPE_NFIELDS (type) == 0)
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "record (?) is null; end record");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
for (i = 0; i < TYPE_NFIELDS (type); i += 1)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
level + 12, "");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
ada_print_type (TYPE_FIELD_TYPE (type, i),
|
|
|
|
|
TYPE_FIELD_NAME (type, i),
|
|
|
|
|
stream, show - 1, level + 12);
|
|
|
|
|
fprintf_filtered (stream, ";");
|
|
|
|
|
}
|
|
|
|
|
|
2004-12-21 10:03:55 +00:00
|
|
|
|
fprintf_filtered (stream, "\n%*send case;\n%*send record",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
level + 4, "", level, "");
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2002-08-18 18:11:12 +00:00
|
|
|
|
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Print function or procedure type TYPE on STREAM. Make it a header
|
2004-06-02 09:55:36 +00:00
|
|
|
|
for function or procedure NAME if NAME is not null. */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_func_type (struct type *type, struct ui_file *stream, char *name)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
int i, len = TYPE_NFIELDS (type);
|
|
|
|
|
|
|
|
|
|
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
|
|
|
|
|
fprintf_filtered (stream, "procedure");
|
|
|
|
|
else
|
|
|
|
|
fprintf_filtered (stream, "function");
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (name != NULL && name[0] != '\0')
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, " %s", name);
|
|
|
|
|
|
2002-08-18 18:11:12 +00:00
|
|
|
|
if (len > 0)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, " (");
|
|
|
|
|
for (i = 0; i < len; i += 1)
|
|
|
|
|
{
|
|
|
|
|
if (i > 0)
|
|
|
|
|
{
|
|
|
|
|
fputs_filtered ("; ", stream);
|
|
|
|
|
wrap_here (" ");
|
|
|
|
|
}
|
2002-08-18 18:11:12 +00:00
|
|
|
|
fprintf_filtered (stream, "a%d: ", i + 1);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
|
|
|
|
|
}
|
|
|
|
|
fprintf_filtered (stream, ")");
|
2002-08-18 18:11:12 +00:00
|
|
|
|
}
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, " return ");
|
|
|
|
|
ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Print a description of a type TYPE0.
|
|
|
|
|
Output goes to STREAM (via stdio).
|
|
|
|
|
If VARSTRING is a non-empty string, print as an Ada variable/field
|
|
|
|
|
declaration.
|
2004-06-02 09:55:36 +00:00
|
|
|
|
SHOW+1 is the maximum number of levels of internal type structure
|
2002-06-04 15:28:49 +00:00
|
|
|
|
to show (this applies to record types, enumerated types, and
|
|
|
|
|
array types).
|
|
|
|
|
SHOW is the number of levels of internal type structure to show
|
2004-06-02 09:55:36 +00:00
|
|
|
|
when there is a type name for the SHOWth deepest level (0th is
|
2002-06-04 15:28:49 +00:00
|
|
|
|
outer level).
|
|
|
|
|
When SHOW<0, no inner structure is shown.
|
2004-06-02 09:55:36 +00:00
|
|
|
|
LEVEL indicates level of recursion (for nested definitions). */
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
void
|
2002-08-18 18:11:12 +00:00
|
|
|
|
ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
|
2002-07-25 01:14:26 +00:00
|
|
|
|
int show, int level)
|
2002-06-04 15:28:49 +00:00
|
|
|
|
{
|
2004-10-08 09:40:12 +00:00
|
|
|
|
struct type *type = ada_check_typedef (ada_get_base_type (type0));
|
2008-01-03 13:11:51 +00:00
|
|
|
|
char *type_name = decoded_type_name (type0);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
int is_var_decl = (varstring != NULL && varstring[0] != '\0');
|
|
|
|
|
|
|
|
|
|
if (type == NULL)
|
|
|
|
|
{
|
|
|
|
|
if (is_var_decl)
|
|
|
|
|
fprintf_filtered (stream, "%.*s: ",
|
2002-08-18 18:11:12 +00:00
|
|
|
|
ada_name_prefix_len (varstring), varstring);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
fprintf_filtered (stream, "<null type?>");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (show > 0)
|
2004-10-08 09:40:12 +00:00
|
|
|
|
type = ada_check_typedef (type);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
|
2002-08-18 18:11:12 +00:00
|
|
|
|
fprintf_filtered (stream, "%.*s: ",
|
|
|
|
|
ada_name_prefix_len (varstring), varstring);
|
2002-06-04 15:28:49 +00:00
|
|
|
|
|
|
|
|
|
if (type_name != NULL && show <= 0)
|
|
|
|
|
{
|
2002-08-18 18:11:12 +00:00
|
|
|
|
fprintf_filtered (stream, "%.*s",
|
2002-06-04 15:28:49 +00:00
|
|
|
|
ada_name_prefix_len (type_name), type_name);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ada_is_aligner_type (type))
|
|
|
|
|
ada_print_type (ada_aligned_type (type), "", stream, show, level);
|
|
|
|
|
else if (ada_is_packed_array_type (type))
|
2008-01-04 20:45:05 +00:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_PTR)
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "access ");
|
|
|
|
|
print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
print_array_type (type, stream, show, level);
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-06-04 15:28:49 +00:00
|
|
|
|
else
|
2002-08-18 18:11:12 +00:00
|
|
|
|
switch (TYPE_CODE (type))
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
fprintf_filtered (stream, "<");
|
|
|
|
|
c_print_type (type, "", stream, show, level);
|
|
|
|
|
fprintf_filtered (stream, ">");
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_PTR:
|
|
|
|
|
fprintf_filtered (stream, "access ");
|
|
|
|
|
ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_REF:
|
|
|
|
|
fprintf_filtered (stream, "<ref> ");
|
|
|
|
|
ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_ARRAY:
|
2002-06-04 15:28:49 +00:00
|
|
|
|
print_array_type (type, stream, show, level);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
break;
|
2008-08-19 10:10:39 +00:00
|
|
|
|
case TYPE_CODE_BOOL:
|
|
|
|
|
fprintf_filtered (stream, "(false, true)");
|
|
|
|
|
break;
|
2002-08-18 18:11:12 +00:00
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
if (ada_is_fixed_point_type (type))
|
|
|
|
|
print_fixed_point_type (type, stream);
|
|
|
|
|
else if (ada_is_vax_floating_type (type))
|
|
|
|
|
print_vax_floating_point_type (type, stream);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *name = ada_type_name (type);
|
|
|
|
|
if (!ada_is_range_type_name (name))
|
2006-01-08 07:19:40 +00:00
|
|
|
|
fprintf_filtered (stream, _("<%d-byte integer>"),
|
2002-08-18 18:11:12 +00:00
|
|
|
|
TYPE_LENGTH (type));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "range ");
|
2009-06-29 17:28:59 +00:00
|
|
|
|
print_range_type_named (name, type, stream);
|
2002-08-18 18:11:12 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_RANGE:
|
|
|
|
|
if (ada_is_fixed_point_type (type))
|
|
|
|
|
print_fixed_point_type (type, stream);
|
|
|
|
|
else if (ada_is_vax_floating_type (type))
|
|
|
|
|
print_vax_floating_point_type (type, stream);
|
|
|
|
|
else if (ada_is_modular_type (type))
|
2006-01-02 09:39:21 +00:00
|
|
|
|
fprintf_filtered (stream, "mod %s",
|
|
|
|
|
int_string (ada_modulus (type), 10, 0, 0, 1));
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (stream, "range ");
|
|
|
|
|
print_range (type, stream);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_FLT:
|
2006-01-08 07:19:40 +00:00
|
|
|
|
fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
|
2002-08-18 18:11:12 +00:00
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
if (show < 0)
|
|
|
|
|
fprintf_filtered (stream, "(...)");
|
|
|
|
|
else
|
|
|
|
|
print_enum_type (type, stream);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_STRUCT:
|
2004-06-02 09:55:36 +00:00
|
|
|
|
if (ada_is_array_descriptor_type (type))
|
2002-08-18 18:11:12 +00:00
|
|
|
|
print_array_type (type, stream, show, level);
|
|
|
|
|
else if (ada_is_bogus_array_descriptor (type))
|
|
|
|
|
fprintf_filtered (stream,
|
2006-01-08 07:19:40 +00:00
|
|
|
|
_("array (?) of ? (<mal-formed descriptor>)"));
|
2002-08-18 18:11:12 +00:00
|
|
|
|
else
|
|
|
|
|
print_record_type (type, stream, show, level);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
print_unchecked_union_type (type, stream, show, level);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_FUNC:
|
|
|
|
|
print_func_type (type, stream, varstring);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2002-06-04 15:28:49 +00:00
|
|
|
|
}
|