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.
This commit is contained in:
Michael Snyder
parent
e1e82ea4dc
commit
5b4ee69b43
7 changed files with 166 additions and 10 deletions
|
|
@ -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>
|
||||
|
||||
* linux-fork.c (inferior_call_waitpid_cleanup): Add check
|
||||
|
|
|
|||
124
gdb/ada-lang.c
124
gdb/ada-lang.c
|
|
@ -377,6 +377,7 @@ static int
|
|||
field_name_match (const char *field_name, const char *target)
|
||||
{
|
||||
int len = strlen (target);
|
||||
|
||||
return
|
||||
(strncmp (field_name, target, len) == 0
|
||||
&& (field_name[len] == '\0'
|
||||
|
|
@ -422,6 +423,7 @@ ada_name_prefix_len (const char *name)
|
|||
else
|
||||
{
|
||||
const char *p = strstr (name, "___");
|
||||
|
||||
if (p == NULL)
|
||||
return strlen (name);
|
||||
else
|
||||
|
|
@ -436,6 +438,7 @@ static int
|
|||
is_suffix (const char *str, const char *suffix)
|
||||
{
|
||||
int len1, len2;
|
||||
|
||||
if (str == NULL)
|
||||
return 0;
|
||||
len1 = strlen (str);
|
||||
|
|
@ -506,8 +509,8 @@ static void
|
|||
lim_warning (const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start (args, format);
|
||||
|
||||
va_start (args, format);
|
||||
warnings_issued += 1;
|
||||
if (warnings_issued <= warning_limit)
|
||||
vwarning (format, args);
|
||||
|
|
@ -531,6 +534,7 @@ static LONGEST
|
|||
max_of_size (int size)
|
||||
{
|
||||
LONGEST top_bit = (LONGEST) 1 << (size * 8 - 2);
|
||||
|
||||
return top_bit | (top_bit - 1);
|
||||
}
|
||||
|
||||
|
|
@ -546,6 +550,7 @@ static ULONGEST
|
|||
umax_of_size (int size)
|
||||
{
|
||||
ULONGEST top_bit = (ULONGEST) 1 << (size * 8 - 1);
|
||||
|
||||
return top_bit | (top_bit - 1);
|
||||
}
|
||||
|
||||
|
|
@ -781,6 +786,7 @@ ada_fold_name (const char *name)
|
|||
else
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= len; i += 1)
|
||||
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]))
|
||||
{
|
||||
int i = *len - 2;
|
||||
|
||||
while (i > 0 && isdigit (encoded[i]))
|
||||
i--;
|
||||
if (i >= 0 && encoded[i] == '.')
|
||||
|
|
@ -967,6 +974,7 @@ ada_decode (const char *encoded)
|
|||
if (at_start_name && encoded[i] == 'O')
|
||||
{
|
||||
int k;
|
||||
|
||||
for (k = 0; ada_opname_table[k].encoded != NULL; k += 1)
|
||||
{
|
||||
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 **) &gsymbol->language_specific.cplus_specific.demangled_name;
|
||||
|
||||
if (*resultp == NULL)
|
||||
{
|
||||
const char *decoded = ada_decode (gsymbol->name);
|
||||
|
||||
if (gsymbol->obj_section != NULL)
|
||||
{
|
||||
struct objfile *objf = gsymbol->obj_section->objfile;
|
||||
|
||||
*resultp = obsavestring (decoded, strlen (decoded),
|
||||
&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,
|
||||
decoded, INSERT);
|
||||
|
||||
if (*slot == NULL)
|
||||
*slot = xstrdup (decoded);
|
||||
*resultp = *slot;
|
||||
|
|
@ -1192,6 +1204,7 @@ ada_match_name (const char *sym_name, const char *name, int wild)
|
|||
else
|
||||
{
|
||||
int len_name = strlen (name);
|
||||
|
||||
return (strncmp (sym_name, name, len_name) == 0
|
||||
&& is_name_suffix (sym_name + len_name))
|
||||
|| (strncmp (sym_name, "_ada_", 5) == 0
|
||||
|
|
@ -1315,6 +1328,7 @@ static struct type *
|
|||
thin_descriptor_type (struct type *type)
|
||||
{
|
||||
struct type *base_type = desc_base_type (type);
|
||||
|
||||
if (base_type == NULL)
|
||||
return NULL;
|
||||
if (is_suffix (ada_type_name (base_type), "___XVE"))
|
||||
|
|
@ -1322,6 +1336,7 @@ thin_descriptor_type (struct type *type)
|
|||
else
|
||||
{
|
||||
struct type *alt_type = ada_find_parallel_type (base_type, "___XVE");
|
||||
|
||||
if (alt_type == NULL)
|
||||
return base_type;
|
||||
else
|
||||
|
|
@ -1336,6 +1351,7 @@ thin_data_pntr (struct value *val)
|
|||
{
|
||||
struct type *type = value_type (val);
|
||||
struct type *data_type = desc_data_target_type (thin_descriptor_type (type));
|
||||
|
||||
data_type = lookup_pointer_type (data_type);
|
||||
|
||||
if (TYPE_CODE (type) == TYPE_CODE_PTR)
|
||||
|
|
@ -1391,6 +1407,7 @@ static struct value *
|
|||
desc_bounds (struct value *arr)
|
||||
{
|
||||
struct type *type = ada_check_typedef (value_type (arr));
|
||||
|
||||
if (is_thin_pntr (type))
|
||||
{
|
||||
struct type *bounds_type =
|
||||
|
|
@ -1475,6 +1492,7 @@ static struct value *
|
|||
desc_data (struct value *arr)
|
||||
{
|
||||
struct type *type = value_type (arr);
|
||||
|
||||
if (is_thin_pntr (type))
|
||||
return thin_data_pntr (arr);
|
||||
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 value *low = desc_one_bound (descriptor, arity, 0);
|
||||
struct value *high = desc_one_bound (descriptor, arity, 1);
|
||||
arity -= 1;
|
||||
|
||||
arity -= 1;
|
||||
create_range_type (range_type, value_type (low),
|
||||
longest_to_int (value_as_long (low)),
|
||||
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)))
|
||||
{
|
||||
struct type *arrType = ada_type_of_array (arr, 1);
|
||||
|
||||
if (arrType == NULL)
|
||||
return NULL;
|
||||
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)))
|
||||
{
|
||||
struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
|
||||
|
||||
if (arrVal == NULL)
|
||||
error (_("Bounds unavailable for null array pointer."));
|
||||
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)
|
||||
{
|
||||
CORE_ADDR new_addr;
|
||||
|
||||
set_value_component_location (v, obj);
|
||||
new_addr = value_address (obj) + offset;
|
||||
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;
|
||||
/* Sign-extend bits for this byte. */
|
||||
unsigned int signMask = sign & ~unusedMSMask;
|
||||
|
||||
accum |=
|
||||
(((bytes[src] >> unusedLS) & unusedMSMask) | signMask) << accumSize;
|
||||
accumSize += HOST_CHAR_BIT - unusedLS;
|
||||
|
|
@ -2221,6 +2243,7 @@ move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
|
|||
while (n > 0)
|
||||
{
|
||||
int unused_right;
|
||||
|
||||
accum = (accum << HOST_CHAR_BIT) + (unsigned char) *source;
|
||||
accum_bits += HOST_CHAR_BIT;
|
||||
source += 1;
|
||||
|
|
@ -2428,6 +2451,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
|
|||
low, high);
|
||||
struct type *slice_type =
|
||||
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
|
||||
|
||||
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);
|
||||
struct type *slice_type =
|
||||
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
|
||||
|
||||
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)),
|
||||
low, low - 1);
|
||||
struct type *elt_type = ada_array_element_type (arr_type, 1);
|
||||
|
||||
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;
|
||||
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]));
|
||||
|
||||
if (!ada_type_match (ftype, atype, 1))
|
||||
|
|
@ -3239,6 +3266,7 @@ encoded_ordered_before (char *N0, char *N1)
|
|||
else
|
||||
{
|
||||
int k0, k1;
|
||||
|
||||
for (k0 = strlen (N0) - 1; k0 > 0 && isdigit (N0[k0]); k0 -= 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')
|
||||
{
|
||||
int n0, n1;
|
||||
|
||||
n0 = k0;
|
||||
while (N0[n0] == '_' && n0 > 0 && N0[n0 - 1] == '_')
|
||||
n0 -= 1;
|
||||
|
|
@ -3267,6 +3296,7 @@ static void
|
|||
sort_choices (struct ada_symbol_info syms[], int nsyms)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i < nsyms; i += 1)
|
||||
{
|
||||
struct ada_symbol_info sym = syms[i];
|
||||
|
|
@ -3331,6 +3361,7 @@ See set/show multiple-symbol."));
|
|||
{
|
||||
struct symtab_and_line sal =
|
||||
find_function_start_sal (syms[i].sym, 1);
|
||||
|
||||
if (sal.symtab == NULL)
|
||||
printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"),
|
||||
i + first_choice,
|
||||
|
|
@ -3464,6 +3495,7 @@ get_selections (int *choices, int n_choices, int max_results,
|
|||
if (j < 0 || choice != choices[j])
|
||||
{
|
||||
int k;
|
||||
|
||||
for (k = n_chosen - 1; k > j; k -= 1)
|
||||
choices[k + 1] = choices[k];
|
||||
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)
|
||||
{
|
||||
struct value *result;
|
||||
|
||||
if (TYPE_CODE (formal_target) == TYPE_CODE_ARRAY
|
||||
&& ada_is_array_descriptor_type (actual_target))
|
||||
result = desc_data (actual);
|
||||
|
|
@ -3891,6 +3924,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0,
|
|||
if (VALUE_LVAL (actual) != lval_memory)
|
||||
{
|
||||
struct value *val;
|
||||
|
||||
actual_type = ada_check_typedef (value_type (actual));
|
||||
val = allocate_value (actual_type);
|
||||
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 *name1 = SYMBOL_LINKAGE_NAME (sym1);
|
||||
int len0 = strlen (name0);
|
||||
|
||||
return
|
||||
TYPE_CODE (type0) == TYPE_CODE (type1)
|
||||
&& (equiv_types (type0, type1)
|
||||
|
|
@ -4206,6 +4241,7 @@ static int
|
|||
is_nondebugging_type (struct type *type)
|
||||
{
|
||||
char *name = ada_type_name (type);
|
||||
|
||||
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 j;
|
||||
|
||||
is_new_style_renaming = 1;
|
||||
for (j = 0; j < nsyms; j += 1)
|
||||
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))
|
||||
{
|
||||
int j;
|
||||
|
||||
for (j = i + 1; j < nsyms; j += 1)
|
||||
syms[j - 1] = syms[j];
|
||||
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;
|
||||
const int block_kind = data->global ? GLOBAL_BLOCK : STATIC_BLOCK;
|
||||
|
||||
ada_add_block_symbols (data->obstackp,
|
||||
BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind),
|
||||
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;
|
||||
const char* start;
|
||||
|
||||
start = name0;
|
||||
while (1)
|
||||
{
|
||||
|
|
@ -4946,6 +4986,7 @@ ada_add_block_symbols (struct obstack *obstackp,
|
|||
if (wild)
|
||||
{
|
||||
struct symbol *sym;
|
||||
|
||||
ALL_BLOCK_SYMBOLS (block, iter, sym)
|
||||
{
|
||||
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
|
||||
|
|
@ -4974,6 +5015,7 @@ ada_add_block_symbols (struct obstack *obstackp,
|
|||
SYMBOL_DOMAIN (sym), domain))
|
||||
{
|
||||
int cmp = strncmp (name, SYMBOL_LINKAGE_NAME (sym), name_len);
|
||||
|
||||
if (cmp == 0
|
||||
&& 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)
|
||||
{
|
||||
struct add_partial_datum *data = user_data;
|
||||
|
||||
symbol_completion_add (data->completions, name,
|
||||
data->text, data->text_len, data->text0, data->word,
|
||||
data->wild_match, data->encoded);
|
||||
|
|
@ -5429,6 +5472,7 @@ ada_is_tag_type (struct type *type)
|
|||
else
|
||||
{
|
||||
const char *name = ada_type_name (TYPE_TARGET_TYPE (type));
|
||||
|
||||
return (name != NULL
|
||||
&& strcmp (name, "ada__tags__dispatch_table") == 0);
|
||||
}
|
||||
|
|
@ -5461,6 +5505,7 @@ value_tag_from_contents_and_address (struct type *type,
|
|||
{
|
||||
int tag_byte_offset;
|
||||
struct type *tag_type;
|
||||
|
||||
if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
|
||||
NULL, NULL, NULL))
|
||||
{
|
||||
|
|
@ -5478,6 +5523,7 @@ static struct type *
|
|||
type_from_tag (struct value *tag)
|
||||
{
|
||||
const char *type_name = ada_tag_name (tag);
|
||||
|
||||
if (type_name != NULL)
|
||||
return ada_find_any_type (ada_encode (type_name));
|
||||
return NULL;
|
||||
|
|
@ -5505,6 +5551,7 @@ ada_tag_name_1 (void *args0)
|
|||
static char name[1024];
|
||||
char *p;
|
||||
struct value *val;
|
||||
|
||||
args->name = NULL;
|
||||
val = ada_value_struct_elt (args->tag, "tsd", 1);
|
||||
if (val == NULL)
|
||||
|
|
@ -5562,6 +5609,7 @@ const char *
|
|||
ada_tag_name (struct value *tag)
|
||||
{
|
||||
struct tag_args args;
|
||||
|
||||
if (!ada_is_tag_type (value_type (tag)))
|
||||
return NULL;
|
||||
args.tag = tag;
|
||||
|
|
@ -5607,6 +5655,7 @@ int
|
|||
ada_is_parent_field (struct type *type, int field_num)
|
||||
{
|
||||
const char *name = TYPE_FIELD_NAME (ada_check_typedef (type), field_num);
|
||||
|
||||
return (name != NULL
|
||||
&& (strncmp (name, "PARENT", 6) == 0
|
||||
|| strncmp (name, "_parent", 7) == 0));
|
||||
|
|
@ -5622,6 +5671,7 @@ int
|
|||
ada_is_wrapper_field (struct type *type, int field_num)
|
||||
{
|
||||
const char *name = TYPE_FIELD_NAME (type, field_num);
|
||||
|
||||
return (name != NULL
|
||||
&& (strncmp (name, "PARENT", 6) == 0
|
||||
|| strcmp (name, "REP") == 0
|
||||
|
|
@ -5637,6 +5687,7 @@ int
|
|||
ada_is_variant_part (struct type *type, int field_num)
|
||||
{
|
||||
struct type *field_type = TYPE_FIELD_TYPE (type, field_num);
|
||||
|
||||
return (TYPE_CODE (field_type) == TYPE_CODE_UNION
|
||||
|| (is_dynamic_field (type, field_num)
|
||||
&& (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)
|
||||
{
|
||||
char *name = ada_variant_discrim_name (var_type);
|
||||
|
||||
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)
|
||||
{
|
||||
const char *name = TYPE_FIELD_NAME (type, field_num);
|
||||
|
||||
return (name != NULL && name[0] == 'O');
|
||||
}
|
||||
|
||||
|
|
@ -5782,6 +5835,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
|
|||
case 'S':
|
||||
{
|
||||
LONGEST W;
|
||||
|
||||
if (!ada_scan_number (name, p + 1, &W, &p))
|
||||
return 0;
|
||||
if (val == W)
|
||||
|
|
@ -5791,6 +5845,7 @@ ada_in_variant (LONGEST val, struct type *type, int field_num)
|
|||
case 'R':
|
||||
{
|
||||
LONGEST L, U;
|
||||
|
||||
if (!ada_scan_number (name, p + 1, &L, &p)
|
||||
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
|
||||
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))
|
||||
{
|
||||
int bit_size = TYPE_FIELD_BITSIZE (type, i);
|
||||
|
||||
if (field_type_p != NULL)
|
||||
*field_type_p = TYPE_FIELD_TYPE (type, i);
|
||||
if (byte_offset_p != NULL)
|
||||
|
|
@ -5930,6 +5986,7 @@ static int
|
|||
num_visible_fields (struct type *type)
|
||||
{
|
||||
int n;
|
||||
|
||||
n = 0;
|
||||
find_struct_field (NULL, type, 0, NULL, NULL, NULL, NULL, &n);
|
||||
return n;
|
||||
|
|
@ -5946,8 +6003,8 @@ ada_search_struct_field (char *name, struct value *arg, int offset,
|
|||
struct type *type)
|
||||
{
|
||||
int i;
|
||||
type = ada_check_typedef (type);
|
||||
|
||||
type = ada_check_typedef (type);
|
||||
for (i = 0; i < TYPE_NFIELDS (type); i += 1)
|
||||
{
|
||||
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,
|
||||
offset + TYPE_FIELD_BITPOS (type, i) / 8,
|
||||
TYPE_FIELD_TYPE (type, i));
|
||||
|
||||
if (v != NULL)
|
||||
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. */
|
||||
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;
|
||||
|
||||
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,
|
||||
var_offset + TYPE_FIELD_BITPOS (field_type, j) / 8,
|
||||
TYPE_FIELD_TYPE (field_type, j));
|
||||
|
||||
if (v != NULL)
|
||||
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,
|
||||
offset + TYPE_FIELD_BITPOS (type, i) / 8,
|
||||
TYPE_FIELD_TYPE (type, i));
|
||||
|
||||
if (v != NULL)
|
||||
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))
|
||||
{
|
||||
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)
|
||||
{
|
||||
|
|
@ -6294,6 +6356,7 @@ static int
|
|||
is_unchecked_variant (struct type *var_type, struct type *outer_type)
|
||||
{
|
||||
char *discrim_name = ada_variant_discrim_name (var_type);
|
||||
|
||||
return (ada_lookup_struct_elt_type (outer_type, discrim_name, 0, 1, NULL)
|
||||
== NULL);
|
||||
}
|
||||
|
|
@ -6378,6 +6441,7 @@ struct value *
|
|||
ada_value_ind (struct value *val0)
|
||||
{
|
||||
struct value *val = unwrap_value (value_ind (val0));
|
||||
|
||||
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)
|
||||
{
|
||||
struct value *val = val0;
|
||||
|
||||
val = coerce_ref (val);
|
||||
val = unwrap_value (val);
|
||||
return ada_to_fixed_value (val);
|
||||
|
|
@ -6537,6 +6602,7 @@ find_old_style_renaming_symbol (const char *name, struct block *block)
|
|||
else
|
||||
{
|
||||
const int rename_len = strlen (name) + 6;
|
||||
|
||||
rename = (char *) alloca (rename_len * sizeof (char));
|
||||
xsnprintf (rename, rename_len * sizeof (char), "%s___XR", name);
|
||||
}
|
||||
|
|
@ -6691,6 +6757,7 @@ dynamic_template_type (struct type *type)
|
|||
else
|
||||
{
|
||||
int len = strlen (ada_type_name (type));
|
||||
|
||||
if (len > 6 && strcmp (ada_type_name (type) + len - 6, "___XVE") == 0)
|
||||
return type;
|
||||
else
|
||||
|
|
@ -6705,6 +6772,7 @@ static int
|
|||
is_dynamic_field (struct type *templ_type, int field_num)
|
||||
{
|
||||
const char *name = TYPE_FIELD_NAME (templ_type, field_num);
|
||||
|
||||
return name != NULL
|
||||
&& TYPE_CODE (TYPE_FIELD_TYPE (templ_type, field_num)) == TYPE_CODE_PTR
|
||||
&& strstr (name, "___XVL") != NULL;
|
||||
|
|
@ -6735,6 +6803,7 @@ static struct type *
|
|||
empty_record (struct type *template)
|
||||
{
|
||||
struct type *type = alloc_type_copy (template);
|
||||
|
||||
TYPE_CODE (type) = TYPE_CODE_STRUCT;
|
||||
TYPE_NFIELDS (type) = 0;
|
||||
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)
|
||||
{
|
||||
int f;
|
||||
|
||||
for (f = variant_field + 1; f < nfields; f += 1)
|
||||
TYPE_FIELDS (rtype)[f - 1] = TYPE_FIELDS (rtype)[f];
|
||||
TYPE_NFIELDS (rtype) -= 1;
|
||||
|
|
@ -7209,6 +7279,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
|
|||
if (index_type_desc == NULL)
|
||||
{
|
||||
struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
|
||||
|
||||
/* NOTE: elt_type---the fixed version of elt_type0---should never
|
||||
depend on the contents of the array in properly constructed
|
||||
debugging data. */
|
||||
|
|
@ -7259,6 +7330,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
|
|||
{
|
||||
struct type *range_type =
|
||||
to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc, i), dval);
|
||||
|
||||
result = create_array_type (alloc_type_copy (elt_type0),
|
||||
result, range_type);
|
||||
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 *fixed_record_type =
|
||||
to_fixed_record_type (type, valaddr, address, NULL);
|
||||
|
||||
/* 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
|
||||
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,
|
||||
valaddr,
|
||||
address));
|
||||
|
||||
if (real_type != NULL)
|
||||
return to_fixed_record_type (real_type, valaddr, address, NULL);
|
||||
}
|
||||
|
|
@ -7452,6 +7526,7 @@ static_unwrap_type (struct type *type)
|
|||
else
|
||||
{
|
||||
struct type *raw_real_type = ada_get_base_type (type);
|
||||
|
||||
if (raw_real_type == type)
|
||||
return type;
|
||||
else
|
||||
|
|
@ -7488,6 +7563,7 @@ ada_check_typedef (struct type *type)
|
|||
{
|
||||
char *name = TYPE_TAG_NAME (type);
|
||||
struct type *type1 = ada_find_any_type (name);
|
||||
|
||||
return (type1 == NULL) ? type : type1;
|
||||
}
|
||||
}
|
||||
|
|
@ -7503,6 +7579,7 @@ ada_to_fixed_value_create (struct type *type0, CORE_ADDR address,
|
|||
struct value *val0)
|
||||
{
|
||||
struct type *type = ada_to_fixed_type (type0, 0, address, NULL, 1);
|
||||
|
||||
if (type == type0 && val0 != NULL)
|
||||
return val0;
|
||||
else
|
||||
|
|
@ -7599,6 +7676,7 @@ value_val_atr (struct type *type, struct value *arg)
|
|||
if (TYPE_CODE (type) == TYPE_CODE_ENUM)
|
||||
{
|
||||
long pos = value_as_long (arg);
|
||||
|
||||
if (pos < 0 || pos >= TYPE_NFIELDS (type))
|
||||
error (_("argument to 'VAL out of range"));
|
||||
return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
|
||||
|
|
@ -7797,6 +7875,7 @@ ada_enum_name (const char *name)
|
|||
if (name[0] == 'Q')
|
||||
{
|
||||
int v;
|
||||
|
||||
if (name[1] == 'U' || name[1] == 'W')
|
||||
{
|
||||
if (sscanf (name + 2, "%x", &v) != 1)
|
||||
|
|
@ -7849,10 +7928,12 @@ static struct value *
|
|||
unwrap_value (struct value *val)
|
||||
{
|
||||
struct type *type = ada_check_typedef (value_type (val));
|
||||
|
||||
if (ada_is_aligner_type (type))
|
||||
{
|
||||
struct value *v = ada_value_struct_elt (val, "F", 0);
|
||||
struct type *val_type = ada_check_typedef (value_type (v));
|
||||
|
||||
if (ada_type_name (val_type) == NULL)
|
||||
TYPE_NAME (val_type) = ada_type_name (type);
|
||||
|
||||
|
|
@ -7891,6 +7972,7 @@ cast_to_fixed (struct type *type, struct value *arg)
|
|||
else
|
||||
{
|
||||
DOUBLEST argd = value_as_double (arg);
|
||||
|
||||
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),
|
||||
value_as_long (arg));
|
||||
|
||||
return value_from_double (type, val);
|
||||
}
|
||||
|
||||
|
|
@ -7912,6 +7995,7 @@ static struct value *
|
|||
coerce_for_assign (struct type *type, struct value *val)
|
||||
{
|
||||
struct type *type2 = value_type (val);
|
||||
|
||||
if (type == type2)
|
||||
return val;
|
||||
|
||||
|
|
@ -8030,6 +8114,7 @@ static int
|
|||
num_component_specs (struct expression *exp, int pc)
|
||||
{
|
||||
int n, m, i;
|
||||
|
||||
m = exp->elts[pc + 1].longconst;
|
||||
pc += 3;
|
||||
n = 0;
|
||||
|
|
@ -8061,10 +8146,12 @@ assign_component (struct value *container, struct value *lhs, LONGEST index,
|
|||
{
|
||||
struct value *mark = value_mark ();
|
||||
struct value *elt;
|
||||
|
||||
if (TYPE_CODE (value_type (lhs)) == TYPE_CODE_ARRAY)
|
||||
{
|
||||
struct type *index_type = builtin_type (exp->gdbarch)->builtin_int;
|
||||
struct value *index_val = value_from_longest (index_type, index);
|
||||
|
||||
elt = unwrap_value (ada_value_subscript (lhs, 1, &index_val));
|
||||
}
|
||||
else
|
||||
|
|
@ -8109,6 +8196,7 @@ assign_aggregate (struct value *container,
|
|||
if (noside != EVAL_NORMAL)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i += 1)
|
||||
ada_evaluate_subexp (NULL, exp, pos, noside);
|
||||
return container;
|
||||
|
|
@ -8227,6 +8315,7 @@ aggregate_assign_from_choices (struct value *container,
|
|||
{
|
||||
LONGEST lower, upper;
|
||||
enum exp_opcode op = exp->elts[choice_pos].opcode;
|
||||
|
||||
if (op == OP_DISCRETE_RANGE)
|
||||
{
|
||||
choice_pos += 1;
|
||||
|
|
@ -8245,6 +8334,7 @@ aggregate_assign_from_choices (struct value *container,
|
|||
{
|
||||
int ind;
|
||||
char *name;
|
||||
|
||||
switch (op)
|
||||
{
|
||||
case OP_NAME:
|
||||
|
|
@ -8272,6 +8362,7 @@ aggregate_assign_from_choices (struct value *container,
|
|||
while (lower <= upper)
|
||||
{
|
||||
int pos1;
|
||||
|
||||
pos1 = expr_pc;
|
||||
assign_component (container, lhs, lower, exp, &pos1);
|
||||
lower += 1;
|
||||
|
|
@ -8296,9 +8387,11 @@ aggregate_assign_others (struct value *container,
|
|||
for (i = 0; i < num_indices - 2; i += 2)
|
||||
{
|
||||
LONGEST ind;
|
||||
|
||||
for (ind = indices[i + 1] + 1; ind < indices[i + 2]; ind += 1)
|
||||
{
|
||||
int pos;
|
||||
|
||||
pos = expr_pc;
|
||||
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)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
for (i = 0; i < *size; i += 2) {
|
||||
if (high >= indices[i] && low <= indices[i + 1])
|
||||
{
|
||||
int kh;
|
||||
|
||||
for (kh = i + 2; kh < *size; kh += 2)
|
||||
if (high < indices[kh])
|
||||
break;
|
||||
|
|
@ -8658,6 +8753,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
|
|||
case OP_STRING:
|
||||
{
|
||||
struct value *result;
|
||||
|
||||
*pos -= 1;
|
||||
result = evaluate_subexp_standard (expect_type, exp, pos, noside);
|
||||
/* 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);
|
||||
LONGEST low_bound;
|
||||
LONGEST high_bound;
|
||||
|
||||
low_bound_val = coerce_ref (low_bound_val);
|
||||
high_bound_val = coerce_ref (high_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 =
|
||||
to_fixed_array_type (TYPE_TARGET_TYPE (value_type (array)),
|
||||
NULL, 1);
|
||||
|
||||
return ada_value_slice_from_ptr (array, arr_type0,
|
||||
longest_to_int (low_bound),
|
||||
longest_to_int (high_bound));
|
||||
|
|
@ -9181,6 +9279,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
|
|||
case OP_ATR_LENGTH:
|
||||
{
|
||||
struct type *type_arg;
|
||||
|
||||
if (exp->elts[*pos].opcode == OP_TYPE)
|
||||
{
|
||||
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;
|
||||
char *name = ada_type_name (type_arg);
|
||||
|
||||
range_type = NULL;
|
||||
if (name != NULL && TYPE_CODE (type_arg) != TYPE_CODE_ENUM)
|
||||
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:
|
||||
{
|
||||
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)
|
||||
goto nosideret;
|
||||
|
||||
|
|
@ -9417,6 +9517,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
|
|||
/* GDB allows dereferencing GNAT array descriptors. */
|
||||
{
|
||||
struct type *arrType = ada_type_of_array (arg1, 0);
|
||||
|
||||
if (arrType == NULL)
|
||||
error (_("Attempt to dereference null array pointer."));
|
||||
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)
|
||||
{
|
||||
struct type *type1 = value_type (arg1);
|
||||
|
||||
if (ada_is_tagged_type (type1, 1))
|
||||
{
|
||||
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)
|
||||
{
|
||||
const char *tail = strstr (name, "___XF_");
|
||||
|
||||
if (tail == NULL)
|
||||
return NULL;
|
||||
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 U = ada_discrete_type_high_bound (raw_type);
|
||||
|
||||
if (L < INT_MIN || U > INT_MAX)
|
||||
return raw_type;
|
||||
else
|
||||
|
|
@ -9818,6 +9922,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
|
|||
else
|
||||
{
|
||||
int ok;
|
||||
|
||||
strcpy (name_buf + prefix_len, "___L");
|
||||
L = get_int_var_value (name_buf, &ok);
|
||||
if (!ok)
|
||||
|
|
@ -9836,6 +9941,7 @@ to_fixed_range_type (struct type *raw_type, struct value *dval)
|
|||
else
|
||||
{
|
||||
int ok;
|
||||
|
||||
strcpy (name_buf + prefix_len, "___U");
|
||||
U = get_int_var_value (name_buf, &ok);
|
||||
if (!ok)
|
||||
|
|
@ -11015,6 +11121,7 @@ ada_forward_operator_length (struct expression *exp, int pc,
|
|||
case OP_NAME:
|
||||
{
|
||||
int len = longest_to_int (exp->elts[pc + 1].longconst);
|
||||
|
||||
*oplenp = 4 + BYTES_TO_EXP_ELEM (len + 1);
|
||||
*argsp = 0;
|
||||
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;
|
||||
int len = longest_to_int (exp->elts[elt + 1].longconst);
|
||||
|
||||
fprintf_filtered (stream, "Text: `%.*s'", len, name);
|
||||
break;
|
||||
}
|
||||
|
|
@ -11162,6 +11270,7 @@ ada_print_subexp (struct expression *exp, int *pos,
|
|||
if (nargs > 1)
|
||||
{
|
||||
int tem;
|
||||
|
||||
for (tem = 1; tem < nargs; tem += 1)
|
||||
{
|
||||
fputs_filtered ((tem == 1) ? " (" : ", ", stream);
|
||||
|
|
@ -11283,6 +11392,7 @@ ada_language_arch_info (struct gdbarch *gdbarch,
|
|||
struct language_arch_info *lai)
|
||||
{
|
||||
const struct builtin_type *builtin = builtin_type (gdbarch);
|
||||
|
||||
lai->primitive_type_vector
|
||||
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1,
|
||||
struct type *);
|
||||
|
|
|
|||
|
|
@ -151,6 +151,7 @@ print_range_bound (struct type *type, char *bounds, int *n,
|
|||
struct ui_file *stream)
|
||||
{
|
||||
LONGEST B;
|
||||
|
||||
if (ada_scan_number (bounds, *n, &B, n))
|
||||
{
|
||||
/* 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
|
||||
{
|
||||
int k;
|
||||
|
||||
n_indices = TYPE_NFIELDS (range_desc_type);
|
||||
for (k = 0, arr_type = type;
|
||||
k < n_indices;
|
||||
|
|
@ -380,6 +382,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
|
|||
else
|
||||
{
|
||||
int i, i0;
|
||||
|
||||
for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
|
||||
fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
|
||||
}
|
||||
|
|
@ -435,6 +438,7 @@ print_choices (struct type *type, int field_num, struct ui_file *stream,
|
|||
case 'S':
|
||||
{
|
||||
LONGEST W;
|
||||
|
||||
if (!ada_scan_number (name, p + 1, &W, &p))
|
||||
goto Huh;
|
||||
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':
|
||||
{
|
||||
LONGEST L, U;
|
||||
|
||||
if (!ada_scan_number (name, p + 1, &L, &p)
|
||||
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
|
||||
goto Huh;
|
||||
|
|
@ -781,6 +786,7 @@ ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
|
|||
else
|
||||
{
|
||||
char *name = ada_type_name (type);
|
||||
|
||||
if (!ada_is_range_type_name (name))
|
||||
fprintf_filtered (stream, _("<%d-byte integer>"),
|
||||
TYPE_LENGTH (type));
|
||||
|
|
|
|||
|
|
@ -163,6 +163,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
|
|||
|
||||
{
|
||||
LONGEST high;
|
||||
|
||||
if (get_discrete_bounds (index_type, &low, &high) < 0)
|
||||
len = 1;
|
||||
else
|
||||
|
|
@ -213,6 +214,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
|
|||
if (i - i0 > options->repeat_count_threshold)
|
||||
{
|
||||
struct value_print_options opts = *options;
|
||||
|
||||
opts.deref_ref = 0;
|
||||
val_print (elttype, value_contents (v0), 0, 0, stream,
|
||||
recurse + 1, &opts, current_language);
|
||||
|
|
@ -225,6 +227,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
|
|||
{
|
||||
int j;
|
||||
struct value_print_options opts = *options;
|
||||
|
||||
opts.deref_ref = 0;
|
||||
for (j = i0; j < i; j += 1)
|
||||
{
|
||||
|
|
@ -598,6 +601,7 @@ static int
|
|||
ada_val_print_stub (void *args0)
|
||||
{
|
||||
struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
|
||||
|
||||
return ada_val_print_1 (argsp->type, argsp->valaddr0,
|
||||
argsp->embedded_offset, argsp->address,
|
||||
argsp->stream, argsp->recurse, argsp->options);
|
||||
|
|
@ -692,6 +696,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
|
|||
int retn;
|
||||
struct value *mark = value_mark ();
|
||||
struct value *val;
|
||||
|
||||
val = value_from_contents_and_address (type, valaddr, address);
|
||||
val = ada_coerce_to_simple_array_ptr (val);
|
||||
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,
|
||||
stream, recurse, options);
|
||||
|
||||
if (ada_is_tag_type (type))
|
||||
{
|
||||
struct value *val =
|
||||
value_from_contents_and_address (type, valaddr, address);
|
||||
const char *name = ada_tag_name (val);
|
||||
|
||||
if (name != NULL)
|
||||
fprintf_filtered (stream, " (%s)", name);
|
||||
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)
|
||||
{
|
||||
struct type *target_type = TYPE_TARGET_TYPE (type);
|
||||
|
||||
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
|
||||
{
|
||||
/* Obscure case of range type that has different length from
|
||||
|
|
@ -755,6 +763,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
|
|||
struct value *v = value_cast (target_type,
|
||||
value_from_contents_and_address
|
||||
(type, valaddr, 0));
|
||||
|
||||
return ada_val_print_1 (target_type, value_contents (v), 0, 0,
|
||||
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
|
||||
: options->output_format);
|
||||
|
||||
if (format)
|
||||
{
|
||||
struct value_print_options opts = *options;
|
||||
|
||||
opts.format = format;
|
||||
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)
|
||||
{
|
||||
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
|
||||
|
||||
if (name[0] == '\'')
|
||||
fprintf_filtered (stream, "%ld %s", (long) val, name);
|
||||
else
|
||||
|
|
@ -876,12 +888,14 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
|
|||
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
|
||||
{
|
||||
LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
|
||||
|
||||
if (deref_val_int != 0)
|
||||
{
|
||||
struct value *deref_val =
|
||||
ada_value_ind (value_from_longest
|
||||
(lookup_pointer_type (elttype),
|
||||
deref_val_int));
|
||||
|
||||
val_print (value_type (deref_val),
|
||||
value_contents (deref_val), 0,
|
||||
value_address (deref_val), stream, recurse + 1,
|
||||
|
|
@ -1098,6 +1112,7 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
|
|||
else
|
||||
{
|
||||
struct value_print_options opts = *options;
|
||||
|
||||
opts.deref_ref = 0;
|
||||
ada_val_print (TYPE_FIELD_TYPE (type, i),
|
||||
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
|
||||
|
|
|
|||
|
|
@ -224,8 +224,8 @@ static splay_tree_key
|
|||
allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
|
||||
{
|
||||
CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
|
||||
*key = addr;
|
||||
|
||||
*key = addr;
|
||||
return (splay_tree_key) key;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -240,6 +240,7 @@ target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
|
|||
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
|
||||
{
|
||||
struct target_ops *t;
|
||||
|
||||
for (t = ops; t != NULL; t = t->beneath)
|
||||
if (t->to_auxv_parse != NULL)
|
||||
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:
|
||||
{
|
||||
struct value_print_options opts;
|
||||
|
||||
get_user_print_options (&opts);
|
||||
if (opts.addressprint)
|
||||
fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
|
||||
|
|
@ -400,6 +402,7 @@ info_auxv_command (char *cmd, int from_tty)
|
|||
else
|
||||
{
|
||||
int ents = fprint_target_auxv (gdb_stdout, ¤t_target);
|
||||
|
||||
if (ents < 0)
|
||||
error (_("No auxiliary vector found, or failed reading it."));
|
||||
else if (ents == 0)
|
||||
|
|
|
|||
17
gdb/ax-gdb.c
17
gdb/ax-gdb.c
|
|
@ -219,6 +219,7 @@ const_expr (union exp_element **pc)
|
|||
{
|
||||
struct type *type = (*pc)[1].type;
|
||||
LONGEST k = (*pc)[2].longconst;
|
||||
|
||||
(*pc) += 4;
|
||||
return value_from_longest (type, k);
|
||||
}
|
||||
|
|
@ -226,6 +227,7 @@ const_expr (union exp_element **pc)
|
|||
case OP_VAR_VALUE:
|
||||
{
|
||||
struct value *v = const_var_ref ((*pc)[2].symbol);
|
||||
|
||||
(*pc) += 4;
|
||||
return v;
|
||||
}
|
||||
|
|
@ -453,6 +455,7 @@ static void
|
|||
gen_extend (struct agent_expr *ax, struct type *type)
|
||||
{
|
||||
int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
|
||||
|
||||
/* I just had to. */
|
||||
((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
|
||||
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
|
||||
|
||||
if (!msym)
|
||||
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:
|
||||
{
|
||||
struct type *elements = TYPE_TARGET_TYPE (value->type);
|
||||
|
||||
value->type = lookup_pointer_type (elements);
|
||||
value->kind = axs_rvalue;
|
||||
/* 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. */
|
||||
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]));
|
||||
|
||||
/* 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 axs_value value1;
|
||||
|
||||
/* We don't want to turn this into an rvalue, so no conversions
|
||||
here. */
|
||||
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,
|
||||
replacing it with code that simply pushes its size. */
|
||||
int start = ax->len;
|
||||
|
||||
gen_expr (exp, pc, ax, value);
|
||||
|
||||
/* 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);
|
||||
struct trace_state_variable *tsv;
|
||||
|
||||
(*pc) += 3;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
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);
|
||||
struct trace_state_variable *tsv;
|
||||
|
||||
(*pc) += 3;
|
||||
tsv = find_trace_state_variable (name);
|
||||
if (tsv)
|
||||
|
|
@ -1944,6 +1952,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
|||
{
|
||||
struct type *type = (*pc)[1].type;
|
||||
LONGEST k = (*pc)[2].longconst;
|
||||
|
||||
(*pc) += 4;
|
||||
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;
|
||||
int reg;
|
||||
|
||||
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
|
||||
reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
|
||||
if (reg == -1)
|
||||
|
|
@ -1982,6 +1992,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
|||
{
|
||||
const char *name = internalvar_name ((*pc)[1].internalvar);
|
||||
struct trace_state_variable *tsv;
|
||||
|
||||
(*pc) += 3;
|
||||
tsv = find_trace_state_variable (name);
|
||||
if (tsv)
|
||||
|
|
@ -2008,6 +2019,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
|||
case UNOP_CAST:
|
||||
{
|
||||
struct type *type = (*pc)[1].type;
|
||||
|
||||
(*pc) += 3;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
gen_cast (ax, value, type);
|
||||
|
|
@ -2017,6 +2029,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
|
|||
case UNOP_MEMVAL:
|
||||
{
|
||||
struct type *type = check_typedef ((*pc)[1].type);
|
||||
|
||||
(*pc) += 3;
|
||||
gen_expr (exp, pc, ax, value);
|
||||
/* I'm not sure I understand UNOP_MEMVAL entirely. I think
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue