FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2010-05-18 Michael Snyder <msnyder@vmware.com>

Browse source 
* ada-lang.c: White space.
	* ada-typeprint.c: White space.
	* ada-valprint.c: White space.
	* addrmap.c: White space.
	* auxv.c: White space.
	* ax-gdb.c: White space.
This commit is contained in:
Michael Snyder 2010-05-18 19:23:37 +00:00
parent e1e82ea4dc
commit 5b4ee69b43
7 changed files with 166 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

9
gdb/ChangeLog
View file

@ -1,3 +1,12 @@
2010-05-18 Michael Snyder <msnyder@vmware.com>
* ada-lang.c: White space.
* ada-typeprint.c: White space.
* ada-valprint.c: White space.
* addrmap.c: White space.
* auxv.c: White space.
* ax-gdb.c: White space.
2010-05-18 Hui Zhu <teawater@gmail.com> 2010-05-18 Hui Zhu <teawater@gmail.com>
* linux-fork.c (inferior_call_waitpid_cleanup): Add check * linux-fork.c (inferior_call_waitpid_cleanup): Add check

124
gdb/ada-lang.c
View file

@ -377,6 +377,7 @@ static int
field_name_match (const char *field_name, const char *target) field_name_match (const char *field_name, const char *target)
{ {
int len = strlen (target); int len = strlen (target);
return return
(strncmp (field_name, target, len) == 0 (strncmp (field_name, target, len) == 0
&& (field_name[len] == '\0' && (field_name[len] == '\0'
@ -422,6 +423,7 @@ ada_name_prefix_len (const char *name)
else else
{ {
const char *p = strstr (name, "___"); const char *p = strstr (name, "___");
if (p == NULL) if (p == NULL)
return strlen (name); return strlen (name);
else else
@ -436,6 +438,7 @@ static int
is_suffix (const char *str, const char *suffix) is_suffix (const char *str, const char *suffix)
{ {
int len1, len2; int len1, len2;
if (str == NULL) if (str == NULL)
return 0; return 0;
len1 = strlen (str); len1 = strlen (str);
@ -506,8 +509,8 @@ static void
lim_warning (const char *format, ...) lim_warning (const char *format, ...)
{ {
va_list args; va_list args;
va_start (args, format);
va_start (args, format);
warnings_issued += 1; warnings_issued += 1;
if (warnings_issued <= warning_limit) if (warnings_issued <= warning_limit)
vwarning (format, args); vwarning (format, args);
@ -531,6 +534,7 @@ static LONGEST
max_of_size (int size) max_of_size (int size)
{ {
LONGEST top_bit = (LONGEST) 1 << (size * 8 - 2); LONGEST top_bit = (LONGEST) 1 << (size * 8 - 2);
return top_bit | (top_bit - 1); return top_bit | (top_bit - 1);
} }
@ -546,6 +550,7 @@ static ULONGEST
umax_of_size (int size) umax_of_size (int size)
{ {
ULONGEST top_bit = (ULONGEST) 1 << (size * 8 - 1); ULONGEST top_bit = (ULONGEST) 1 << (size * 8 - 1);
return top_bit | (top_bit - 1); return top_bit | (top_bit - 1);
} }
@ -781,6 +786,7 @@ ada_fold_name (const char *name)
else else
{ {
int i; int i;
for (i = 0; i <= len; i += 1) for (i = 0; i <= len; i += 1)
fold_buffer[i] = tolower (name[i]); fold_buffer[i] = tolower (name[i]);
} }
@ -811,6 +817,7 @@ ada_remove_trailing_digits (const char *encoded, int *len)
if (*len > 1 && isdigit (encoded[*len - 1])) if (*len > 1 && isdigit (encoded[*len - 1]))
{ {
int i = *len - 2; int i = *len - 2;
while (i > 0 && isdigit (encoded[i])) while (i > 0 && isdigit (encoded[i]))
i--; i--;
if (i >= 0 && encoded[i] == '.') if (i >= 0 && encoded[i] == '.')
@ -967,6 +974,7 @@ ada_decode (const char *encoded)
if (at_start_name && encoded[i] == 'O') if (at_start_name && encoded[i] == 'O')
{ {
int k; int k;
for (k = 0; ada_opname_table[k].encoded != NULL; k += 1) for (k = 0; ada_opname_table[k].encoded != NULL; k += 1)
{ {
int op_len = strlen (ada_opname_table[k].encoded); int op_len = strlen (ada_opname_table[k].encoded);
@ -1143,12 +1151,15 @@ ada_decode_symbol (const struct general_symbol_info *gsymbol)
{ {
char **resultp = char **resultp =
(char **) &gsymbol->language_specific.cplus_specific.demangled_name; (char **) &gsymbol->language_specific.cplus_specific.demangled_name;
if (*resultp == NULL) if (*resultp == NULL)
{ {
const char *decoded = ada_decode (gsymbol->name); const char *decoded = ada_decode (gsymbol->name);
if (gsymbol->obj_section != NULL) if (gsymbol->obj_section != NULL)
{ {
struct objfile *objf = gsymbol->obj_section->objfile; struct objfile *objf = gsymbol->obj_section->objfile;
*resultp = obsavestring (decoded, strlen (decoded), *resultp = obsavestring (decoded, strlen (decoded),
&objf->objfile_obstack); &objf->objfile_obstack);
} }
@ -1160,6 +1171,7 @@ ada_decode_symbol (const struct general_symbol_info *gsymbol)
{ {
char **slot = (char **) htab_find_slot (decoded_names_store, char **slot = (char **) htab_find_slot (decoded_names_store,
decoded, INSERT); decoded, INSERT);
if (*slot == NULL) if (*slot == NULL)
*slot = xstrdup (decoded); *slot = xstrdup (decoded);
*resultp = *slot; *resultp = *slot;
@ -1192,6 +1204,7 @@ ada_match_name (const char *sym_name, const char *name, int wild)
else else
{ {
int len_name = strlen (name); int len_name = strlen (name);
return (strncmp (sym_name, name, len_name) == 0 return (strncmp (sym_name, name, len_name) == 0
&& is_name_suffix (sym_name + len_name)) && is_name_suffix (sym_name + len_name))
|| (strncmp (sym_name, "_ada_", 5) == 0 || (strncmp (sym_name, "_ada_", 5) == 0
@ -1315,6 +1328,7 @@ static struct type *
thin_descriptor_type (struct type *type) thin_descriptor_type (struct type *type)
{ {
struct type *base_type = desc_base_type (type); struct type *base_type = desc_base_type (type);
if (base_type == NULL) if (base_type == NULL)
return NULL; return NULL;
if (is_suffix (ada_type_name (base_type), "___XVE")) if (is_suffix (ada_type_name (base_type), "___XVE"))
@ -1322,6 +1336,7 @@ thin_descriptor_type (struct type *type)
else else
{ {
struct type *alt_type = ada_find_parallel_type (base_type, "___XVE"); struct type *alt_type = ada_find_parallel_type (base_type, "___XVE");
if (alt_type == NULL) if (alt_type == NULL)
return base_type; return base_type;
else else
@ -1336,6 +1351,7 @@ thin_data_pntr (struct value *val)
{ {
struct type *type = value_type (val); struct type *type = value_type (val);
struct type *data_type = desc_data_target_type (thin_descriptor_type (type)); struct type *data_type = desc_data_target_type (thin_descriptor_type (type));
data_type = lookup_pointer_type (data_type); data_type = lookup_pointer_type (data_type);
if (TYPE_CODE (type) == TYPE_CODE_PTR) if (TYPE_CODE (type) == TYPE_CODE_PTR)
@ -1391,6 +1407,7 @@ static struct value *
desc_bounds (struct value *arr) desc_bounds (struct value *arr)
{ {
struct type *type = ada_check_typedef (value_type (arr)); struct type *type = ada_check_typedef (value_type (arr));
if (is_thin_pntr (type)) if (is_thin_pntr (type))
{ {
struct type *bounds_type = struct type *bounds_type =
@ -1475,6 +1492,7 @@ static struct value *
desc_data (struct value *arr) desc_data (struct value *arr)
{ {
struct type *type = value_type (arr); struct type *type = value_type (arr);
if (is_thin_pntr (type)) if (is_thin_pntr (type))
return thin_data_pntr (arr); return thin_data_pntr (arr);
else if (is_thick_pntr (type)) else if (is_thick_pntr (type))
@ -1691,8 +1709,8 @@ ada_type_of_array (struct value *arr, int bounds)
struct type *array_type = alloc_type_copy (value_type (arr)); struct type *array_type = alloc_type_copy (value_type (arr));
struct value *low = desc_one_bound (descriptor, arity, 0); struct value *low = desc_one_bound (descriptor, arity, 0);
struct value *high = desc_one_bound (descriptor, arity, 1); struct value *high = desc_one_bound (descriptor, arity, 1);
arity -= 1;
arity -= 1;
create_range_type (range_type, value_type (low), create_range_type (range_type, value_type (low),
longest_to_int (value_as_long (low)), longest_to_int (value_as_long (low)),
longest_to_int (value_as_long (high))); longest_to_int (value_as_long (high)));
@ -1718,6 +1736,7 @@ ada_coerce_to_simple_array_ptr (struct value *arr)
if (ada_is_array_descriptor_type (value_type (arr))) if (ada_is_array_descriptor_type (value_type (arr)))
{ {
struct type *arrType = ada_type_of_array (arr, 1); struct type *arrType = ada_type_of_array (arr, 1);
if (arrType == NULL) if (arrType == NULL)
return NULL; return NULL;
return value_cast (arrType, value_copy (desc_data (arr))); return value_cast (arrType, value_copy (desc_data (arr)));
@ -1738,6 +1757,7 @@ ada_coerce_to_simple_array (struct value *arr)
if (ada_is_array_descriptor_type (value_type (arr))) if (ada_is_array_descriptor_type (value_type (arr)))
{ {
struct value *arrVal = ada_coerce_to_simple_array_ptr (arr); struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
if (arrVal == NULL) if (arrVal == NULL)
error (_("Bounds unavailable for null array pointer.")); error (_("Bounds unavailable for null array pointer."));
check_size (TYPE_TARGET_TYPE (value_type (arrVal))); check_size (TYPE_TARGET_TYPE (value_type (arrVal)));
@ -2093,6 +2113,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
if (obj != NULL) if (obj != NULL)
{ {
CORE_ADDR new_addr; CORE_ADDR new_addr;
set_value_component_location (v, obj); set_value_component_location (v, obj);
new_addr = value_address (obj) + offset; new_addr = value_address (obj) + offset;
set_value_bitpos (v, bit_offset + value_bitpos (obj)); set_value_bitpos (v, bit_offset + value_bitpos (obj));
@ -2169,6 +2190,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
1; 1;
/* Sign-extend bits for this byte. */ /* Sign-extend bits for this byte. */
unsigned int signMask = sign & ~unusedMSMask; unsigned int signMask = sign & ~unusedMSMask;
accum |= accum |=
(((bytes[src] >> unusedLS) & unusedMSMask) | signMask) << accumSize; (((bytes[src] >> unusedLS) & unusedMSMask) | signMask) << accumSize;
accumSize += HOST_CHAR_BIT - unusedLS; accumSize += HOST_CHAR_BIT - unusedLS;
@ -2221,6 +2243,7 @@ move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
while (n > 0) while (n > 0)
{ {
int unused_right; int unused_right;
accum = (accum << HOST_CHAR_BIT) + (unsigned char) *source; accum = (accum << HOST_CHAR_BIT) + (unsigned char) *source;
accum_bits += HOST_CHAR_BIT; accum_bits += HOST_CHAR_BIT;
source += 1; source += 1;
@ -2428,6 +2451,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
low, high); low, high);
struct type *slice_type = struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type); create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
return value_at_lazy (slice_type, base); return value_at_lazy (slice_type, base);
} }
@ -2440,6 +2464,7 @@ ada_value_slice (struct value *array, int low, int high)
create_range_type (NULL, TYPE_INDEX_TYPE (type), low, high); create_range_type (NULL, TYPE_INDEX_TYPE (type), low, high);
struct type *slice_type = struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type); create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
return value_cast (slice_type, value_slice (array, low, high - low + 1)); return value_cast (slice_type, value_slice (array, low, high - low + 1));
} }
@ -2647,6 +2672,7 @@ empty_array (struct type *arr_type, int low)
create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (arr_type)), create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (arr_type)),
low, low - 1); low, low - 1);
struct type *elt_type = ada_array_element_type (arr_type, 1); struct type *elt_type = ada_array_element_type (arr_type, 1);
return allocate_value (create_array_type (NULL, elt_type, index_type)); return allocate_value (create_array_type (NULL, elt_type, index_type));
} }
@ -3131,7 +3157,8 @@ ada_args_match (struct symbol *func, struct value **actuals, int n_actuals)
return 0; return 0;
else else
{ {
struct type *ftype = ada_check_typedef (TYPE_FIELD_TYPE (func_type, i)); struct type *ftype = ada_check_typedef (TYPE_FIELD_TYPE (func_type,
i));
struct type *atype = ada_check_typedef (value_type (actuals[i])); struct type *atype = ada_check_typedef (value_type (actuals[i]));
if (!ada_type_match (ftype, atype, 1)) if (!ada_type_match (ftype, atype, 1))
@ -3239,6 +3266,7 @@ encoded_ordered_before (char *N0, char *N1)
else else
{ {
int k0, k1; int k0, k1;
for (k0 = strlen (N0) - 1; k0 > 0 && isdigit (N0[k0]); k0 -= 1) for (k0 = strlen (N0) - 1; k0 > 0 && isdigit (N0[k0]); k0 -= 1)
; ;
for (k1 = strlen (N1) - 1; k1 > 0 && isdigit (N1[k1]); k1 -= 1) for (k1 = strlen (N1) - 1; k1 > 0 && isdigit (N1[k1]); k1 -= 1)
@ -3247,6 +3275,7 @@ encoded_ordered_before (char *N0, char *N1)
&& (N1[k1] == '_' || N1[k1] == '$') && N1[k1 + 1] != '\000') && (N1[k1] == '_' || N1[k1] == '$') && N1[k1 + 1] != '\000')
{ {
int n0, n1; int n0, n1;
n0 = k0; n0 = k0;
while (N0[n0] == '_' && n0 > 0 && N0[n0 - 1] == '_') while (N0[n0] == '_' && n0 > 0 && N0[n0 - 1] == '_')
n0 -= 1; n0 -= 1;
@ -3267,6 +3296,7 @@ static void
sort_choices (struct ada_symbol_info syms[], int nsyms) sort_choices (struct ada_symbol_info syms[], int nsyms)
{ {
int i; int i;
for (i = 1; i < nsyms; i += 1) for (i = 1; i < nsyms; i += 1)
{ {
struct ada_symbol_info sym = syms[i]; struct ada_symbol_info sym = syms[i];
@ -3331,6 +3361,7 @@ See set/show multiple-symbol."));
{ {
struct symtab_and_line sal = struct symtab_and_line sal =
find_function_start_sal (syms[i].sym, 1); find_function_start_sal (syms[i].sym, 1);
if (sal.symtab == NULL) if (sal.symtab == NULL)
printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"), printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"),
i + first_choice, i + first_choice,
@ -3464,6 +3495,7 @@ get_selections (int *choices, int n_choices, int max_results,
if (j < 0 || choice != choices[j]) if (j < 0 || choice != choices[j])
{ {
int k; int k;
for (k = n_chosen - 1; k > j; k -= 1) for (k = n_chosen - 1; k > j; k -= 1)
choices[k + 1] = choices[k]; choices[k + 1] = choices[k];
choices[j + 1] = choice; choices[j + 1] = choice;
@ -3883,6 +3915,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0,
|| TYPE_CODE (formal_type) == TYPE_CODE_REF) || TYPE_CODE (formal_type) == TYPE_CODE_REF)
{ {
struct value *result; struct value *result;
if (TYPE_CODE (formal_target) == TYPE_CODE_ARRAY if (TYPE_CODE (formal_target) == TYPE_CODE_ARRAY
&& ada_is_array_descriptor_type (actual_target)) && ada_is_array_descriptor_type (actual_target))
result = desc_data (actual); result = desc_data (actual);
@ -3891,6 +3924,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0,
if (VALUE_LVAL (actual) != lval_memory) if (VALUE_LVAL (actual) != lval_memory)
{ {
struct value *val; struct value *val;
actual_type = ada_check_typedef (value_type (actual)); actual_type = ada_check_typedef (value_type (actual));
val = allocate_value (actual_type); val = allocate_value (actual_type);
memcpy ((char *) value_contents_raw (val), memcpy ((char *) value_contents_raw (val),
@ -4079,6 +4113,7 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
char *name0 = SYMBOL_LINKAGE_NAME (sym0); char *name0 = SYMBOL_LINKAGE_NAME (sym0);
char *name1 = SYMBOL_LINKAGE_NAME (sym1); char *name1 = SYMBOL_LINKAGE_NAME (sym1);
int len0 = strlen (name0); int len0 = strlen (name0);
return return
TYPE_CODE (type0) == TYPE_CODE (type1) TYPE_CODE (type0) == TYPE_CODE (type1)
&& (equiv_types (type0, type1) && (equiv_types (type0, type1)
@ -4206,6 +4241,7 @@ static int
is_nondebugging_type (struct type *type) is_nondebugging_type (struct type *type)
{ {
char *name = ada_type_name (type); char *name = ada_type_name (type);
return (name != NULL && strcmp (name, "<variable, no debug info>") == 0); return (name != NULL && strcmp (name, "<variable, no debug info>") == 0);
} }
@ -4441,6 +4477,7 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,
{ {
int name_len = suffix - name; int name_len = suffix - name;
int j; int j;
is_new_style_renaming = 1; is_new_style_renaming = 1;
for (j = 0; j < nsyms; j += 1) for (j = 0; j < nsyms; j += 1)
if (i != j && syms[j].sym != NULL if (i != j && syms[j].sym != NULL
@ -4489,6 +4526,7 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms,
&& old_renaming_is_invisible (syms[i].sym, current_function_name)) && old_renaming_is_invisible (syms[i].sym, current_function_name))
{ {
int j; int j;
for (j = i + 1; j < nsyms; j += 1) for (j = i + 1; j < nsyms; j += 1)
syms[j - 1] = syms[j]; syms[j - 1] = syms[j];
nsyms -= 1; nsyms -= 1;
@ -4553,6 +4591,7 @@ ada_add_psyms (struct objfile *objfile, struct symtab *s, void *user_data)
{ {
struct ada_psym_data *data = user_data; struct ada_psym_data *data = user_data;
const int block_kind = data->global ? GLOBAL_BLOCK : STATIC_BLOCK; const int block_kind = data->global ? GLOBAL_BLOCK : STATIC_BLOCK;
ada_add_block_symbols (data->obstackp, ada_add_block_symbols (data->obstackp,
BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind), BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind),
data->name, data->domain, objfile, data->wild_match); data->name, data->domain, objfile, data->wild_match);
@ -4905,6 +4944,7 @@ wild_match (const char *patn0, int patn_len, const char *name0)
{ {
char* match; char* match;
const char* start; const char* start;
start = name0; start = name0;
while (1) while (1)
{ {
@ -4946,6 +4986,7 @@ ada_add_block_symbols (struct obstack *obstackp,
if (wild) if (wild)
{ {
struct symbol *sym; struct symbol *sym;
ALL_BLOCK_SYMBOLS (block, iter, sym) ALL_BLOCK_SYMBOLS (block, iter, sym)
{ {
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
@ -4974,6 +5015,7 @@ ada_add_block_symbols (struct obstack *obstackp,
SYMBOL_DOMAIN (sym), domain)) SYMBOL_DOMAIN (sym), domain))
{ {
int cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym), name_len); int cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym), name_len);
if (cmp == 0 if (cmp == 0
&& is_name_suffix (SYMBOL_LINKAGE_NAME (sym) + name_len)) && is_name_suffix (SYMBOL_LINKAGE_NAME (sym) + name_len))
{ {
@ -5215,6 +5257,7 @@ static void
ada_add_partial_symbol_completions (const char *name, void *user_data) ada_add_partial_symbol_completions (const char *name, void *user_data)
{ {
struct add_partial_datum *data = user_data; struct add_partial_datum *data = user_data;
symbol_completion_add (data->completions, name, symbol_completion_add (data->completions, name,
data->text, data->text_len, data->text0, data->word, data->text, data->text_len, data->text0, data->word,
data->wild_match, data->encoded); data->wild_match, data->encoded);
@ -5429,6 +5472,7 @@ ada_is_tag_type (struct type *type)
else else
{ {
const char *name = ada_type_name (TYPE_TARGET_TYPE (type)); const char *name = ada_type_name (TYPE_TARGET_TYPE (type));
return (name != NULL return (name != NULL
&& strcmp (name, "ada__tags__dispatch_table") == 0); && strcmp (name, "ada__tags__dispatch_table") == 0);
} }
@ -5461,6 +5505,7 @@ value_tag_from_contents_and_address (struct type *type,
{ {
int tag_byte_offset; int tag_byte_offset;
struct type *tag_type; struct type *tag_type;
if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset, if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
NULL, NULL, NULL)) NULL, NULL, NULL))
{ {
@ -5478,6 +5523,7 @@ static struct type *
type_from_tag (struct value *tag) type_from_tag (struct value *tag)
{ {
const char *type_name = ada_tag_name (tag); const char *type_name = ada_tag_name (tag);
if (type_name != NULL) if (type_name != NULL)
return ada_find_any_type (ada_encode (type_name)); return ada_find_any_type (ada_encode (type_name));
return NULL; return NULL;
@ -5505,6 +5551,7 @@ ada_tag_name_1 (void *args0)
static char name[1024]; static char name[1024];
char *p; char *p;
struct value *val; struct value *val;
args->name = NULL; args->name = NULL;
val = ada_value_struct_elt (args->tag, "tsd", 1); val = ada_value_struct_elt (args->tag, "tsd", 1);
if (val == NULL) if (val == NULL)
@ -5562,6 +5609,7 @@ const char *
ada_tag_name (struct value *tag) ada_tag_name (struct value *tag)
{ {
struct tag_args args; struct tag_args args;
if (!ada_is_tag_type (value_type (tag))) if (!ada_is_tag_type (value_type (tag)))
return NULL; return NULL;
args.tag = tag; args.tag = tag;
@ -5607,6 +5655,7 @@ int
ada_is_parent_field (struct type *type, int field_num) ada_is_parent_field (struct type *type, int field_num)
{ {
const char *name = TYPE_FIELD_NAME (ada_check_typedef (type), field_num); const char *name = TYPE_FIELD_NAME (ada_check_typedef (type), field_num);
return (name != NULL return (name != NULL
&& (strncmp (name, "PARENT", 6) == 0 && (strncmp (name, "PARENT", 6) == 0
|| strncmp (name, "_parent", 7) == 0)); || strncmp (name, "_parent", 7) == 0));
@ -5622,6 +5671,7 @@ int
ada_is_wrapper_field (struct type *type, int field_num) ada_is_wrapper_field (struct type *type, int field_num)
{ {
const char *name = TYPE_FIELD_NAME (type, field_num); const char *name = TYPE_FIELD_NAME (type, field_num);
return (name != NULL return (name != NULL
&& (strncmp (name, "PARENT", 6) == 0 && (strncmp (name, "PARENT", 6) == 0
|| strcmp (name, "REP") == 0 || strcmp (name, "REP") == 0
@ -5637,6 +5687,7 @@ int
ada_is_variant_part (struct type *type, int field_num) ada_is_variant_part (struct type *type, int field_num)
{ {
struct type *field_type = TYPE_FIELD_TYPE (type, field_num); struct type *field_type = TYPE_FIELD_TYPE (type, field_num);
return (TYPE_CODE (field_type) == TYPE_CODE_UNION return (TYPE_CODE (field_type) == TYPE_CODE_UNION
|| (is_dynamic_field (type, field_num) || (is_dynamic_field (type, field_num)
&& (TYPE_CODE (TYPE_TARGET_TYPE (field_type)) && (TYPE_CODE (TYPE_TARGET_TYPE (field_type))
@ -5652,6 +5703,7 @@ struct type *
ada_variant_discrim_type (struct type *var_type, struct type *outer_type) ada_variant_discrim_type (struct type *var_type, struct type *outer_type)
{ {
char *name = ada_variant_discrim_name (var_type); char *name = ada_variant_discrim_name (var_type);
return ada_lookup_struct_elt_type (outer_type, name, 1, 1, NULL); return ada_lookup_struct_elt_type (outer_type, name, 1, 1, NULL);
} }
@ -5663,6 +5715,7 @@ int
ada_is_others_clause (struct type *type, int field_num) ada_is_others_clause (struct type *type, int field_num)
{ {
const char *name = TYPE_FIELD_NAME (type, field_num); const char *name = TYPE_FIELD_NAME (type, field_num);
return (name != NULL && name[0] == 'O'); return (name != NULL && name[0] == 'O');
} }
@ -5782,6 +5835,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
case 'S': case 'S':
{ {
LONGEST W; LONGEST W;
if (!ada_scan_number (name, p + 1, &W, &p)) if (!ada_scan_number (name, p + 1, &W, &p))
return 0; return 0;
if (val == W) if (val == W)
@ -5791,6 +5845,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
case 'R': case 'R':
{ {
LONGEST L, U; LONGEST L, U;
if (!ada_scan_number (name, p + 1, &L, &p) if (!ada_scan_number (name, p + 1, &L, &p)
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p)) || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
return 0; return 0;
@ -5883,6 +5938,7 @@ find_struct_field (char *name, struct type *type, int offset,
else if (name != NULL && field_name_match (t_field_name, name)) else if (name != NULL && field_name_match (t_field_name, name))
{ {
int bit_size = TYPE_FIELD_BITSIZE (type, i); int bit_size = TYPE_FIELD_BITSIZE (type, i);
if (field_type_p != NULL) if (field_type_p != NULL)
*field_type_p = TYPE_FIELD_TYPE (type, i); *field_type_p = TYPE_FIELD_TYPE (type, i);
if (byte_offset_p != NULL) if (byte_offset_p != NULL)
@ -5930,6 +5986,7 @@ static int
num_visible_fields (struct type *type) num_visible_fields (struct type *type)
{ {
int n; int n;
n = 0; n = 0;
find_struct_field (NULL, type, 0, NULL, NULL, NULL, NULL, &n); find_struct_field (NULL, type, 0, NULL, NULL, NULL, NULL, &n);
return n; return n;
@ -5946,8 +6003,8 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
struct type *type) struct type *type)
{ {
int i; int i;
type = ada_check_typedef (type);
type = ada_check_typedef (type);
for (i = 0; i < TYPE_NFIELDS (type); i += 1) for (i = 0; i < TYPE_NFIELDS (type); i += 1)
{ {
char *t_field_name = TYPE_FIELD_NAME (type, i); char *t_field_name = TYPE_FIELD_NAME (type, i);
@ -5964,6 +6021,7 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
ada_search_struct_field (name, arg, ada_search_struct_field (name, arg,
offset + TYPE_FIELD_BITPOS (type, i) / 8, offset + TYPE_FIELD_BITPOS (type, i) / 8,
TYPE_FIELD_TYPE (type, i)); TYPE_FIELD_TYPE (type, i));
if (v != NULL) if (v != NULL)
return v; return v;
} }
@ -5972,7 +6030,8 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
{ {
/* PNH: Do we ever get here? See find_struct_field. */ /* PNH: Do we ever get here? See find_struct_field. */
int j; int j;
struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type, i)); struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
i));
int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8; int var_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
for (j = 0; j < TYPE_NFIELDS (field_type); j += 1) for (j = 0; j < TYPE_NFIELDS (field_type); j += 1)
@ -5981,6 +6040,7 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
(name, arg, (name, arg,
var_offset + TYPE_FIELD_BITPOS (field_type, j) / 8, var_offset + TYPE_FIELD_BITPOS (field_type, j) / 8,
TYPE_FIELD_TYPE (field_type, j)); TYPE_FIELD_TYPE (field_type, j));
if (v != NULL) if (v != NULL)
return v; return v;
} }
@ -6027,6 +6087,7 @@ ada_index_struct_field_1 (int *index_p, struct value *arg, int offset,
ada_index_struct_field_1 (index_p, arg, ada_index_struct_field_1 (index_p, arg,
offset + TYPE_FIELD_BITPOS (type, i) / 8, offset + TYPE_FIELD_BITPOS (type, i) / 8,
TYPE_FIELD_TYPE (type, i)); TYPE_FIELD_TYPE (type, i));
if (v != NULL) if (v != NULL)
return v; return v;
} }
@ -6233,7 +6294,8 @@ ada_lookup_struct_elt_type (struct type *type, char *name, int refok,
else if (ada_is_variant_part (type, i)) else if (ada_is_variant_part (type, i))
{ {
int j; int j;
struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type, i)); struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
i));
for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1) for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
{ {
@ -6294,6 +6356,7 @@ static int
is_unchecked_variant (struct type *var_type, struct type *outer_type) is_unchecked_variant (struct type *var_type, struct type *outer_type)
{ {
char *discrim_name = ada_variant_discrim_name (var_type); char *discrim_name = ada_variant_discrim_name (var_type);
return (ada_lookup_struct_elt_type (outer_type, discrim_name, 0, 1, NULL) return (ada_lookup_struct_elt_type (outer_type, discrim_name, 0, 1, NULL)
== NULL); == NULL);
} }
@ -6378,6 +6441,7 @@ struct value *
ada_value_ind (struct value *val0) ada_value_ind (struct value *val0)
{ {
struct value *val = unwrap_value (value_ind (val0)); struct value *val = unwrap_value (value_ind (val0));
return ada_to_fixed_value (val); return ada_to_fixed_value (val);
} }
@ -6390,6 +6454,7 @@ ada_coerce_ref (struct value *val0)
if (TYPE_CODE (value_type (val0)) == TYPE_CODE_REF) if (TYPE_CODE (value_type (val0)) == TYPE_CODE_REF)
{ {
struct value *val = val0; struct value *val = val0;
val = coerce_ref (val); val = coerce_ref (val);
val = unwrap_value (val); val = unwrap_value (val);
return ada_to_fixed_value (val); return ada_to_fixed_value (val);
@ -6537,6 +6602,7 @@ find_old_style_renaming_symbol (const char *name, struct block *block)
else else
{ {
const int rename_len = strlen (name) + 6; const int rename_len = strlen (name) + 6;
rename = (char *) alloca (rename_len * sizeof (char)); rename = (char *) alloca (rename_len * sizeof (char));
xsnprintf (rename, rename_len * sizeof (char), "%s___XR", name); xsnprintf (rename, rename_len * sizeof (char), "%s___XR", name);
} }
@ -6691,6 +6757,7 @@ dynamic_template_type (struct type *type)
else else
{ {
int len = strlen (ada_type_name (type)); int len = strlen (ada_type_name (type));
if (len > 6 && strcmp (ada_type_name (type) + len - 6, "___XVE") == 0) if (len > 6 && strcmp (ada_type_name (type) + len - 6, "___XVE") == 0)
return type; return type;
else else
@ -6705,6 +6772,7 @@ static int
is_dynamic_field (struct type *templ_type, int field_num) is_dynamic_field (struct type *templ_type, int field_num)
{ {
const char *name = TYPE_FIELD_NAME (templ_type, field_num); const char *name = TYPE_FIELD_NAME (templ_type, field_num);
return name != NULL return name != NULL
&& TYPE_CODE (TYPE_FIELD_TYPE (templ_type, field_num)) == TYPE_CODE_PTR && TYPE_CODE (TYPE_FIELD_TYPE (templ_type, field_num)) == TYPE_CODE_PTR
&& strstr (name, "___XVL") != NULL; && strstr (name, "___XVL") != NULL;
@ -6735,6 +6803,7 @@ static struct type *
empty_record (struct type *template) empty_record (struct type *template)
{ {
struct type *type = alloc_type_copy (template); struct type *type = alloc_type_copy (template);
TYPE_CODE (type) = TYPE_CODE_STRUCT; TYPE_CODE (type) = TYPE_CODE_STRUCT;
TYPE_NFIELDS (type) = 0; TYPE_NFIELDS (type) = 0;
TYPE_FIELDS (type) = NULL; TYPE_FIELDS (type) = NULL;
@ -7072,6 +7141,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
if (branch_type == NULL) if (branch_type == NULL)
{ {
int f; int f;
for (f = variant_field + 1; f < nfields; f += 1) for (f = variant_field + 1; f < nfields; f += 1)
TYPE_FIELDS (rtype)[f - 1] = TYPE_FIELDS (rtype)[f]; TYPE_FIELDS (rtype)[f - 1] = TYPE_FIELDS (rtype)[f];
TYPE_NFIELDS (rtype) -= 1; TYPE_NFIELDS (rtype) -= 1;
@ -7209,6 +7279,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
if (index_type_desc == NULL) if (index_type_desc == NULL)
{ {
struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0)); struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
/* NOTE: elt_type---the fixed version of elt_type0---should never /* NOTE: elt_type---the fixed version of elt_type0---should never
depend on the contents of the array in properly constructed depend on the contents of the array in properly constructed
debugging data. */ debugging data. */
@ -7259,6 +7330,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
{ {
struct type *range_type = struct type *range_type =
to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc, i), dval); to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc, i), dval);
result = create_array_type (alloc_type_copy (elt_type0), result = create_array_type (alloc_type_copy (elt_type0),
result, range_type); result, range_type);
elt_type0 = TYPE_TARGET_TYPE (elt_type0); elt_type0 = TYPE_TARGET_TYPE (elt_type0);
@ -7313,6 +7385,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
struct type *static_type = to_static_fixed_type (type); struct type *static_type = to_static_fixed_type (type);
struct type *fixed_record_type = struct type *fixed_record_type =
to_fixed_record_type (type, valaddr, address, NULL); to_fixed_record_type (type, valaddr, address, NULL);
/* If STATIC_TYPE is a tagged type and we know the object's address, /* If STATIC_TYPE is a tagged type and we know the object's address,
then we can determine its tag, and compute the object's actual then we can determine its tag, and compute the object's actual
type from there. Note that we have to use the fixed record type from there. Note that we have to use the fixed record
@ -7327,6 +7400,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
(fixed_record_type, (fixed_record_type,
valaddr, valaddr,
address)); address));
if (real_type != NULL) if (real_type != NULL)
return to_fixed_record_type (real_type, valaddr, address, NULL); return to_fixed_record_type (real_type, valaddr, address, NULL);
} }
@ -7452,6 +7526,7 @@ static_unwrap_type (struct type *type)
else else
{ {
struct type *raw_real_type = ada_get_base_type (type); struct type *raw_real_type = ada_get_base_type (type);
if (raw_real_type == type) if (raw_real_type == type)
return type; return type;
else else
@ -7488,6 +7563,7 @@ ada_check_typedef (struct type *type)
{ {
char *name = TYPE_TAG_NAME (type); char *name = TYPE_TAG_NAME (type);
struct type *type1 = ada_find_any_type (name); struct type *type1 = ada_find_any_type (name);
return (type1 == NULL) ? type : type1; return (type1 == NULL) ? type : type1;
} }
} }
@ -7503,6 +7579,7 @@ ada_to_fixed_value_create (struct type *type0, CORE_ADDR address,
struct value *val0) struct value *val0)
{ {
struct type *type = ada_to_fixed_type (type0, 0, address, NULL, 1); struct type *type = ada_to_fixed_type (type0, 0, address, NULL, 1);
if (type == type0 && val0 != NULL) if (type == type0 && val0 != NULL)
return val0; return val0;
else else
@ -7599,6 +7676,7 @@ value_val_atr (struct type *type, struct value *arg)
if (TYPE_CODE (type) == TYPE_CODE_ENUM) if (TYPE_CODE (type) == TYPE_CODE_ENUM)
{ {
long pos = value_as_long (arg); long pos = value_as_long (arg);
if (pos < 0 || pos >= TYPE_NFIELDS (type)) if (pos < 0 || pos >= TYPE_NFIELDS (type))
error (_("argument to 'VAL out of range")); error (_("argument to 'VAL out of range"));
return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos)); return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
@ -7797,6 +7875,7 @@ ada_enum_name (const char *name)
if (name[0] == 'Q') if (name[0] == 'Q')
{ {
int v; int v;
if (name[1] == 'U' || name[1] == 'W') if (name[1] == 'U' || name[1] == 'W')
{ {
if (sscanf (name + 2, "%x", &v) != 1) if (sscanf (name + 2, "%x", &v) != 1)
@ -7849,10 +7928,12 @@ static struct value *
unwrap_value (struct value *val) unwrap_value (struct value *val)
{ {
struct type *type = ada_check_typedef (value_type (val)); struct type *type = ada_check_typedef (value_type (val));
if (ada_is_aligner_type (type)) if (ada_is_aligner_type (type))
{ {
struct value *v = ada_value_struct_elt (val, "F", 0); struct value *v = ada_value_struct_elt (val, "F", 0);
struct type *val_type = ada_check_typedef (value_type (v)); struct type *val_type = ada_check_typedef (value_type (v));
if (ada_type_name (val_type) == NULL) if (ada_type_name (val_type) == NULL)
TYPE_NAME (val_type) = ada_type_name (type); TYPE_NAME (val_type) = ada_type_name (type);
@ -7891,6 +7972,7 @@ cast_to_fixed (struct type *type, struct value *arg)
else else
{ {
DOUBLEST argd = value_as_double (arg); DOUBLEST argd = value_as_double (arg);
val = ada_float_to_fixed (type, argd); val = ada_float_to_fixed (type, argd);
} }
@ -7902,6 +7984,7 @@ cast_from_fixed (struct type *type, struct value *arg)
{ {
DOUBLEST val = ada_fixed_to_float (value_type (arg), DOUBLEST val = ada_fixed_to_float (value_type (arg),
value_as_long (arg)); value_as_long (arg));
return value_from_double (type, val); return value_from_double (type, val);
} }
@ -7912,6 +7995,7 @@ static struct value *
coerce_for_assign (struct type *type, struct value *val) coerce_for_assign (struct type *type, struct value *val)
{ {
struct type *type2 = value_type (val); struct type *type2 = value_type (val);
if (type == type2) if (type == type2)
return val; return val;
@ -8030,6 +8114,7 @@ static int
num_component_specs (struct expression *exp, int pc) num_component_specs (struct expression *exp, int pc)
{ {
int n, m, i; int n, m, i;
m = exp->elts[pc + 1].longconst; m = exp->elts[pc + 1].longconst;
pc += 3; pc += 3;
n = 0; n = 0;
@ -8061,10 +8146,12 @@ assign_component (struct value *container, struct value *lhs, LONGEST index,
{ {
struct value *mark = value_mark (); struct value *mark = value_mark ();
struct value *elt; struct value *elt;
if (TYPE_CODE (value_type (lhs)) == TYPE_CODE_ARRAY) if (TYPE_CODE (value_type (lhs)) == TYPE_CODE_ARRAY)
{ {
struct type *index_type = builtin_type (exp->gdbarch)->builtin_int; struct type *index_type = builtin_type (exp->gdbarch)->builtin_int;
struct value *index_val = value_from_longest (index_type, index); struct value *index_val = value_from_longest (index_type, index);
elt = unwrap_value (ada_value_subscript (lhs, 1, &index_val)); elt = unwrap_value (ada_value_subscript (lhs, 1, &index_val));
} }
else else
@ -8109,6 +8196,7 @@ assign_aggregate (struct value *container,
if (noside != EVAL_NORMAL) if (noside != EVAL_NORMAL)
{ {
int i; int i;
for (i = 0; i < n; i += 1) for (i = 0; i < n; i += 1)
ada_evaluate_subexp (NULL, exp, pos, noside); ada_evaluate_subexp (NULL, exp, pos, noside);
return container; return container;
@ -8227,6 +8315,7 @@ aggregate_assign_from_choices (struct value *container,
{ {
LONGEST lower, upper; LONGEST lower, upper;
enum exp_opcode op = exp->elts[choice_pos].opcode; enum exp_opcode op = exp->elts[choice_pos].opcode;
if (op == OP_DISCRETE_RANGE) if (op == OP_DISCRETE_RANGE)
{ {
choice_pos += 1; choice_pos += 1;
@ -8245,6 +8334,7 @@ aggregate_assign_from_choices (struct value *container,
{ {
int ind; int ind;
char *name; char *name;
switch (op) switch (op)
{ {
case OP_NAME: case OP_NAME:
@ -8272,6 +8362,7 @@ aggregate_assign_from_choices (struct value *container,
while (lower <= upper) while (lower <= upper)
{ {
int pos1; int pos1;
pos1 = expr_pc; pos1 = expr_pc;
assign_component (container, lhs, lower, exp, &pos1); assign_component (container, lhs, lower, exp, &pos1);
lower += 1; lower += 1;
@ -8296,9 +8387,11 @@ aggregate_assign_others (struct value *container,
for (i = 0; i < num_indices - 2; i += 2) for (i = 0; i < num_indices - 2; i += 2)
{ {
LONGEST ind; LONGEST ind;
for (ind = indices[i + 1] + 1; ind < indices[i + 2]; ind += 1) for (ind = indices[i + 1] + 1; ind < indices[i + 2]; ind += 1)
{ {
int pos; int pos;
pos = expr_pc; pos = expr_pc;
assign_component (container, lhs, ind, exp, &pos); assign_component (container, lhs, ind, exp, &pos);
} }
@ -8315,10 +8408,12 @@ add_component_interval (LONGEST low, LONGEST high,
LONGEST* indices, int *size, int max_size) LONGEST* indices, int *size, int max_size)
{ {
int i, j; int i, j;
for (i = 0; i < *size; i += 2) { for (i = 0; i < *size; i += 2) {
if (high >= indices[i] && low <= indices[i + 1]) if (high >= indices[i] && low <= indices[i + 1])
{ {
int kh; int kh;
for (kh = i + 2; kh < *size; kh += 2) for (kh = i + 2; kh < *size; kh += 2)
if (high < indices[kh]) if (high < indices[kh])
break; break;
@ -8658,6 +8753,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
case OP_STRING: case OP_STRING:
{ {
struct value *result; struct value *result;
*pos -= 1; *pos -= 1;
result = evaluate_subexp_standard (expect_type, exp, pos, noside); result = evaluate_subexp_standard (expect_type, exp, pos, noside);
/* The result type will have code OP_STRING, bashed there from /* The result type will have code OP_STRING, bashed there from
@ -9025,6 +9121,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
evaluate_subexp (NULL_TYPE, exp, pos, noside); evaluate_subexp (NULL_TYPE, exp, pos, noside);
LONGEST low_bound; LONGEST low_bound;
LONGEST high_bound; LONGEST high_bound;
low_bound_val = coerce_ref (low_bound_val); low_bound_val = coerce_ref (low_bound_val);
high_bound_val = coerce_ref (high_bound_val); high_bound_val = coerce_ref (high_bound_val);
low_bound = pos_atr (low_bound_val); low_bound = pos_atr (low_bound_val);
@ -9081,6 +9178,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
struct type *arr_type0 = struct type *arr_type0 =
to_fixed_array_type (TYPE_TARGET_TYPE (value_type (array)), to_fixed_array_type (TYPE_TARGET_TYPE (value_type (array)),
NULL, 1); NULL, 1);
return ada_value_slice_from_ptr (array, arr_type0, return ada_value_slice_from_ptr (array, arr_type0,
longest_to_int (low_bound), longest_to_int (low_bound),
longest_to_int (high_bound)); longest_to_int (high_bound));
@ -9181,6 +9279,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
case OP_ATR_LENGTH: case OP_ATR_LENGTH:
{ {
struct type *type_arg; struct type *type_arg;
if (exp->elts[*pos].opcode == OP_TYPE) if (exp->elts[*pos].opcode == OP_TYPE)
{ {
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
@ -9235,6 +9334,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
{ {
struct type *range_type; struct type *range_type;
char *name = ada_type_name (type_arg); char *name = ada_type_name (type_arg);
range_type = NULL; range_type = NULL;
if (name != NULL && TYPE_CODE (type_arg) != TYPE_CODE_ENUM) if (name != NULL && TYPE_CODE (type_arg) != TYPE_CODE_ENUM)
range_type = to_fixed_range_type (type_arg, NULL); range_type = to_fixed_range_type (type_arg, NULL);
@ -9317,8 +9417,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
case OP_ATR_MODULUS: case OP_ATR_MODULUS:
{ {
struct type *type_arg = check_typedef (exp->elts[pc + 2].type); struct type *type_arg = check_typedef (exp->elts[pc + 2].type);
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
if (noside == EVAL_SKIP) if (noside == EVAL_SKIP)
goto nosideret; goto nosideret;
@ -9417,6 +9517,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
/* GDB allows dereferencing GNAT array descriptors. */ /* GDB allows dereferencing GNAT array descriptors. */
{ {
struct type *arrType = ada_type_of_array (arg1, 0); struct type *arrType = ada_type_of_array (arg1, 0);
if (arrType == NULL) if (arrType == NULL)
error (_("Attempt to dereference null array pointer.")); error (_("Attempt to dereference null array pointer."));
return value_at_lazy (arrType, 0); return value_at_lazy (arrType, 0);
@ -9479,6 +9580,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
if (noside == EVAL_AVOID_SIDE_EFFECTS) if (noside == EVAL_AVOID_SIDE_EFFECTS)
{ {
struct type *type1 = value_type (arg1); struct type *type1 = value_type (arg1);
if (ada_is_tagged_type (type1, 1)) if (ada_is_tagged_type (type1, 1))
{ {
type = ada_lookup_struct_elt_type (type1, type = ada_lookup_struct_elt_type (type1,
@ -9560,6 +9662,7 @@ fixed_type_info (struct type *type)
if ((code == TYPE_CODE_INT || code == TYPE_CODE_RANGE) && name != NULL) if ((code == TYPE_CODE_INT || code == TYPE_CODE_RANGE) && name != NULL)
{ {
const char *tail = strstr (name, "___XF_"); const char *tail = strstr (name, "___XF_");
if (tail == NULL) if (tail == NULL)
return NULL; return NULL;
else else
@ -9779,6 +9882,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
{ {
LONGEST L = ada_discrete_type_low_bound (raw_type); LONGEST L = ada_discrete_type_low_bound (raw_type);
LONGEST U = ada_discrete_type_high_bound (raw_type); LONGEST U = ada_discrete_type_high_bound (raw_type);
if (L < INT_MIN || U > INT_MAX) if (L < INT_MIN || U > INT_MAX)
return raw_type; return raw_type;
else else
@ -9818,6 +9922,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
else else
{ {
int ok; int ok;
strcpy (name_buf + prefix_len, "___L"); strcpy (name_buf + prefix_len, "___L");
L = get_int_var_value (name_buf, &ok); L = get_int_var_value (name_buf, &ok);
if (!ok) if (!ok)
@ -9836,6 +9941,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
else else
{ {
int ok; int ok;
strcpy (name_buf + prefix_len, "___U"); strcpy (name_buf + prefix_len, "___U");
U = get_int_var_value (name_buf, &ok); U = get_int_var_value (name_buf, &ok);
if (!ok) if (!ok)
@ -11015,6 +11121,7 @@ ada_forward_operator_length (struct expression *exp, int pc,
case OP_NAME: case OP_NAME:
{ {
int len = longest_to_int (exp->elts[pc + 1].longconst); int len = longest_to_int (exp->elts[pc + 1].longconst);
*oplenp = 4 + BYTES_TO_EXP_ELEM (len + 1); *oplenp = 4 + BYTES_TO_EXP_ELEM (len + 1);
*argsp = 0; *argsp = 0;
break; break;
@ -11076,6 +11183,7 @@ ada_dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
{ {
char *name = &exp->elts[elt + 2].string; char *name = &exp->elts[elt + 2].string;
int len = longest_to_int (exp->elts[elt + 1].longconst); int len = longest_to_int (exp->elts[elt + 1].longconst);
fprintf_filtered (stream, "Text: `%.*s'", len, name); fprintf_filtered (stream, "Text: `%.*s'", len, name);
break; break;
} }
@ -11162,6 +11270,7 @@ ada_print_subexp (struct expression *exp, int *pos,
if (nargs > 1) if (nargs > 1)
{ {
int tem; int tem;
for (tem = 1; tem < nargs; tem += 1) for (tem = 1; tem < nargs; tem += 1)
{ {
fputs_filtered ((tem == 1) ? " (" : ", ", stream); fputs_filtered ((tem == 1) ? " (" : ", ", stream);
@ -11283,6 +11392,7 @@ ada_language_arch_info (struct gdbarch *gdbarch,
struct language_arch_info *lai) struct language_arch_info *lai)
{ {
const struct builtin_type *builtin = builtin_type (gdbarch); const struct builtin_type *builtin = builtin_type (gdbarch);
lai->primitive_type_vector lai->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1, = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1,
struct type *); struct type *);

6
gdb/ada-typeprint.c
View file

@ -151,6 +151,7 @@ print_range_bound (struct type *type, char *bounds, int *n,
struct ui_file *stream) struct ui_file *stream)
{ {
LONGEST B; LONGEST B;
if (ada_scan_number (bounds, *n, &B, n)) if (ada_scan_number (bounds, *n, &B, n))
{ {
/* STABS decodes all range types which bounds are 0 .. -1 as /* STABS decodes all range types which bounds are 0 .. -1 as
@ -363,6 +364,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
else else
{ {
int k; int k;
n_indices = TYPE_NFIELDS (range_desc_type); n_indices = TYPE_NFIELDS (range_desc_type);
for (k = 0, arr_type = type; for (k = 0, arr_type = type;
k < n_indices; k < n_indices;
@ -380,6 +382,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
else else
{ {
int i, i0; int i, i0;
for (i = i0 = ada_array_arity (type); i > 0; i -= 1) for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", "); fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
} }
@ -435,6 +438,7 @@ print_choices (struct type *type, int field_num, struct ui_file *stream,
case 'S': case 'S':
{ {
LONGEST W; LONGEST W;
if (!ada_scan_number (name, p + 1, &W, &p)) if (!ada_scan_number (name, p + 1, &W, &p))
goto Huh; goto Huh;
ada_print_scalar (val_type, W, stream); ada_print_scalar (val_type, W, stream);
@ -443,6 +447,7 @@ print_choices (struct type *type, int field_num, struct ui_file *stream,
case 'R': case 'R':
{ {
LONGEST L, U; LONGEST L, U;
if (!ada_scan_number (name, p + 1, &L, &p) if (!ada_scan_number (name, p + 1, &L, &p)
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p)) || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
goto Huh; goto Huh;
@ -781,6 +786,7 @@ ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
else else
{ {
char *name = ada_type_name (type); char *name = ada_type_name (type);
if (!ada_is_range_type_name (name)) if (!ada_is_range_type_name (name))
fprintf_filtered (stream, _("<%d-byte integer>"), fprintf_filtered (stream, _("<%d-byte integer>"),
TYPE_LENGTH (type)); TYPE_LENGTH (type));

15
gdb/ada-valprint.c
View file

@ -163,6 +163,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
{ {
LONGEST high; LONGEST high;
if (get_discrete_bounds (index_type, &low, &high) < 0) if (get_discrete_bounds (index_type, &low, &high) < 0)
len = 1; len = 1;
else else
@ -213,6 +214,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
if (i - i0 > options->repeat_count_threshold) if (i - i0 > options->repeat_count_threshold)
{ {
struct value_print_options opts = *options; struct value_print_options opts = *options;
opts.deref_ref = 0; opts.deref_ref = 0;
val_print (elttype, value_contents (v0), 0, 0, stream, val_print (elttype, value_contents (v0), 0, 0, stream,
recurse + 1, &opts, current_language); recurse + 1, &opts, current_language);
@ -225,6 +227,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
{ {
int j; int j;
struct value_print_options opts = *options; struct value_print_options opts = *options;
opts.deref_ref = 0; opts.deref_ref = 0;
for (j = i0; j < i; j += 1) for (j = i0; j < i; j += 1)
{ {
@ -598,6 +601,7 @@ static int
ada_val_print_stub (void *args0) ada_val_print_stub (void *args0)
{ {
struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0; struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
return ada_val_print_1 (argsp->type, argsp->valaddr0, return ada_val_print_1 (argsp->type, argsp->valaddr0,
argsp->embedded_offset, argsp->address, argsp->embedded_offset, argsp->address,
argsp->stream, argsp->recurse, argsp->options); argsp->stream, argsp->recurse, argsp->options);
@ -692,6 +696,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
int retn; int retn;
struct value *mark = value_mark (); struct value *mark = value_mark ();
struct value *val; struct value *val;
val = value_from_contents_and_address (type, valaddr, address); val = value_from_contents_and_address (type, valaddr, address);
val = ada_coerce_to_simple_array_ptr (val); val = ada_coerce_to_simple_array_ptr (val);
if (val == NULL) if (val == NULL)
@ -720,11 +725,13 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
{ {
int ret = c_val_print (type, valaddr0, embedded_offset, address, int ret = c_val_print (type, valaddr0, embedded_offset, address,
stream, recurse, options); stream, recurse, options);
if (ada_is_tag_type (type)) if (ada_is_tag_type (type))
{ {
struct value *val = struct value *val =
value_from_contents_and_address (type, valaddr, address); value_from_contents_and_address (type, valaddr, address);
const char *name = ada_tag_name (val); const char *name = ada_tag_name (val);
if (name != NULL) if (name != NULL)
fprintf_filtered (stream, " (%s)", name); fprintf_filtered (stream, " (%s)", name);
return 0; return 0;
@ -746,6 +753,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
else if (TYPE_CODE (type) == TYPE_CODE_RANGE) else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{ {
struct type *target_type = TYPE_TARGET_TYPE (type); struct type *target_type = TYPE_TARGET_TYPE (type);
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type)) if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
{ {
/* Obscure case of range type that has different length from /* Obscure case of range type that has different length from
@ -755,6 +763,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
struct value *v = value_cast (target_type, struct value *v = value_cast (target_type,
value_from_contents_and_address value_from_contents_and_address
(type, valaddr, 0)); (type, valaddr, 0));
return ada_val_print_1 (target_type, value_contents (v), 0, 0, return ada_val_print_1 (target_type, value_contents (v), 0, 0,
stream, recurse + 1, options); stream, recurse + 1, options);
} }
@ -767,9 +776,11 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
{ {
int format = (options->format ? options->format int format = (options->format ? options->format
: options->output_format); : options->output_format);
if (format) if (format)
{ {
struct value_print_options opts = *options; struct value_print_options opts = *options;
opts.format = format; opts.format = format;
print_scalar_formatted (valaddr, type, &opts, 0, stream); print_scalar_formatted (valaddr, type, &opts, 0, stream);
} }
@ -822,6 +833,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
if (i < len) if (i < len)
{ {
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i)); const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
if (name[0] == '\'') if (name[0] == '\'')
fprintf_filtered (stream, "%ld %s", (long) val, name); fprintf_filtered (stream, "%ld %s", (long) val, name);
else else
@ -876,12 +888,14 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{ {
LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr); LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
if (deref_val_int != 0) if (deref_val_int != 0)
{ {
struct value *deref_val = struct value *deref_val =
ada_value_ind (value_from_longest ada_value_ind (value_from_longest
(lookup_pointer_type (elttype), (lookup_pointer_type (elttype),
deref_val_int)); deref_val_int));
val_print (value_type (deref_val), val_print (value_type (deref_val),
value_contents (deref_val), 0, value_contents (deref_val), 0,
value_address (deref_val), stream, recurse + 1, value_address (deref_val), stream, recurse + 1,
@ -1098,6 +1112,7 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
else else
{ {
struct value_print_options opts = *options; struct value_print_options opts = *options;
opts.deref_ref = 0; opts.deref_ref = 0;
ada_val_print (TYPE_FIELD_TYPE (type, i), ada_val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT, valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,

2
gdb/addrmap.c
View file

@ -224,8 +224,8 @@ static splay_tree_key
allocate_key (struct addrmap_mutable *map, CORE_ADDR addr) allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
{ {
CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key)); CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
*key = addr;
*key = addr;
return (splay_tree_key) key; return (splay_tree_key) key;
} }

3
gdb/auxv.c
View file

@ -240,6 +240,7 @@ target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{ {
struct target_ops *t; struct target_ops *t;
for (t = ops; t != NULL; t = t->beneath) for (t = ops; t != NULL; t = t->beneath)
if (t->to_auxv_parse != NULL) if (t->to_auxv_parse != NULL)
return t->to_auxv_parse (t, readptr, endptr, typep, valp); return t->to_auxv_parse (t, readptr, endptr, typep, valp);
@ -373,6 +374,7 @@ fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
case str: case str:
{ {
struct value_print_options opts; struct value_print_options opts;
get_user_print_options (&opts); get_user_print_options (&opts);
if (opts.addressprint) if (opts.addressprint)
fprintf_filtered (file, "%s", paddress (target_gdbarch, val)); fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
@ -400,6 +402,7 @@ info_auxv_command (char *cmd, int from_tty)
else else
{ {
int ents = fprint_target_auxv (gdb_stdout, &current_target); int ents = fprint_target_auxv (gdb_stdout, &current_target);
if (ents < 0) if (ents < 0)
error (_("No auxiliary vector found, or failed reading it.")); error (_("No auxiliary vector found, or failed reading it."));
else if (ents == 0) else if (ents == 0)

17
gdb/ax-gdb.c
View file

@ -219,6 +219,7 @@ const_expr (union exp_element **pc)
{ {
struct type *type = (*pc)[1].type; struct type *type = (*pc)[1].type;
LONGEST k = (*pc)[2].longconst; LONGEST k = (*pc)[2].longconst;
(*pc) += 4; (*pc) += 4;
return value_from_longest (type, k); return value_from_longest (type, k);
} }
@ -226,6 +227,7 @@ const_expr (union exp_element **pc)
case OP_VAR_VALUE: case OP_VAR_VALUE:
{ {
struct value *v = const_var_ref ((*pc)[2].symbol); struct value *v = const_var_ref ((*pc)[2].symbol);
(*pc) += 4; (*pc) += 4;
return v; return v;
} }
@ -453,6 +455,7 @@ static void
gen_extend (struct agent_expr *ax, struct type *type) gen_extend (struct agent_expr *ax, struct type *type)
{ {
int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT; int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
/* I just had to. */ /* I just had to. */
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits)); ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
} }
@ -691,6 +694,7 @@ gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
{ {
struct minimal_symbol *msym struct minimal_symbol *msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
if (!msym) if (!msym)
error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var)); error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
@ -818,6 +822,7 @@ gen_usual_unary (struct expression *exp, struct agent_expr *ax,
case TYPE_CODE_ARRAY: case TYPE_CODE_ARRAY:
{ {
struct type *elements = TYPE_TARGET_TYPE (value->type); struct type *elements = TYPE_TARGET_TYPE (value->type);
value->type = lookup_pointer_type (elements); value->type = lookup_pointer_type (elements);
value->kind = axs_rvalue; value->kind = axs_rvalue;
/* We don't need to generate any code; the address of the array /* We don't need to generate any code; the address of the array
@ -1238,8 +1243,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
{ {
/* Note that ops[i] fetches 8 << i bits. */ /* Note that ops[i] fetches 8 << i bits. */
static enum agent_op ops[] static enum agent_op ops[]
= = {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
{aop_ref8, aop_ref16, aop_ref32, aop_ref64};
static int num_ops = (sizeof (ops) / sizeof (ops[0])); static int num_ops = (sizeof (ops) / sizeof (ops[0]));
/* We don't want to touch any byte that the bitfield doesn't /* We don't want to touch any byte that the bitfield doesn't
@ -1689,6 +1693,7 @@ gen_repeat (struct expression *exp, union exp_element **pc,
struct agent_expr *ax, struct axs_value *value) struct agent_expr *ax, struct axs_value *value)
{ {
struct axs_value value1; struct axs_value value1;
/* We don't want to turn this into an rvalue, so no conversions /* We don't want to turn this into an rvalue, so no conversions
here. */ here. */
gen_expr (exp, pc, ax, &value1); gen_expr (exp, pc, ax, &value1);
@ -1737,6 +1742,7 @@ gen_sizeof (struct expression *exp, union exp_element **pc,
So we generate code for the operand, and then throw it away, So we generate code for the operand, and then throw it away,
replacing it with code that simply pushes its size. */ replacing it with code that simply pushes its size. */
int start = ax->len; int start = ax->len;
gen_expr (exp, pc, ax, value); gen_expr (exp, pc, ax, value);
/* Throw away the code we just generated. */ /* Throw away the code we just generated. */
@ -1873,6 +1879,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
{ {
char *name = internalvar_name ((*pc)[1].internalvar); char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv; struct trace_state_variable *tsv;
(*pc) += 3; (*pc) += 3;
gen_expr (exp, pc, ax, value); gen_expr (exp, pc, ax, value);
tsv = find_trace_state_variable (name); tsv = find_trace_state_variable (name);
@ -1898,6 +1905,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
{ {
char *name = internalvar_name ((*pc)[1].internalvar); char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv; struct trace_state_variable *tsv;
(*pc) += 3; (*pc) += 3;
tsv = find_trace_state_variable (name); tsv = find_trace_state_variable (name);
if (tsv) if (tsv)
@ -1944,6 +1952,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
{ {
struct type *type = (*pc)[1].type; struct type *type = (*pc)[1].type;
LONGEST k = (*pc)[2].longconst; LONGEST k = (*pc)[2].longconst;
(*pc) += 4; (*pc) += 4;
gen_int_literal (ax, value, k, type); gen_int_literal (ax, value, k, type);
} }
@ -1963,6 +1972,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
{ {
const char *name = &(*pc)[2].string; const char *name = &(*pc)[2].string;
int reg; int reg;
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1); (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name)); reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
if (reg == -1) if (reg == -1)
@ -1982,6 +1992,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
{ {
const char *name = internalvar_name ((*pc)[1].internalvar); const char *name = internalvar_name ((*pc)[1].internalvar);
struct trace_state_variable *tsv; struct trace_state_variable *tsv;
(*pc) += 3; (*pc) += 3;
tsv = find_trace_state_variable (name); tsv = find_trace_state_variable (name);
if (tsv) if (tsv)
@ -2008,6 +2019,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
case UNOP_CAST: case UNOP_CAST:
{ {
struct type *type = (*pc)[1].type; struct type *type = (*pc)[1].type;
(*pc) += 3; (*pc) += 3;
gen_expr (exp, pc, ax, value); gen_expr (exp, pc, ax, value);
gen_cast (ax, value, type); gen_cast (ax, value, type);
@ -2017,6 +2029,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
case UNOP_MEMVAL: case UNOP_MEMVAL:
{ {
struct type *type = check_typedef ((*pc)[1].type); struct type *type = check_typedef ((*pc)[1].type);
(*pc) += 3; (*pc) += 3;
gen_expr (exp, pc, ax, value); gen_expr (exp, pc, ax, value);
/* I'm not sure I understand UNOP_MEMVAL entirely. I think /* I'm not sure I understand UNOP_MEMVAL entirely. I think