This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[ob] a*.c white space
- From: Michael Snyder <msnyder at vmware dot com>
- To: "gdb-patches at sourceware dot org" <gdb-patches at sourceware dot org>
- Date: Tue, 18 May 2010 12:24:24 -0700
- Subject: [ob] a*.c white space
How about that -- forgot the a's!
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.
Index: ada-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-lang.c,v
retrieving revision 1.262
diff -u -p -r1.262 ada-lang.c
--- ada-lang.c 17 May 2010 16:55:31 -0000 1.262
+++ ada-lang.c 18 May 2010 19:22:38 -0000
@@ -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 *
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_
{
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_
{
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, co
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, in
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 v
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
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 v
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 v
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_of
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 *
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, in
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
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, str
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 *
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[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_choi
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
|| 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
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
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_
{
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_
&& 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 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_
{
char* match;
const char* start;
+
start = name0;
while (1)
{
@@ -4946,6 +4986,7 @@ ada_add_block_symbols (struct obstack *o
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 *o
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 (str
{
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
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
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 ty
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, str
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, str
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, str
{
/* 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, str
(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,
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
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 ch
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 (struc
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,
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 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,
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,
(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 *
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
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
else
{
DOUBLEST argd = value_as_double (arg);
+
val = ada_float_to_fixed (type, argd);
}
@@ -7902,6 +7984,7 @@ cast_from_fixed (struct type *type, stru
{
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 *containe
{
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 *containe
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 va
{
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 va
{
int ind;
char *name;
+
switch (op)
{
case OP_NAME:
@@ -8272,6 +8362,7 @@ aggregate_assign_from_choices (struct va
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 *c
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, LON
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
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
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
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
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
{
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
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
/* 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
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_ty
{
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_ty
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_ty
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 expr
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
{
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
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 *
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 *);
Index: ada-typeprint.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-typeprint.c,v
retrieving revision 1.34
diff -u -p -r1.34 ada-typeprint.c
--- ada-typeprint.c 17 May 2010 16:55:31 -0000 1.34
+++ ada-typeprint.c 18 May 2010 19:22:38 -0000
@@ -151,6 +151,7 @@ print_range_bound (struct type *type, ch
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, str
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, str
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 fi
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 fi
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
else
{
char *name = ada_type_name (type);
+
if (!ada_is_range_type_name (name))
fprintf_filtered (stream, _("<%d-byte integer>"),
TYPE_LENGTH (type));
Index: ada-valprint.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-valprint.c,v
retrieving revision 1.63
diff -u -p -r1.63 ada-valprint.c
--- ada-valprint.c 7 May 2010 00:28:32 -0000 1.63
+++ ada-valprint.c 18 May 2010 19:22:38 -0000
@@ -163,6 +163,7 @@ val_print_packed_array_elements (struct
{
LONGEST high;
+
if (get_discrete_bounds (index_type, &low, &high) < 0)
len = 1;
else
@@ -213,6 +214,7 @@ val_print_packed_array_elements (struct
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
{
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, cons
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, cons
{
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, cons
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, cons
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, cons
{
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, cons
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, cons
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, c
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,
Index: addrmap.c
===================================================================
RCS file: /cvs/src/src/gdb/addrmap.c,v
retrieving revision 1.7
diff -u -p -r1.7 addrmap.c
--- addrmap.c 1 Jan 2010 07:31:29 -0000 1.7
+++ addrmap.c 18 May 2010 19:22:38 -0000
@@ -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;
}
Index: auxv.c
===================================================================
RCS file: /cvs/src/src/gdb/auxv.c,v
retrieving revision 1.26
diff -u -p -r1.26 auxv.c
--- auxv.c 6 May 2010 18:07:08 -0000 1.26
+++ auxv.c 18 May 2010 19:22:38 -0000
@@ -240,6 +240,7 @@ target_auxv_parse (struct target_ops *op
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
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_t
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)
Index: ax-gdb.c
===================================================================
RCS file: /cvs/src/src/gdb/ax-gdb.c,v
retrieving revision 1.75
diff -u -p -r1.75 ax-gdb.c
--- ax-gdb.c 6 May 2010 00:31:46 -0000 1.75
+++ ax-gdb.c 18 May 2010 19:22:38 -0000
@@ -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, st
{
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,
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
{
/* 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, unio
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, unio
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
{
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
{
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
{
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
{
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
{
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
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
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